def test_buy_product__not_existing_product():
    session = MagicMock()
    session.query().all.return_value = []
    session.query().filter_by().first.return_value = None

    bought, data = buy_product(session, "invalid_product_name")

    assert not bought and data == {"display": "INVALID PRODUCT"}
Ejemplo n.º 2
0
 def test_remove_files_max_size(self):
     f1, f2 = MagicMock(), MagicMock()
     session = MagicMock()
     session.query().filter().subquery().c.total = 50
     session.query().filter().all.return_value = [f1, f2]
     res = module.File.remove_files_max_size(10, session)
     self.assertEqual(res, 2)
     f1.remove_file_from_fs.assert_called_once()
     f2.remove_file_from_fs.assert_called_once()
Ejemplo n.º 3
0
 def test_find_by_name(self, m_Tag, m_File):
     m_session = MagicMock()
     name = "something"
     tag = MagicMock()
     tag.id = randint(0, 10)
     tags = [tag.id]
     FileExt.query_find_by_name(name, tags, m_session)
     m_session.query.called_with(m_Tag)
     m_session.query().filter_by.assert_called_once_with(id=tag.id)
     m_session.query().filter_by().one.assert_called_once()
Ejemplo n.º 4
0
 def test_find_by_name(self, m_Tag, m_File):
     m_session = MagicMock()
     name = "something"
     tag = MagicMock()
     tag.id = randint(0, 10)
     tags = [tag.id]
     FileExt.query_find_by_name(name, tags, m_session)
     m_session.query.called_with(m_Tag)
     m_session.query().filter_by.assert_called_once_with(id=tag.id)
     m_session.query().filter_by().one.assert_called_once()
Ejemplo n.º 5
0
 def test_find_by_hash(self, m_Tag, m_File):
     m_session = MagicMock()
     hash_type, hash = "something", "anotherthing"
     tag = MagicMock()
     tag.id = randint(0, 10)
     tags = [tag.id]
     FileExt.query_find_by_hash(hash_type, hash, tags, m_session)
     m_session.query.called_with(FileExt)
     m_session.query().filter_by.assert_called_once_with(id=tag.id)
     m_session.query().filter_by().one.assert_called_once()
Ejemplo n.º 6
0
 def test_find_by_hash(self, m_Tag, m_File):
     m_session = MagicMock()
     hash_type, hash = "something", "anotherthing"
     tag = MagicMock()
     tag.id = randint(0, 10)
     tags = [tag.id]
     FileExt.query_find_by_hash(hash_type, hash, tags, m_session)
     m_session.query.called_with(FileExt)
     m_session.query().filter_by.assert_called_once_with(id=tag.id)
     m_session.query().filter_by().one.assert_called_once()
Ejemplo n.º 7
0
 def test004_list_custom_request(self, m_scan_schema):
     db_mock = MagicMock()
     offset, limit = randint(1, 100), randint(1, 100)
     expected = {"total": db_mock.query().count(),
                 "offset": offset,
                 "limit": limit,
                 "data": m_scan_schema.dump().data}
     api_scans.request.query.offset = offset
     api_scans.request.query.limit = limit
     result = api_scans.list(db_mock)
     self.assertEqual(result, expected)
     db_mock.query().count.assert_called()
Ejemplo n.º 8
0
 def test004_list_custom_request(self, m_scan_schema):
     db_mock = MagicMock()
     offset, limit = randint(1, 100), randint(1, 100)
     expected = {"total": db_mock.query().options().count(),
                 "offset": offset,
                 "limit": limit,
                 "data": m_scan_schema.dump().data}
     api_scans.request.query['offset'] = offset
     api_scans.request.query['limit'] = limit
     result = api_scans.list(db_mock)
     self.assertEqual(result, expected)
     db_mock.query().options().count.assert_called()
def test_buy_product__existing_product__exactly_enough_inserted_coins():
    test_product_to_buy = MagicMock()
    test_product_to_buy.worth = 1.0

    test_product = MagicMock()
    test_product.price = 1.0

    session = MagicMock()
    session.query().all.return_value = [test_product_to_buy]
    session.query().filter_by().first.return_value = test_product

    bought, data = buy_product(session, "cola")

    assert bought and data == {"product": "cola"}
