def test_magic_method_wrapping(self): mock = Mock() def f(self, name): return self, 'fish' mock.__getitem__ = f self.assertIsNot(mock.__getitem__, f) self.assertEqual(mock['foo'], (mock, 'fish')) self.assertEqual(mock.__getitem__('foo'), (mock, 'fish')) mock.__getitem__ = mock self.assertIs(mock.__getitem__, mock)
def testDictMethods(self): mock = Mock() self.assertRaises(TypeError, lambda: mock['foo']) def _del(): del mock['foo'] def _set(): mock['foo'] = 3 self.assertRaises(TypeError, _del) self.assertRaises(TypeError, _set) _dict = {} def getitem(s, name): return _dict[name] def setitem(s, name, value): _dict[name] = value def delitem(s, name): del _dict[name] mock.__setitem__ = setitem mock.__getitem__ = getitem mock.__delitem__ = delitem self.assertRaises(KeyError, lambda: mock['foo']) mock['foo'] = 'bar' self.assertEqual(_dict, {'foo': 'bar'}) self.assertEqual(mock['foo'], 'bar') del mock['foo'] self.assertEqual(_dict, {})
def qs(self, count): """Returns mock queryset with given count.""" qs = Mock() qs.count.return_value = count qs.empty.return_value = [] qs.__getitem__ = Mock() return qs
def case_no_endpoint_match(self, scObj): # empty endpoint list scObj.catalog = dict() scObj.catalog['endpoints'] = list() self.assertRaises(exceptions.EndpointNotFound, scObj._url_for) def side_effect_func_ep(attr): return "test_attr_value" # simulating dict endpoint = Mock() mock = Mock() mock.side_effect = side_effect_func_ep endpoint.__getitem__ = mock scObj.catalog['endpoints'].append(endpoint) # not-empty list but not matching endpoint filter_value = "not_matching_value" self.assertRaises(exceptions.EndpointNotFound, scObj._url_for, attr="test_attr", filter_value=filter_value) filter_value = "test_attr_value" # so that we have an endpoint match scObj.root_key = "access" scObj.catalog[scObj.root_key] = dict() self.assertRaises(exceptions.EndpointNotFound, scObj._url_for, attr="test_attr", filter_value=filter_value)
def prepare_orm(self, spec): orm = Mock(autospec=spec) items = { "social_auth.UserSocialAuth": Mock() } orm.__getitem__ = lambda self, name: items[name] return orm
def test_ServerDetails(self): hw_id = 1234 client = Mock() client.__getitem__ = Mock() service = client['Hardware_Server'] service.getObject = hardware_mock.getObject_Mock(1000) dns_mock = hardware_mock.getReverseDomainRecords_Mock(1000) service.getReverseDomainRecords = dns_mock args = {'<identifier>': hw_id, '--passwords': True, '--price': True} output = server.ServerDetails.execute(client, args) expected = { 'status': 'ACTIVE', 'datacenter': 'TEST00', 'created': '2013-08-01 15:23:45', 'notes': 'These are test notes.', 'hostname': 'hardware-test1.test.sftlyr.ws', 'public_ip': '172.16.1.100', 'private_ip': '10.1.0.2', 'price rate': 1.54, 'memory': 2048, 'cores': 2, 'ptr': '2.0.1.10.in-addr.arpa', 'os': 'Ubuntu', 'id': 1000, 'tags': ['test_tag'], 'users': ['root abc123'], 'vlans': [{'id': 9653, 'number': 1800, 'type': 'PRIVATE'}, {'id': 19082, 'number': 3672, 'type': 'PUBLIC'}] } self.assertEqual(expected, format_output(output, 'python'))
def data(self, addr_type, ver=False, connect=False, rsv=False): addr_types = { 'ipv4': '\x01', 'domain name': '\x03', 'ipv6': '\x04', 'unsupported': 'unsupported' } end_data = { 'ipv4': ['a'] * 4 + ['b'] * 2, 'domain name': ['c'] + ['d'] * 5 + ['e'] * 2, 'ipv6': ['f'] * 16 + ['g'] * 2, 'unsupported': [] } data_arr = [ '\x05' if ver else 'ver', '\x01' if connect else 'connect', '\x00' if rsv else 'rsv', addr_types[addr_type] ] + end_data[addr_type] # creating a custom getitem operator is easier than creating a new # bytestring from scratch (overloading array[slice]) data = Mock() data.__getitem__ = lambda s, val: (''.join(data_arr[ val.start:val.stop]) if isinstance(val, slice) else data_arr[val]) return data
def data(self, addr_type, ver=False, connect=False, rsv=False): addr_types = { 'ipv4': '\x01', 'domain name': '\x03', 'ipv6': '\x04', 'unsupported': 'unsupported' } end_data = { 'ipv4': ['a'] * 4 + ['b'] * 2, 'domain name': ['c'] + ['d'] * 5 + ['e'] * 2, 'ipv6': ['f'] * 16 + ['g'] * 2, 'unsupported': [] } data_arr = [ '\x05' if ver else 'ver', '\x01' if connect else 'connect', '\x00' if rsv else 'rsv', addr_types[addr_type]] + end_data[addr_type] # creating a custom getitem operator is easier than creating a new # bytestring from scratch (overloading array[slice]) data = Mock() data.__getitem__ = lambda s, val: ( ''.join(data_arr[val.start:val.stop]) if isinstance(val, slice) else data_arr[val]) return data
def setUp(self): # NOTE this context will not push and pop so we can inspect it self.context = {} mock_cxt = Mock() mock_cxt.__getitem__ = lambda _, x: self.context[x] mock_cxt.__setitem__ = lambda _, x, y: self.context.__setitem__(x, y) self.mock_cxt = mock_cxt
def testMagicMethodWrapping(self): mock = Mock() def f(self, name): return self, 'fish' mock.__getitem__ = f self.assertFalse(mock.__getitem__ is f) self.assertEqual(mock['foo'], (mock, 'fish')) # When you pull the function back of the *instance* # the first argument (self) is removed def instance_f(name): pass self.assertEqual(inspect.getargspec(mock.__getitem__), inspect.getargspec(instance_f)) mock.__getitem__ = mock self.assertTrue(mock.__getitem__ is mock)
def test_input_sample_init_getitem_noexpand_param(): mock_obj = Mock() mock_obj.__getitem__ = Mock(return_value=[0, 1, 2]) mock_obj.__setitem__ = Mock() s = InputSample(4, 3, mock_obj, expand=False) assert hasattr(s, "__getitem__") assert s[1] == [0, 1, 2] mock_obj.__getitem__.assert_called_once_with(1)
def _dict_mock(self, **kwargs): """ Get a mock that allows __getitem__ """ item = Mock() item.data = kwargs item.__getitem__ = lambda s, k: s.data[k] return item
def test_input_sample_init_getitem_noexpand_param(): mock_obj = Mock() mock_obj.__getitem__ = Mock(return_value=[0, 1, 2]) mock_obj.__setitem__ = Mock() s = InputSample(4, 3, mock_obj, expand=False) assert hasattr(s, '__getitem__') assert s[1] == [0, 1, 2] mock_obj.__getitem__.assert_called_once_with(1)
def testDeletingMagicMethods(self): mock = Mock() self.assertFalse(hasattr(mock, '__getitem__')) mock.__getitem__ = Mock() self.assertTrue(hasattr(mock, '__getitem__')) del mock.__getitem__ self.assertFalse(hasattr(mock, '__getitem__'))
def test_global_read(self): o = Mock() o.__getitem__ = Mock(return_value=3) o.__setitem__ = Mock() self.e.register_global('test', o) self.assertEqual(self.e['test'][1], 3) o.__getitem__.assert_called_once() self.e['test'][1] = 3 o.__setitem__.assert_called_with(1, 3) self.assertEqual(self.e, Environment())
def mock_component(): mock_component = Mock(spec=Component) mock_component.name = COMPONENT_NAME set_item_mock = Mock() set_item_mock.side_effect = setitem get_item_mock = Mock() get_item_mock.side_effect = getitem mock_component.__setitem__ = set_item_mock mock_component.__getitem__ = get_item_mock return mock_component
def test_del_variabledefattr_backwards(self): migration = self._pick_migration("0013_del_variabledefattr") orm = Mock(autospec=migration.prev_orm()) available_models = {"platform.variabledef": Mock()} orm.__getitem__ = lambda self, model: available_models[model.lower()] with patch("wirecloud.platform.south_migrations.0013_del_variabledefattr.db", autospec=True): migration_instance = migration.migration_instance() with patch.object(migration_instance, "gf", autospec=True): migration_instance.backwards(orm)
def test_input_sample_init_getitem_expand_param(): mock_obj = Mock() mock_obj.__getitem__ = Mock(return_value=[0, 1, 2]) mock_obj.__setitem__ = Mock() s = InputSample(4, 3, mock_obj, expand=True) assert s._array == [[0, 1, 2]] * 4 expected = [((0,), {})] * 3 + [((1,), {})] * 3 + [((2,), {})] * 3 + [((3,), {})] * 3 assert mock_obj.__getitem__.call_args_list == expected s[3] = ["s"] assert s._setitem == s._assign_to_array assert not mock_obj.__setitem__.called # expand=T copied the contents
def test(get_database): database_mock = Mock() database_mock.__getitem__ = Mock(return_value='$20.33') database_mock.close = Mock(return_value=None) get_database.return_value = database_mock assert get_transaction('mocked_transaction_id') == '$20.33' get_database.assert_called_with() database_mock.__getitem__.assert_called_with('mocked_transaction_id')
def make_mock_manifest(*items): rv = Mock(tests_root="/foobar") tests = [] rv.__iter__ = lambda self: iter(tests) rv.__getitem__ = lambda self, k: tests[k] for test_type, dir_path, num_tests in items: for i in range(num_tests): filename = dir_path + "/%i.html" % i tests.append((test_type, filename, {TestharnessTest("/foo.bar", filename, "/", filename)})) return rv
def test_input_sample_init_getitem_expand_param(): mock_obj = Mock() mock_obj.__getitem__ = Mock(return_value=[0, 1, 2]) mock_obj.__setitem__ = Mock() s = InputSample(4, 3, mock_obj, expand=True) assert s._array == [[0, 1, 2]] * 4 expected = [((0,), {})] * 3 + \ [((1,), {})] * 3 + [((2,), {})] * 3 + [((3,), {})] * 3 assert mock_obj.__getitem__.call_args_list == expected s[3] = ["s"] assert s._setitem == s._assign_to_array assert not mock_obj.__setitem__.called # expand=T copied the contents
def test_add_gcode_file(self): fake = Mock() fake.filename = "test_stl.gcode" self.filenames.append(fake.filename) fake.__getitem__ = "SOMETHING" result, done = self.manager.addFile(fake, FileDestinations.LOCAL) logging.info("RESULT:%s" % str(result)) self.assertTrue(fake.filename == result) self.assertTrue(done)
def test_remove_userprefoption_model_and_metadata_fields_backwards(self): migration = self._pick_migration("0012_remove_userprefoption_model_and_metadata_fields") orm = Mock(autospec=migration.prev_orm()) available_models = {"platform.variabledef": Mock()} orm.__getitem__ = lambda self, model: available_models[model.lower()] with patch( "wirecloud.platform.south_migrations.0012_remove_userprefoption_model_and_metadata_fields.db", autospec=True ): migration_instance = migration.migration_instance() with patch.object(migration_instance, "gf", autospec=True): migration_instance.backwards(orm)
def test__list(self): self.instances.api.client.get = Mock(return_value=('resp', None)) self.assertRaises(Exception, self.instances._list, "url", None) body = Mock() body.get = Mock(return_value=[{'href': 'http://test.net/test_file', 'rel': 'next'}]) body.__getitem__ = Mock(return_value='instance1') #self.instances.resource_class = Mock(return_value="instance-1") self.instances.api.client.get = Mock(return_value=('resp', body)) _expected = [{'href': 'http://test.net/test_file', 'rel': 'next'}] self.assertEqual(_expected, self.instances._list("url", None).links)
def test_find_elements(self): expected = [{ '_id': 'some id 1', 'foo': 'bar', 'i': 5 }, { '_id': 'some id 2', 'foo': 'bar', 'i': 9 }, { '_id': 'some id 3', 'foo': 'bar', 'i': 15 }] iterator = iter(expected) fake_cursor = Mock() fake_cursor_next = lambda self: next(iterator) attrs = { 'next.side_effect': fake_cursor_next, # Python2 compatiblity } fake_cursor.configure_mock(**attrs) fake_cursor.__next__ = fake_cursor_next fake_cursor.__len__ = lambda self: len(expected) fake_cursor.__getitem__ = lambda self, idx: expected.__getitem__(idx) self.driver.process_query = MagicMock(return_value=fake_cursor) ast = [{ 'name': 'filter', 'val': [{ 'name': 'prop', 'val': 'foo' }, { 'name': 'cond', 'val': '==' }, { 'name': 'val', 'val': 'bar' }] }] cursor = self.driver.find_elements(ast) self.assertIsInstance(cursor, Cursor) self.assertIsInstance(cursor[0], Model) self.assertEqual(len(cursor), len(expected)) self.assertEqual([model.data for model in cursor], expected) self.driver.process_query.assert_called_with({ 'type': Driver.QUERY_READ, 'filter': ast })
def test_get_df_handles_dttm_col(self): datasource = Mock() datasource.type = 'table' datasource.offset = 1 mock_dttm_col = Mock() mock_dttm_col.python_date_format = 'epoch_ms' datasource.get_col = Mock(return_value=mock_dttm_col) form_data = {'dummy': 123} query_obj = {'granularity': 'day'} results = Mock() results.query = Mock() results.status = Mock() results.error_message = Mock() df = Mock() df.columns = [DTTM_ALIAS] f_datetime = datetime(1960, 1, 1, 5, 0) df.__getitem__ = Mock(return_value=pd.Series([f_datetime])) df.__setitem__ = Mock() df.replace = Mock() df.fillna = Mock() results.df = df results.df.empty = False datasource.query = Mock(return_value=results) test_viz = viz.BaseViz(datasource, form_data) test_viz.df_metrics_to_num = Mock() test_viz.get_fillna_for_columns = Mock(return_value=0) test_viz.get_df(query_obj) mock_call = df.__setitem__.mock_calls[0] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertFalse(mock_call[1][1].empty) self.assertEqual(mock_call[1][1][0], f_datetime) mock_call = df.__setitem__.mock_calls[1] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertEqual(mock_call[1][1][0].hour, 6) self.assertEqual(mock_call[1][1].dtype, 'datetime64[ns]') mock_dttm_col.python_date_format = 'utc' test_viz.get_df(query_obj) mock_call = df.__setitem__.mock_calls[2] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertFalse(mock_call[1][1].empty) self.assertEqual(mock_call[1][1][0].hour, 7) mock_call = df.__setitem__.mock_calls[3] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertEqual(mock_call[1][1][0].hour, 6) self.assertEqual(mock_call[1][1].dtype, 'datetime64[ns]') mock_call = df.__setitem__.mock_calls[4] self.assertEqual(mock_call[1][0], DTTM_ALIAS) self.assertEqual(mock_call[1][1][0].hour, 7) self.assertEqual(mock_call[1][1].dtype, 'datetime64[ns]')
def test_del_variabledefattr_backwards(self): migration = self._pick_migration('0013_del_variabledefattr') orm = Mock(autospec=migration.prev_orm()) available_models = { 'platform.variabledef': Mock(), } orm.__getitem__ = lambda self, model: available_models[model.lower()] with patch( 'wirecloud.platform.south_migrations.0013_del_variabledefattr.db', autospec=True): migration_instance = migration.migration_instance() with patch.object(migration_instance, 'gf', autospec=True): migration_instance.backwards(orm)
def test__list(self): self.management.api.client.get = Mock(return_value=('resp', None)) self.assertRaises(Exception, self.management._list, "url", None) body = Mock() body.get = Mock(return_value=[{ 'href': 'http://test.net/test_file', 'rel': 'next' }]) body.__getitem__ = Mock(return_value='instance1') self.management.resource_class = Mock(return_value="instance-1") self.management.api.client.get = Mock(return_value=('resp', body)) _expected = [{'href': 'http://test.net/test_file', 'rel': 'next'}] self.assertEqual(_expected, self.management._list("url", None).links)
def test_count_two_live_neighbours(): """We should be able to count our live neighbours""" row_one = Mock(Row) row_one.__getitem__ = Mock() row_one_cellstates = [".", "*", "."] def get_row_one_cell(key): return row_one_cellstates[key] row_one.__getitem__.side_effect = get_row_one_cell row_two = Mock(Row) row_two.__getitem__ = Mock() row_two_cellstates = [".", "*", "."] def get_row_two_cell(key): return row_two_cellstates[key] row_two.__getitem__.side_effect = get_row_two_cell row_three = Mock(Row) row_three.__getitem__ = Mock() row_three_cellstates = [".", "*", "."] def get_row_three_cell(key): return row_three_cellstates[key] row_three.__getitem__.side_effect = get_row_three_cell board = Board(0, Size(3, 3), [row_one, row_two, row_three]) assert board.get_live_neigbour_count(0, 1) == 1 assert board.get_live_neigbour_count(1, 1) == 2 assert board.get_live_neigbour_count(2, 1) == 1
def test_remove_userprefoption_model_and_metadata_fields_backwards(self): migration = self._pick_migration( '0012_remove_userprefoption_model_and_metadata_fields') orm = Mock(autospec=migration.prev_orm()) available_models = { 'platform.variabledef': Mock(), } orm.__getitem__ = lambda self, model: available_models[model.lower()] with patch( 'wirecloud.platform.south_migrations.0012_remove_userprefoption_model_and_metadata_fields.db', autospec=True): migration_instance = migration.migration_instance() with patch.object(migration_instance, 'gf', autospec=True): migration_instance.backwards(orm)
def test_pagination_es_query_no_data(self): request = Mock() request.query_params = {'limit': 20, 'offset': 30} search_result = Mock() search_result.hits = Mock() search_result.hits.total = 0 search_result.__iter__ = Mock(return_value=iter([])) query = Mock() query.__getitem__ = Mock(return_value=query) query.execute.return_value = search_result pagination = ESQueryPagination() paginated_query = pagination.paginate_es_query(query, request) expect(paginated_query).to.eq([])
def test_subscribe_target_is_allowed(self): mock_receiver = Mock(Receiver) mock_config = Mock(ReceiverConfig) mock_config.configuration = {'allowed_targets': ['foo']} mock_config.__getitem__ = lambda _self, key: mock_config.configuration[ key] mock_receiver.broadcaster = Mock() mock_receiver.broadcaster.client = Mock() mock_receiver.configuration = mock_config Receiver.subscribeTarget(mock_receiver, 'foo') mock_receiver.configuration.reload_targets.assert_called_with() mock_receiver.broadcaster.client.subscribe.assert_called_with( mock_receiver.onEvent, 'foo')
def test_sync_data_existing_bad_snapper_config(self, mock_exists, mock_command, mock_sync, mock_sysconf): item = {'SNAPPER_CONFIGS': '"root foo"'} def getitem(key): return item[key] def contains(key): return key in item sysconf = Mock() sysconf.__contains__ = Mock(side_effect=contains) sysconf.__getitem__ = Mock(side_effect=getitem) mock_sysconf.return_value = sysconf self.volume_manager.custom_args['quota_groups'] = True mock_exists.return_value = True xml_info = etree.tostring( etree.parse('../data/info.xml', etree.XMLParser(remove_blank_text=True))) datetime.datetime.now.return_value = datetime.datetime(2016, 1, 1) self.volume_manager.toplevel_mount = Mock() self.volume_manager.mountpoint = 'tmpdir' self.volume_manager.custom_args['root_is_snapshot'] = True sync = Mock() mock_sync.return_value = sync m_open = mock_open() with patch('builtins.open', m_open, create=True): with raises(KiwiVolumeManagerSetupError): self.volume_manager.sync_data(['exclude_me']) mock_sync.assert_called_once_with('root_dir', 'tmpdir/@/.snapshots/1/snapshot') sync.sync_data.assert_called_once_with(exclude=['exclude_me'], options=[ '--archive', '--hard-links', '--xattrs', '--acls', '--one-file-system', '--inplace' ]) assert m_open.call_args_list == [ call('tmpdir/@/.snapshots/1/info.xml', 'w'), ] assert m_open.return_value.write.call_args_list == [ call(minidom.parseString(xml_info).toprettyxml(indent=" ")) ]
def test_add_stl_file_curaDisabled(self, process, getterMock): getterMock.return_value = False fake = Mock() fake.filename = "test_stl.stl" self.filenames.append(fake.filename) fake.__getitem__ = "SOMETHING" result, done = self.manager.addFile(fake, FileDestinations.LOCAL) logging.info("RESULT:%s" % str(result)) self.assertFalse(process.called) self.assertIsNone(result) self.assertTrue(done)
def side_effect(*args_, **kwargs_): d = dict(*args_, **kwargs_) def getitem(name): return d[name] def setitem(name, value): d[name] = value def contains(name): return name in d m = Mock() m.__getitem__ = Mock(side_effect=getitem) m.__setitem__ = Mock(side_effect=setitem) m.__contains__ = Mock(side_effect=contains) m.get = Mock(side_effect=d.get) m.pop = Mock(side_effect=d.pop) m.update = Mock(side_effect=d.update) self.instances.append(m) return m
def test_index_user(): #setup test_name = 'test' module.DB_NAME = module.USER_COLLECTION = test_name mocked_client = Mock() mocked_db = Mock() mocked_collection = Mock() mocked_client.get_database = Mock(return_value=mocked_db) mocked_db.__getitem__ = Mock(return_value=mocked_collection) mocked_collection.insert_one = Mock() module.MongoClient = Mock(return_value=mocked_client) user = User('*****@*****.**', 'test_display_name') mongo_conn = MongoConn() #functionality mongo_conn.index_user(user) #test mocked_collection.insert_one.assert_called_with(user)
def test_add_stl_file_curaEnabled(self, process, getterMock): getterMock.return_value = True fake = Mock() fake.filename = "test_stl.stl" self.filenames.append(fake.filename) fake.__getitem__ = "SOMETHING" result, done = self.manager.addFile(fake, FileDestinations.LOCAL) logging.info("RESULT:%s" % str(result)) getterMock.assert_called_once_with(["cura", "enabled"]) self.assertTrue(process.called) self.assertTrue("test_stl.gcode" == result) self.assertFalse(done)
def make_mock(shape=[5, 10, 1, 1], maxshape=None): mds = Mock() mds.dataset = np.zeros(shape) mds.refresh = lambda: print("Refresh") if maxshape is None: mds.maxshape = shape else: mds.maxshape = maxshape mds.shape = shape def slicemock(value): return mds.dataset[value] mds.__getitem__ = Mock(side_effect=slicemock) return mds
def test_anchor(self): target = Mock() target.type = "node" source = Mock() source.type = "node" relation = Mock() relation.type = "edge" # given two node objects connected by an edge object target.name = "target" source.name = "source" properties = {"source-object": "source", "target-object": "target"} def getitem(name): return properties[name] relation.__getitem__ = Mock(side_effect=getitem) relation.name = "relation" # added to diagram self.diagram.add(relation) self.diagram.add(target) self.diagram.add(source) # when anchors are set self.diagram.set_anchors() # each DrawableNode object should be referenced by proper DrawableEdge object's anchors drawable_relation = self.diagram.edges["relation"] drawable_source = self.diagram.nodes["source"] drawable_target = self.diagram.nodes["target"] self.assertEquals(drawable_source, drawable_relation.source_anchor.slot) self.assertEquals(drawable_target, drawable_relation.target_anchor.slot) # and each DrawableNode object's anchor should reference the # DrawableEdge object self.assertEquals(drawable_relation, drawable_source.anchors.pop().connector) self.assertEquals(drawable_relation, drawable_target.anchors.pop().connector)
def test__authenticate(self): authObj = auth.Authenticator(Mock(), auth.KeyStoneV2Authenticator, Mock(), Mock(), Mock(), Mock()) # test response code 200 resp = Mock() resp.status = 200 body = "test_body" auth.ServiceCatalog._load = Mock(return_value=1) authObj.client._time_request = Mock(return_value=(resp, body)) sc = authObj._authenticate(Mock(), Mock()) self.assertEqual(body, sc.catalog) # test AmbiguousEndpoints exception auth.ServiceCatalog.__init__ = \ Mock(side_effect=exceptions.AmbiguousEndpoints) self.assertRaises(exceptions.AmbiguousEndpoints, authObj._authenticate, Mock(), Mock()) # test handling KeyError and raising AuthorizationFailure exception auth.ServiceCatalog.__init__ = Mock(side_effect=KeyError) self.assertRaises(exceptions.AuthorizationFailure, authObj._authenticate, Mock(), Mock()) # test EndpointNotFound exception mock = Mock(side_effect=exceptions.EndpointNotFound) auth.ServiceCatalog.__init__ = mock self.assertRaises(exceptions.EndpointNotFound, authObj._authenticate, Mock(), Mock()) mock.side_effect = None # test response code 305 resp.__getitem__ = Mock(return_value='loc') resp.status = 305 body = "test_body" authObj.client._time_request = Mock(return_value=(resp, body)) l = authObj._authenticate(Mock(), Mock()) self.assertEqual('loc', l) # test any response code other than 200 and 305 resp.status = 404 exceptions.from_response = Mock(side_effect=ValueError) self.assertRaises(ValueError, authObj._authenticate, Mock(), Mock())
def test__list(self): def side_effect_func(self, val): return val key = 'key' body = Mock() body.get = Mock(return_value=[{'href': 'http://test.net/test_file', 'rel': 'next'}]) body.__getitem__ = Mock(return_value=["test-value"]) resp = Mock() resp.status_code = 200 self.users.resource_class = Mock(side_effect=side_effect_func) self.users.api.client.get = Mock(return_value=(resp, body)) self.assertEqual(["test-value"], self.users._list('url', key).items) self.users.api.client.get = Mock(return_value=(resp, None)) self.assertRaises(Exception, self.users._list, 'url', None)
def test__list(self): def side_effect_func(self, val): return val key = 'key' body = Mock() body.get = Mock(return_value=[{'href': 'http://test.net/test_file', 'rel': 'next'}]) body.__getitem__ = Mock(return_value=["test-value"]) resp = Mock() resp.status = 200 self.users.resource_class = Mock(side_effect=side_effect_func) self.users.api.client.get = Mock(return_value=(resp, body)) self.assertEqual(["test-value"], self.users._list('url', key).items) self.users.api.client.get = Mock(return_value=(resp, None)) self.assertRaises(Exception, self.users._list, 'url', None)
def test_memcached_decorator(self, cached_data, cache): data = {} key = 'data' func_data = { 'count': 0, 'called': False } expected_value = 'ValueOfDecoratedFunc' cached = Mock() cached.is_valid.return_value = False cached.__getitem__ = lambda s, k: data[k] cached.__setitem__ = lambda s, k, v: data.update({k: v}) cache.get = lambda k: cached cache.set = lambda k, v, e: data.update({key: v, 'e-%s' % key: e}) reload(decorators.base) @decorators.memcached('1s') def decorated_func(): func_data['called'] = True func_data['count'] += 1 return expected_value decorated_func() self.assertTrue(func_data['called']) self.assertIn('data', data) self.assertIn('e-data', data) self.assertIsInstance( data['data'], MagicMock ) self.assertIsInstance( data['e-data'], int ) self.assertEqual((expected_value,), cached_data.call_args[0]) cached.is_valid.return_value = True value = decorated_func() self.assertEqual(1, func_data['count']) self.assertEqual(cached['data'], value)
def case_ambiguous_endpoint(self, scObj): scObj.service_type = "reddwarf" scObj.service_name = "test_service_name" def side_effect_func_service(key): if key == "type": return "reddwarf" elif key == "name": return "test_service_name" return None mock1 = Mock() mock1.side_effect = side_effect_func_service service1 = Mock() service1.get = mock1 endpoint2 = {"test_attr": "test_attr_value"} service1.__getitem__ = Mock(return_value=[endpoint2]) scObj.catalog[scObj.root_key]['serviceCatalog'] = [service1] self.assertRaises(exceptions.AmbiguousEndpoints, scObj._url_for, attr="test_attr", filter_value="test_attr_value")