Add tests for CKRenderTreeNodeWithChild

Summary: Self-explanatory

Reviewed By: gkassabli

Differential Revision: D7830085

fbshipit-source-id: 0cebcb9899fa6d13a4d435bf5dd1226f923af562

Author: kfirapps

ComponentKitTests/CKBuildComponentTreeTests.mm

@@ -16,6 +16,7 @@
 #import "CKComponentInternal.h"
 #import "CKButtonComponent.h"
 #import "CKTreeNode.h"
+#import "CKRenderTreeNodeWithChild.h"
 #import "CKRenderTreeNodeWithChildren.h"
 #import "CKThreadLocalComponentScope.h"
 
@@ -43,22 +44,25 @@ @interface CKBuildComponentTreeTests : XCTestCase
 @end
 
 @implementation CKBuildComponentTreeTests
+{
+  BOOL _forceParent;
+}
 
 #pragma mark - CKComponent
 
 - (void)test_buildComponentTree_onCKComponent
 {
   CKRenderTreeNodeWithChildren *root = [[CKRenderTreeNodeWithChildren alloc] init];
   CKComponent *c = [CKComponent newWithView:{} size:{}];
-  [c buildComponentTree:root previousOwner:nil scopeRoot:nil stateUpdates:{} forceParent:NO];
+  [c buildComponentTree:root previousOwner:nil scopeRoot:nil stateUpdates:{} forceParent:_forceParent];
 
   XCTAssertEqual(root.children.size(), 1);
   XCTAssertEqual(root.children[0].component, c);
 
   // Simulate a second tree creation.
   CKRenderTreeNodeWithChildren *root2 = [[CKRenderTreeNodeWithChildren alloc] init];
   CKComponent *c2 = [CKComponent newWithView:{} size:{}];
-  [c2 buildComponentTree:root2 previousOwner:root scopeRoot:nil stateUpdates:{} forceParent:NO];
+  [c2 buildComponentTree:root2 previousOwner:root scopeRoot:nil stateUpdates:{} forceParent:_forceParent];
   XCTAssertTrue(areTreesEqual(root, root2));
 }
 
@@ -69,28 +73,33 @@ - (void)test_buildComponentTree_onCKRenderComponent
   CKRenderTreeNodeWithChildren *root = [[CKRenderTreeNodeWithChildren alloc] init];
   CKComponent *c = [CKComponent newWithView:{} size:{}];
   CKRenderComponent *renderComponent = [CKComponentTreeTestComponent_Render newWithComponent:c];
-  [renderComponent buildComponentTree:root previousOwner:nil scopeRoot:nil stateUpdates:{} forceParent:NO];
+  [renderComponent buildComponentTree:root previousOwner:nil scopeRoot:nil stateUpdates:{} forceParent:_forceParent];
 
   // Make sure the root has only one child.
   XCTAssertEqual(root.children.size(), 1);
   CKTreeNode *singleChildNode = root.children[0];
   verifyChildToParentConnection(root, singleChildNode, renderComponent);
 
   // Check the next level of the tree
-  if ([singleChildNode isKindOfClass:[CKRenderTreeNodeWithChildren class]]) {
+  if ((!_forceParent && [singleChildNode isKindOfClass:[CKRenderTreeNodeWithChildren class]]) ||
+      (_forceParent && [singleChildNode isKindOfClass:[CKRenderTreeNodeWithChild class]])) {
     CKRenderTreeNodeWithChildren *parentNode = (CKRenderTreeNodeWithChildren *)singleChildNode;
     XCTAssertEqual(parentNode.children.size(), 1);
     CKTreeNode *componentNode = parentNode.children[0];
     verifyChildToParentConnection(parentNode, componentNode, c);
   } else {
-    XCTFail(@"singleChildNode has to be CKRenderTreeNodeWithChildren as it has children.");
+    if (_forceParent) {
+      XCTFail(@"singleChildNode has to be CKRenderTreeNodeWithChild as it has a child.");
+    } else {
+      XCTFail(@"singleChildNode has to be CKRenderTreeNodeWithChildren as it has children.");
+    }
   }
 
   // Simulate a second tree creation.
   CKRenderTreeNodeWithChildren *root2 = [[CKRenderTreeNodeWithChildren alloc] init];
   CKComponent *c2 = [CKComponent newWithView:{} size:{}];
   CKRenderComponent *renderComponent2 = [CKComponentTreeTestComponent_Render newWithComponent:c2];
-  [renderComponent2 buildComponentTree:root2 previousOwner:root scopeRoot:nil stateUpdates:{} forceParent:NO];
+  [renderComponent2 buildComponentTree:root2 previousOwner:root scopeRoot:nil stateUpdates:{} forceParent:_forceParent];
   XCTAssertTrue(areTreesEqual(root, root2));
 }
 