def test_buy_product__existing_product__not_enough_inserted_coins():
    test_product_to_buy = MagicMock()
    test_product_to_buy.worth = 0.25

    test_product = MagicMock()
    test_product.price = 1.0

    session = MagicMock()
    session.query().all.return_value = [test_product_to_buy]
    session.query().filter_by().first.return_value = test_product

    bought, data = buy_product(session, "cola")

    assert not bought and data == {"display": "INSERT COINS"}
Ejemplo n.º 11
0
 def test004_list_custom_request(self):
     db_mock = MagicMock()
     scan_schema_mock = MagicMock()
     offset, limit = randint(1, 100), randint(1, 100)
     expected = {"total": db_mock.query().count(),
                 "offset": offset,
                 "limit": limit,
                 "data": scan_schema_mock.dump().data}
     api_scans.request.query.offset = offset
     api_scans.request.query.limit = limit
     scan_schema = "frontend.api.controllers.scans.scan_schema"
     with patch(scan_schema, scan_schema_mock):
         result = api_scans.list(db_mock)
     self.assertEqual(result, expected)
     self.assertTrue(db_mock.query().count.called)
Ejemplo n.º 12
0
 def test010_remove_old_files(self):
     m_session = MagicMock()
     m_file = MagicMock()
     m_session.query().filter().filter().all.return_value = [m_file]
     res = File.remove_old_files(10, m_session)
     m_file.remove_file_from_fs.assert_called_once()
     self.assertEqual(res, 1)
Ejemplo n.º 13
0
class TestModelsScan(TestCase):
    def setUp(self):
        self.frontend_scanid = "frontend_scanid"
        self.user_id = "user_id"
        self.session = MagicMock()

    def test___init__(self):
        scan = Scan(self.frontend_scanid, self.user_id)
        self.assertEqual(scan.scan_id, self.frontend_scanid)
        self.assertEqual(scan.user_id, self.user_id)
        self.assertEqual(scan.status, IrmaScanStatus.empty)
        self.assertIsNotNone(scan.timestamp)

    def test_get_scan(self):
        scan_id = "scan_id"
        Scan.get_scan(scan_id, self.user_id, self.session)
        self.session.query.assert_called_once_with(Scan)
        m_filter = self.session.query(Scan).filter
        m_filter.assert_called_once()
        m_filter().one.assert_called_once()

    def test_get_scan_not_found(self):
        self.session.query.side_effect = NoResultFound
        with self.assertRaises(IrmaDatabaseResultNotFound):
            Scan.get_scan("whatever", self.user_id, self.session)

    def test_get_scan_multiple_found(self):
        self.session.query.side_effect = MultipleResultsFound
        with self.assertRaises(IrmaDatabaseError):
            Scan.get_scan("whatever", self.user_id, self.session)
Ejemplo n.º 14
0
 def test013_load_from_ext_id_multiple(self):
     m_session = MagicMock()
     external_id = "whatever"
     m_filter = m_session.query().filter
     m_filter.side_effect = MultipleResultsFound()
     with self.assertRaises(IrmaDatabaseError):
         Scan.load_from_ext_id(external_id, m_session)
