def test_delete_interface(self, m): ip1 = Mock() ip1.ip = "1.1.1.1/16" ip1.description = "My IPv4 ip" ip2 = Mock() ip2.ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334/64" ip2.description = "My IPv6 ip" # interfaces intf1 = Mock() intf1.name = "intf1" intf1.vlanUntagged = None intf1.ips.all.return_value = [ip1, ip2] # bindings # create a mock SwitchPort instance interface_to_remove = Mock() interface_to_remove.id = 1 interface_to_remove.tologdict.return_value = {} interface_to_remove.leaf_model_name = "PortInterface" interface_to_remove.port.interfaces.all.return_value = [intf1] interface_to_remove.port.switch.ofId = "of:1234" interface_to_remove.port.portId = "1" interface_to_remove.port.host_learning = True m.post("http://onos-fabric:8181/onos/v1/network/configuration/", status_code=200) m.post("http://onos-fabric:8181/onos/v1/devices/%s/portstate/%s" % (interface_to_remove.port.switch.ofId, interface_to_remove.port.portId), status_code=200) with patch.object(Service.objects, "get") as onos_fabric_get: onos_fabric_get.return_value = self.fabric self.sync_step(model_accessor=self.model_accessor).delete_record(interface_to_remove) self.assertTrue(m.called)
def test_sync_port(self, m): # IPs ip1 = Mock() ip1.ip = "1.1.1.1/16" ip1.description = "My IPv4 ip" ip2 = Mock() ip2.ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334/64" ip2.description = "My IPv6 ip" ip3 = Mock() ip3.ip = "2.2.2.2/8" ip3.description = "My other IPv4 ip" intf1 = Mock() intf1.name = "intf1" intf1.vlanUntagged = None intf1.ips.all.return_value = [ip1, ip2] intf2 = Mock() intf2.name = "intf2" intf2.vlanUntagged = 42 intf2.ips.all.return_value = [ip3] port = Mock() port.id = 1 port.tologdict.return_value = {} port.host_learning = True port.interfaces.all.return_value = [intf1, intf2] port.switch.ofId = "of:1234" port.portId = "1" expected_conf = { "ports": { "%s/%s" % (port.switch.ofId, port.portId): { "interfaces": [{ "name": intf1.name, "ips": [ip1.ip, ip2.ip] }, { "name": intf2.name, "ips": [ip3.ip], "vlan-untagged": intf2.vlanUntagged }], "hostLearning": { "enabled": port.host_learning } } } } m.post("http://onos-fabric:8181/onos/v1/network/configuration/", status_code=200, additional_matcher=functools.partial(match_json, expected_conf)) with patch.object(Service.objects, "get") as onos_fabric_get: onos_fabric_get.return_value = self.fabric self.sync_step( model_accessor=self.model_accessor).sync_record(port) self.assertTrue(m.called)
def test_sync(self, mock_ndb, mock_repo, mock_set): """Ensure that a Repository entity is created for every GitHub repo that doesn't already have an entity and a list of the user's repos is returned. """ mock_user = Mock() repo1 = Mock() repo1.id = 'repo1' repo2 = Mock() repo2.id = 'repo2' repo2.name = 'repo2' repo2.description = 'description' mock_user.github_repos = [repo1, repo2] key1 = Mock() key2 = Mock() keys = [key1, key2] mock_ndb.Key.side_effect = keys mock_ndb.get_multi.return_value = [repo1, None] actual = repository.sync_repos(mock_user) self.assertEqual([repo1, mock_repo.return_value], actual) expected = [call(repository.Repository, 'github_%s' % repo.id) for repo in [repo1, repo2]] self.assertEqual(expected, mock_ndb.Key.call_args_list) mock_ndb.get_multi.assert_called_once_with(keys) mock_repo.assert_called_once_with(id='github_%s' % repo2.id, description=repo2.description, name=repo2.name, owner=mock_user.key) mock_ndb.put_multi.assert_called_once_with([mock_repo.return_value]) mock_set.assert_called_once_with( 'kaput:repos:%s' % mock_user.key.id(), [repo1, mock_repo.return_value])
def _mock_asn(): asn = Mock() asn.id = 1 asn.name = '640404' asn.description = 'ASN_640404' return asn
def test_files(self): gist = Mock() gist.description = "Dale Name #notebook #hello" gist.files = object() tg = TaggedGist.from_gist(gist) assert tg.files is gist.files
def test_read_and_update_resource(self): with self.assertRaises(BadRequest): self.sms.read_service_definition() service_definition = Mock() service_definition.name = "name" service_definition.definition = self.yaml_definition service_definition.description = "This is just a test, don't panic" self.mock_clients.resource_registry.read.return_value = service_definition sd = self.sms.read_service_definition("123") self.assertTrue(sd is service_definition) self.mock_clients.resource_registry.read.assert_called_once_with( '123', '') sd.name = "new name" with self.assertRaises(BadRequest): self.sms.update_service_definition(sd) sd.definition = self.bad_yaml with self.assertRaises(BadRequest): self.sms.update_service_definition(service_definition) sd.name = "new_name" sd.definition = self.yaml_definition self.mock_clients.resource_registry.update.return_value = ['123', 2] sd_id = self.sms.update_service_definition(sd) self.assertEqual(sd_id, '123') self.mock_clients.resource_registry.update.assert_called_once_with(sd)
def test_read_and_update_resource(self): with self.assertRaises(BadRequest): self.sms.read_service_definition() service_definition = Mock() service_definition.name = "name" service_definition.definition = self.yaml_definition service_definition.description = "This is just a test, don't panic" self.mock_clients.resource_registry.read.return_value = service_definition sd = self.sms.read_service_definition("123") self.assertTrue(sd is service_definition) self.mock_clients.resource_registry.read.assert_called_once_with('123', '') sd.name = "new name" with self.assertRaises(BadRequest): self.sms.update_service_definition(sd) sd.definition = self.bad_yaml with self.assertRaises(BadRequest): self.sms.update_service_definition(service_definition) sd.name = "new_name" sd.definition = self.yaml_definition self.mock_clients.resource_registry.update.return_value = ['123', 2] sd_id = self.sms.update_service_definition(sd) self.assertEqual(sd_id, '123') self.mock_clients.resource_registry.update.assert_called_once_with(sd)
def test_delete_ip(self, m): ip1 = Mock() ip1.ip = "1.1.1.1/16" ip1.description = "My IPv4 ip" intf1 = Mock() intf1.name = "intf1" intf1.vlanUntagged = None intf1.ips.all.return_value = [ip1] ip_to_remove = Mock() ip_to_remove.id = 1 ip_to_remove.leaf_model_name = "FabricIpAddress" ip_to_remove.interface.port.interfaces.all.return_value = [intf1] ip_to_remove.interface.port.switch.ofId = "of:1234" ip_to_remove.interface.port.portId = "1" ip_to_remove.interface.port.host_learning = True m.post("http://onos-fabric:8181/onos/v1/network/configuration/", status_code=200) m.post("http://onos-fabric:8181/onos/v1/devices/%s/portstate/%s" % (ip_to_remove.interface.port.switch.ofId, ip_to_remove.interface.port.portId), status_code=200) with patch.object(Service.objects, "get") as onos_fabric_get: onos_fabric_get.return_value = self.fabric self.sync_step(model_accessor=self.model_accessor).delete_record(ip_to_remove) self.assertTrue(m.called)
def test__get_or_create_node(self): file = Mock() src_node = Mock() file.get_node.return_value = sentinel.node node = publicdb._get_or_create_node(file, sentinel.group, src_node) file.get_node.assert_called_once_with(sentinel.group, src_node.name) self.assertEqual(node, sentinel.node) file.get_node.side_effect = tables.NoSuchNodeError('no such node!') # Raise exception because type of Mock src_node is not Table or VLArray self.assertRaises(Exception, publicdb._get_or_create_node, file, sentinel.group, src_node) src_node = Mock(spec=tables.Table) src_node.description = sentinel.description node = publicdb._get_or_create_node(file, sentinel.group, src_node) file.create_table.assert_called_once_with(sentinel.group, src_node.name, src_node.description, src_node.title) src_node = Mock(spec=tables.VLArray) src_node.atom = sentinel.atom node = publicdb._get_or_create_node(file, sentinel.group, src_node) file.create_vlarray.assert_called_once_with(sentinel.group, src_node.name, src_node.atom, src_node.title)
def test_create_resource(self): # Create ResourceType rt = Mock() rt.name = "bad name" with self.assertRaises(BadRequest): self.rms.create_resource_type(rt, "123") rt.name = "good_name" bad_object_id = None with self.assertRaises(BadRequest): self.rms.create_resource_type(rt, bad_object_id) # Create ObjectType ot = Mock() ot.definition = self.object_definition ot.name = "good_name" ot.description = "This is just a test. No need to panic" self.rms.clients.resource_registry.read.return_value = ot resource_id_return_value = '123' version_return_value = 1 self.rms.clients.resource_registry.create.return_value = [ resource_id_return_value, version_return_value ] self.rms.clients.resource_registry.create_association.return_value = '999' object_id = "444" resource_id = self.rms.create_resource_type(rt, object_id) self.assertEqual(resource_id, '123') self.rms.clients.resource_registry.read.assert_called_once_with( object_id, '') self.rms.clients.resource_registry.create.assert_called_once_with(rt) self.rms.clients.resource_registry.create_association.assert_called_once_with( resource_id_return_value, PRED.hasObjectType, object_id, None)
def test_end_step(self): feature = Mock() feature.filename = 'foo/bar.md' feature.description = u'This is an example.' feature.tags = [] feature.scenarios = [] scenario = Mock() scenario.name = 'Scenario 1' scenario.status = 'passed' feature.scenarios.append(scenario) context = Mock() def side_effect(arg): raise Exception('No browser') context.browser.driver.get_screenshot_as_file = side_effect self.maker.start_feature(context, feature) self.maker.start_scenario(context, scenario) step = Mock() step.keyword = u'foo' step.name = u'bar' step.status = u'passed' step.duration = 1.01 self.maker.end_step(context, step) step_line = 'foo bar | passed | 1.01 | error capturing' self.assertIn(step_line, self.maker.doc.getcontents())
def test_create_resource(self): # Create ResourceType rt = Mock() rt.name = "bad name" with self.assertRaises(BadRequest): self.rms.create_resource_type(rt, "123") rt.name = "good_name" bad_object_id = None with self.assertRaises(BadRequest): self.rms.create_resource_type(rt, bad_object_id) # Create ObjectType ot = Mock() ot.definition = self.object_definition ot.name = "good_name" ot.description = "This is just a test. No need to panic" self.rms.clients.resource_registry.read.return_value = ot resource_id_return_value = '123' version_return_value = 1 self.rms.clients.resource_registry.create.return_value = [resource_id_return_value, version_return_value] self.rms.clients.resource_registry.create_association.return_value = '999' object_id = "444" resource_id = self.rms.create_resource_type(rt, object_id) self.assertEqual(resource_id, '123') self.rms.clients.resource_registry.read.assert_called_once_with(object_id, '') self.rms.clients.resource_registry.create.assert_called_once_with(rt) self.rms.clients.resource_registry.create_association.assert_called_once_with(resource_id_return_value, PRED.hasObjectType, object_id, 'H2H')
def test_files(self): gist = Mock() gist.description = "Dale Name #notebook #hello" gist.files = object() tg = TaggedGist.from_gist(gist) nt.assert_is(tg.files, gist.files)
def test_read_and_update_object(self): with self.assertRaises(BadRequest): self.oms.read_object_type(None) ot = Mock() ot.definition = self.yaml_definition ot.name = "name" ot.description = "This is just a test, don't panic" self.oms.clients.resource_registry.read.return_value = ot ot_return = self.oms.read_object_type("123") self.assertTrue(ot_return is ot) self.oms.clients.resource_registry.read.assert_called_once_with('123','') ot_return.name = "new name" with self.assertRaises(BadRequest): self.oms.update_object_type(ot_return) ot_return.name = "new_name" ot_return.definition = self.bad_yaml with self.assertRaises(BadRequest): self.oms.update_object_type(ot_return) ot.definition = self.yaml_definition self.oms.clients.resource_registry.update.return_value = ['123', 2] ot_id = self.oms.update_object_type(ot_return) self.assertEqual(ot_id, '123') self.oms.clients.resource_registry.update.assert_called_once_with(ot_return)
def test__get_or_create_node(self): file = Mock() src_node = Mock() file.get_node.return_value = sentinel.node node = publicdb._get_or_create_node(file, sentinel.group, src_node) file.get_node.assert_called_once_with(sentinel.group, src_node.name) self.assertEqual(node, sentinel.node) file.get_node.side_effect = tables.NoSuchNodeError('no such node!') # Raise exception because type of Mock src_node is not Table or VLArray self.assertRaises(Exception, publicdb._get_or_create_node, file, sentinel.group, src_node) src_node = Mock(spec=tables.Table) src_node.description = sentinel.description node = publicdb._get_or_create_node(file, sentinel.group, src_node) file.create_table.assert_called_once_with( sentinel.group, src_node.name, src_node.description, src_node.title) src_node = Mock(spec=tables.VLArray) src_node.atom = sentinel.atom node = publicdb._get_or_create_node(file, sentinel.group, src_node) file.create_vlarray.assert_called_once_with( sentinel.group, src_node.name, src_node.atom, src_node.title)
def the_policy_profile(): the_policy_profile = Mock() the_policy_profile.name = POLICY_PROFILE_NAME the_policy_profile.id = 1 the_policy_profile.guid = '0bf2e43a-1211-11e6-aa9c-02424d459b45' the_policy_profile.description = "test policy profile" yield the_policy_profile
def _mock_virtual_interface(): virtual_interface = Mock() virtual_interface.id = 1 virtual_interface.vrf_id = 1 virtual_interface.name = 'Virt-Test' virtual_interface.description = 'ASN_640404' return virtual_interface
def test_fetchone_nt(self): cursor = Mock() cursor.description = (('id', 3, 2, 11, 11, 0, 0), ('status', 253, 7, 80, 80, 0, 0)) cursor.fetchone = Mock(return_value=(34, 'info')) r = fetchone_nt(cursor) self.assertEqual(r.__class__.__name__, 'Results') self.assertEqual(r.id, 34) self.assertEqual(r.status, 'info')
def test_init(self): params = Mock() params.mri = "MyMRI" params.description = "My description" process = Mock() o = BasicController(process, [], params) assert o.mri == params.mri assert o.params is params assert o.process is process
def test_fetchiter_nt(self): cursor = Mock() cursor.description = (('id', 3, 2, 11, 11, 0, 0), ('status', 253, 7, 80, 80, 0, 0)) # Standard cursor.fetchmany = Mock(return_value=((34, 'info'), (99, 'warning'))) num_it = 0 for row in fetchiter_nt(cursor): self.assertEqual(row.__class__.__name__, 'Results') if num_it == 0: self.assertEqual(row.id, 34) self.assertEqual(row.status, 'info') if num_it == 1: self.assertEqual(row.id, 99) self.assertEqual(row.status, 'warning') if num_it == 2: raise StopIteration num_it += 1 if num_it == 2: cursor.fetchmany = Mock(return_value=[]) self.assertEqual(num_it, 2) # Batch cursor.fetchmany = Mock(return_value=((34, 'info'), (99, 'warning'))) num_it = 0 for row in fetchiter_nt(cursor, batch=True): self.assertEqual(row.__class__.__name__, 'list') self.assertEqual(row[0].__class__.__name__, 'Results') self.assertEqual(row[0].id, 34) self.assertEqual(row[0].status, 'info') self.assertEqual(row[1].__class__.__name__, 'Results') self.assertEqual(row[1].id, 99) self.assertEqual(row[1].status, 'warning') if num_it == 1: raise StopIteration num_it += 1 if num_it == 1: cursor.fetchmany = Mock(return_value=[]) self.assertEqual(num_it, 1) # Server cursor cursor.fetchall = Mock(return_value=((34, 'info'), (99, 'warning'))) num_it = 0 for row in fetchiter_nt(cursor, server_cursor='C'): self.assertEqual(row.__class__.__name__, 'Results') if num_it == 0: self.assertEqual(row.id, 34) self.assertEqual(row.status, 'info') if num_it == 1: self.assertEqual(row.id, 99) self.assertEqual(row.status, 'warning') if num_it == 2: raise StopIteration num_it += 1 if num_it == 2: cursor.fetchall = Mock(return_value=[]) self.assertEqual(num_it, 2)
def test_start_feature(self): feature = Mock() feature.filename = 'foo/bar.md' feature.description = u'This is an example.' feature.tags = [] context = Mock() self.maker.start_feature(context, feature) self.assertIn('This is an example.', self.maker.doc.getcontents()) dir_name = self.maker.output_dir + '/' + self.maker.doc.path assert os.path.isdir(dir_name)
def get_contest(): contest = Mock() contest.id = get_int() contest.name = get_string() start = get_int(2 ** 11) duration = get_int(2 ** 8) contest.start = make_datetime(start) contest.stop = make_datetime(start + duration) contest.score_precision = 2 contest.description = get_string() return contest
def test_make_float64_meta(self): params = Mock() params.name = "me" params.description = "desc" params.default = 32.6 name, meta, default = parameters.float64(params) assert default == 32.6 assert name == "me" assert meta.description == "desc" self.assertIsInstance(meta, NumberMeta) assert meta.dtype == "float64"
def test_make_float64_meta(self): params = Mock() params.name = "me" params.description = "desc" params.default = 32.6 name, meta, default = parameters.float64(params) self.assertEqual(default, 32.6) self.assertEqual(name, "me") self.assertEqual(meta.description, "desc") self.assertIsInstance(meta, NumberMeta) self.assertEqual(meta.dtype, "float64")
def test_from_gist(self): gist = Mock() gist.description = "Dale Name #notebook #hello" tg = TaggedGist.from_gist(gist) assert tg.name == "Dale Name" assert_items_equal(tg.tags, ['#notebook', '#hello']) assert tg.active gist = Mock() gist.description = "Dale Name #notebook #inactive" tg = TaggedGist.from_gist(gist) assert tg.name == "Dale Name" assert_items_equal(tg.tags, ['#notebook']) # explicitly test system tags assert '#inactive' in TaggedGist.system_tags assert '#inactive' not in tg.tags assert not tg.active
def test_from_gist(self): gist = Mock() gist.description = "Dale Name #notebook #hello" tg = TaggedGist.from_gist(gist) nt.assert_equals(tg.name, "Dale Name") nt.assert_items_equal(tg.tags, ['#notebook', '#hello']) nt.assert_true(tg.active) gist = Mock() gist.description = "Dale Name #notebook #inactive" tg = TaggedGist.from_gist(gist) nt.assert_equals(tg.name, "Dale Name") nt.assert_items_equal(tg.tags, ['#notebook']) # explicitly test system tags nt.assert_in('#inactive', TaggedGist.system_tags) nt.assert_not_in('#inactive', tg.tags) nt.assert_false(tg.active)
def get_contest(): contest = Mock() contest.id = get_int() contest.name = get_string() start = get_int(2**11) duration = get_int(2**8) contest.start = make_datetime(start) contest.stop = make_datetime(start + duration) contest.score_precision = 2 contest.description = get_string() return contest
def generate_tagged_gists(names): mocks = [] for id, name in enumerate(names, 1): mock = Mock() mock.description = name mock.id = id mocks.append(mock) tagged_gists = [(mock.id, TaggedGist.from_gist(mock)) for mock in mocks if mock.description] tagged_gists = dict(tagged_gists) return tagged_gists
def test_fetchall_nt(self): cursor = Mock() cursor.description = (('id', 3, 2, 11, 11, 0, 0), ('status', 253, 7, 80, 80, 0, 0)) cursor.fetchall = Mock(return_value=((34, 'info'), (99, 'warning'))) r = fetchall_nt(cursor) self.assertEqual(r.__class__.__name__, 'list') self.assertEqual(r[0].__class__.__name__, 'Results') self.assertEqual(r[0].id, 34) self.assertEqual(r[0].status, 'info') self.assertEqual(r[1].__class__.__name__, 'Results') self.assertEqual(r[1].id, 99) self.assertEqual(r[1].status, 'warning')
def _make_version(self, not_automatic): ver = Mock(_Version) ver.description = "not_automatic: %s" % not_automatic ver.summary = "summary not_automatic: %s" % not_automatic ver.version = "version not_automatic: %s" % not_automatic mock_origin = Mock() if not_automatic: mock_origin.archive = "precise-backports" else: mock_origin.archive = "precise" ver.origins = [mock_origin] ver.not_automatic = not_automatic return ver
def test_make_int32_meta(self): params = Mock() params.name = "me" params.description = "desc" params.default = 32 default_meta = parameters.int32.MethodMeta.takes.elements["default"] self.assertIsInstance(default_meta, NumberMeta) self.assertEqual(default_meta.dtype, "int32") name, meta, default = parameters.int32(params) self.assertEqual(default, 32) self.assertEqual(name, "me") self.assertEqual(meta.description, "desc") self.assertIsInstance(meta, NumberMeta) self.assertEqual(meta.dtype, "int32")
def test_make_string_meta(self): params = Mock() params.name = "me" params.description = "desc" del params.default self.assertEqual(list(parameters.string.MethodMeta.takes.elements), ["name", "description", "default"]) default_meta = parameters.string.MethodMeta.takes.elements["default"] self.assertIsInstance(default_meta, StringMeta) name, meta, default = parameters.string(params) self.assertEqual(default, REQUIRED) self.assertEqual(name, "me") self.assertEqual(meta.description, "desc") self.assertIsInstance(meta, StringMeta)
def test_make_string_meta(self): params = Mock() params.name = "me" params.description = "desc" del params.default assert list(parameters.string.MethodModel.takes.elements) == ( ["name", "description", "default"]) default_meta = parameters.string.MethodModel.takes.elements["default"] self.assertIsInstance(default_meta, StringMeta) name, meta, default = parameters.string(params) assert default == REQUIRED assert name == "me" assert meta.description == "desc" self.assertIsInstance(meta, StringMeta)
def test_make_int32_meta(self): params = Mock() params.name = "me" params.description = "desc" params.default = 32 default_meta = parameters.int32.MethodModel.takes.elements["default"] self.assertIsInstance(default_meta, NumberMeta) assert default_meta.dtype == "int32" name, meta, default = parameters.int32(params) assert default == 32 assert name == "me" assert meta.description == "desc" self.assertIsInstance(meta, NumberMeta) assert meta.dtype == "int32"
def test_start_scenario(self): feature = Mock() feature.filename = 'foo/bar.md' feature.description = u'This is an example.' feature.tags = [] feature.scenarios = [] scenario = Mock() scenario.name = 'Scenario 1' scenario.status = 'passed' feature.scenarios.append(scenario) context = Mock() self.maker.start_feature(context, feature) self.maker.start_scenario(context, scenario) scenario_line = '### %s' % scenario.name self.assertIn(scenario_line, self.maker.doc.getcontents())
def test_feed_entry_future_published_time(self): """Test with future entry published time""" parse_mock = self.parse_mock entry_attrs = {'link': 'test_entry_link', 'published_parsed': (2114, 01, 01, 12, 0, 0, 2, 1, 0), # 2114-01-01 12:00:00 } entry_mock = Mock(**entry_attrs) entry_mock.description_detail.type = 'text/plain' entry_mock.description = 'Test Feed Description' parse_mock.return_value.entries = [entry_mock] db_entry_mock = Mock() db_entry_mock.objects.get_or_create.return_value = (Mock(), True) with patch('feedreader.utils.feedparser.parse', parse_mock): with patch('feedreader.utils.Entry', db_entry_mock): with patch('sys.stdout', new=StringIO()): # Suppress printed output from test poll_feed(self.feed_mock, verbose=True)
def test_failing_blacklist_means_query_doesnt_execute(self, mocked_conn): # I should really learn to set up mocks correctly because this CANT be the most efficient way... cursor_result = Mock() cursor_result.fetchall.return_value = [] cursor_result.description = [('foo', 'bar')] conn = Mock() conn.cursor.return_value = cursor_result mocked_conn.return_value = conn query = SimpleQueryFactory(sql="select 1;") resp = self.client.post(reverse("query_detail", kwargs={'query_id': query.id}), data={'sql': "select 'delete';"}) self.assertTemplateUsed(resp, 'explorer/query.html') self.assertContains(resp, MSG_FAILED_BLACKLIST % '') # Feels fragile, but nor sure how else to access the called-with params of .execute self.assertEqual(conn.cursor.mock_calls[1][1][0], "select 1;")
def test_end_feature(self): feature = Mock() feature.filename = 'foo/bar.md' feature.description = u'This is an example.' feature.tags = [] feature.scenarios = [] scenario = Mock() scenario.name = 'Scenario 1' scenario.status = 'passed' feature.scenarios.append(scenario) context = Mock() self.maker.start_feature(context, feature) self.maker.end_feature(context, feature) num_scenarios = 'num_scenarios = "1"' num_scenarios_passing = 'num_scenarios_passing = "1"' self.assertIn(num_scenarios, self.maker.doc.header()) self.assertIn(num_scenarios_passing, self.maker.doc.header())
def fake_job(self): job = Mock(Job) job.id = 'foo' job.description = "" job.ms_filename = "" job.dir = '/somedir/foo' job.state = 'STOPPED' job.db = Mock(JobDb) job.db.runInfo.return_value = 'bla' job.db.maxMSLevel.return_value = 3 job.db.molecules.return_value = {'total': 3, 'rows': [1, 2, 3]} job.db.moleculesTotalCount.return_value = 3 job.db.scansWithMolecules.return_value = [4, 5] job.db.chromatogram.return_value = [1, 2, 3] job.db.extractedIonChromatogram.return_value = [1, 2, 3] job.db.fragments.return_value = [1, 2, 3] return job
def get_repo_mock(namespace, name): repo_mock = Mock() repo_mock.owner = Mock() repo_mock.owner.login = namespace repo_mock.full_name = '%s/%s' % (namespace, name) repo_mock.name = name repo_mock.description = 'some %s repo' % (name) if name != 'anotherrepo': repo_mock.pushed_at = datetime.utcfromtimestamp(0) else: repo_mock.pushed_at = None repo_mock.html_url = 'https://bitbucket.org/%s/%s' % (namespace, name) repo_mock.private = name == 'somerepo' repo_mock.permissions = Mock() repo_mock.permissions.admin = namespace == 'knownuser' return repo_mock
def makeFakeGist(): gist = Mock() gist.description = "Test Gist #notebook #pandas #woo" gist.id = 123 # fake files filenames = ['a.ipynb', 'b.ipynb', 'test.txt'] files = {} for fn in filenames: fo = Mock() fo.filename = fn fo.content = fn+" content" files[fn] = fo gist.files = files # fake history history = [] dates = pd.date_range("2000", freq="D", periods=4).to_pydatetime() for i, date in enumerate(dates): state = Mock() state.version = i state.committed_at = date raw_data = {} files = {} for fn in filenames: fo = { 'content': "{fn}_{i}_revision_content".format(fn=fn, i=i), 'filename': fn, } files[fn] = fo # after 2, don't include 'a.ipynb' if i >= 2: del files['a.ipynb'] raw_data['files'] = files state.raw_data = raw_data history.append(state) gist.history = history return gist
_gs_resource = Mock() _gs_resource.native_bbox = [1, 2, 3, 4] Layer.objects.geonetwork = Mock() Layer.objects.gs_catalog = Mock() Layer.objects.gs_catalog.get_resource.return_value = _gs_resource geonode.maps.models.get_csw = Mock() geonode.maps.models.get_csw.return_value.records.get.return_value.identification.keywords = [] _csw_resource = Mock() _csw_resource.protocol = "WWW:LINK-1.0-http--link" _csw_resource.url = "http://example.com/" _csw_resource.description = "example link" geonode.maps.models.get_csw.return_value.records.get.return_value.distribution.online = [_csw_resource] from geonode.maps.utils import forward_mercator, inverse_mercator DUMMY_RESULT ={'rows': [], 'total':0, 'query_info': {'start':0, 'limit': 0, 'q':''}} geonode.maps.views._metadata_search = Mock() geonode.maps.views._metadata_search.return_value = DUMMY_RESULT geonode.maps.views.get_csw = Mock() geonode.maps.views.get_csw.return_value.getrecordbyid.return_value = None geonode.maps.views.get_csw.return_value.records.values.return_value = [None] geonode.maps.views._extract_links = Mock() geonode.maps.views._extract_links.return_value = {} class MapTest(TestCase):
def test_areas(self): p1, p2, project = Mock(), Mock(), Mock() p1.description = 'a' p2.description = 'b' project.areas.all = Mock(return_value=[p1, p2]) self.assertEquals(areas(project), 'a, b')
def test_track_changes_inserted(self): xml = '''<p>some text <name>Some Name</name></p>''' test_doc = etree.parse(StringIO(xml)) name_node = list(test_doc.iter('name'))[0] rsrc = Mock(spec=spotlight.DBpediaResource) rsrc.uri = 'http://dbpedia.org/resource/TestResource' initial_length = len(list(test_doc.iter())) # no label/description rsrc.description = None rsrc.label = None old_text = 'Some Name' self.tei_annotater.track_changes_inserted( name_node, old_text, rsrc) # should have added 3 nodes: 1 deletion, 2 for start/end insertion self.assertEqual(initial_length + 3, len(list(test_doc.iter()))) preceding_sibs = list(name_node.itersiblings(preceding=True)) following_sib = list(name_node.itersiblings()) # second (farthest away) preceding sibling should be deletion, # then insert start deletion = preceding_sibs[1] insert_start = preceding_sibs[0] # insert end should be immediately after the node insert_end = following_sib[0] # inspect deletion marker self.assertEqual('oxy_delete', deletion.target) self.assertEqual(self.tei_annotater.track_changes_author, deletion.get('author')) self.assertEqual(old_text, deletion.get('content')) # inspect insert start self.assertEqual('oxy_insert_start', insert_start.target) self.assertEqual(self.tei_annotater.track_changes_author, insert_start.get('author')) self.assertEqual('(label/description unavailable)', insert_start.get('comment')) # inspect insert end self.assertEqual('oxy_insert_end', insert_end.target) # reset to test dbpedia with label test_doc = etree.parse(StringIO(xml)) name_node = list(test_doc.iter('name'))[0] # no description but a label rsrc.label = 'Some person\'s name' old_text = 'Some Name' self.tei_annotater.track_changes_inserted( name_node, old_text, rsrc) insert_start = list(name_node.itersiblings(preceding=True))[0] self.assertEqual( rsrc.label, insert_start.get('comment'), 'dbpedia resource label should be used as insert comment ' + ' when no description is available') # reset to test dbpedia with description test_doc = etree.parse(StringIO(xml)) name_node = list(test_doc.iter('name'))[0] # description (with quotes) rsrc.description = 'This person was "born" and is famous for ...' escaped_desc = rsrc.description.replace('"', '\'') old_text = 'Some Name' self.tei_annotater.track_changes_inserted( name_node, old_text, rsrc) insert_start = list(name_node.itersiblings(preceding=True))[0] self.assertEqual( escaped_desc, insert_start.get('comment'), 'dbpedia resource description should be used as ' + 'insertion comment when available')
def test_technologies(self): p1, p2, project = Mock(), Mock(), Mock() p1.description = 'a' p2.description = 'b' project.technologies.all = Mock(return_value=[p1, p2]) self.assertEquals(technologies(project), 'a, b')
def test_sync_port(self, m): # IPs ip1 = Mock() ip1.ip = "1.1.1.1/16" ip1.description = "My IPv4 ip" ip2 = Mock() ip2.ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334/64" ip2.description = "My IPv6 ip" ip3 = Mock() ip3.ip = "2.2.2.2/8" ip3.description = "My other IPv4 ip" intf1 = Mock() intf1.name = "intf1" intf1.vlanUntagged = None intf1.ips.all.return_value = [ip1, ip2] intf2 = Mock() intf2.name = "intf2" intf2.vlanUntagged = 42 intf2.ips.all.return_value = [ip3] port = Mock() port.id = 1 port.tologdict.return_value = {} port.host_learning = True port.interfaces.all.return_value = [intf1, intf2] port.switch.ofId = "of:1234" port.portId = "1" port.admin_state = "enabled" expected_conf = { "ports": { "%s/%s" % (port.switch.ofId, port.portId): { "interfaces": [ { "name": intf1.name, "ips": [ip1.ip, ip2.ip] }, { "name": intf2.name, "ips": [ip3.ip], "vlan-untagged": intf2.vlanUntagged } ], "hostLearning": { "enabled": port.host_learning } } } } m.post("http://onos-fabric:8181/onos/v1/network/configuration/", status_code=200, additional_matcher=functools.partial(match_json, expected_conf)) expected_activation = {"enabled": True} m.post("http://onos-fabric:8181/onos/v1/devices/%s/portstate/%s" % (port.switch.ofId, port.portId), status_code=200, additional_matcher=functools.partial(match_json, expected_activation)) with patch.object(Service.objects, "get") as onos_fabric_get: onos_fabric_get.return_value = self.fabric self.sync_step(model_accessor=self.model_accessor).sync_record(port) self.assertTrue(m.called)