Adding an additional test and catching some bugs

Author: StanleyGoldman

src/GitHub.Api/UI/TreeBase.cs

@@ -261,7 +261,7 @@ protected void ToggleNodeChecked(int idx, TNode node)
                 ToggleChildrenChecked(idx, node, isChecked);
             }
 
-            ToggleParentFolderAndContainersChecked(idx, node, isChecked);
+            ToggleParentFolderAndContainersChecked(idx, node, checkState);
         }
 
         private void ToggleChildrenChecked(int idx, TNode node, bool isChecked)
@@ -270,8 +270,7 @@ private void ToggleChildrenChecked(int idx, TNode node, bool isChecked)
             {
                 var childNode = Nodes[i];
 
-                var wasChecked = childNode.CheckState == CheckState.Checked;
-                SetCheckStateOnNode(node, isChecked);
+                SetCheckStateOnNode(childNode, isChecked);
 
                 if (childNode.IsFolderOrContainer)
                 {
@@ -327,8 +326,9 @@ private void SetCheckStateOnNode(TNode node, CheckState setCheckState)
             }
         }
 
-        private void ToggleParentFolderAndContainersChecked(int idx, TNode node, bool isChecked)
+        private void ToggleParentFolderAndContainersChecked(int idx, TNode node, CheckState checkState)
         {
+            var isChecked = checkState != CheckState.Empty;
             while (true)
             {
                 if (node.Level > 0)
@@ -381,9 +381,7 @@ private void ToggleParentFolderAndContainersChecked(int idx, TNode node, bool is
 
                     var parentNodeState =
                         siblingsInSameState
-                            ? isChecked
-                                ? CheckState.Checked
-                                : CheckState.Empty
+                            ? node.CheckState
                             : CheckState.Mixed;
 
                     SetCheckStateOnNode(parentNode, parentNodeState);

src/tests/UnitTests/UI/TreeBaseTests.cs

@@ -679,6 +679,120 @@ public void ShouldCheckParentOfMetaFile()
             testTreeListener.Received(2).AddCheckedNode(Arg.Any<TestTreeNode>());
         }
 
+        [Test]
+        public void ShouldRippleUncheckCorrectly()
+        {
+            var testTree = new TestTree(true);
+            var testTreeListener = testTree.TestTreeListener;
+
+            testTreeListener.GetCollapsedFolders().Returns(new string[0]);
+            testTreeListener.SelectedNode.Returns((TestTreeNode)null);
+            testTreeListener.GetCheckedFiles().Returns(new string[0]);
+            testTreeListener.Nodes.Returns(new List<TestTreeNode>());
+            testTreeListener.PathSeparator.Returns(@"\");
+            testTreeListener.DisplayRootNode.Returns(true);
+            testTreeListener.IsSelectable.Returns(false);
+            testTreeListener.Title.Returns("Test Tree");
+            testTreeListener.PromoteMetaFiles.Returns(true);
+
+            var testTreeData = new[] {
+                new TestTreeData {
+                    Path = "Root\\Parent\\A.txt"
+                },
+                new TestTreeData {
+                    Path = "Root\\Parent\\B.txt"
+                },
+                new TestTreeData {
+                    Path = "Root\\Parent\\C.txt"
+                }
+            };
+
+            testTree.Load(testTreeData);
+
+            testTree.CreatedTreeNodes.ShouldAllBeEquivalentTo(new[] {
+                new TestTreeNode {
+                    Path = "Test Tree",
+                    Label = "Test Tree",
+                    IsFolder = true
+                },
+                new TestTreeNode {
+                    Path = "Root",
+                    Label = "Root",
+                    Level = 1,
+                    IsFolder = true
+                },
+                new TestTreeNode {
+                    Path = "Root\\Parent",
+                    Label = "Parent",
+                    Level = 2,
+                    IsFolder = true
+                },
+                new TestTreeNode {
+                    Path = "Root\\Parent\\A.txt",
+                    Label = "A.txt",
+                    Level = 3,
+                    TreeData = testTreeData[0],
+                },
+                new TestTreeNode {
+                    Path = "Root\\Parent\\B.txt",
+                    Label = "B.txt",
+                    Level = 3,
+                    TreeData = testTreeData[1],
+                },
+                new TestTreeNode {
+                    Path = "Root\\Parent\\C.txt",
+                    Label = "C.txt",
+                    Level = 3,
+                    TreeData = testTreeData[2],
+                }
+            });
+
+            var rootNode = testTree.CreatedTreeNodes[1];
+            var parentNode = testTree.CreatedTreeNodes[2];
+            var aNode = testTree.CreatedTreeNodes[3];
+            var bNode = testTree.CreatedTreeNodes[4];
+            var cNode = testTree.CreatedTreeNodes[5];
+
+            Assert.AreEqual(CheckState.Empty, rootNode.CheckState);
+            Assert.AreEqual(CheckState.Empty, parentNode.CheckState);
+            Assert.AreEqual(CheckState.Empty, aNode.CheckState);
+            Assert.AreEqual(CheckState.Empty, bNode.CheckState);
+            Assert.AreEqual(CheckState.Empty, cNode.CheckState);
+
+            testTree.ToggleNodeChecked(1, rootNode);
+
+            Assert.AreEqual(CheckState.Checked, rootNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, parentNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, aNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, bNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, cNode.CheckState);
+
+            testTreeListener.Received(3).AddCheckedNode(Arg.Any<TestTreeNode>());
+            testTreeListener.ClearReceivedCalls();
+
+            testTree.ToggleNodeChecked(5, cNode);
+
+            Assert.AreEqual(CheckState.Mixed, rootNode.CheckState);
+            Assert.AreEqual(CheckState.Mixed, parentNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, aNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, bNode.CheckState);
+            Assert.AreEqual(CheckState.Empty, cNode.CheckState);
+
+            testTreeListener.Received(1).RemoveCheckedNode(Arg.Any<TestTreeNode>());
+            testTreeListener.ClearReceivedCalls();
+
+            testTree.ToggleNodeChecked(5, cNode);
+
+            Assert.AreEqual(CheckState.Checked, rootNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, parentNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, aNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, bNode.CheckState);
+            Assert.AreEqual(CheckState.Checked, cNode.CheckState);
+
+            testTreeListener.Received(1).AddCheckedNode(Arg.Any<TestTreeNode>());
+            testTreeListener.ClearReceivedCalls();
+        }
+
         [Test]
         public void ShouldPopulateTreeWithSingleEntryWithNonPromotedMetaInPath()
         {