def test_complex_queries(self):
        res_objs = [
            dict(res=IonObject(RT.ActorIdentity, name="Act1")),
            dict(res=IonObject(RT.ActorIdentity, name="Act2")),

            dict(res=IonObject(RT.Org, name="Org1"), act="Act1"),
            dict(res=IonObject(RT.TestSite, name="Obs1"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestSite, name="PS1"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestSite, name="PSC1"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestSite, name="IS1"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel, name="PM1", manufacturer="CGSN"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel, name="PMC1", manufacturer="Bluefin"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel, name="PM2", manufacturer="Webb"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel, name="IM1", manufacturer="SeaBird"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel, name="IM2", manufacturer="Teledyne"), act="Act1", org="Org1"),
            dict(res=IonObject(RT.TestPlatform, name="PD1"), act="Act1", org="Org1", lcstate=LCS.DEPLOYED),
            dict(res=IonObject(RT.TestPlatform, name="PDC1"), act="Act1", org="Org1", lcstate=LCS.INTEGRATED),
            dict(res=IonObject(RT.TestInstrument, name="ID1", firmware_version='A1'), act="Act1", org="Org1", lcstate=LCS.DEPLOYED),
            dict(res=IonObject(RT.TestInstrument, name="ID2", firmware_version='A2'), act="Act1", org="Org1", lcstate=LCS.INTEGRATED),

            dict(res=IonObject(RT.Org, name="Org2"), act="Act2"),
            dict(res=IonObject(RT.TestSite, name="Obs2"), act="Act2", org="Org2"),
            dict(res=IonObject(RT.TestSite, name="PS2"), act="Act2", org="Org2"),
            dict(res=IonObject(RT.TestPlatform, name="PD2"), act="Act2", org="Org2"),
            dict(res=IonObject(RT.TestInstrument, name="ID3", lcstate=LCS.DEPLOYED, firmware_version='A3'), act="Act2", org="Org2"),
            dict(res=IonObject(RT.Stream, name="Stream1")),
        ]
        assocs = [
            ("Obs1", PRED.hasTestSite, "PS1"),
            ("PS1", PRED.hasTestSite, "PSC1"),
            ("PSC1", PRED.hasTestSite, "IS1"),
            ("PS1", PRED.hasTestDevice, "PD1"),
            ("PSC1", PRED.hasTestDevice, "PDC1"),
            ("IS1", PRED.hasTestDevice, "ID1"),
            ("PD1", PRED.hasTestDevice, "PDC1"),
            ("PDC1", PRED.hasTestDevice, "ID1"),

            ("PS1", PRED.hasTestModel, "PM1"),
            ("PSC1", PRED.hasTestModel, "PMC1"),
            ("IS1", PRED.hasTestModel, "IM1"),
            ("PD1", PRED.hasTestModel, "PM1"),
            ("PDC1", PRED.hasTestModel, "PMC1"),
            ("ID1", PRED.hasTestModel, "IM1"),
            ("PD2", PRED.hasTestModel, "PM2"),
            ("ID2", PRED.hasTestModel, "IM2"),

        ]
        res_by_name = create_dummy_resources(res_objs, assocs)

        log.info("TEST: Query for all resources owned by actor Act1")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_associated_from_object(res_by_name["Act1"], None, "hasOwner"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 14)

        log.info("TEST: Query for all Site descendants of TestSite Obs1")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_object_descendants(res_by_name["Obs1"], [RT.TestSite, RT.TestSite], PRED.hasTestSite))
        result = self.discovery.query(rq.get_query(), id_only=False)
        # import pprint
        # pprint.pprint(rq.get_query())
        self.assertEquals(len(result), 3)

        log.info("TEST: Query for all resources belonging to Org Org1")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_associated_from_subject(res_by_name["Org1"], None, "hasResource"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 13)

        log.info("TEST: Query for all resources belonging to Org Org1 AND of type TestInstrument")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_associated_from_subject(res_by_name["Org1"], None, "hasResource"),
                      rq.filter_type(RT.TestInstrument))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 2)

        log.info("TEST: Query for instruments whose platform parent has a name of PDC1")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_type(RT.TestInstrument),
                      rq.filter_associated_from_subject(subject_type=RT.TestPlatform, predicate=PRED.hasTestDevice, target_filter=rq.filter_name("PDC1")))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 1)
        self.assertEquals(result[0].name, "ID1")

        log.info("TEST: Query for instruments in Org1 whose platform parent has a specific attribute set")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_type(RT.TestInstrument),
                      rq.filter_associated_from_subject(res_by_name["Org1"], None, "hasResource"),
                      rq.filter_associated_from_subject(subject_type=RT.TestPlatform, predicate=PRED.hasTestDevice, target_filter=rq.filter_name("PDC1")))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 1)
        self.assertEquals(result[0].name, "ID1")

        log.info("TEST: Query for instruments in Org1 that are lcstate INTEGRATED")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_type(RT.TestInstrument),
                      rq.filter_lcstate(LCS.INTEGRATED),
                      rq.filter_associated_from_subject(res_by_name["Org1"], None, "hasResource"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 1)
        self.assertEquals(result[0].name, "ID2")

        log.info("TEST: Query for instruments in Org1 that are lcstate INTEGRATED OR platforms in Org1 that are lcstate DEPLOYED")
        rq = ResourceQuery()
        rq.set_filter(rq.filter_or(rq.filter_and(rq.filter_type(RT.TestInstrument),
                                                 rq.filter_lcstate(LCS.INTEGRATED)),
                                   rq.filter_and(rq.filter_type(RT.TestPlatform),
                                                 rq.filter_lcstate(LCS.DEPLOYED))),
                      rq.filter_associated_from_subject(res_by_name["Org1"], None, "hasResource"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 2)
    def test_complex_queries(self):
        res_objs = [
            dict(res=IonObject(RT.ActorIdentity, name="Act1")),
            dict(res=IonObject(RT.ActorIdentity, name="Act2")),
            dict(res=IonObject(RT.Org, name="Org1"), act="Act1"),
            dict(res=IonObject(RT.TestSite, name="Obs1"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestSite, name="PS1"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestSite, name="PSC1"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestSite, name="IS1"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel,
                               name="PM1",
                               manufacturer="CGSN"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel,
                               name="PMC1",
                               manufacturer="Bluefin"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel,
                               name="PM2",
                               manufacturer="Webb"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel,
                               name="IM1",
                               manufacturer="SeaBird"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestDeviceModel,
                               name="IM2",
                               manufacturer="Teledyne"),
                 act="Act1",
                 org="Org1"),
            dict(res=IonObject(RT.TestPlatform, name="PD1"),
                 act="Act1",
                 org="Org1",
                 lcstate=LCS.DEPLOYED),
            dict(res=IonObject(RT.TestPlatform, name="PDC1"),
                 act="Act1",
                 org="Org1",
                 lcstate=LCS.INTEGRATED),
            dict(res=IonObject(RT.TestInstrument,
                               name="ID1",
                               firmware_version='A1'),
                 act="Act1",
                 org="Org1",
                 lcstate=LCS.DEPLOYED),
            dict(res=IonObject(RT.TestInstrument,
                               name="ID2",
                               firmware_version='A2'),
                 act="Act1",
                 org="Org1",
                 lcstate=LCS.INTEGRATED),
            dict(res=IonObject(RT.Org, name="Org2"), act="Act2"),
            dict(res=IonObject(RT.TestSite, name="Obs2"),
                 act="Act2",
                 org="Org2"),
            dict(res=IonObject(RT.TestSite, name="PS2"),
                 act="Act2",
                 org="Org2"),
            dict(res=IonObject(RT.TestPlatform, name="PD2"),
                 act="Act2",
                 org="Org2"),
            dict(res=IonObject(RT.TestInstrument,
                               name="ID3",
                               lcstate=LCS.DEPLOYED,
                               firmware_version='A3'),
                 act="Act2",
                 org="Org2"),
            dict(res=IonObject(RT.Stream, name="Stream1")),
        ]
        assocs = [
            ("Obs1", PRED.hasTestSite, "PS1"),
            ("PS1", PRED.hasTestSite, "PSC1"),
            ("PSC1", PRED.hasTestSite, "IS1"),
            ("PS1", PRED.hasTestDevice, "PD1"),
            ("PSC1", PRED.hasTestDevice, "PDC1"),
            ("IS1", PRED.hasTestDevice, "ID1"),
            ("PD1", PRED.hasTestDevice, "PDC1"),
            ("PDC1", PRED.hasTestDevice, "ID1"),
            ("PS1", PRED.hasTestModel, "PM1"),
            ("PSC1", PRED.hasTestModel, "PMC1"),
            ("IS1", PRED.hasTestModel, "IM1"),
            ("PD1", PRED.hasTestModel, "PM1"),
            ("PDC1", PRED.hasTestModel, "PMC1"),
            ("ID1", PRED.hasTestModel, "IM1"),
            ("PD2", PRED.hasTestModel, "PM2"),
            ("ID2", PRED.hasTestModel, "IM2"),
        ]
        res_by_name = create_dummy_resources(res_objs, assocs)

        log.info("TEST: Query for all resources owned by actor Act1")
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_associated_from_object(res_by_name["Act1"], None,
                                             "hasOwner"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 14)

        log.info("TEST: Query for all Site descendants of TestSite Obs1")
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_object_descendants(res_by_name["Obs1"],
                                         [RT.TestSite, RT.TestSite],
                                         PRED.hasTestSite))
        result = self.discovery.query(rq.get_query(), id_only=False)
        # import pprint
        # pprint.pprint(rq.get_query())
        self.assertEquals(len(result), 3)

        log.info("TEST: Query for all resources belonging to Org Org1")
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_associated_from_subject(res_by_name["Org1"], None,
                                              "hasResource"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 13)

        log.info(
            "TEST: Query for all resources belonging to Org Org1 AND of type TestInstrument"
        )
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_associated_from_subject(res_by_name["Org1"], None,
                                              "hasResource"),
            rq.filter_type(RT.TestInstrument))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 2)

        log.info(
            "TEST: Query for instruments whose platform parent has a name of PDC1"
        )
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_type(RT.TestInstrument),
            rq.filter_associated_from_subject(
                subject_type=RT.TestPlatform,
                predicate=PRED.hasTestDevice,
                target_filter=rq.filter_name("PDC1")))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 1)
        self.assertEquals(result[0].name, "ID1")

        log.info(
            "TEST: Query for instruments in Org1 whose platform parent has a specific attribute set"
        )
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_type(RT.TestInstrument),
            rq.filter_associated_from_subject(res_by_name["Org1"], None,
                                              "hasResource"),
            rq.filter_associated_from_subject(
                subject_type=RT.TestPlatform,
                predicate=PRED.hasTestDevice,
                target_filter=rq.filter_name("PDC1")))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 1)
        self.assertEquals(result[0].name, "ID1")

        log.info(
            "TEST: Query for instruments in Org1 that are lcstate INTEGRATED")
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_type(RT.TestInstrument),
            rq.filter_lcstate(LCS.INTEGRATED),
            rq.filter_associated_from_subject(res_by_name["Org1"], None,
                                              "hasResource"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 1)
        self.assertEquals(result[0].name, "ID2")

        log.info(
            "TEST: Query for instruments in Org1 that are lcstate INTEGRATED OR platforms in Org1 that are lcstate DEPLOYED"
        )
        rq = ResourceQuery()
        rq.set_filter(
            rq.filter_or(
                rq.filter_and(rq.filter_type(RT.TestInstrument),
                              rq.filter_lcstate(LCS.INTEGRATED)),
                rq.filter_and(rq.filter_type(RT.TestPlatform),
                              rq.filter_lcstate(LCS.DEPLOYED))),
            rq.filter_associated_from_subject(res_by_name["Org1"], None,
                                              "hasResource"))
        result = self.discovery.query(rq.get_query(), id_only=False)
        self.assertEquals(len(result), 2)