Ejemplo n.º 15
0
def test_get_coin_amount():
    session = MagicMock()
    session.query().all.return_value = []

    coin_amount = get_coin_amount(session)

    assert coin_amount == 0.0
 def test_symbol_not_in_cache_no_but_got_hit_with_cache_check(self):
     mock = MagicMock()
     mock.query = MagicMock(return_value={'max_score': 437.58682, 'took': 62,
                                          'total': 5031,
                                          'hits': [{'_id': '7157',
                                                    '_score': 437.58682,
                                                    'entrezgene': '7157',
                                                    'name': 'tumor protein p53',
                                                    'symbol': 'TP53',
                                                    'taxid': 9606},
                                                   {'_id': '24842',
                                                    '_score': 306.22318,
                                                    'entrezgene': '24842',
                                                    'name': 'tumor protein p53',
                                                    'symbol': 'Tp53',
                                                    'taxid': 10116},
                                                   {'_id': '109394672',
                                                    '_score': 296.02454,
                                                    'entrezgene': '109394672',
                                                    'name': 'tumor protein p53',
                                                    'symbol': 'TP53',
                                                    'taxid': 186990},
                                                   {'_id': '113633022',
                                                    '_score': 296.02454,
                                                    'entrezgene': '113633022',
                                                    'name': 'tumor protein p53',
                                                    'symbol': 'TP53',
                                                    'taxid': 90247},
                                                   {'_id': '102169621', '_score': 296.02454, 'entrezgene': '102169621', 'name': 'tumor protein p53', 'symbol': 'TP53', 'taxid': 9925}, {'_id': '113878373', '_score': 296.02454, 'entrezgene': '113878373', 'name': 'tumor protein p53', 'symbol': 'TP53', 'taxid': 30522}, {'_id': '101285670', '_score': 296.02454, 'entrezgene': '101285670', 'name': 'tumor protein p53', 'symbol': 'TP53', 'taxid': 9733}, {'_id': '105819395', '_score': 296.02454, 'entrezgene': '105819395', 'name': 'tumor protein p53', 'symbol': 'TP53', 'taxid': 379532}, {'_id': 'ENSMMMG00000019747', '_score': 296.02454, 'name': 'tumor protein p53', 'symbol': 'TP53', 'taxid': 9994}, {'_id': '100583326', '_score': 296.02454, 'entrezgene': '100583326', 'name': 'tumor protein p53', 'symbol': 'TP53', 'taxid': 61853}]})
     searcher = GeneSymbolSearcher(bclient=mock)
     self.assertEqual('TP53', searcher.get_symbol('tp53'))
     self.assertEqual('TP53', searcher.get_symbol('tp53'))
     mock.query.assert_called_once_with('tp53')
Ejemplo n.º 17
0
class TestModelsScan(TestCase):
    def setUp(self):
        self.frontend_scanid = "frontend_scanid"
        self.nb_files = randint(10, 20)
        self.user_id = "user_id"
        self.session = MagicMock()

    def test001___init__(self):
        scan = Scan(self.frontend_scanid, self.user_id, self.nb_files)
        self.assertEqual(scan.scan_id, self.frontend_scanid)
        self.assertEqual(scan.user_id, self.user_id)
        self.assertEqual(scan.nb_files, self.nb_files)
        self.assertEqual(scan.status, IrmaScanStatus.empty)
        self.assertIsNotNone(scan.timestamp)

    def test002_get_scan(self):
        scan_id = "scan_id"
        Scan.get_scan(scan_id, self.user_id, self.session)
        self.session.query.assert_called_once_with(Scan)
        m_filter = self.session.query(Scan).filter
        m_filter.assert_called_once()
        m_filter().one.assert_called_once()

    def test003_get_scan_not_found(self):
        self.session.query.side_effect = NoResultFound
        with self.assertRaises(IrmaDatabaseResultNotFound):
            Scan.get_scan("whatever", self.user_id, self.session)

    def test004_get_scan_multiple_found(self):
        self.session.query.side_effect = MultipleResultsFound
        with self.assertRaises(IrmaDatabaseError):
            Scan.get_scan("whatever", self.user_id, self.session)
Ejemplo n.º 18
0
 def test012_load_from_ext_id_none(self):
     m_session = MagicMock()
     external_id = "whatever"
     m_filter = m_session.query().filter
     m_filter.side_effect = NoResultFound()
     with self.assertRaises(IrmaDatabaseResultNotFound):
         Scan.load_from_ext_id(external_id, m_session)
Ejemplo n.º 19
0
def setup_mock_db():
    # not setup database
    db._initialized = True
    mock_session = MagicMock()
    mock_session.query = MagicMock(
        side_effect=OperationalError(None, None, None))
    db._session = mock_session
Ejemplo n.º 20
0
 def test_remove_old_files(self):
     m_session = MagicMock()
     m_file = MagicMock()
     m_session.query().filter().filter().all.return_value = [m_file]
     res = module.File.remove_old_files(10, m_session)
     m_file.remove_file_from_fs.assert_called_once()
     self.assertEqual(res, 1)
