Revert "fix nested multi-entities query (shotgunsoftware#138)"

Jean-Fran&ccedil;ois Boismenu · Jean-Fran&ccedil;ois Boismenu · commit 3187e01fa717 · 2017-05-04T15:25:17.000-04:00
This reverts commit 73554b5.
diff --git a/shotgun_api3/lib/mockgun/mockgun.py b/shotgun_api3/lib/mockgun/mockgun.py
@@ -242,31 +242,16 @@ def schema_field_read(self, entity_type, field_name=None):
         else:
             return dict((k, v) for k, v in self._schema[entity_type].items() if k == field_name)
 
+
     def find(self, entity_type, filters, fields=None, order=None, filter_operator=None, limit=0, retired_only=False, page=0):
+        
+
         self.finds += 1
 
         self._validate_entity_type(entity_type)
         # do not validate custom fields - this makes it hard to mock up a field quickly
         #self._validate_entity_fields(entity_type, fields)
 
-        # Configure fields
-        if fields is None:
-            requested_fields = set(["type", "id"])
-        else:
-            requested_fields = set(fields) | set(["type", "id"])
-
-        # Include fields from the order argument in the searched fields
-        order_fields = set()
-        if order:
-            for o in order:
-                order_fields.add(o['field_name'])
-
-        # Merge the requested fields and the order fields.
-        # We need all those to property order the results but still return only requested fields.
-        all_fields = set()
-        all_fields.update(requested_fields)
-        all_fields.update(order_fields)
-
         # FIXME: This should be refactored so that we can use the complex filer
         # style in nested filter operations.
         if isinstance(filters, dict):
