Lets be careful to use assertIs vs assertEqual when testing compositions and nesting.

Author: jminor

tests/test_composition.py

@@ -45,7 +45,7 @@ def test_cons(self):
     def test_iterable(self):
         it = otio.core.Item()
         co = otio.core.Composition(children=[it])
-        self.assertEqual(co[0], it)
+        self.assertIs(co[0], it)
         self.assertEqual([i for i in co], [it])
         self.assertEqual(len(co), 1)
 
@@ -96,31 +96,31 @@ def test_replacing_children(self):
         c = otio.core.Item(name="C")
         co = otio.core.Composition(children=[a, b])
         self.assertEqual(2, len(co))
-        self.assertEqual(co[0], a)
-        self.assertEqual(co[1], b)
+        self.assertIs(co[0], a)
+        self.assertIs(co[1], b)
         del co[1]
         self.assertEqual(1, len(co))
-        self.assertEqual(co[0], a)
+        self.assertIs(co[0], a)
         co[0] = c
         self.assertEqual(1, len(co))
-        self.assertEqual(co[0], c)
+        self.assertIs(co[0], c)
         co[:] = [a, b]
         self.assertEqual(2, len(co))
-        self.assertEqual(co[0], a)
-        self.assertEqual(co[1], b)
+        self.assertIs(co[0], a)
+        self.assertIs(co[1], b)
         co[0:2] = [c]
         self.assertEqual(1, len(co))
-        self.assertEqual(co[0], c)
+        self.assertIs(co[0], c)
         co[:] = [c, b, a]
         self.assertEqual(3, len(co))
-        self.assertEqual(co[0], c)
-        self.assertEqual(co[1], b)
-        self.assertEqual(co[2], a)
+        self.assertIs(co[0], c)
+        self.assertIs(co[1], b)
+        self.assertIs(co[2], a)
 
     def test_parent_manip(self):
         it = otio.core.Item()
         co = otio.core.Composition(children=[it])
-        self.assertEqual(it._parent, co)
+        self.assertIs(it._parent, co)
 
     def test_each_child_recursion(self):
         tl = otio.schema.Timeline(name="TL")
@@ -159,29 +159,29 @@ def test_each_child_recursion(self):
         self.assertEqual(2, len(tr3))
 
         clips = list(tl.each_clip())
-        self.assertEqual(
+        self.assertListEqual(
             [c1, c2, c3, c4, c5, c6, c7, c8],
             clips
         )
 
         all_tracks = list(tl.each_child(
             descended_from_type=otio.schema.Track
         ))
-        self.assertEqual(
+        self.assertListEqual(
             [tr1, tr2, tr3],
             all_tracks
         )
 
         all_stacks = list(tl.each_child(
             descended_from_type=otio.schema.Stack
         ))
-        self.assertEqual(
+        self.assertListEqual(
             [st],
             all_stacks
         )
 
         all_children = list(tl.each_child())
-        self.assertEqual(
+        self.assertListEqual(
             [tr1, c1, c2, c3, tr2, c4, c5, st, c6, tr3, c7, c8],
             all_children
         )
@@ -1176,17 +1176,6 @@ def test_empty_compositions(self):
         )
 
 
-def _nest(item):
-    parent = item.parent()
-    index = parent.index(item)
-    wrapper = otio.schema.Stack()
-    # swap out the item for the wrapper
-    parent[index] = wrapper
-    # now put the item inside the wrapper
-    wrapper.append(item)
-    return wrapper
-
-
 class NestingTest(unittest.TestCase):
 
     def test_deeply_nested(self):
@@ -1245,12 +1234,38 @@ def test_deeply_nested(self):
         self.assertEqual(stack.transformed_time(fifty, clip), middle)
         self.assertEqual(stack.transformed_time(ninetynine, clip), last)
 
+        def _nest(self, item):
+
+            self.assertIsNotNone(item)
+            self.assertIsNotNone(item.parent())
+
+            parent = item.parent()
+            index = parent.index(item)
+            wrapper = otio.schema.Stack()
+
+            self.assertIs(parent[index], item)
+
+            # swap out the item for the wrapper
+            parent[index] = wrapper
+
+            self.assertIs(parent[index], wrapper)
+            self.assertIsNot(parent[index], item)
+
+            self.assertIs(wrapper.parent(), parent)
+
+            # now put the item inside the wrapper
+            wrapper.append(item)
+
+            self.assertIs(item.parent(), wrapper)
+
+            return wrapper
+
         # now nest it many layers deeper
         wrappers = []
         num_wrappers = 10
         for i in range(num_wrappers):
             # print "Nesting", (i+1), "levels deep"
-            wrapper = _nest(clip)
+            wrapper = _nest(self, clip)
             wrappers.append(wrapper)
 
         # nothing should have shifted at all