Ejemplo n.º 21
0
class TestModelsUser(TestCase):
    def setUp(self):
        self.name = "name"
        self.rmqvhost = "rmqvhost"
        self.ftpuser = "******"
        self.session = MagicMock()

    def test001___init__(self):
        user = User(self.name, self.rmqvhost, self.ftpuser)
        self.assertEqual(user.name, self.name)
        self.assertEqual(user.rmqvhost, self.rmqvhost)
        self.assertEqual(user.ftpuser, self.ftpuser)

    def test002_get_by_rmqvhost(self):
        User.get_by_rmqvhost(self.session)
        self.session.query.assert_called_once_with(User)
        m_filter = self.session.query(User).filter
        m_filter.assert_called_once()
        m_filter().one.assert_called_once()

    def test003_get_by_rmqvhost_not_found(self):
        self.session.query.side_effect = NoResultFound
        with self.assertRaises(IrmaDatabaseResultNotFound):
            User.get_by_rmqvhost(self.session, rmqvhost="whatever")

    def test004_get_by_rmqvhost_multiple_found(self):
        self.session.query.side_effect = MultipleResultsFound
        with self.assertRaises(IrmaDatabaseError):
            User.get_by_rmqvhost(self.session, rmqvhost="whatever")
Ejemplo n.º 22
0
class TestDelNwaTenantBinding(testscenarios.WithScenarios, base.BaseTestCase):

    scenarios = [
        ('old value json is None',
         {
             'expected_return_value': False,
             'old_value_json': None
         }),
        ('old value json is 1',
         {
             'expected_return_value': True,
             'old_value_json': 1
         }),
        ('no result found',
         {
             'expected_return_value': False,
             'old_value_json': 1,
             'delete_not_found': True,
         }),
    ]

    @patch('networking_nec.nwa.l2.db_api.get_nwa_tenant_binding')
    def test_del_nwa_tenant_binding(self, gntb):
        gntb.return_value = self.old_value_json
        self.session = MagicMock()
        if getattr(self, 'delete_not_found', False):
            self.session.query().filter().delete.side_effect = NoResultFound
        rc = db_api.del_nwa_tenant_binding(self.session, TENANT_ID,
                                           NWA_TENANT_ID)
        self.assertEqual(rc, self.expected_return_value)
Ejemplo n.º 23
0
 def test_with_answer_matches_query_result(self):
     mocked_graph = MagicMock()
     query_result = ([("test",)], None, ["?s"], None, None, None)
     mocked_graph.query = MagicMock(return_value=SPARQLQueryResult(query_result))
     with patch("diderot.assertion.parse_facts", return_value=mocked_graph):
         assertion = can_answer("ASK { ?s a ?o }").from_ontology("A_ONTOLOGY").with_answer([("test",)])
         self.assertTrue(assertion.assertion_value)
Ejemplo n.º 24
0
 def test013_load_from_ext_id_multiple(self):
     m_session = MagicMock()
     external_id = "whatever"
     m_filter = m_session.query().options().filter
     m_filter.side_effect = MultipleResultsFound()
     with self.assertRaises(IrmaDatabaseError):
         Scan.load_from_ext_id(external_id, m_session)
Ejemplo n.º 25
0
 def test012_load_from_ext_id_none(self):
     m_session = MagicMock()
     external_id = "whatever"
     m_filter = m_session.query().options().filter
     m_filter.side_effect = NoResultFound()
     with self.assertRaises(IrmaDatabaseResultNotFound):
         Scan.load_from_ext_id(external_id, m_session)
Ejemplo n.º 26
0
    def test_query_uniprot(self):
        mock = MagicMock()
        mock.query = MagicMock(return_value={'total': 0, 'hits': []})
        searcher = GeneSymbolSearcher(bclient=mock)
        with requests_mock.Mocker() as m:
            m.register_uri(
                'GET',
                'https://www.uniprot.org/uniprot/HAHA.txt',
                status_code='200',
                text="""ID   BXA1_CLOBO              Reviewed;        1296 AA.
AC   P0DPI0; A5HZZ9; A7G1U9; P01561; P10845; P18639;
DT   18-JUL-2018, integrated into UniProtKB/Swiss-Prot.
DT   18-JUL-2018, sequence version 1.
DT   08-MAY-2019, entry version 9.
DE   RecName: Full=Botulinum neurotoxin type A;
DE            Short=BoNT/A;
DE   AltName: Full=Bontoxilysin-A;
DE            Short=BOTOX;
DE   AltName: Full=Botulinum neurotoxin type A1;
DE   Contains:
DE     RecName: Full=Botulinum neurotoxin A light chain;
DE              Short=LC;
DE              EC=3.4.24.69 {ECO:0000269|PubMed:8243676};
DE   Contains:
DE     RecName: Full=Botulinum neurotoxin A heavy chain;
DE              Short=HC;
DE   Flags: Precursor;
GN   Name=botA {ECO:0000303|PubMed:2185020};
GN   Synonyms=atx {ECO:0000303|PubMed:8521962},
GN   bonT {ECO:0000303|PubMed:8863443};
OS   Clostridium botulinum.""")
            self.assertEqual('botA', searcher.get_symbol('haha'))
