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"}
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()
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()
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()
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()
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"}
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)
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)
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)
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)
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')
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)
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)
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
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)
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")
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)
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)
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)
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)
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'))
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')
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)
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)
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_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)
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)
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)
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")
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)
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 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)
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])
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
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)
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)
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])
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)
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)
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
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")
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)
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)
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'))
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 )