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 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 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 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 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 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 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 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 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 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 _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 _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 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 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 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_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_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_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 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 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 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_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 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__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")