@@ -166,16 +175,23 @@ - (void)test_buildComponentTree_onCKRenderWithChildrenComponent_MakeGroupAnOwner
   XCTAssertTrue(areTreesEqual(root, root2));
 }
 
+- (void)test_buildComponentTree_withForceParent
+{
+  _forceParent = YES;
+  [self test_buildComponentTree_onCKComponent];
+  [self test_buildComponentTree_onCKRenderComponent];
+}
+
 #pragma mark - Helpers
 
-static BOOL verifyChildToParentConnection(CKRenderTreeNodeWithChildren * parentNode, CKTreeNode *childNode, CKComponent *c) {
+static BOOL verifyChildToParentConnection(id<CKTreeNodeWithChildrenProtocol> parentNode, CKTreeNode *childNode, CKComponent *c) {
   auto const componentKey = [childNode componentKey];
   auto const childComponent = [parentNode childForComponentKey:componentKey].component;
   return [childComponent isEqual:c];
 }
 
 /** Compare the components array to the components in the children nodes of 'parentNode' */
-static BOOL verifyComponentsInNode(CKRenderTreeNodeWithChildren *parentNode, NSArray<CKComponent *> *components) {
+static BOOL verifyComponentsInNode(id<CKTreeNodeWithChildrenProtocol> parentNode, NSArray<CKComponent *> *components) {
   // Verify that the root holds two components has its direct children
   NSMutableSet<CKComponent *> *componentsFromTheTree = [NSMutableSet set];
   for (auto const node : parentNode.children) {
@@ -186,7 +202,7 @@ static BOOL verifyComponentsInNode(CKRenderTreeNodeWithChildren *parentNode, NSA
 }
 
 /** Compare the children of the trees recursively; returns true if the two trees are equal */
-static BOOL areTreesEqual(CKRenderTreeNodeWithChildren *lhs, CKRenderTreeNodeWithChildren *rhs) {
+static BOOL areTreesEqual(id<CKTreeNodeWithChildrenProtocol> lhs, id<CKTreeNodeWithChildrenProtocol> rhs) {
   NSMutableSet<NSString *> *lhsChildrenIdentifiers = [NSMutableSet set];
   treeChildrenIdentifiers(lhs, lhsChildrenIdentifiers, 0);
   NSMutableSet<NSString *> *rhsChildrenIdentifiers = [NSMutableSet set];
@@ -195,7 +211,7 @@ static BOOL areTreesEqual(CKRenderTreeNodeWithChildren *lhs, CKRenderTreeNodeWit
 }
 
 /** Iterate recursively over the tree and add its node identifiers to the set */
-static void treeChildrenIdentifiers(CKRenderTreeNodeWithChildren *node, NSMutableSet<NSString *> *identifiers, int level) {
+static void treeChildrenIdentifiers(id<CKTreeNodeWithChildrenProtocol> node, NSMutableSet<NSString *> *identifiers, int level) {
   for (auto const childNode : node.children) {
     // We add the child identifier + its level in the tree.
     [identifiers addObject:[NSString stringWithFormat:@"%d-%d",childNode.nodeIdentifier, level]];

ComponentKitTests/CKTreeNodeTests.mm

@@ -17,6 +17,7 @@
 #import "CKButtonComponent.h"
 #import "CKTreeNode.h"
 #import "CKRenderTreeNode.h"
+#import "CKRenderTreeNodeWithChild.h"
 #import "CKRenderTreeNodeWithChildren.h"
 #import "CKThreadLocalComponentScope.h"
 
@@ -128,6 +129,53 @@ - (void)test_childForComponentKey_onCKRenderTreeNodeWithChildren_withMultipleChi
   XCTAssertTrue(areTreesEqual(root, root2));
 }
 
+#pragma mark - CKRenderTreeNodeWithChild
+
+- (void)test_childForComponentKey_onCKRenderTreeNodeWithChild {
+  // Simulate first component tree creation
+  CKRenderTreeNodeWithChild *root1 = [[CKRenderTreeNodeWithChild alloc] init];
+  auto const component1 = [CKComponent newWithView:{} size:{}];
+  CKTreeNode *childNode1 = [[CKTreeNode alloc] initWithComponent:component1
+                                                           owner:root1
+                                                   previousOwner:nil
+                                                       scopeRoot:nil
+                                                    stateUpdates:{}];
+
+  // Simulate a component tree creation due to a state update
+  CKRenderTreeNodeWithChild *root2 = [[CKRenderTreeNodeWithChild alloc] init];
+  auto const component2 = [CKComponent newWithView:{} size:{}];
+  CKTreeNode *childNode2 = [[CKTreeNode alloc] initWithComponent:component2
+                                                           owner:root2
+                                                   previousOwner:root1
+                                                       scopeRoot:nil
+                                                    stateUpdates:{}];
+
+  XCTAssertTrue(verifyChildToParentConnection(root1, childNode1, component1));
+  XCTAssertTrue(verifyChildToParentConnection(root2, childNode2, component2));
+}
+
+- (void)test_nodeIdentifier_onCKRenderTreeNodeWithChild_betweenGenerations {
+  // Simulate first component tree creation
+  CKRenderTreeNodeWithChild *root1 = [[CKRenderTreeNodeWithChild alloc] init];
+  auto const component1 = [CKComponent newWithView:{} size:{}];
+  CKTreeNode *childNode1 = [[CKTreeNode alloc] initWithComponent:component1
+                                                           owner:root1
+                                                   previousOwner:nil
+                                                       scopeRoot:nil
+                                                    stateUpdates:{}];
+
+  // Simulate a component tree creation due to a state update
+  CKRenderTreeNodeWithChild *root2 = [[CKRenderTreeNodeWithChild alloc] init];
+  auto const component2 = [CKComponent newWithView:{} size:{}];
+  CKTreeNode *childNode2 = [[CKTreeNode alloc] initWithComponent:component2
+                                                           owner:root2
+                                                   previousOwner:root1
+                                                       scopeRoot:nil
+                                                    stateUpdates:{}];
+
+  XCTAssertEqual(childNode1.nodeIdentifier, childNode2.nodeIdentifier);
+}
+
 #pragma mark - State
 
 - (void)test_stateUpdate_onCKTreeNode
@@ -292,29 +340,29 @@ - (void)_test_initialState_withComponent:(CKComponent *)c initialState:(id)initi
   XCTAssertNotNil(node.handle);
 }
 
-static BOOL verifyChildToParentConnection(CKRenderTreeNodeWithChildren * parentNode, CKTreeNode *childNode, CKComponent *c) {
+static BOOL verifyChildToParentConnection(id<CKTreeNodeWithChildrenProtocol> parentNode, CKTreeNode *childNode, CKComponent *c) {
   auto const componentKey = [childNode componentKey];
   auto const childComponent = [parentNode childForComponentKey:componentKey].component;
   return [childComponent isEqual:c];
 }
 
-static NSMutableArray<CKTreeNode*> *createsNodesForComponentsWithOwner(CKRenderTreeNodeWithChildren *owner,
-                                                                       CKRenderTreeNodeWithChildren *previousOwner,
+static NSMutableArray<CKTreeNode*> *createsNodesForComponentsWithOwner(id<CKTreeNodeWithChildrenProtocol> owner,
+                                                                       id<CKTreeNodeWithChildrenProtocol> previousOwner,
                                                                        NSArray<CKComponent *> *components) {
   NSMutableArray<CKTreeNode*> *nodes = [NSMutableArray array];
   for (CKComponent *component in components) {
     CKTreeNode *childNode = [[CKTreeNode alloc] initWithComponent:component
-                                                             owner:owner
-                                                     previousOwner:previousOwner
-                                                         scopeRoot:nil
-                                                      stateUpdates:{}];
+                                                            owner:owner
+                                                    previousOwner:previousOwner
+                                                        scopeRoot:nil
+                                                     stateUpdates:{}];
     [nodes addObject:childNode];
   }
   return nodes;
 }
 
 /** Compare the children of the trees recursively; returns true if the two trees are equal */
-static BOOL areTreesEqual(CKRenderTreeNodeWithChildren *lhs, CKRenderTreeNodeWithChildren *rhs) {
+static BOOL areTreesEqual(id<CKTreeNodeWithChildrenProtocol> lhs, id<CKTreeNodeWithChildrenProtocol> rhs) {
   NSMutableSet<NSString *> *lhsChildrenIdentifiers = [NSMutableSet set];
   treeChildrenIdentifiers(lhs, lhsChildrenIdentifiers, 0);
   NSMutableSet<NSString *> *rhsChildrenIdentifiers = [NSMutableSet set];
@@ -323,7 +371,7 @@ static BOOL areTreesEqual(CKRenderTreeNodeWithChildren *lhs, CKRenderTreeNodeWit
 }
 
 /** Iterate recursively over the tree and add its node identifiers to the set */
-static void treeChildrenIdentifiers(CKRenderTreeNodeWithChildren *node, NSMutableSet<NSString *> *identifiers, int level) {
+static void treeChildrenIdentifiers(id<CKTreeNodeWithChildrenProtocol> node, NSMutableSet<NSString *> *identifiers, int level) {
   for (auto const childNode : node.children) {
     // We add the child identifier + its level in the tree.
     [identifiers addObject:[NSString stringWithFormat:@"%d-%d",childNode.nodeIdentifier, level]];