Exemplo n.º 1
0
class TestFilter(unittest.TestCase):
    @patch("pdm_utils.classes.filter.isinstance")
    def setUp(self, is_instance_mock):
        is_instance_mock.return_value = True

        alchemist = Mock(spec=AlchemyHandler)
        engine = Mock(spec=Engine)
        graph = Mock(spec=Graph)
        session = Mock(spec=Session)
        mapper = Mock(spec=DeclarativeMeta)
        key = Mock(spec=Column)
        proxy = Mock()

        type(alchemist).engine = PropertyMock(return_value=engine)
        type(alchemist).graph = PropertyMock(return_value=graph)
        type(alchemist).session = PropertyMock(return_value=session)
        type(alchemist).mapper = PropertyMock(return_value=mapper)
        type(alchemist).connected = PropertyMock(return_value=True)

        engine.execute.return_value = proxy
        proxy.fetchall.return_value = []

        self.mock_isinstance = is_instance_mock
        self.mock_alchemist = alchemist
        self.mock_engine = engine
        self.mock_graph = graph
        self.mock_session = session
        self.mock_mapper = mapper
        self.mock_key = key

        self.db_filter = Filter(alchemist=alchemist, key=key)
        self.assertEqual(self.db_filter.engine, self.mock_engine)
        self.assertEqual(self.db_filter.graph, self.mock_graph)

    def test_updated_1(self):
        """Verify that the upload property portrays Filter._upload.
        """
        self.db_filter._updated = True

        self.assertTrue(self.db_filter.updated)

    def test_updated_2(self):
        """Verify that upload property is immutable.
        """
        with self.assertRaises(AttributeError):
            self.db_filter.updated = True

    def test_values_valid_1(self):
        """Verify that the values_valid property portrays Filter._values_valid.
        """
        self.db_filter._values_valid = True

        self.assertTrue(self.db_filter.values_valid)

    def test_values_valid_2(self):
        """Verify that the values_valid property is immutable.
        """
        with self.assertRaises(AttributeError):
            self.db_filter.values_valid = True

    def test_connected_1(self):
        """Verify that the connected property portrays Filter._connected.
        """
        self.db_filter._connected = True

        self.assertTrue(self.db_filter.connected)

    def test_connected_2(self):
        """Verify that the connected property is immutable.
        """
        with self.assertRaises(AttributeError):
            self.db_filter.connected = True

    def test_engine_1(self):
        """Verify that the engine property portrays Filter._engine.
        """
        self.db_filter._engine = self.mock_engine

        self.assertEqual(self.db_filter.engine, self.mock_engine)

    def test_graph_1(self):
        """Verify that the graph property portrays Filter._graph.
        """
        self.db_filter._graph = self.mock_graph

        self.assertEqual(self.db_filter.graph, self.mock_graph)

    def test_session_1(self):
        """Verify that the session property portrays Filter._session.
        """
        self.db_filter._session = self.mock_session

        self.assertEqual(self.db_filter.session, self.mock_session)

    def test_mapper_1(self):
        """Verify that the mapper property portrays Filter._mapper.
        """
        self.db_filter._mapper = self.mock_mapper

        self.assertEqual(self.db_filter.mapper, self.mock_mapper)

    def test_values_1(self):
        """Verify that the values property portrays Filter._values.
        """
        self.db_filter._values = ["Test1", "Test2"]

        self.assertEqual(self.db_filter.values, ["Test1", "Test2"])

    def test_values_2(self):
        """Verify that the values property can set Filter._values.
        """
        self.db_filter.values = ["Test1", "Test2"]

        self.assertEqual(self.db_filter.values, ["Test1", "Test2"])

    def test_values_3(self):
        """Verify that the values property modifies the values_valid property.
        """
        self.db_filter.values = ["Test1", "Test2"]

        self.assertFalse(self.db_filter.values_valid)

    def test_values_2(self):
        """Verify that the values property raises TypeError on invalid input.
        """
        with self.assertRaises(TypeError):
            self.db_filter.values = "Hello"

    def test_key_1(self):
        """Verify that the key property modifies the Filter._key
        """
        self.db_filter.key = self.mock_key

        self.assertEqual(self.db_filter.key, self.mock_key)

    def test_key_2(self):
        """Verify that the key property raises TypeError on invalid input.
        """
        with self.assertRaises(TypeError):
            self.db_filter.key = Mock()

    @patch("pdm_utils.classes.filter.AlchemyHandler")
    def test_connect_1(self, alchemyhandler_mock):
        """Verfiy that connect() returns when Filter is already connected.
        """
        alchemyhandler_mock.return_value = self.mock_alchemist

        self.db_filter._connected = True

        self.db_filter.connect()
        alchemyhandler_mock.assert_not_called()

    @patch("pdm_utils.classes.filter.AlchemyHandler")
    def test_connect_2(self, alchemyhandler_mock):
        """Verify that the Filter creates an AlchemyHandler.
        """
        alchemyhandler_mock.return_value = self.mock_alchemist

        self.db_filter._connected = False

        self.db_filter.connect()
        alchemyhandler_mock.assert_called()

    @patch("pdm_utils.classes.filter.AlchemyHandler")
    def test_connect_3(self, alchemyhandler_mock):
        """Verify that the Filter uses an AlchemyHandler to connect. 
        """
        alchemyhandler_mock.return_value = self.mock_alchemist

        self.db_filter._connected = False

        self.db_filter.connect()

        self.mock_alchemist.connect.assert_called()

    @patch("pdm_utils.classes.filter.isinstance")
    def test_link_1(self, isinstance_mock):
        """Verify link() calls isinstance().
        """
        self.db_filter.link(self.mock_alchemist)

        isinstance_mock.assert_called()

    def test_link_2(self):
        """Verify link() raises TypeError upon bad alchemist input.
        """
        with self.assertRaises(TypeError):
            self.db_filter.link("Bad input")

    def test_link_3(self):
        """Verify function structure of link().
        """
        type(self.mock_alchemist).connected = PropertyMock(return_value=False)
        type(self.mock_alchemist).graph = PropertyMock(return_value=None)

        self.db_filter.link(self.mock_alchemist)

        self.mock_alchemist.connect.assert_called()

    @patch("pdm_utils.classes.filter.Filter.connect")
    def test_check_1(self, connect_mock):
        """Verify that the Filter will connect if not connected.
        """
        self.db_filter._connected = False

        self.db_filter.check()

        connect_mock.assert_called()

    @patch("pdm_utils.classes.filter.isinstance")
    def test_check_2(self, is_instance_mock):
        """Verify that the Filter calls isinstance() with correct paremeters.
        """
        is_instance_mock.return_value = True

        self.db_filter.check()

        is_instance_mock.assert_any_call(self.mock_engine, Engine)
        is_instance_mock.assert_any_call(self.mock_graph, Graph)
        is_instance_mock.assert_any_call(self.mock_key, Column)

    def test_check_3(self):
        """Verify that the Filter raises AttributeError with an invalid engine.
        """
        self.db_filter._engine = "Not a valid engine"

        with self.assertRaises(AttributeError):
            self.db_filter.check()

    def test_check_4(self):
        """Verify that the Filter raises AttributeError with an invalid graph.
        """
        self.db_filter._graph = "Not a valid graph"

        with self.assertRaises(AttributeError):
            self.db_filter.check()

    def test_check_5(self):
        """Verify that the Filter raises AttibuteError with an invalid key.
        """
        self.db_filter._key = "Not a valid key"

        with self.assertRaises(AttributeError):
            self.db_filter.check()

    @patch("pdm_utils.classes.filter.q.build_distinct")
    @patch("pdm_utils.classes.filter.isinstance")
    def test_build_values_1(self, is_instance_mock, build_distinct_mock):
        """Verify that build_distinct() is called with correct parameters.
        """
        is_instance_mock.return_value = True
        self.db_filter.build_values(where="Not a list")

        build_distinct_mock.assert_called_with(self.mock_graph,
                                               self.mock_key,
                                               where="Not a list",
                                               add_in=self.mock_key)

    @patch("pdm_utils.classes.filter.Filter.check")
    def test_transpose_1(self, check_mock):
        """Verify that transpose() returns without values.
        """
        self.db_filter.transpose("gene.Notes")

        check_mock.assert_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    def test_mass_transpose_1(self, check_mock):
        """Verify that mass_tranpose() returns without values.
        """
        self.db_filter.mass_transpose("Column")

        check_mock.assert_called()

    @patch("pdm_utils.classes.filter.q.build_distinct")
    @patch("pdm_utils.classes.filter.Filter.check")
    def test_retrieve_1(self, check_mock, build_distinct_mock):
        """Verify that retrieve() returns without values.
        """
        self.db_filter.retrieve("Column")

        check_mock.assert_called()
        build_distinct_mock.assert_not_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_refresh_1(self, build_values_mock, check_mock):
        """Verify that refresh() returns without values.
        """
        self.db_filter.refresh()

        check_mock.assert_called()
        build_values_mock.assert_not_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_refresh_2(self, build_values_mock, check_mock):
        """Verify that refresh() calls build_values() and conserves values.
        """
        build_values_mock.return_value = ["Phage"]

        self.db_filter._values_valid = False
        self.db_filter.refresh()

        check_mock.assert_called()
        build_values_mock.assert_called()

        self.assertTrue(self.db_filter.values_valid)
        self.assertEqual(self.db_filter.values, ["Phage"])

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.refresh")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_update_1(self, build_values_mock, Refresh, check_mock):
        """Verify update() returns without values.
        """
        self.db_filter.update()

        check_mock.assert_called()
        Refresh.assert_not_called()
        build_values_mock.assert_not_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.refresh")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_update_2(self, build_values_mock, Refresh, check_mock):
        """Verify update() refreshes values before updating.
        """
        self.db_filter._values_valid = False

        self.db_filter.update()

        check_mock.assert_called()
        Refresh.assert_called()
        build_values_mock.assert_not_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.refresh")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_update_3(self, build_values_mock, Refresh, check_mock):
        """Verify function structure of update().
        """
        self.db_filter._values_valid = False
        self.db_filter._updated = False

        self.db_filter.update()

        check_mock.assert_called()
        Refresh.assert_called()
        build_values_mock.assert_called()

        self.assertTrue(self.db_filter._values_valid)
        self.assertTrue(self.db_filter._values_valid)

    @patch("pdm_utils.classes.filter.q.first_column")
    @patch("pdm_utils.classes.filter.q.build_select")
    @patch("pdm_utils.classes.filter.Filter.get_column")
    def test_sort_1(self, get_column_mock, build_select_mock,
                    first_column_mock):
        """Verify function structure of sort().
        """
        self.db_filter._values_valid = False

        first_column_mock.return_value = ["Phage"]

        self.db_filter.sort("column")

        get_column_mock.assert_called()
        build_select_mock.assert_called()
        first_column_mock.assert_called()

        self.assertTrue(self.db_filter._values_valid)
        self.assertEqual(self.db_filter.values, ["Phage"])

    def test_sort_2(self):
        """Verify that sort() raises TypeError at bad ORDER BY input.
        """
        with self.assertRaises(TypeError):
            self.db_filter.sort(None)

    def test_reset_1(self):
        """Verify that reset() clears filters.
        """
        self.db_filter._filters = [{"Expression": "Some Whereclause"}]

        self.db_filter.reset()

        self.assertEqual(self.db_filter.filters, [])

    def test_reset_2(self):
        """Verify that reset() clears values.
        """
        self.db_filter._values = ["Phage1", "Phage2", "Phage3"]

        self.db_filter.reset()

        self.assertEqual(self.db_filter.values, [])

    def test_reset_3(self):
        """Verify that reset() sets values_valid Filter property.
        """
        self.db_filter._values_valid = False

        self.db_filter.reset()

        self.assertTrue(self.db_filter.values_valid)

    def test_reset_4(self):
        """Verify that reset() sets updated Filter property.
        """
        self.db_filter._updated = False

        self.db_filter.reset()

        self.assertTrue(self.db_filter.updated)

    def test_reset_5(self):
        """Verify that reset sets on_index property.
        """
        self.db_filter._on_index = 5

        self.db_filter.reset()

        self.assertEqual(self.db_filter.or_index, -1)

    def test_hits_1(self):
        """Verify that hits() accurately portrays no values.
        """
        self.assertEqual(self.db_filter.hits(), 0)

    def test_hits_2(self):
        """Verify that hits() accurately portrays a number of values.
        """
        self.db_filter._values = ["Phage1", "Phage2", "Phage3"]

        self.assertEqual(self.db_filter.hits(), 3)

    def test_copy_1(self):
        """Verify that copy() reflects a Filter's updated property.
        """
        self.db_filter._updated = False

        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.updated, self.db_filter.updated)

    def test_copy_2(self):
        """Verify that copy() reflects a Filter's values_valid property.
        """
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.values_valid, self.db_filter.values_valid)

    def test_copy_3(self):
        """Verify that copy() reflects a Filter's filters property.
        """
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.filters, self.db_filter.filters)

    def test_copy_4(self):
        """Verify that copy() reflects a Filter's engine property.
        """
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.engine, self.db_filter.engine)

    def test_copy_5(self):
        """Verify that copy() reflects a Filter's graph property.
        """
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.graph, self.db_filter.graph)

    def test_copy_6(self):
        """Verify that copy() reflects a Fitler's key property.
        """
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.key, self.db_filter.key)

    def test_copy_7(self):
        """Verify that copy() reflects a Filter's values property.
        """
        self.db_filter._values = ["Values"]

        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.values, self.db_filter.values)

    def test_copy_8(self):
        """Verify that copy() reflects a Filter's connected property.
        """
        self.db_filter._connected = True
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter._connected, self.db_filter._connected)

    def test_copy_filters_1(self):
        """Verify that copy_filters() replicates filters.
        """
        self.db_filter._filters = [{
            "Filter1": "Filter1",
            "Filter2": "Filter2",
            "Filter3": "Filter3"
        }]

        filters_copy = self.db_filter.copy_filters()

        self.assertEqual(filters_copy, self.db_filter._filters)

    def test_copy_filters_2(self):
        """Verify that copy_filters() creates new address for copied filters.
        """
        self.db_filter._filters = [{
            "Filter1": "Filter1",
            "Filter2": "Filter2",
            "Filter3": "Filter3"
        }]

        filters_copy = self.db_filter.copy_filters()

        self.db_filter._filters[0].update({"Filter2": "filter2"})

        self.assertNotEqual(filters_copy, self.db_filter._filters)
