def make_homeserver(self, reactor, clock):
hs = self.setup_test_homeserver(
"blue",
federation_client=Mock(),
ratelimiter=NonCallableMock(spec_set=["can_do_action"]),
)
hs.get_ratelimiter().can_do_action.return_value = (True, 0)
return hs
def test_attribute_deletion(self):
for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
NonCallableMock()):
self.assertTrue(hasattr(mock, 'm'))
del mock.m
self.assertFalse(hasattr(mock, 'm'))
del mock.f
self.assertFalse(hasattr(mock, 'f'))
self.assertRaises(AttributeError, getattr, mock, 'f')
def test_GetPotatoSprite(self):
spriteMock = NonCallableMock()
self.spriteManager.getSprite.return_value = spriteMock
sprite = self.target.getSprite()
self.spriteManagerExpected.append(call.getSprite())
self.assertIsNotNone(spriteMock)
self.assertEqual(sprite, spriteMock)
def _inject_mock_valid_consumer(self, uuid=None):
"""For changing injected consumer identity to one that passes is_valid()
Returns the injected identity if it need to be examined.
"""
identity = NonCallableMock(name="ValidIdentityMock")
identity.uuid = uuid or "VALIDCONSUMERUUID"
identity.is_valid = Mock(return_value=True)
identity.cert_dir_path = "/not/a/real/path/to/pki/consumer/"
inj.provide(inj.IDENTITY, identity)
return identity
def test_authorize_on_tenant(self):
test_rule = NonCallableMock()
trove_policy.authorize_on_tenant(self.context, test_rule)
self.mock_get_enforcer.assert_called_once_with()
self.mock_enforcer.authorize.assert_called_once_with(
test_rule,
{'tenant': self.context.project_id},
self.context.to_dict(),
do_raise=True, exc=trove_exceptions.PolicyNotAuthorized,
action=test_rule
)
def test_get_value_from_iterable(self):
field = ObjectField(attr='person',
properties={
'first_name': TextField(analyzer='foo'),
'last_name': TextField()
})
instance = NonCallableMock(person=[
NonCallableMock(first_name="foo1", last_name="bar1"),
NonCallableMock(first_name="foo2", last_name="bar2")
])
self.assertEqual(field.get_value_from_instance(instance),
[{
'first_name': "foo1",
'last_name': "bar1",
}, {
'first_name': "foo2",
'last_name': "bar2",
}])
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.mock_config = NonCallableMock()
self.mock_config.signing_key = [MockKey()]
db_pool = SQLiteMemoryDbPool()
yield db_pool.prepare()
hs = HomeServer(
"red",
db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
config=self.mock_config,
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
hs.get_handlers().federation_handler = Mock()
self.auth_user_id = self.user_id
def _get_user_by_token(token=None):
return {
"user": hs.parse_userid(self.auth_user_id),
"admin": False,
"device_id": None,
}
hs.get_auth().get_user_by_token = _get_user_by_token
def _insert_client_ip(*args, **kwargs):
return defer.succeed(None)
hs.get_datastore().insert_client_ip = _insert_client_ip
synapse.rest.room.register_servlets(hs, self.mock_resource)
def test_get_value_from_instance_without_properties(self):
field = ObjectField(attr='person')
instance = NonCallableMock(person={
'first_name': 'foo',
'last_name': 'bar'
})
self.assertEqual(field.get_value_from_instance(instance), {
'first_name': "foo",
'last_name': "bar"
})
def test_get_value_from_instance_with_none_inner_objectfield(self):
field = ObjectField(
attr="person",
properties={
"first_name": TextField(analyzier="foo"),
"last_name": TextField(),
"aditional": ObjectField(properties={"age": IntegerField()}),
},
)
instance = NonCallableMock(person=NonCallableMock(
first_name="foo", last_name="bar", aditional=None))
self.assertEqual(
field.get_value_from_instance(instance),
{
"first_name": "foo",
"last_name": "bar",
"aditional": {}
},
)
def test_push_later(self):
# Ask for an item from the worklist
ret = self.worklist.pop()
# It is an empy, uncalled deferred
self.assertFalse(ret.called)
# Push an item to the worklist later
item = NonCallableMock(spec_set=[])
self.worklist.push('a', item)
# now the item we got before, will be called,
# and contain the item we pushed
self.assertTrue(ret.called)
self.assertEqual(item, ret.result)
def test_buffer():
es_mock = NonCallableMock(spec=Elasticsearch)
callback = ElasticCallback(
'test_run',
'test_index',
es_client=es_mock,
buffer_length=10
)
callback.on_batch_begin(1)
callback.on_batch_end(1)
es_mock.index.assert_not_called()
def test_assert_called_with_failure_message(self):
mock = NonCallableMock()
expected = "mock(1, '2', 3, bar='foo')"
message = 'Expected call: %s\nNot called'
self.assertRaisesWithMsg(
AssertionError, message % (expected,),
mock.assert_called_with, 1, '2', 3, bar='foo'
)
mock.foo(1, '2', 3, foo='foo')
asserters = [
mock.foo.assert_called_with, mock.foo.assert_called_once_with
]
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo(1, '2', 3, bar='foo')"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual),
meth, 1, '2', 3, bar='foo'
)
# just kwargs
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo(bar='foo')"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual),
meth, bar='foo'
)
# just args
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo(1, 2, 3)"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual),
meth, 1, 2, 3
)
# empty
for meth in asserters:
actual = "foo(1, '2', 3, foo='foo')"
expected = "foo()"
message = 'Expected call: %s\nActual call: %s'
self.assertRaisesWithMsg(
AssertionError, message % (expected, actual), meth
)
def test_GetSprite(self):
spriteMock = NonCallableMock()
self.spriteManager.getSprite.return_value = spriteMock
sprite = self.target.getSprite()
self.spriteManagerExpected.append(
call.createSpriteFromImagePath(
0, 0, 600, 300,
os.path.join('JumperPY', 'bin', 'Resources', 'menu.png')))
self.spriteManagerExpected.append(call.getSprite())
self.assertIsNotNone(spriteMock)
self.assertEqual(sprite, spriteMock)
def test_get_value_from_instance_with_inner_objectfield(self):
field = ObjectField(attr='person',
properties={
'first_name':
StringField(analyzier='foo'),
'last_name':
StringField(),
'aditional':
ObjectField(properties={'age': IntegerField()})
})
instance = NonCallableMock(
person=NonCallableMock(first_name="foo",
last_name="bar",
aditional=NonCallableMock(age=12)))
self.assertEqual(field.get_value_from_instance(instance), {
'first_name': "foo",
'last_name': "bar",
'aditional': {
'age': 12
}
})
def test_clean_up_remove_180_pem(self, mock_remove, mock_isfile):
mock_product_directory = NonCallableMock(spec=ProductDirectory)
mock_product_directory.path = "/some/path"
inj.provide(inj.PROD_DIR, mock_product_directory)
self.engine.db = MagicMock()
mock_isfile.side_effect = iter([False, False])
self.engine.clean_up([
"rhel-i386-client-dts-5-beta",
"rhel-i386-client-dts-5",
])
mock_remove.assert_called_with("/some/path/180.pem")
self.engine.db.delete.assert_called_with("180")
self.engine.db.write.assert_called_with()
def test_get_value_from_instance_with_inner_objectfield_without_properties(self):
field = ObjectField(
attr='person',
properties={
'first_name': TextField(analyzer='foo'),
'last_name': TextField(),
'additional': ObjectField()
}
)
instance = NonCallableMock(person=NonCallableMock(
first_name="foo",
last_name="bar",
additional={'age': 12}
))
self.assertEqual(field.get_value_from_instance(instance),
{
'first_name': "foo",
'last_name': "bar",
'additional': {'age': 12}
}
)
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
state_handler = Mock(spec=["handle_new_event"])
state_handler.handle_new_event.return_value = True
persistence_service = Mock(spec=["get_latest_pdus_in_context"])
persistence_service.get_latest_pdus_in_context.return_value = []
hs = HomeServer(
"red",
db_pool=None,
http_client=None,
datastore=MemoryDataStore(),
replication_layer=Mock(),
state_handler=state_handler,
persistence_service=persistence_service,
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
config=NonCallableMock(),
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
hs.get_handlers().federation_handler = Mock()
def _get_user_by_token(token=None):
return hs.parse_userid(self.auth_user_id)
hs.get_auth().get_user_by_token = _get_user_by_token
synapse.rest.room.register_servlets(hs, self.mock_resource)
# create the room
self.room_id = yield self.create_room_as(self.user_id)
self.path = "/rooms/%s/state/m.room.topic" % self.room_id
def setUp(self):
self.hs = yield setup_test_homeserver(
"red",
http_client=None,
replication_layer=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
)
self.user_id = "@seeing:red"
self.user = UserID.from_string(self.user_id)
self.hs.get_ratelimiter().send_message.return_value = (True, 0)
self.resource = ReplicationResource(self.hs)
def test_update_button_disabled(self):
# Need an unregistered consumer object:
id_mock = NonCallableMock()
id_mock.name = None
id_mock.uuid = None
def new_identity():
return id_mock
provide(IDENTITY, new_identity)
dialog = factsgui.SystemFactsDialog()
dialog.show()
enabled = dialog.update_button.get_property('sensitive')
self.assertFalse(enabled)
def setUp(self):
self.hs = yield setup_test_homeserver(
"blue",
http_client=None,
replication_layer=Mock(),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
)
self.hs.get_ratelimiter().send_message.return_value = (True, 0)
self.replication = ReplicationResource(self.hs)
self.master_store = self.hs.get_datastore()
self.slaved_store = self.STORE_TYPE(self.hs.get_db_conn(), self.hs)
self.event_id = 0
def make_homeserver(self, reactor, clock):
config = self.default_config()
config.enable_registration_captcha = False
config.enable_registration = True
config.auto_join_rooms = []
hs = self.setup_test_homeserver(
config=config,
ratelimiter=NonCallableMock(spec_set=["send_message"]))
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
hs.get_handlers().federation_handler = Mock()
return hs
def make_homeserver(self, reactor, clock):
config = self.default_config()
config["enable_registration_captcha"] = False
config["enable_registration"] = True
config["auto_join_rooms"] = []
hs = self.setup_test_homeserver(
config=config,
ratelimiter=NonCallableMock(spec_set=["can_do_action"]))
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.can_do_action.return_value = (True, 0)
hs.get_handlers().federation_handler = Mock()
return hs
def setUp(self):
self.mock_config = NonCallableMock()
self.mock_config.signing_key = [MockKey()]
self.state_handler = NonCallableMock(spec_set=[
"compute_event_context",
])
self.auth = NonCallableMock(spec_set=[
"check",
"check_host_in_room",
])
self.hostname = "test"
hs = HomeServer(
self.hostname,
db_pool=None,
datastore=NonCallableMock(spec_set=[
"persist_event",
"store_room",
"get_room",
"get_destination_retry_timings",
"set_destination_retry_timings",
]),
resource_for_federation=NonCallableMock(),
http_client=NonCallableMock(spec_set=[]),
notifier=NonCallableMock(spec_set=["on_new_room_event"]),
handlers=NonCallableMock(spec_set=[
"room_member_handler",
"federation_handler",
]),
config=self.mock_config,
auth=self.auth,
state_handler=self.state_handler,
keyring=Mock(),
)
self.datastore = hs.get_datastore()
self.handlers = hs.get_handlers()
self.notifier = hs.get_notifier()
self.hs = hs
self.handlers.federation_handler = FederationHandler(self.hs)
def setUp(self):
self.mock_federation = Mock(spec=[
"make_query",
])
self.query_handlers = {}
def register_query_handler(query_type, handler):
self.query_handlers[query_type] = handler
self.mock_federation.register_query_handler = register_query_handler
db_pool = SQLiteMemoryDbPool()
yield db_pool.prepare()
self.mock_config = Mock()
self.mock_config.signing_key = [MockKey()]
hs = HomeServer("test",
db_pool=db_pool,
http_client=None,
handlers=None,
resource_for_federation=Mock(),
replication_layer=self.mock_federation,
config=self.mock_config,
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]))
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
hs.handlers = ProfileHandlers(hs)
self.store = hs.get_datastore()
self.frank = hs.parse_userid("@1234ABCD:test")
self.bob = hs.parse_userid("@4567:test")
self.alice = hs.parse_userid("@alice:remote")
yield self.store.create_profile(self.frank.localpart)
self.handler = hs.get_handlers().profile_handler
# TODO(paul): Icky signal declarings.. booo
hs.get_distributor().declare("changed_presencelike_data")
def test_simple(tmpdir, capsys):
with tmpdir.join('ceph.conf').open('w') as f:
f.write("""\
[global]
fsid = 6ede5564-3cf1-44b5-aa96-1c77b0c3e1d0
mon initial members = host1
""")
ns = argparse.Namespace()
ns.pushy = Mock()
conn = NonCallableMock(name='PushyClient')
ns.pushy.return_value = conn
mock_compiled = collections.defaultdict(Mock)
conn.compile.side_effect = mock_compiled.__getitem__
MON_SECRET = 'AQBWDj5QAP6LHhAAskVBnUkYHJ7eYREmKo5qKA=='
def _create_mon(cluster, get_monitor_secret):
secret = get_monitor_secret()
assert secret == MON_SECRET
fake_ip_addresses = lambda x: ['10.0.0.1']
try:
with patch('ceph_deploy.new.net.ip_addresses', fake_ip_addresses):
with patch('ceph_deploy.new.net.get_nonlocal_ip', lambda x: '10.0.0.1'):
with patch('ceph_deploy.new.arg_validators.Hostname', lambda: lambda x: x):
with patch('ceph_deploy.new.hosts'):
with directory(str(tmpdir)):
main(
args=['-v', 'new', '--no-ssh-copykey', 'host1'],
namespace=ns,
)
main(
args=['-v', 'mon', 'create', 'host1'],
namespace=ns,
)
except SystemExit as e:
raise AssertionError('Unexpected exit: %s', e)
out, err = capsys.readouterr()
err = err.lower()
assert 'creating new cluster named ceph' in err
assert 'monitor host1 at 10.0.0.1' in err
assert 'resolving host host1' in err
assert "monitor initial members are ['host1']" in err
assert "monitor addrs are ['10.0.0.1']" in err
def test_all_events():
es_mock = NonCallableMock(spec=Elasticsearch)
callback = ElasticCallback(
'test_run',
'test_index',
es_client=es_mock,
)
for event in events_names:
func = getattr(callback, 'on_' + event)
if 'batch' in event or 'epoch' in event:
func(1)
else:
func()
args = es_mock.index.call_args[1]
assert args['doc_type'] == event
def setUp(self):
self.mock_http_client = Mock(spec=[])
self.mock_http_client.put_json = DeferredMockCallable()
self.mock_federation_resource = MockHttpResource()
db_pool = SQLiteMemoryDbPool()
yield db_pool.prepare()
self.mock_config = NonCallableMock()
self.mock_config.signing_key = [MockKey()]
hs = HomeServer(
"test",
clock=MockClock(),
db_pool=db_pool,
handlers=None,
resource_for_client=Mock(),
resource_for_federation=self.mock_federation_resource,
http_client=self.mock_http_client,
config=self.mock_config,
keyring=Mock(),
)
hs.handlers = JustPresenceHandlers(hs)
self.store = hs.get_datastore()
# Some local users to test with
self.u_apple = hs.parse_userid("@apple:test")
self.u_banana = hs.parse_userid("@banana:test")
yield self.store.create_presence(self.u_apple.localpart)
yield self.store.create_presence(self.u_banana.localpart)
# ID of a local user that does not exist
self.u_durian = hs.parse_userid("@durian:test")
# A remote user
self.u_cabbage = hs.parse_userid("@cabbage:elsewhere")
self.handler = hs.get_handlers().presence_handler
self.mock_start = Mock()
self.mock_stop = Mock()
self.handler.start_polling_presence = self.mock_start
self.handler.stop_polling_presence = self.mock_stop
def setUp(self):
self.clock = ThreadedMemoryReactorClock()
self.hs_clock = Clock(self.clock)
self.hs = setup_test_homeserver(
self.addCleanup,
"red",
http_client=None,
clock=self.hs_clock,
reactor=self.clock,
federation_client=Mock(),
ratelimiter=NonCallableMock(spec_set=["send_message"]),
)
self.ratelimiter = self.hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
self.hs.get_federation_handler = Mock(return_value=Mock())
def get_user_by_access_token(token=None, allow_guest=False):
return {
"user": UserID.from_string(self.helper.auth_user_id),
"token_id": 1,
"is_guest": False,
}
def get_user_by_req(request, allow_guest=False, rights="access"):
return synapse.types.create_requester(
UserID.from_string(self.helper.auth_user_id), 1, False, None)
self.hs.get_auth().get_user_by_req = get_user_by_req
self.hs.get_auth().get_user_by_access_token = get_user_by_access_token
self.hs.get_auth().get_access_token_from_request = Mock(
return_value=b"1234")
def _insert_client_ip(*args, **kwargs):
return defer.succeed(None)
self.hs.get_datastore().insert_client_ip = _insert_client_ip
self.resource = JsonResource(self.hs)
synapse.rest.client.v1.room.register_servlets(self.hs, self.resource)
synapse.rest.client.v1.room.register_deprecated_servlets(
self.hs, self.resource)
self.helper = RestHelper(self.hs, self.resource, self.user_id)
def test_setting_custom_mock(self, mock_open):
"""Check 'manually' setting a mock for a file."""
custom_mock = NonCallableMock()
mock_open["/path/to/file"] = custom_mock
# Make sure other files aren't affected.
self.assertIsInstance(open("/path/to/other_file", "r"), FileLikeMock)
# Check with a regular call.
self.assertEqual(custom_mock, open("/path/to/file", "r"))
# Check as a context manager.
custom_mock.read.side_effect = IOError()
custom_mock.write.side_effect = IOError()
with open("/path/to/file") as handle:
self.assertIs(custom_mock, handle)
self.assertRaises(IOError, handle.read)
self.assertRaises(IOError, handle.write, "error")
def test_data():
es_mock = NonCallableMock(spec=Elasticsearch)
callback = ElasticCallback(
'test_run',
'test_index',
event_data={'data_key': 'data_value'},
es_client=es_mock,
)
callback.on_epoch_begin(1)
es_mock.index.assert_called_once()
args = es_mock.index.call_args[1]
assert args['index'] == 'test_index'
assert args['doc_type'] == 'epoch_begin'
assert args['body']['event'] == 'epoch_begin'
assert args['body']['run_name'] == 'test_run'
assert args['body']['data_key'] == 'data_value'
assert args['body']['epoch'] == 1