Ejemplo n.º 27
0
class TestDelNwaTenantBinding(testscenarios.WithScenarios, base.BaseTestCase):

    scenarios = [
        ('old value json is None',
         {
             'expected_return_value': False,
             'old_value_json': None
         }),
        ('old value json is 1',
         {
             'expected_return_value': True,
             'old_value_json': 1
         }),
        ('no result found',
         {
             'expected_return_value': False,
             'old_value_json': 1,
             'delete_not_found': True,
         }),
    ]

    @patch('networking_nec.nwa.l2.db_api.get_nwa_tenant_binding')
    def test_del_nwa_tenant_binding(self, gntb):
        gntb.return_value = self.old_value_json
        self.session = MagicMock()
        if getattr(self, 'delete_not_found', False):
            self.session.query().filter().delete.side_effect = NoResultFound
        rc = db_api.del_nwa_tenant_binding(self.session, TENANT_ID,
                                           NWA_TENANT_ID)
        self.assertEqual(rc, self.expected_return_value)
Ejemplo n.º 28
0
 def TestCommandParsing(self):
     request = MagicMock()
     request.path = "/test"
     request.query = "item1=value1"
     request.remote_ip = "1.2.3.4"
     request.method = "PUT"
     request.headers = {
         'User': '******',
         'Creation-Time': 'test_time',
         'User-Agent': 'test_user_agent'
     }
     request.body="item2=value2&item2=value3&item2=value4"
     self.command = Command(request)
     self.assertEqual(self.command.command_name, 'test')
     self.assertEqual(self.command.command_type, 'PUT')
     self.assertEqual(self.command.has_param('item1'), True)
     self.assertEqual(self.command.has_param('item2'), True)
     self.assertEqual(self.command.has_param('item3'), False)
     self.assertEqual(self.command.get_param('item1'), 'value1')
     self.assertEqual('value2' in self.command.get_param('item2'), True)
     self.assertEqual('value3' in self.command.get_param('item2'), True)
     self.assertEqual('value4' in self.command.get_param('item2'), True)
     data = self.command.format_trace
     self.assertEqual(data['Username'], 'test_user')
     self.assertEqual(data['Created'], 'test_time')
     self.assertEqual(data['Source_Address'], '1.2.3.4')
     self.assertEqual(data['Source_ID'], 'test_user_agent')
Ejemplo n.º 29
0
 def test_result_to_ask_returns_false(self):
     mocked_graph = MagicMock()
     mocked_graph.query = MagicMock(return_value=SPARQLQueryResult(False))
     with patch("diderot.assertion.parse_facts", return_value=mocked_graph):
         assertion = can_answer("ASK { ?s a ?o }").from_ontology("A_ONTOLOGY")
         self.assertFalse(assertion.assertion_value)
         self.assertIsNotNone(assertion.assertion_error_message)
Ejemplo n.º 30
0
 def test_with_answer_does_not_match_query_result(self):
     mocked_graph = MagicMock()
     query_result = ([("test",), ("not_expected_answer",)], None, ["?s"], None, None, None)
     mocked_graph.query = MagicMock(return_value=SPARQLQueryResult(query_result))
     with patch("diderot.assertion.parse_facts", return_value=mocked_graph):
         assertion = can_answer("ASK { ?s a ?o }").from_ontology("A_ONTOLOGY").with_answer([("test",)])
         self.assertFalse(assertion.assertion_value)
         self.assertIn("Query result is different from expected answer", assertion.assertion_error_message)
 def test004_load_by_scanid(self):
     m_session = MagicMock()
     scanid = "scanid"
     fileid = "fileid"
     FileWeb.load_by_scanid_fileid(scanid, fileid, m_session)
     m_filter = m_session.query(FileWeb).filter
     m_filter.is_called_once_with(FileWeb.id_scan == scanid,
                                  FileWeb.id_file == fileid)