Exemplo n.º 2
0
class TestFilter(unittest.TestCase):
    @patch("pdm_utils.classes.filter.isinstance")
    def setUp(self, IsInstance):
        IsInstance.return_value = True

        alchemist = Mock()
        engine = Mock()
        graph = Mock()
        key = Mock()

        alchemist.engine.return_value = engine
        alchemist.graph.return_value = graph
        alchemist.connected.return_value = True

        self.mock_isinstance = IsInstance
        self.mock_alchemist = alchemist
        self.mock_engine = engine
        self.mock_graph = graph
        self.mock_key = key

        self.db_filter = Filter(alchemist=alchemist, key=key)

    def test_constructor_1(self):
        db_filter = Filter()

    def test_constructor_2(self):
        self.mock_isinstance.assert_any_call(self.mock_alchemist,
                                             AlchemyHandler)
        self.mock_isinstance.assert_any_call(self.mock_key, Column)

    def test_values_1(self):
        self.db_filter.values = ["Test1", "Test2"]
        self.assertFalse(self.db_filter.values_valid)

    def test_values_2(self):
        with self.assertRaises(TypeError):
            self.db_filter.values = "Hello"

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.q.build_distinct")
    def test_transpose_2(self, BuildDistinct, Check):
        empty_values = self.db_filter.transpose("gene.Notes")

        self.assertEqual(empty_values, [])

        BuildDistinct.assert_not_called()
        Check.assert_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.transpose")
    def test_retrieve_1(self, Transpose, Check):
        empty_data = self.db_filter.retrieve("Error")

        self.assertEqual(empty_data, {})

        Transpose.assert_not_called()
        Check.assert_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_refresh_1(self, BuildValues, Check):
        self.db_filter.refresh()

        Check.assert_called()
        BuildValues.assert_not_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_refresh_2(self, BuildValues, Check):
        BuildValues.return_value = ["Phage"]

        self.db_filter._values_valid = False
        self.db_filter.refresh()

        Check.assert_called()
        BuildValues.assert_called()

        self.assertTrue(self.db_filter.values_valid)
        self.assertEqual(self.db_filter.values, ["Phage"])

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.refresh")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_update_1(self, BuildValues, Refresh, Check):
        self.db_filter.update()

        Check.assert_called()
        Refresh.assert_not_called()
        BuildValues.assert_not_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.refresh")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_update_2(self, BuildValues, Refresh, Check):
        self.db_filter._values_valid = False

        self.db_filter.update()

        Check.assert_called()
        Refresh.assert_called()
        BuildValues.assert_not_called()

    @patch("pdm_utils.classes.filter.Filter.check")
    @patch("pdm_utils.classes.filter.Filter.refresh")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_update_3(self, BuildValues, Refresh, Check):
        self.db_filter._values_valid = False
        self.db_filter._updated = False

        self.db_filter.update()

        Check.assert_called()
        Refresh.assert_called()
        BuildValues.assert_called()

        self.assertTrue(self.db_filter._values_valid)
        self.assertTrue(self.db_filter._values_valid)

    @patch("pdm_utils.classes.filter.isinstance")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_sort_1(self, BuildValues, IsInstance):
        IsInstance.return_value = True
        BuildValues.return_value = ["Phage"]

        self.db_filter._values_valid = False

        self.db_filter.sort("column")

        IsInstance.assert_called()
        BuildValues.assert_called()

        self.assertTrue(self.db_filter._values_valid)
        self.assertEqual(self.db_filter.values, ["Phage"])

    @patch("pdm_utils.classes.filter.isinstance")
    @patch("pdm_utils.classes.filter.Filter.build_values")
    def test_sort_1(self, BuildValues, IsInstance):
        IsInstance.return_value = False

        with self.assertRaises(TypeError):
            self.db_filter.sort()

    def test_reset_1(self):
        self.db_filter._filters = {"Expression": "Some Whereclause"}

        self.db_filter.reset()

        self.assertEqual(self.db_filter.filters, {})

    def test_reset_2(self):
        self.db_filter._values = ["Phage1", "Phage2", "Phage3"]

        self.db_filter.reset()

        self.assertEqual(self.db_filter.values, [])

    def test_reset_3(self):
        self.db_filter._values_valid = False

        self.db_filter.reset()

        self.assertTrue(self.db_filter.values_valid)

    def test_reset_4(self):
        self.db_filter._updated = False

        self.db_filter.reset()

        self.assertTrue(self.db_filter.updated)

    def test_hits_1(self):
        self.assertEqual(self.db_filter.hits(), 0)

    def test_hits_2(self):
        self.db_filter._values = ["Phage1", "Phage2", "Phage3"]

        self.assertEqual(self.db_filter.hits(), 3)

    def test_copy_1(self):
        self.db_filter._updated = False

        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.updated, self.db_filter.updated)

    def test_copy_2(self):
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.values_valid, self.db_filter.values_valid)

    def test_copy_3(self):
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.filters, self.db_filter.filters)

    def test_copy_4(self):
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.engine, self.db_filter.engine)

    def test_copy_5(self):
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.graph, self.db_filter.graph)

    def test_copy_6(self):
        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.key, self.db_filter.key)

    def test_copy_7(self):
        self.db_filter._values = ["Values"]

        copy_filter = self.db_filter.copy()

        self.assertEqual(copy_filter.values, self.db_filter.values)

    def test_copy_filters_1(self):
        self.db_filter._filters = {
            "Filter1": ["Filter1"],
            "Filter2": ["Filter2"],
            "Filter3": ["Filter3"]
        }

        filters_copy = self.db_filter.copy_filters()

        self.assertEqual(filters_copy, self.db_filter._filters)

    def test_copy_filters_2(self):
        self.db_filter._filters = {
            "Filter1": ["Filter1"],
            "Filter2": ["Filter2"],
            "Filter3": ["Filter3"]
        }

        filters_copy = self.db_filter.copy_filters()

        self.db_filter._filters.update({"Filter2": []})

        self.assertNotEqual(filters_copy, self.db_filter._filters)