@@ -289,7 +274,7 @@ def find(self, entity_type, filters, fields=None, order=None, filter_operator=No
                     resolved_filters.append([ f["path"], f["relation"], f["values"][0] ])
 
         else:
-            # traditional style sg filters
+            # traditiona style sg filters
             resolved_filters = filters
 
         results = [
@@ -300,10 +285,7 @@ def find(self, entity_type, filters, fields=None, order=None, filter_operator=No
             )
         ]
 
-        # Extract fields from row
-        val = [dict((field, self._get_field_from_row(entity_type, row, field)) for field in all_fields) for row in results]
-
-        # Handle the ordering of the result after we requested additional fields from results.
+        # handle the ordering of the recordset
         if order:
             # order: [{"field_name": "code", "direction": "asc"}, ... ]
             for order_entry in order:
@@ -318,20 +300,23 @@ def find(self, entity_type, filters, fields=None, order=None, filter_operator=No
                 else:
                     raise ValueError("Unknown ordering direction")
 
-                val = sorted(val, key=lambda k: k[order_field], reverse=desc_order)
+                results = sorted(results, key=lambda k: k[order_field], reverse=desc_order)
 
-        # Remove any fields that was not explicitely requested.
-        fields_to_remove = all_fields - requested_fields
-        for v in val:
-            for field in fields_to_remove:
-                v.pop(field)
+        if fields is None:
+            fields = set(["type", "id"])
+        else:
+            fields = set(fields) | set(["type", "id"])
 
-        return val
+        # get the values requested
+        val = [dict((field, self._get_field_from_row(entity_type, row, field)) for field in fields) for row in results]
 
+        return val
+    
+    
     def find_one(self, entity_type, filters, fields=None, order=None, filter_operator=None, retired_only=False):
         results = self.find(entity_type, filters, fields=fields, order=order, filter_operator=filter_operator, retired_only=retired_only)
         return results[0] if results else None
-
+    
     def batch(self, requests):
         results = []
         for request in requests:
@@ -376,12 +361,9 @@ def create(self, entity_type, data, return_fields=None):
         
         row = self._get_new_row(entity_type)
         
-        self._update_row(entity_type, row, data)
+        self._update_row(entity_type, row, data)        
         row["id"] = next_id
         
-        if "created_at" not in row:
-            row["created_at"] = datetime.datetime.now()
-        
         self._db[entity_type][next_id] = row
         
         if return_fields is None:
@@ -655,12 +637,15 @@ def _get_field_from_row(self, entity_type, row, field):
                         sub_field_value = self._get_field_from_row(entity_type2, entity, field3)
                         values.append(sub_field_value)
                     return values
-                elif field_value is None:
-                    return None
                 # not multi entity, must be entity.
                 elif not isinstance(field_value, dict):
                     raise ShotgunError("Invalid deep query field %s.%s" % (entity_type, field))
 
+                # make sure that types in the query match type in the linked field
+                if entity_type2 != field_value["type"]:
+                    raise ShotgunError("Deep query field %s.%s does not match type "
+                                       "with data %s" % (entity_type, field, field_value))
+
                 # ok so looks like the value is an entity link
                 # e.g. db contains: {"sg_sequence": {"type":"Sequence", "id": 123 } }
                 linked_row = self._db[ field_value["type"] ][ field_value["id"] ]
diff --git a/tests/test_mockgun.py b/tests/test_mockgun.py
@@ -216,33 +216,23 @@ def setUp(self):
         self._user1 = self._mockgun.create("HumanUser", {"login": "user1"})
         self._user2 = self._mockgun.create("HumanUser", {"login": "user2"})
 
-        # Create a project for nested sub entity field
-        self._project1 = self._mockgun.create("Project", {"name": "project1", "users": [self._user1]})
-        self._project2 = self._mockgun.create("Project", {"name": "project2", "users": [self._user2]})
-        
-        self._sequence1 = self._mockgun.create("Sequence", {"code":"01", "project":self._project1})
-        self._shot1 = self._mockgun.create("Shot", {"code":"01_0010", "project":self._project1, "sg_sequence": self._sequence1})
-        
-        self._task_seq = self._mockgun.create("Task", {"entity": self._sequence1})
-        self._task_shot = self._mockgun.create("Task", {"entity": self._shot1})
-
         # Create pipeline configurations that are assigned none, one or two users.
-        self._pipeline_config_1 = self._mockgun.create(
+        self._mockgun.create(
             "PipelineConfiguration",
-            {"code": "with_user1", "users": [self._user1], "project": self._project1}
+            {"code": "with_user1", "users": [self._user1]}
         )
 
-        self._pipeline_config_2 = self._mockgun.create(
+        self._mockgun.create(
             "PipelineConfiguration",
-            {"code": "with_user2", "users": [self._user2], "project": self._project2}
+            {"code": "with_user2", "users": [self._user2]}
         )
 
-        self._pipeline_config_3 = self._mockgun.create(
+        self._mockgun.create(
             "PipelineConfiguration",
             {"code": "with_both", "users": [self._user2, self._user1]}
         )
 
-        self._pipeline_config_4 = self._mockgun.create(
+        self._mockgun.create(
             "PipelineConfiguration",
             {"code": "with_none", "users": []}
         )
@@ -278,126 +268,6 @@ def test_find_by_sub_entity_field(self):
             ]}]
         )
         self.assertEqual(len(items), 1)
-        
-        # Try with multi entities
-        item = self._mockgun.find_one("Task", [
-            ['entity.Shot.code', 'is', self._shot1['code']]
-        ])
-        self.assertNotEqual(None, item)
-        self.assertEqual(self._task_shot["id"], item["id"])
-        
-        item = self._mockgun.find_one("Task", [
-            ['entity.Sequence.code', 'is', self._sequence1['code']]
-        ])
-        self.assertNotEqual(None, item)
-        self.assertEqual(self._task_seq["id"], item["id"])
-
-    def test_find_by_sub_entity_field_nested(self):
-        """
-        Ensure that queries on nested linked entity fields work.
-        """
-        items = self._mockgun.find("PipelineConfiguration", [
-            ["project.Project.users.HumanUser.login", "is", "user1"]
-        ])
-        self.assertEqual(len(items), 1)
-        self.assertEqual(self._pipeline_config_1['id'], items[0]['id'])
-
-        items = self._mockgun.find("PipelineConfiguration", [
-            ["project.Project.users.HumanUser.login", "is", "user2"]
-        ])
-        self.assertEqual(len(items), 1)
-        self.assertEqual(self._pipeline_config_2['id'], items[0]['id'])
-        
-
-
-class TestFindFields(TestBaseWithExceptionTests):
-    """
-    Ensure that using the 'field' argument in the find method work.
-    """
-
-    def setUp(self):
-        """Creates test data."""
-        self._mockgun = Mockgun("https://test.shotgunstudio.com", login="user", password="1234")
-
-        # Create two users to assign to the pipeline configurations.
-        self._user1 = self._mockgun.create("HumanUser", {"login": "user1", "firstname": "firstname1"})
-
-        # Create a project for nested sub entity field
-        self._project1 = self._mockgun.create("Project", {"name": "project1", "users": [self._user1]})
-
-        # Create pipeline configurations that are assigned none, one or two users.
-        self._mockgun.create(
-            "PipelineConfiguration",
-            {"code": "with_user1", "users": [self._user1], "project": self._project1}
-        )
-
-    def test_field(self):
-        item = self._mockgun.find_one("HumanUser", [
-            ["login", "is", "user1"]
-        ], ["firstname"])
-        self.assertIn("firstname",item)
-        self.assertEqual("firstname1", item["firstname"])
-
-    def test_find_field_multi_entity(self):
-        item = self._mockgun.find_one("PipelineConfiguration", [
-            ["project.Project.users.HumanUser.login", "is", "user1"]
-        ], ["project.Project.name"])
-        self.assertIn("project.Project.name", item)
-        self.assertEqual("project1", item["project.Project.name"])
-
-
-class TestFindOrder(TestBaseWithExceptionTests):
-    """
-    Ensure that using the 'order' argument in the find method work.
-    """
-    def setUp(self):
-        self._mockgun = Mockgun("https://test.shotgunstudio.com", login="user", password="1234")
-
-        # Create two users to assign to the pipeline configurations.
-        self._user1 = self._mockgun.create("HumanUser", {"login": "user1", "firstname": "firstname1", "email": "user1@foobar.com"})
-        self._user2 = self._mockgun.create("HumanUser", {"login": "user2", "firstname": "firstname2", "email": "user2@foobar.com"})
-
-        # Create a project for nested sub entity field
-        self._project1 = self._mockgun.create("Project", {"name": "project1", "users": [self._user1]})
-        self._project2 = self._mockgun.create("Project", {"name": "project2", "users": [self._user2]})
-
-        # Create two PipelineConfiguration entities so we can test multi-entity sorting.
-        self._pipeline_configutation_1 = self._mockgun.create("PipelineConfiguration", {
-            "code": "PipelineConfiguration1", "users": [self._user2], "project": self._project1})
-        self._pipeline_configutation_2 = self._mockgun.create("PipelineConfiguration", {
-            "code": "PipelineConfiguration2", "users": [self._user1], "project": self._project2})
-
-    def test_find_order(self):
-        # Test ascending order
-        item = self._mockgun.find_one("HumanUser", [], order=[{'field_name': 'login', 'direction': 'asc'}])
-        self.assertEqual(self._user1['id'], item['id'])
-
-        # Test descending order
-        item = self._mockgun.find_one("HumanUser", [], order=[{'field_name': 'login', 'direction': 'desc'}])
-        self.assertEqual(self._user2['id'], item['id'])
-
-    def test_find_order_linked_entity_field(self):
-        """Ensure we are able to sort data using a linked entity field."""
-        # Test ascending order
-        item = self._mockgun.find_one("PipelineConfiguration", [], order=[{'field_name': 'project.Project.name', 'direction': 'asc'}])
-        self.assertEqual(self._pipeline_configutation_1['id'], item['id'])
-
-        # Test descending order
-        item = self._mockgun.find_one("PipelineConfiguration", [], order=[{'field_name': 'project.Project.name', 'direction': 'desc'}])
-        self.assertEqual(self._pipeline_configutation_2['id'], item['id'])
-
-    def test_find_order_fields_leak(self):
-        """Ensure that additional fields passed through the order argument but NOT via the field argument are not added to the resulting fields."""
-        item = self._mockgun.find_one("HumanUser", [], fields=['email'], order=[{'field_name': 'login', 'direction': 'asc'}])
-        self.assertEqual(set(item.keys()), set(['id', 'type', 'email']))  # note: we don't verify the order yet
-
-    def test_find_order_date_created(self):
-        """Ensure we are able to sort entities by their creation date."""
-        item = self._mockgun.find_one("PipelineConfiguration", [], order=[{'field_name': 'created_at', 'direction': 'asc'}])
-        self.assertEqual(self._pipeline_configutation_1['id'], item['id'])
-
-        item = self._mockgun.find_one("PipelineConfiguration", [], order=[{'field_name': 'created_at', 'direction': 'desc'}])
-        self.assertEqual(self._pipeline_configutation_2['id'], item['id'])
 
     def test_find_with_none(self):
         """