Ejemplo n.º 32
0
 def test_other_results(self, m_inspect):
     m_session = MagicMock()
     ret = MagicMock()
     ret.session = m_session
     m_inspect.return_value = ret
     res = self.fw.other_results
     self.assertEqual(res,
                      m_session.query().join().filter().order_by().all())
Ejemplo n.º 33
0
 def test004_load_by_scanid(self):
     m_session = MagicMock()
     scanid = "scanid"
     fileid = "fileid"
     FileWeb.load_by_scanid_fileid(scanid, fileid, m_session)
     m_filter = m_session.query(FileWeb).filter
     m_filter.is_called_once_with(FileWeb.id_scan == scanid,
                                  FileWeb.id_file == fileid)
Ejemplo n.º 34
0
 def test_remove_tag_error(self):
     text = "whatever"
     t = Tag(text=text)
     m_session = MagicMock()
     m_session.query(Tag).filter().one.return_value = t
     with self.assertRaises(IrmaDatabaseError):
         self.file.remove_tag("id", m_session)
     self.assertEqual(len(self.file.tags), 0)
def test_reload_stock():
    session = MagicMock()

    session.query().delete.return_value = None
    session.commit.return_value = None
    session.add.return_value = None

    assert reload_stock(session)
Ejemplo n.º 36
0
 def test015_remove_tag_error(self):
     text = "whatever"
     t = Tag(text=text)
     m_session = MagicMock()
     m_session.query(Tag).filter().one.return_value = t
     with self.assertRaises(IrmaDatabaseError):
         self.file.remove_tag("id", m_session)
     self.assertEqual(len(self.file.tags), 0)
Ejemplo n.º 37
0
 def test_with_answer_with_non_select_query(self):
     mocked_graph = MagicMock()
     mocked_graph.query = MagicMock(return_value=SPARQLQueryResult(False))
     with patch("diderot.assertion.parse_facts", return_value=mocked_graph):
         try:
             can_answer("ASK { ?s a ?o }").from_ontology("A_ONTOLOGY").with_answer([("test",)])
         except RuntimeError as e:
             self.assertIn("Query result is None. Have you called from_ontology() first?", e.message)
Ejemplo n.º 38
0
 def test_other_results(self, m_inspect):
     m_session = MagicMock()
     ret = MagicMock()
     ret.session = m_session
     m_inspect.return_value = ret
     res = self.fw.other_results
     self.assertEqual(res,
                      m_session.query().join().filter().order_by().all())
def test_remove_one__amount_is_zero():
    test_product = MagicMock()
    test_product.amount = 0

    session = MagicMock()
    session.query().filter_by().first.return_value = test_product

    assert not remove_one(session, "nickel")
Ejemplo n.º 40
0
 def test019_load_from_sha256_no_more_exists(self, m_os):
     path = "RandomPath"
     self.file.path = path
     m_os.path.exists.return_value = False
     m_session = MagicMock()
     m_session.query().filter().one.return_value = self.file
     ret_file = File.load_from_sha256("sha256", m_session)
     self.assertEqual(ret_file, self.file)
     self.assertIsNone(self.file.path)
Ejemplo n.º 41
0
 def test_get_context_for_directories(self):
     fake_res = {'name': 'test'}
     coll = MagicMock()
     coll.query = lambda name=None: [fake_res]
     client = MagicMock()
     client.directories = coll
     args = {'--in-directory': 'test'}
     ret = resources._get_context(client, args)
     self.assertEquals(ret, fake_res)
Ejemplo n.º 42
0
 def test014_remove_tag(self):
     text = "whatever"
     t = Tag(text=text)
     m_session = MagicMock()
     m_session.query(Tag).filter().one.return_value = t
     self.assertEqual(len(self.file.tags), 0)
     self.file.add_tag("id", m_session)
     self.file.remove_tag("id", m_session)
     self.assertEqual(len(self.file.tags), 0)