Exemplo n.º 3
0
class TestFilter(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        setup_test_db()

    def setUp(self):
        alchemist = AlchemyHandler()
        alchemist.username = "******"
        alchemist.password = "******"
        alchemist.database = "test_db"
        alchemist.connect()
        alchemist.build_graph()
        self.alchemist = alchemist

        self.db_filter = Filter(alchemist=self.alchemist)

        phageid = self.alchemist.get_column("phage.PhageID")
        self.phageid = phageid

    def test_constructor_1(self):
        db_filter = Filter(alchemist=self.alchemist)

    def test_constructor_2(self):
        self.assertTrue(isinstance(self.db_filter.graph, Graph))
        self.assertTrue(isinstance(self.db_filter.engine, Engine))

    def test_add_1(self):
        self.db_filter.add("phage.PhageID=Myrna")
        self.assertTrue("phage.PhageID=" in self.db_filter.filters.keys())

    def test_add_2(self):
        self.db_filter.add("phage.PhageID=Myrna")
        where_clauses = self.db_filter.filters["phage.PhageID="]
        self.assertTrue(isinstance(where_clauses, list))
        self.assertTrue(isinstance(where_clauses[0], BinaryExpression))

    def test_add_3(self):
        self.db_filter.add("phage.PhageID=Myrna")
        self.db_filter.add("phage.PhageID=D29")
        where_clauses = self.db_filter.filters["phage.PhageID="]
        self.assertEqual(len(where_clauses), 2)

    def test_remove_1(self):
        self.db_filter.add("phage.PhageID=Myrna")
        self.db_filter.remove("phage.PhageID=Myrna")
        self.assertEqual(self.db_filter.filters, {})

    def test_remove_2(self):
        self.db_filter.add("phage.PhageID=Myrna")
        self.db_filter.add("phage.PhageID=D29")
        self.db_filter.remove("phage.PhageID=Myrna")
        where_clauses = self.db_filter.filters["phage.PhageID="]
        self.assertTrue(len(where_clauses) == 1)
        self.assertEqual(where_clauses[0].right.value, "D29")

    def test_build_where_clauses_1(self):
        self.db_filter.add("phage.PhageID=Myrna")
        self.db_filter.add("phage.PhageID=D29")

        queries = self.db_filter.build_where_clauses()

        self.assertEqual(len(queries), 2)

    def test_build_where_clauses_2(self):
        self.db_filter.add("phage.PhageID=Myrna")
        self.db_filter.add("phage.PhageID=D29")

        queries = self.db_filter.build_where_clauses()

        for query in queries:
            self.assertTrue(isinstance(query, BinaryExpression))

    def test_build_values_1(self):
        self.db_filter.key = self.phageid

        self.db_filter.values = ["Myrna", "D29"]
        values = self.db_filter.build_values()

        self.assertTrue("Myrna" in values)
        self.assertTrue("D29" in values)

    def test_transpose_1(self):
        self.db_filter.values = ["Myrna"]
        self.db_filter.key = self.phageid

        self.db_filter.refresh()

        host_genera = self.db_filter.transpose("phage.HostGenus")

        self.assertEqual(host_genera, ["Mycobacterium"])

    def test_retrieve_1(self):
        self.db_filter.values = ["Myrna"]
        self.db_filter.key = self.phageid

        self.db_filter.refresh()

        myrna_data = self.db_filter.retrieve(
            ["phage.HostGenus", "phage.Cluster", "gene.Notes"])

        self.assertTrue(len(myrna_data) == 3)
        self.assertTrue(isinstance(myrna_data, dict))

        self.assertEqual(myrna_data["HostGenus"], ["Mycobacterium"])
        self.assertEqual(myrna_data["Cluster"], ["C"])

    def test_refresh_2(self):
        self.db_filter.key = self.phageid
        self.db_filter.values = ["Myrna", "D29", "Sheetz"]
        self.db_filter.refresh()

        self.assertTrue("Myrna" in self.db_filter.values)
        self.assertTrue("D29" in self.db_filter.values)
        self.assertFalse("Sheetz" in self.db_filter.values)

    def test_update_1(self):
        self.db_filter.key = self.phageid
        self.db_filter.values = ["Myrna", "D29"]
        self.db_filter.add("phage.PhageID=Myrna")
        self.db_filter.update()

        self.assertTrue("Myrna" in self.db_filter.values)
        self.assertFalse("D29" in self.db_filter.values)

    def test_sort_1(self):
        self.db_filter.key = self.phageid
        self.db_filter.values = ["Myrna", "D29"]
        self.db_filter.sort(self.phageid)

        self.assertTrue("Myrna" in self.db_filter.values)
        self.assertTrue("D29" in self.db_filter.values)
        self.assertEqual(self.db_filter.values[0], "D29")

    def test_group_1(self):
        self.db_filter.key = self.phageid
        self.db_filter.values = ["Myrna", "D29"]
        group_results = self.db_filter.group(self.phageid)

        self.assertTrue("Myrna" in group_results.keys())
        self.assertTrue("Myrna" in group_results["Myrna"])

        self.assertTrue("D29" in group_results.keys())
        self.assertTrue("D29" in group_results.keys())

    def test_group_2(self):
        self.db_filter.key = self.phageid
        self.db_filter.values = ["Myrna", "D29"]
        group_results = self.db_filter.group("phage.HostGenus")

        self.assertTrue("Mycobacterium" in group_results.keys())

        self.assertTrue("Myrna" in group_results["Mycobacterium"])
        self.assertTrue("D29" in group_results["Mycobacterium"])

    @classmethod
    def tearDownClass(self):
        teardown_test_db()
Exemplo n.º 4
0
class TestFilter(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        test_db_utils.create_filled_test_db()

    @classmethod
    def tearDownClass(self):
        test_db_utils.remove_db()

    def setUp(self):
        alchemist = AlchemyHandler()
        alchemist.username=user
        alchemist.password=pwd
        alchemist.database=db
        alchemist.connect()
        self.alchemist = alchemist

        self.db_filter = Filter(alchemist=self.alchemist)

        self.phage = self.alchemist.metadata.tables["phage"]
        self.gene = self.alchemist.metadata.tables["gene"]
        self.trna = self.alchemist.metadata.tables["trna"]

        self.PhageID = self.phage.c.PhageID
        self.Cluster = self.phage.c.Cluster
        self.Subcluster = self.phage.c.Subcluster
        
        self.Notes = self.gene.c.Notes

    def tearDown(self):
        self.alchemist.clear()

    def test_and__1(self):
        """Verify that and_() creates a dictionary key as expected.
        """
        self.db_filter.and_("phage.PhageID=Myrna")

        or_block = self.db_filter.filters[0]
        self.assertTrue("phage.PhageID=Myrna" in or_block.keys())

    def test_and__2(self):
        """Verify that and_() stores BinaryExpression data as expected.
        """

        self.db_filter.and_("phage.PhageID=Myrna")

        or_block = self.db_filter.filters[0]
        self.assertTrue(isinstance(or_block, dict))

        where_clauses = or_block["phage.PhageID=Myrna"]
        self.assertTrue(isinstance(where_clauses, BinaryExpression))

    def test_and_3(self):
        """Verify that and_() recognizes previous and_() data.
        """
        self.db_filter.and_("phage.PhageID =  Myrna")
        self.db_filter.and_("phage.PhageID=Myrna")
        self.db_filter.and_("phage.PhageID=D29")

        or_block = self.db_filter.filters[0]
        self.assertEqual(len(or_block), 2)

    def test_remove_1(self):
        """Verify that remove() removes dictionary entry after depleted.
        """
        self.db_filter.and_("phage.PhageID=Myrna")
        self.db_filter.remove("phage.PhageID=Myrna")
        self.assertEqual(self.db_filter.filters, [{}])

    def test_remove_2(self):
        """Verify that remove() conserves dictionary entry if not depleted.
        """
        self.db_filter.and_("phage.PhageID=Myrna")
        self.db_filter.and_("phage.PhageID=D29")

        self.db_filter.remove("phage.PhageID=Myrna")

        or_block = self.db_filter.filters[0]
        where_clauses = or_block["phage.PhageID=D29"]

        self.assertEqual(where_clauses.right.value, "D29")

    def test_add_1(self):
        """Verify that add() creates a dictionary key as expected.
        """
        self.db_filter.add("phage.PhageID=Myrna")

        or_block = self.db_filter.filters[0]
        self.assertTrue("phage.PhageID=Myrna" in or_block.keys())

    def test_add_2(self):
        """Verify that add() creates multiple keys as expected.
        """
        self.db_filter.add("phage.PhageID=Myrna AND phage.PhageID = Trixie")

        or_block = self.db_filter.filters[0]

        self.assertTrue(len(or_block) == 2)

        self.assertTrue("phage.PhageID=Myrna" in or_block.keys())
        self.assertTrue("phage.PhageID=Trixie" in or_block.keys())

    def test_add_3(self):
        """Verify that add() creates multiple or blocks as expected.
        """
        self.db_filter.add("phage.PhageID=Myrna OR phage.PhageID = Trixie")

        self.assertTrue(len(self.db_filter.filters) == 2)

        first_or_block = self.db_filter.filters[0]
        second_or_block = self.db_filter.filters[1]

        self.assertTrue("phage.PhageID=Myrna" in first_or_block.keys())
        self.assertFalse("phage.PhageID=Trixie" in first_or_block.keys())

        self.assertFalse("phage.PhageID=Myrna" in second_or_block.keys())
        self.assertTrue("phage.PhageID=Trixie" in second_or_block.keys())


    def test_get_column_1(self):
        """Verify that get_column() converts string column input.
        """
        self.db_filter.key = self.Cluster

        column = self.db_filter.get_column("phage.PhageID")

        self.assertEqual(column, self.PhageID)

    def test_get_column_2(self):
        """Verify that get_column() conserves Column input.
        """
        self.db_filter.key = self.Cluster

        column = self.db_filter.get_column(self.PhageID)

        self.assertEqual(column, self.PhageID)

    def test_get_column_3(self):
        """Verify that get_column() raises TypeError.
        get_column() should raise TypeError when column input is
        neither a string or a Column.
        """
        self.db_filter.key = self.Cluster

        with self.assertRaises(TypeError):
            self.db_filter.get_column(None)

    def test_build_where_clauses_1(self):
        """Verify that build_where_clauses() forms list of expected length.
        """
        self.db_filter.and_("phage.PhageID=Myrna")
        self.db_filter.and_("phage.PhageID=D29")

        queries = self.db_filter.build_where_clauses()

        self.assertEqual(len(queries[0]), 2)

    def test_build_where_clauses_2(self):
        """Verify that build_where_clauses() forms list of BinaryExpressions.
        """
        self.db_filter.and_("phage.PhageID=Myrna")
        self.db_filter.and_("phage.PhageID=D29")

        queries = self.db_filter.build_where_clauses()

        for query in queries:
            self.assertTrue(isinstance(query, BooleanClauseList))

    def test_build_values_1(self):
        """Verify that build_values() does not exclude values as expected.
        """
        self.db_filter.key = self.PhageID

        values = self.db_filter.build_values()

        self.assertTrue("Myrna" in values)
        self.assertTrue("D29" in values)
        self.assertTrue("Alice" in values)
        self.assertTrue("Trixie" in values)

    def test_build_values_2(self):
        """Verify that build_values() utilizes WHERE clauses as expected.
        """
        self.db_filter.key = self.PhageID

        where_clause = (self.Cluster == "A")
        values = self.db_filter.build_values(where=where_clause)

        self.assertTrue("D29" in values)
        self.assertTrue("Trixie" in values)
        self.assertFalse("Myrna" in values)
        self.assertFalse("Alice" in values)

    def test_build_values_3(self):
        """Verify that build_values() creates DISTINCT values as expected.
        """
        self.db_filter.key = self.Cluster

        where_clause = (self.Subcluster == "A2")
        values = self.db_filter.build_values(where=where_clause)

        self.assertEqual(len(values), 1)
        self.assertEqual(values, ["A"])

    def test_build_values_4(self):
        """Verify that build_values() recognizes bytes-type column data.
        """
        self.db_filter.key = self.Notes

        values = self.db_filter.build_values()

        self.assertTrue(isinstance(values[0], str))

    def test_query_1(self):
        """Verify that query() creates instances as expected.
        """
        self.db_filter.key = "phage.PhageID"
        self.db_filter.values = ["Trixie", "D29"]
        self.db_filter.refresh()

        instances = self.db_filter.query("phage")

        instance_ids = []
        for instance in instances:
            instance_ids.append(instance.PhageID)

        self.assertTrue("Trixie" in instance_ids)
        self.assertTrue("D29" in instance_ids)
        self.assertFalse("Myrna" in instance_ids)

    def test_query_2(self):
        """Verify that query() creates instances as expected.
        """
        self.db_filter.key = "phage.PhageID"
        self.db_filter.values = ["Trixie", "D29"]
        self.db_filter.refresh()

        instances = self.db_filter.query("gene")

        instance_ids = set()

        for instance in instances:
            instance_ids.add(instance.phage.PhageID)

        instance_ids = list(instance_ids)

        self.assertTrue("Trixie" in instance_ids)
        self.assertTrue("D29" in instance_ids)
        self.assertFalse("Myrna" in instance_ids)

    def test_transpose_1(self):
        """Verify that transpose() utilizes Filter values as expected.
        """
        self.db_filter.values = ["Myrna"]
        self.db_filter.key = self.PhageID

        self.db_filter.refresh()

        clusters = self.db_filter.transpose("phage.Cluster")

        self.assertEqual(clusters, ["C"])

    def test_transpose_2(self):
        """Verify that transpose() can optionally create dict return value.
        """
        self.db_filter.values = ["Myrna"]
        self.db_filter.key = self.PhageID

        self.db_filter.refresh()

        clusters_dict = self.db_filter.transpose(self.Cluster, return_dict=True)

        self.assertEqual(clusters_dict["Cluster"], ["C"])

    def test_transpose_3(self):
        """Verify that transpose() can alter Filter properties as expected.
        """
        self.db_filter.values = ["Myrna"]
        self.db_filter.key = self.PhageID

        self.db_filter.refresh()

        self.db_filter.transpose("phage.Cluster", set_values=True)

        self.assertEqual(self.db_filter.key, self.Cluster)
        self.assertEqual(self.db_filter.values, ["C"])

    def test_transpose_4(self):
        """Verify that transpose() filter parameter functions as expected.
        """
        self.db_filter.values = ["Myrna", "D29"]
        self.db_filter.key = self.PhageID

        self.db_filter.add("gene.GeneID = Myrna_CDS_28")
        values = self.db_filter.transpose("gene.GeneID", filter=True)

        self.assertEqual(len(values), 1)
        self.assertEqual(values[0], "Myrna_CDS_28")

    def test_mass_transpose_1(self):
        """Verify that mass_tranpose() returns DISTINCT values as expected.
        """
        self.db_filter.values = ["Myrna"]
        self.db_filter.key = self.PhageID

        self.db_filter.refresh()

        myrna_data = self.db_filter.mass_transpose(["phage.HostGenus",
                                              "phage.Cluster",
                                              "gene.Notes"])

        self.assertTrue(len(myrna_data) == 3 )
        self.assertTrue(isinstance(myrna_data, dict))

        self.assertEqual(myrna_data["HostGenus"], ["Mycobacterium"])
        self.assertEqual(myrna_data["Cluster"], ["C"])

    def test_mass_transpose_2(self):
        """Verify that mass_tranpose() utilizes all values as expected.
        """
        self.db_filter.values = ["Myrna", "Trixie"]
        self.db_filter.key = self.PhageID

        self.db_filter.refresh()

        data = self.db_filter.mass_transpose(["phage.HostGenus",
                                        "phage.Cluster",
                                        "gene.Notes"])

        self.assertTrue(len(data) == 3)
        self.assertTrue(isinstance(data, dict))

        self.assertEqual(data["HostGenus"], ["Mycobacterium"])
        self.assertEqual(data["Cluster"], ["C", "A"])

    def test_retrieve_1(self):
        """Verify that retrieve() separates data as expected.
        """
        self.db_filter.values = ["Myrna", "Trixie"]
        self.db_filter.key = self.PhageID

        self.db_filter.refresh()

        data = self.db_filter.retrieve(["phage.HostGenus",
                                        "phage.Cluster"])

        myrna_data = data["Myrna"]
        self.assertEqual(myrna_data["HostGenus"], ["Mycobacterium"])
        self.assertEqual(myrna_data["Cluster"], ["C"])

        trixie_data = data["Trixie"]
        self.assertEqual(trixie_data["HostGenus"], ["Mycobacterium"])
        self.assertEqual(trixie_data["Cluster"], ["A"])

    def test_retrieve_2(self):
        """Verify that retrieve() separates data as expected.
        """
        self.db_filter.values = ["A", "C"]
        self.db_filter.key = self.Cluster

        self.db_filter.refresh()

        data = self.db_filter.retrieve(["phage.Cluster", "phage.PhageID"])

        a_data = data["A"]
        self.assertEqual(a_data["Cluster"], ["A"])
        self.assertTrue("Trixie" in a_data["PhageID"])
        self.assertFalse("Myrna" in a_data["PhageID"])

        c_data = data["C"]
        self.assertEqual(c_data["Cluster"], ["C"])
        self.assertFalse("Trixie" in c_data["PhageID"])
        self.assertTrue("Myrna" in c_data["PhageID"])
    
    def test_refresh_1(self):
        """Verify that refresh() eliminates invalid data.
        """
        self.db_filter.key = self.PhageID
        self.db_filter.values = ["Myrna", "D29", "Sheetz"]
        self.db_filter.refresh()

        self.assertTrue("Myrna" in self.db_filter.values)
        self.assertTrue("D29" in self.db_filter.values)
        self.assertFalse("Sheetz" in self.db_filter.values)

    def test_update_1(self):
        """Verify that update() filters out values.
        """
        self.db_filter.key = self.PhageID
        self.db_filter.values = ["Myrna", "D29"]
        self.db_filter.and_("phage.PhageID=Myrna")
        self.db_filter.update()

        self.assertTrue("Myrna" in self.db_filter.values)
        self.assertFalse("D29" in self.db_filter.values)

    def test_sort_1(self):
        """Verify that sort() orders values as expected.
        """
        self.db_filter.key = self.PhageID
        self.db_filter.values = ["Myrna", "D29"]
        self.db_filter.sort(self.PhageID)

        self.assertTrue("Myrna" in self.db_filter.values)
        self.assertTrue("D29" in self.db_filter.values)
        self.assertEqual(self.db_filter.values[0], "D29")

    def test_sort_2(self):
        """Verify that sort() orders values with multiple sort columns.
        """
        self.db_filter.key = self.PhageID
        self.db_filter.values = ["Myrna", "D29", "Alice"]
        self.db_filter.sort([self.Cluster, self.PhageID])

        self.assertTrue("Myrna" in self.db_filter.values)
        self.assertTrue("D29" in self.db_filter.values)
        self.assertTrue("Alice" in self.db_filter.values)
        
        self.assertEqual(self.db_filter.values[0], "D29")
        self.assertEqual(self.db_filter.values[1], "Alice")

    def test_group_1(self):
        """Verify that group() creates separate groups as expected.
        """
        self.db_filter.key = self.PhageID
        self.db_filter.values = ["Myrna", "D29"]
        group_results = self.db_filter.group(self.PhageID)

        self.assertTrue("Myrna" in group_results.keys())
        self.assertTrue("Myrna" in group_results["Myrna"])

        self.assertTrue("D29" in group_results.keys())
        self.assertTrue("D29" in group_results["D29"])

    def test_group_2(self):
        """Verify that group() recognizes similarities in values as expected.
        """
        self.db_filter.key = self.PhageID
        self.db_filter.values = ["Myrna", "D29"]
        group_results = self.db_filter.group("phage.HostGenus")

        self.assertTrue("Mycobacterium" in group_results.keys())

        self.assertTrue("Myrna" in group_results["Mycobacterium"])
        self.assertTrue("D29" in group_results["Mycobacterium"])

    def test_group_3(self):
        """Verify that group() recognizes differences in values as expected.
        """
        self.db_filter.key = self.PhageID
        self.db_filter.values = ["Myrna", "D29", "Trixie"]
        group_results = self.db_filter.group("phage.Cluster")

        self.assertTrue("A" in group_results.keys())
        self.assertTrue("C" in group_results.keys())

        self.assertTrue("Myrna" in group_results["C"])
        self.assertTrue("D29" in group_results["A"])
        self.assertTrue("Trixie" in group_results["A"])