Ejemplo n.º 43
0
 def test013_add_tag_error(self):
     text = "whatever"
     t = Tag(text=text)
     m_session = MagicMock()
     m_session.query(Tag).filter().one.return_value = t
     self.file.add_tag("id", m_session)
     with self.assertRaises(IrmaDatabaseError):
         self.file.add_tag("id", m_session)
     self.assertItemsEqual(self.file.tags, [t])
Ejemplo n.º 44
0
 def test_get_context_for_directories(self):
     fake_res = {'name': 'test'}
     coll = MagicMock()
     coll.query = lambda name=None: [fake_res]
     client = MagicMock()
     client.directories = coll
     args = {'--in-directory': 'test'}
     ret = resources._get_context(client, args)
     self.assertEquals(ret, fake_res)
 def test_poke_true_no_delta(self):
     context = {'execution_date': datetime(2020, 1, 1, 0, 0)}
     session = MagicMock()
     session.query().filter().count.return_value = 1
     test_task = ExternalTaskSensorBasic(task_id='test_task',
                                         external_dag_id=TEST_DAG_ID,
                                         external_task_id=TEST_TASK_ID,
                                         allowed_states=['success'])
     self.assertTrue(test_task.poke(context, session))
def test_get_product_cost():
    test_product = MagicMock()
    test_product.price = 0.0

    session = MagicMock()

    session.query().filter_by().first.return_value = test_product

    assert get_product_cost(session, "nickel") == 0.0
Ejemplo n.º 47
0
 def test_result_to_select_query(self):
     mocked_graph = MagicMock()
     # result,selectionF,allVars,orderBy,distinct,topUnion
     query_result = ([("test")], None, ["?s"], None, None, None)
     mocked_graph.query = MagicMock(return_value=SPARQLQueryResult(query_result))  # Non Empty result
     with patch("diderot.assertion.parse_facts", return_value=mocked_graph):
         assertion = can_answer("SELECT { ?s a ?o }").from_ontology("A_ONTOLOGY")
         self.assertTrue(assertion.assertion_value)
         self.assertIsNone(assertion.assertion_error_message)
Ejemplo n.º 48
0
class TestEnsurePortBinding(base.BaseTestCase):
    def setUp(self):
        super(TestEnsurePortBinding, self).setUp()
        self.session = MagicMock()

    def test_ensure_port_binding(self):
        port_id = 'uuid-port_id-1'
        self.session.query().filter_by().one.return_value = port_id
        rc = db_api.ensure_port_binding(self.session, port_id)
        self.assertEqual(rc, port_id)

    @patch('neutron.plugins.ml2.models.PortBinding')
    def test_ensure_port_binding_no_result_found(self, mpb):
        port_id = 'uuid-port_id-1'
        self.session.query().filter_by().one.side_effect = NoResultFound
        mpb.return_value = 'uuid-port_id-2'
        self.assertRaises(NoResultFound, db_api.ensure_port_binding,
                          self.session, port_id)
Ejemplo n.º 49
0
 def test_add_tag_error(self):
     text = "whatever"
     t = Tag(text=text)
     m_session = MagicMock()
     m_session.query(Tag).filter().one.return_value = t
     self.file.add_tag("id", m_session)
     with self.assertRaises(IrmaDatabaseError):
         self.file.add_tag("id", m_session)
     self.assertCountEqual(self.file.tags, [t])
Ejemplo n.º 50
0
 def test_load_from_sha256_no_more_exists(self, m_os):
     path = "RandomPath"
     self.file.path = path
     m_os.path.exists.return_value = False
     m_session = MagicMock()
     m_session.query().filter().one.return_value = self.file
     ret_file = module.File.load_from_sha256("sha256", m_session)
     self.assertEqual(ret_file, self.file)
     self.assertIsNone(self.file.path)
Ejemplo n.º 51
0
 def test_remove_tag(self):
     text = "whatever"
     t = Tag(text=text)
     m_session = MagicMock()
     m_session.query(Tag).filter().one.return_value = t
     self.assertEqual(len(self.file.tags), 0)
     self.file.add_tag("id", m_session)
     self.file.remove_tag("id", m_session)
     self.assertEqual(len(self.file.tags), 0)
Ejemplo n.º 52
0
 def test_add_tag(self):
     text = "whatever"
     t = Tag(text=text)
     m_session = MagicMock()
     m_session.query(Tag).filter_by().one.return_value = t
     self.assertEqual(len(self.file.tags), 0)
     self.file.add_tag("id", m_session)
     self.assertEqual(len(self.file.tags), 1)
     self.assertCountEqual(self.file.tags, [t])
def test_buy_product__existing_product__more_inserted_coins_than_price():
    bought_product = {
        "product": "cola",
        "coins": [0.25, 0.25, 0.25, 0.25]
    }

    test_product_to_buy = MagicMock()
    test_product_to_buy.worth = 2.0

    test_product = MagicMock()
    test_product.price = 1.0

    session = MagicMock()
    session.query().all.return_value = [test_product_to_buy]
    session.query().filter_by().first.return_value = test_product

    bought, data = buy_product(session, "cola")

    assert bought and data == bought_product
Ejemplo n.º 54
0
 def test_result_to_construct_query_raises_exception(self):
     mocked_graph = MagicMock()
     mocked_graph.query = MagicMock(return_value=SPARQLQueryResult(get_empty_graph()))  # Graph object
     with patch("diderot.assertion.parse_facts", return_value=mocked_graph):
         try:
             can_answer("SELECT { ?s a ?o }").from_ontology("A_ONTOLOGY")
         except RuntimeError:
             pass
         else:
             self.fail("RuntimeError not raised")
Ejemplo n.º 55
0
 def test_get_ref_result(self, m_inspect):
     m_session = MagicMock()
     m_inspect(self.file).session = m_session
     probename = "probeX"
     res = self.file.get_ref_result(probename)
     expected = m_session.query().join().filter().\
         filter(module.ProbeResult.name == probename).\
         order_by().\
         first()
     self.assertEqual(res, expected)
Ejemplo n.º 56
0
 def test003_list_default(self):
     db_mock = MagicMock()
     default_offset, default_limit = 0, 5
     scan_schema_mock = MagicMock()
     expected = {"total": len(db_mock.query().limit().offset().all()),
                 "offset": default_offset,
                 "limit": default_limit,
                 "data": scan_schema_mock.dump().data}
     scan_schema = "frontend.api.controllers.scans.scan_schema"
     with patch(scan_schema, scan_schema_mock):
         result = api_scans.list(db_mock)
     self.assertEqual(result, expected)
     self.assertEqual(api_scans.response.content_type,
                      "application/json; charset=UTF-8")
     self.assertEqual(db_mock.query.call_args, ((Scan,),))
     self.assertEqual(db_mock.query().limit.call_args, ((default_limit,),))
     self.assertEqual(db_mock.query().limit().offset.call_args,
                      ((default_offset,),))
     self.assertFalse(db_mock.query().count.called)
Ejemplo n.º 57
0
 def test_named_tree__file(self):
     value = 2052016
     # Mocking chained methods
     query_rv = MagicMock()
     query_rv.filter_by = MagicMock(return_value=value)
     object_session_rv = MagicMock()
     object_session_rv.query = MagicMock(return_value=query_rv)
     pet.models.Session.object_session = MagicMock(
         return_value=object_session_rv
     )
     self.assertEqual(value, self.nt1._file('filename'))
Ejemplo n.º 58
0
class TestEnsurePortBinding(base.BaseTestCase):
    def setUp(self):
        super(TestEnsurePortBinding, self).setUp()
        self.session = MagicMock()

    def test_ensure_port_binding(self):
        port_id = 'uuid-port_id-1'
        self.session.query().filter_by().one.return_value = port_id
        rc = db_api.ensure_port_binding(self.session, port_id)
        self.assertEqual(rc, port_id)

    @patch('neutron.plugins.ml2.models.PortBinding')
    def test_ensure_port_binding_no_result_found(self, mpb):
        port_id = 'uuid-port_id-1'
        self.session.query().filter_by().one.side_effect = NoResultFound
        mpb.return_value = 'uuid-port_id-2'
        self.assertRaises(
            NoResultFound,
            db_api.ensure_port_binding, self.session, port_id
        )