def test_volume_export(self, mockrepo):
mockobj = NonCallableMock()
mockobj.pid = 'vol:1'
mockobj.title = 'Lecoq, the detective'
mockobj.volume = 'V.1'
mockobj.date = ['1801']
mockrepo.return_value.get_object.return_value = mockobj
# to support for last modified conditional
mockobj.ocr.created = datetime.now()
# anonymous
export_url = reverse('books:webexport', kwargs={'pid': mockobj.pid})
response = self.client.get(export_url)
self.assertContains(response,
'''<div class="alert alert-warning">Export functionality is only available
to logged in users.</div>''',
msg_prefix='Anonymous user should see warning when viewing export page',
html=True)
# log in as a regular user
self.client.login(**self.user_credentials['user'])
response = self.client.get(export_url)
self.assert_('export_form' in response.context,
'export form should be set in response context for logged in user')
self.assertContains(response, 'Export to GitHub requires a GitHub account.',
msg_prefix='user should see a warning about github account')
def get(self, **params):
request = NonCallableMock(spec_set=[
"write", "finish", "setResponseCode", "setHeader", "args",
"method", "processing"
])
request.method = "GET"
request.args = {k: [v] for k, v in params.items()}
@contextlib.contextmanager
def processing():
yield
request.processing = processing
yield self.resource._async_render_GET(request)
self.assertTrue(request.finish.called)
if request.setResponseCode.called:
response_code = request.setResponseCode.call_args[0][0]
else:
response_code = 200
response_json = "".join(call[0][0]
for call in request.write.call_args_list)
response_body = json.loads(response_json)
if response_code == 200:
self.check_response(response_body)
defer.returnValue((response_code, response_body))
def test_get_value_from_instance(self):
instance = NonCallableMock(
foo=NonCallableMock(bar=["alpha", "beta", "gamma"])
)
field = ListField(TextField(attr='foo.bar'))
self.assertEqual(
field.get_value_from_instance(instance), instance.foo.bar)
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 test_get_value_from_iterable(self):
field = ObjectField(
attr="person",
properties={
"first_name": TextField(analyzier="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 test_get_value_from_instance_with_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=NonCallableMock(age=12)))
self.assertEqual(
field.get_value_from_instance(instance),
{
"first_name": "foo",
"last_name": "bar",
"aditional": {
"age": 12
}
},
)
def mock_virtualenv_winreg(cls, monkeypatch, data):
def enum_key(key, index):
try:
return data.get(key, [])[index]
except IndexError:
raise WindowsError
def query_value(key, path):
installed_version_tags = data.get(key, [])
suffix = "\\InstallPath"
if path.endswith(suffix):
version_tag = path[: -len(suffix)]
if version_tag in installed_version_tags:
return "{}-{}-path".format(key, version_tag)
raise WindowsError
mock_winreg = NonCallableMock(
spec_set=["HKEY_LOCAL_MACHINE", "HKEY_CURRENT_USER", "CreateKey", "EnumKey", "QueryValue", "CloseKey"]
)
mock_winreg.HKEY_LOCAL_MACHINE = "HKEY_LOCAL_MACHINE"
mock_winreg.HKEY_CURRENT_USER = "******"
mock_winreg.CreateKey.side_effect = [cls.key_local_machine, cls.key_current_user]
mock_winreg.EnumKey.side_effect = enum_key
mock_winreg.QueryValue.side_effect = query_value
mock_winreg.CloseKey.return_value = None
monkeypatch.setattr(virtualenv, "winreg", mock_winreg)
return mock_winreg
def test_start_server(
self, _setKeepAlive, _serverFromString, _tcpd, _getUtility, _executors,
):
executor = Mock(spec=["start"])
_executors.values.return_value = [executor]
config = Mock(spec=["pbport"])
_getUtility.return_value = config
with_port = _tcpd.with_port
descriptor = with_port.return_value
server = _serverFromString.return_value
dfr = defer.Deferred()
server.listen.return_value = dfr
reactor = NonCallableMock(spec=[])
factory = NonCallableMock(spec=[])
listener = Mock(spec=["socket"])
start_server(reactor, factory)
dfr.callback(listener)
executor.start.assert_called_once_with(reactor)
_getUtility.assert_called_once_with(IHubServerConfig)
with_port.assert_called_once_with(config.pbport)
_serverFromString.assert_called_once_with(reactor, descriptor)
server.listen.assert_called_once_with(factory)
_setKeepAlive.assert_called_once_with(listener.socket)
def get(self, **params):
request = NonCallableMock(spec_set=[
"write", "finish", "setResponseCode", "setHeader", "args",
"method", "processing"
])
request.method = "GET"
request.args = {k: [v] for k, v in params.items()}
@contextlib.contextmanager
def processing():
yield
request.processing = processing
yield self.resource._async_render_GET(request)
self.assertTrue(request.finish.called)
if request.setResponseCode.called:
response_code = request.setResponseCode.call_args[0][0]
else:
response_code = 200
response_json = "".join(
call[0][0] for call in request.write.call_args_list
)
response_body = json.loads(response_json)
if response_code == 200:
self.check_response(response_body)
defer.returnValue((response_code, response_body))
def setUp(self):
self.hostname = "test"
hs = HomeServer(
self.hostname,
db_pool=None,
datastore=NonCallableMock(spec_set=[
"persist_event",
"store_room",
"get_room",
]),
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",
]),
)
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_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)
self.room_id = yield self.create_room_as(self.user_id)
def test_authorize_on_target(self):
test_rule = NonCallableMock()
test_target = NonCallableMock()
trove_policy.authorize_on_target(self.context, test_rule, test_target)
self.mock_get_enforcer.assert_called_once_with()
self.mock_enforcer.authorize.assert_called_once_with(
test_rule, test_target, self.context.to_dict(),
do_raise=True, exc=trove_exceptions.PolicyNotAuthorized,
action=test_rule)
def test_pushfront(self):
item1 = NonCallableMock(spec_set=[])
self.worklist.pushfront('a', item1)
item2 = NonCallableMock(spec_set=[])
self.worklist.pushfront('a', item2)
popped_item = self.worklist.pop()
self.assertEqual(item2, popped_item.result)
self.assertEqual(1, len(self.worklist))
def STALE_test_invite_join_public(self):
room_id = "#foo:blue"
user_id = "@bob:red"
target_user_id = "@bob:red"
content = {"membership": Membership.JOIN}
event = self.hs.get_event_factory().create_event(
etype=RoomMemberEvent.TYPE,
user_id=user_id,
target_user_id=target_user_id,
room_id=room_id,
membership=Membership.JOIN,
content=content,
)
joined = ["red", "blue", "green"]
self.state_handler.handle_new_event.return_value = defer.succeed(True)
self.datastore.get_joined_hosts_for_room.return_value = (
defer.succeed(joined)
)
store_id = "store_id_fooo"
self.datastore.store_room_member.return_value = defer.succeed(store_id)
self.datastore.get_room.return_value = defer.succeed(None)
prev_state = NonCallableMock(name="prev_state")
prev_state.membership = Membership.INVITE
prev_state.sender = "@foo:blue"
self.datastore.get_room_member.return_value = defer.succeed(prev_state)
# Actual invocation
yield self.room_member_handler.change_membership(event)
self.assertTrue(self.federation.handle_new_event.called)
args = self.federation.handle_new_event.call_args[0]
invite_join_event = args[0]
self.assertTrue(InviteJoinEvent.TYPE, invite_join_event.TYPE)
self.assertTrue("blue", invite_join_event.target_host)
self.assertTrue("foo", invite_join_event.room_id)
self.assertTrue(user_id, invite_join_event.user_id)
self.assertFalse(hasattr(invite_join_event, "state_key"))
self.assertEquals(
set(["blue"]),
set(invite_join_event.destinations)
)
self.federation.get_state_for_room.assert_called_once_with(
"blue", "foo"
)
self.assertFalse(self.datastore.store_room_member.called)
self.assertFalse(self.notifier.on_new_room_event.called)
self.assertFalse(self.state_handler.handle_new_event.called)
def test_clean_up_remove_68_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([True, True])
self.engine.clean_up([])
mock_remove.assert_called_with("/some/path/68.pem")
self.engine.db.delete.assert_called_with("68")
self.engine.db.write.assert_called_with()
def _inject_mock_invalid_consumer(self, uuid=None):
"""For chaning injected consumer identity to one that fails is_valid()
Returns the injected identity if it need to be examined.
"""
invalid_identity = NonCallableMock(name='InvalidIdentityMock')
invalid_identity.is_valid = Mock(return_value=False)
invalid_identity.uuid = uuid or "INVALIDCONSUMERUUID"
inj.provide(inj.IDENTITY, invalid_identity)
return invalid_identity
def test_clean_up_remove_68_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([True, True])
self.engine.clean_up([])
mock_remove.assert_called_with("/some/path/68.pem")
self.engine.db.delete.assert_called_with("68")
self.engine.db.write.assert_called_with()
def test_get_value_from_instance_with_partial_properties(self):
field = ObjectField(
attr='person',
properties={'first_name': TextField(analyzer='foo')})
instance = NonCallableMock(
person=NonCallableMock(first_name='foo', last_name='bar'))
self.assertEqual(field.get_value_from_instance(instance),
{'first_name': "foo"})
def setUp(self):
self.mock_notifier = NonCallableMock(MeetmeServiceNotifier)
self.ami_class = Mock(xivo_ami.AMIClass)
self.manager = service_manager.MeetmeServiceManager(
self.mock_notifier,
self.ami_class,
)
self.mock_manager = NonCallableMock(MeetmeServiceManager)
context.register('meetme_service_notifier', self.mock_notifier)
context.register('meetme_service_manager', self.mock_manager)
def _inject_mock_invalid_consumer(self, uuid=None):
"""For chaning injected consumer identity to one that fails is_valid()
Returns the injected identity if it need to be examined.
"""
invalid_identity = NonCallableMock(name='InvalidIdentityMock')
invalid_identity.is_valid = Mock(return_value=False)
invalid_identity.uuid = uuid or "INVALIDCONSUMERUUID"
inj.provide(inj.IDENTITY, invalid_identity)
return invalid_identity
def test_volume_pages(self, mockpaginator, mockrepo):
mockvol = NonCallableMock(spec=Volume)
mockvol.pid = 'vol:1'
mockvol.title = 'Lecoq, the detective'
mockvol.date = ['1801']
# second object retrieved from fedora is page, for layout
mockvol.width = 150
mockvol.height = 200
# volume url needed to identify annotations for pages in this volume
mockvol.get_absolute_url.return_value = reverse(
'books:volume', kwargs={'pid': mockvol.pid})
mockrepo.return_value.get_object.return_value = mockvol
mockvol.find_solr_pages = MagicMock()
mockvol.find_solr_pages.return_value.count = 3
mockvol.find_solr_pages.__len__.return_value = 3
mockpage = Mock(width=640, height=400)
mockvol.pages = [mockpage]
vol_page_url = reverse('books:pages', kwargs={'pid': mockvol.pid})
response = self.client.get(vol_page_url)
# volume method should be used to find pages
self.assert_(call() in mockvol.find_solr_pages.call_args_list)
# volume should be set in context
self.assert_(mockvol, response.context['vol'])
# annotated pages should be empty for anonymous user
self.assertEqual({}, response.context['annotated_pages'])
# log in as a regular user
self.client.login(**self.user_credentials['user'])
testuser = get_user_model().objects.get(
username=self.user_credentials['user']['username'])
page1_url = reverse('books:page',
kwargs={
'vol_pid': mockvol.pid,
'pid': 'page:1'
})
page2_url = reverse('books:page',
kwargs={
'vol_pid': mockvol.pid,
'pid': 'page:2'
})
page3_url = reverse('books:page',
kwargs={
'vol_pid': mockvol.pid,
'pid': 'page:3'
})
mockvol.page_annotation_count.return_value = {
absolutize_url(page1_url): 5,
absolutize_url(page2_url): 2,
page3_url: 13
}
response = self.client.get(vol_page_url)
mockvol.page_annotation_count.assert_called_with(testuser)
annotated_pages = response.context['annotated_pages']
# counts should be preserved; urls should be non-absolute
# whether they started that way or not
self.assertEqual(5, annotated_pages[absolutize_url(page1_url)])
self.assertEqual(2, annotated_pages[absolutize_url(page2_url)])
self.assertEqual(13, annotated_pages[page3_url])
def test_get_value_from_instance(self):
field = FileField(attr="file")
instance = NonCallableMock(file=NonCallableMock(spec=FieldFile,
url="myfile.pdf"), )
self.assertEqual(field.get_value_from_instance(instance), "myfile.pdf")
field = FileField(attr="related.attr1")
instance = NonCallableMock(attr1="foo",
related=NonCallableMock(attr1="bar"))
self.assertEqual(field.get_value_from_instance(instance), "bar")
def test_get_value_from_instance(self):
field = FileField(attr='file')
instance = NonCallableMock(file=NonCallableMock(spec=FieldFile,
url='myfile.pdf'), )
self.assertEqual(field.get_value_from_instance(instance), 'myfile.pdf')
field = FileField(attr='related.attr1')
instance = NonCallableMock(attr1="foo",
related=NonCallableMock(attr1="bar"))
self.assertEqual(field.get_value_from_instance(instance), 'bar')
def request(self, **request):
req = super(MonkeyPatchedRF, self).request(**request)
if self.add_session:
req.session = NonCallableMock(name='request session')
req.session.session_key = 'abc123'
if self.add_user:
req.user = NonCallableMock(name='request user')
return req
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 _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_multiple_priorities(self):
item1 = NonCallableMock(spec_set=[])
self.worklist.push('a', item1)
item2 = NonCallableMock(spec_set=[])
self.worklist.push('b', item2)
self.assertEqual(2, len(self.worklist))
items = []
items.append(self.worklist.pop().result)
items.append(self.worklist.pop().result)
self.assertEqual([item1, item2], items)
def test_when_available_differs(self):
self.selection.ignored = "a"
item1 = NonCallableMock(spec_set=[])
self.worklist.push('a', item1)
item2 = NonCallableMock(spec_set=[])
self.worklist.push('b', item2)
self.assertEqual(2, len(self.worklist))
items = []
items.append(self.worklist.pop())
items.append(self.worklist.pop())
self.assertEqual([item2, None], items)
def setUp(self):
self.hostname = "red"
hs = yield setup_test_homeserver(
self.hostname,
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
datastore=NonCallableMock(spec_set=[
"persist_event",
"get_room_member",
"get_room",
"store_room",
"get_latest_events_in_room",
]),
resource_for_federation=NonCallableMock(),
http_client=NonCallableMock(spec_set=[]),
notifier=NonCallableMock(spec_set=["on_new_room_event"]),
handlers=NonCallableMock(spec_set=[
"room_member_handler",
"profile_handler",
"federation_handler",
]),
auth=NonCallableMock(spec_set=[
"check",
"add_auth_events",
"check_host_in_room",
]),
state_handler=NonCallableMock(spec_set=[
"compute_event_context",
"get_current_state",
]),
)
self.federation = NonCallableMock(spec_set=[
"handle_new_event",
"send_invite",
"get_state_for_room",
])
self.datastore = hs.get_datastore()
self.handlers = hs.get_handlers()
self.notifier = hs.get_notifier()
self.state_handler = hs.get_state_handler()
self.distributor = hs.get_distributor()
self.auth = hs.get_auth()
self.hs = hs
self.handlers.federation_handler = self.federation
self.distributor.declare("collect_presencelike_data")
self.handlers.room_member_handler = RoomMemberHandler(self.hs)
self.handlers.profile_handler = ProfileHandler(self.hs)
self.room_member_handler = self.handlers.room_member_handler
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
def setUp(self):
# By default mock that we are registered. Individual test cases
# can override if they are testing disconnected scenario.
id_mock = NonCallableMock(name='FixtureIdentityMock')
id_mock.exists_and_valid = Mock(return_value=True)
id_mock.uuid = 'fixture_identity_mock_uuid'
id_mock.name = 'fixture_identity_mock_name'
# Don't really care about date ranges here:
self.mock_calc = NonCallableMock()
self.mock_calc.calculate.return_value = None
inj.provide(inj.IDENTITY, id_mock)
inj.provide(inj.PRODUCT_DATE_RANGE_CALCULATOR, self.mock_calc)
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, stubs.StubEntitlementStatusCache())
inj.provide(inj.PROD_STATUS_CACHE, stubs.StubProductStatusCache())
inj.provide(inj.OVERRIDE_STATUS_CACHE, stubs.StubOverrideStatusCache())
inj.provide(inj.PROFILE_MANAGER, stubs.StubProfileManager())
# By default set up an empty stub entitlement and product dir.
# Tests need to modify or create their own but nothing should hit
# the system.
self.ent_dir = stubs.StubEntitlementDirectory()
inj.provide(inj.ENT_DIR, self.ent_dir)
self.prod_dir = stubs.StubProductDirectory()
inj.provide(inj.PROD_DIR, self.prod_dir)
# Installed products manager needs PROD_DIR injected first
inj.provide(inj.INSTALLED_PRODUCTS_MANAGER, stubs.StubInstalledProductsManager())
self.stub_cp_provider = stubs.StubCPProvider()
self._release_versions = []
self.stub_cp_provider.content_connection.get_versions = self._get_release_versions
inj.provide(inj.CP_PROVIDER, self.stub_cp_provider)
inj.provide(inj.CERT_SORTER, stubs.StubCertSorter())
# setup and mock the plugin_manager
plugin_manager_mock = Mock(name='FixturePluginManagerMock')
inj.provide(inj.PLUGIN_MANAGER, plugin_manager_mock)
inj.provide(inj.DBUS_IFACE, Mock(name='FixtureDbusIfaceMock'))
pooltype_cache = Mock()
inj.provide(inj.POOLTYPE_CACHE, pooltype_cache)
# don't use file based locks for tests
inj.provide(inj.ACTION_LOCK, RLock)
self.stub_facts = stubs.StubFacts()
inj.provide(inj.FACTS, self.stub_facts)
self.dbus_patcher = patch('subscription_manager.managercli.CliCommand._request_validity_check')
self.dbus_patcher.start()
def test_get_value_from_instance(self):
field = ObjectField(attr='person', properties={
'first_name': StringField(analyzier='foo'),
'last_name': StringField()
})
instance = NonCallableMock(person=NonCallableMock(
first_name='foo', last_name='bar'))
self.assertEqual(field.get_value_from_instance(instance), {
'first_name': "foo",
'last_name': "bar",
})
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_set_header_reply_to(self):
from med_djutils.email import set_header_reply_to
func = set_header_reply_to
email1 = NonCallableMock(spec=str)
email2 = NonCallableMock(spec=str)
self.assertEqual(func(None, email1), {'Reply-To': email1})
self.assertEqual(func({}, email1), {'Reply-To': email1})
self.assertEqual(func({'Reply-To': email1}, email2),
{'Reply-To': email2})
self.assertIsNone(func(None, None))
self.assertEqual(func({}, None), {})
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 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(
"test",
db_pool=db_pool,
http_client=None,
replication_layer=Mock(),
clock=Mock(spec=[
"call_later",
"cancel_call_later",
"time_msec",
"time"
]),
ratelimiter=NonCallableMock(spec_set=[
"send_message",
]),
config=self.mock_config,
)
self.ratelimiter = hs.get_ratelimiter()
self.ratelimiter.send_message.return_value = (True, 0)
hs.config.enable_registration_captcha = False
hs.get_handlers().federation_handler = Mock()
hs.get_clock().time_msec.return_value = 1000000
hs.get_clock().time.return_value = 1000
synapse.rest.register.register_servlets(hs, self.mock_resource)
synapse.rest.events.register_servlets(hs, self.mock_resource)
synapse.rest.room.register_servlets(hs, self.mock_resource)
# register an account
self.user_id = "sid1"
response = yield self.register(self.user_id)
self.token = response["access_token"]
self.user_id = response["user_id"]
# register a 2nd account
self.other_user = "******"
response = yield self.register(self.other_user)
self.other_token = response["access_token"]
self.other_user = response["user_id"]
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
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.hs = hs
self.event_source = hs.get_event_sources().sources["typing"]
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 {
"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)
self.room_id = yield self.create_room_as(self.user_id)
# Need another user to make notifications actually work
yield self.join(self.room_id, user="******")
def setUp(self):
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX)
self.auth_user_id = self.user_id
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()
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)
# Since I'm getting my own presence I need to exist as far as presence
# is concerned.
hs.get_handlers().presence_handler.registered_user(
hs.parse_userid(self.user_id))
# create the room
self.room_id = yield self.create_room_as(self.user_id)
def test_arg_lists(self):
mocks = [
Mock(),
MagicMock(),
NonCallableMock(),
NonCallableMagicMock()
]
def assert_attrs(mock):
names = 'call_args_list', 'method_calls', 'mock_calls'
for name in names:
attr = getattr(mock, name)
self.assertIsInstance(attr, _CallList)
self.assertIsInstance(attr, list)
self.assertEqual(attr, [])
for mock in mocks:
assert_attrs(mock)
if callable(mock):
mock()
mock(1, 2)
mock(a=3)
mock.reset_mock()
assert_attrs(mock)
mock.foo()
mock.foo.bar(1, a=3)
mock.foo(1).bar().baz(3)
mock.reset_mock()
assert_attrs(mock)
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.mock_notifier = NonCallableMock(MeetmeServiceNotifier)
self.ami_class = Mock(xivo_ami.AMIClass)
self.manager = service_manager.MeetmeServiceManager(
self.mock_notifier,
self.ami_class,
)
self.mock_manager = NonCallableMock(MeetmeServiceManager)
context.register('meetme_service_notifier', self.mock_notifier)
context.register('meetme_service_manager', self.mock_manager)
def _mock_response(self):
response = NonCallableMock()
response._headers = {}
response.status_code = 200
response.queries = []
response.get = response._headers.get
response.content = ""
return response
def test_pushapps_noatomic(discover_apps_, hook, document_):
'''
Test case for pushapps with ``--no-atomic``
Algo:
1. discover apps
#. for each app
1. pre-push
2. push
3. post-push
'''
conf = NonCallableMock(name='conf')
dest = 'http://localhost:5984'
doc = document_()
dbs = conf.get_dbs()
ret_code = commands.pushapps(conf, '/mock_dir', dest, no_atomic=True)
assert ret_code == 0
conf.get_dbs.assert_called_with(dest)
hook.assert_any_call(conf, 'foo', 'pre-push', dbs=dbs, pushapps=True)
hook.assert_any_call(conf, 'foo', 'post-push', dbs=dbs, pushapps=True)
doc.push.assert_called_with(dbs, True, False)
def test_pushapps_export(discover_apps_, hook, document_, dumps):
'''
Test case for pushapps with ``--export``,
Algo:
1. discover apps
#. pre-push
#. add app to a list ``apps``
#. post-push
#. json.dumps from apps
'''
conf = NonCallableMock(name='conf')
dest = None
ret_code = commands.pushapps(conf, '/mock_dir', dest, export=True)
assert ret_code == 0
discover_apps_.assert_called_with('/mock_dir')
hook.assert_any_call(conf, 'foo', 'pre-push',
dbs=conf.get_dbs(), pushapps=True)
hook.assert_any_call(conf, 'foo', 'post-push',
dbs=conf.get_dbs(), pushapps=True)
assert dumps.called
def test_pushapps_output(discover_apps_, hook, document_, write_json):
'''
Test case for pushapps with ``--export --output file``
Algo:
1. discover apps
#. pre-push
#. add app to a list ``apps``
#. post-push
#. write_json(apps)
'''
conf = NonCallableMock(name='conf')
dest = None
ret_code = commands.pushapps(conf, '/mock_dir', dest, export=True, output='file')
assert ret_code == 0
discover_apps_.assert_called_with('/mock_dir')
hook.assert_any_call(conf, 'foo', 'pre-push',
dbs=conf.get_dbs(), pushapps=True)
hook.assert_any_call(conf, 'foo', 'post-push',
dbs=conf.get_dbs(), pushapps=True)
'file' in write_json.call_args[0]
def test_volume_pages(self, mockpaginator, mockrepo):
mockvol = NonCallableMock(spec=Volume)
mockvol.pid = 'vol:1'
mockvol.title = 'Lecoq, the detective'
mockvol.date = ['1801']
# second object retrieved from fedora is page, for layout
mockvol.width = 150
mockvol.height = 200
# volume url needed to identify annotations for pages in this volume
mockvol.get_absolute_url.return_value = reverse('books:volume',
kwargs={'pid': mockvol.pid})
mockrepo.return_value.get_object.return_value = mockvol
mockvol.find_solr_pages = MagicMock()
mockvol.find_solr_pages.return_value.count = 3
mockvol.find_solr_pages.__len__.return_value = 3
mockpage = Mock(width=640, height=400)
mockvol.pages = [mockpage]
vol_page_url = reverse('books:pages', kwargs={'pid': mockvol.pid})
response = self.client.get(vol_page_url)
# volume method should be used to find pages
self.assert_(call() in mockvol.find_solr_pages.call_args_list)
# volume should be set in context
self.assert_(mockvol, response.context['vol'])
# annotated pages should be empty for anonymous user
self.assertEqual({}, response.context['annotated_pages'])
# log in as a regular user
self.client.login(**self.user_credentials['user'])
testuser = get_user_model().objects.get(username=self.user_credentials['user']['username'])
page1_url = reverse('books:page', kwargs={'vol_pid': mockvol.pid, 'pid': 'page:1'})
page2_url = reverse('books:page', kwargs={'vol_pid': mockvol.pid, 'pid': 'page:2'})
page3_url = reverse('books:page', kwargs={'vol_pid': mockvol.pid, 'pid': 'page:3'})
mockvol.page_annotation_count.return_value = {
absolutize_url(page1_url): 5,
absolutize_url(page2_url): 2,
page3_url: 13
}
response = self.client.get(vol_page_url)
mockvol.page_annotation_count.assert_called_with(testuser)
annotated_pages = response.context['annotated_pages']
# counts should be preserved; urls should be non-absolute
# whether they started that way or not
self.assertEqual(5, annotated_pages[absolutize_url(page1_url)])
self.assertEqual(2, annotated_pages[absolutize_url(page2_url)])
self.assertEqual(13, annotated_pages[page3_url])
def _inject_ipm(self):
mock_ipm = NonCallableMock(spec=cache.InstalledProductsManager)
mock_ipm.tags = None
inj.provide(inj.INSTALLED_PRODUCTS_MANAGER, mock_ipm)
return mock_ipm
def test_volume_page_search(self, mocksolr_interface, mockpaginator, mockrepo):
mockobj = NonCallableMock()
mockobj.pid = 'vol:1'
mockobj.title = 'Lecoq, the detective'
mockobj.date = ['1801']
mockrepo.return_value.get_object.return_value = mockobj
mocksolr = mocksolr_interface.return_value
# simulate sunburnt's fluid interface
mocksolr.query.return_value = mocksolr.query
for method in ['query', 'facet_by', 'sort_by', 'field_limit', 'highlight',
'exclude', 'filter', 'join', 'paginate', 'results_as']:
getattr(mocksolr.query, method).return_value = mocksolr.query
# set up mock results for collection query and facet counts
solr_result = NonCallableMagicMock(spec_set=['__iter__', 'facet_counts'])
# *only* mock iter, to avoid weirdness with django templates & callables
solr_results = [
SolrPage(**{'pid': 'page:1', 'page_order': '1', 'score': 0.5,
'solr_highlights': {'page_text': ['snippet with search term']},
'identifier': ['http://testpid.co/ark:/1234/11/']}),
SolrPage(**{'pid': 'page:233', 'page_order': '123', 'score': 0.02,
'solr_highlights': {'page_text': ['sample text result from content']},
'identifier': ['http://testpid.co/ark:/1234/22/']}),
]
solr_result.__iter__.return_value = solr_results
mocksolr.query.__iter__.return_value = iter(solr_result)
mocksolr.count.return_value = 2
mockpage = NonCallableMock()
mockpaginator.return_value.page.return_value = mockpage
results = NonCallableMagicMock(spec=['__iter__', 'facet_counts', 'highlighting'])
results.__iter__.return_value = iter(solr_result)
mockpage.object_list = results
mockpage.has_other_pages = False
mockpage.paginator.count = 2
mockpage.paginator.page_range = [1]
# patch in highlighting - apparent change in sunburnt behavior
results.highlighting = {
'page:1': {'page_text': ['snippet with search term']},
'page:233': {'page_text': ['sample text result from content']}
}
vol_url = reverse('books:volume', kwargs={'pid': mockobj.pid})
response = self.client.get(vol_url, {'keyword': 'determine'})
self.assertEqual(response.templates[0].name,
views.VolumeDetail.search_template_name,
'volume search template should be used for valid search submission')
for page in iter(solr_result):
self.assertContains(response,
reverse('books:page-image', kwargs={'vol_pid': mockobj.pid,
'pid': page.pid, 'mode': 'mini-thumbnail'}),
msg_prefix='search results should include mini page thumbnail url')
self.assertContains(response, "Page %(page_order)s" % page,
msg_prefix='search results should include page number')
self.assertContains(response, page['score'],
msg_prefix='search results should display page relevance score')
self.assertContains(response, reverse('books:page',
kwargs={'vol_pid': mockobj.pid, 'pid': page['pid']}),
msg_prefix='search results should link to full page view')
self.assertContains(response, '... %s ...' % page['solr_highlights']['page_text'][0],
msg_prefix='solr snippets should display when available')
# ajax request
with patch('readux.books.views.VolumeDetail.get_context_data') as mock_ctx:
results = NonCallableMagicMock(spec=['__iter__', 'facet_counts', 'highlighting'])
results.__iter__.return_value = iter(solr_result)
results.highlighting = {
solr_results[0].pid: {
'page_text': 'sample highlighting snippet'
},
solr_results[1].pid: {
'page_text': 'another highlighting snippet'
}
}
mockpage = NonCallableMagicMock(spec=['__iter__'])
mockpage.object_list = results
mock_ctx.return_value = {
'pages': mockpage,
}
response = self.client.get(vol_url, {'keyword': 'determine'},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual('application/json', response['content-type'])
data = json.loads(response.content)
for idx in range(len(data)):
self.assertEqual(solr_results[idx].pid, data[idx]['pid'])
self.assertEqual('p. %s' % solr_results[idx]['page_order'],
data[idx]['label'])
self.assertEqual(reverse('books:page-image', kwargs={'vol_pid': mockobj.pid,
'pid': solr_results[idx].pid, 'mode': 'mini-thumbnail'}),
data[idx]['thumbnail'])
self.assertEqual(results.highlighting[solr_results[idx].pid]['page_text'],
data[idx]['highlights'])
from __future__ import unicode_literals, absolute_import, print_function, division
import json
import requests
from requests.models import Response
from requests.structures import CaseInsensitiveDict
from mock import Mock, NonCallableMock
from core.tests.mocks.data import MOCK_DATA
ok_response = NonCallableMock(spec=Response)
ok_response.headers = CaseInsensitiveDict(data={"content-type": "application/json"})
ok_response.content = json.dumps(MOCK_DATA)
ok_response.status_code = 200
agent_response = NonCallableMock(spec=Response)
agent_response.headers = CaseInsensitiveDict(data={
"content-type": "application/json",
"user-agent": "Mozilla /5.0 (Compatible MSIE 9.0;Windows NT 6.1;WOW64; Trident/5.0)"
})
agent_response.content = json.dumps(MOCK_DATA)
agent_response.status_code = 200
not_found_response = NonCallableMock(spec=Response)
not_found_response.headers = CaseInsensitiveDict(data={"content-type": "application/json"})
not_found_response.content = json.dumps({"error": "not found"})
not_found_response.status_code = 404
def setUp(self):
# No matter what, stop all patching (even if we have a failure in setUp itself)
self.addCleanup(patch.stopall)
# Never attempt to use the actual managercli.cfg which points to a
# real file in etc.
self.mock_cfg_parser = stubs.StubConfig()
original_conf = subscription_manager.managercli.conf
def unstub_conf():
subscription_manager.managercli.conf = original_conf
# Mock makes it damn near impossible to mock a module attribute (which we shouldn't be using
# in the first place because it's terrible) so we monkey-patch it ourselves.
# TODO Fix this idiocy by not reading the damn config on module import
subscription_manager.managercli.conf = config.Config(self.mock_cfg_parser)
self.addCleanup(unstub_conf)
facts_host_patcher = patch('rhsmlib.dbus.facts.FactsClient', auto_spec=True)
self.mock_facts_host = facts_host_patcher.start()
self.mock_facts_host.return_value.GetFacts.return_value = self.set_facts()
# By default mock that we are registered. Individual test cases
# can override if they are testing disconnected scenario.
id_mock = NonCallableMock(name='FixtureIdentityMock')
id_mock.exists_and_valid = Mock(return_value=True)
id_mock.uuid = 'fixture_identity_mock_uuid'
id_mock.name = 'fixture_identity_mock_name'
id_mock.cert_dir_path = "/not/a/real/path/to/pki/consumer/"
id_mock.keypath.return_value = "/not/a/real/key/path"
id_mock.certpath.return_value = "/not/a/real/cert/path"
# Don't really care about date ranges here:
self.mock_calc = NonCallableMock()
self.mock_calc.calculate.return_value = None
# Avoid trying to read real /etc/yum.repos.d/redhat.repo
self.mock_repofile_path_exists_patcher = patch('subscription_manager.repolib.YumRepoFile.path_exists')
mock_repofile_path_exists = self.mock_repofile_path_exists_patcher.start()
mock_repofile_path_exists.return_value = True
inj.provide(inj.IDENTITY, id_mock)
inj.provide(inj.PRODUCT_DATE_RANGE_CALCULATOR, self.mock_calc)
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, stubs.StubEntitlementStatusCache())
inj.provide(inj.POOL_STATUS_CACHE, stubs.StubPoolStatusCache())
inj.provide(inj.PROD_STATUS_CACHE, stubs.StubProductStatusCache())
inj.provide(inj.OVERRIDE_STATUS_CACHE, stubs.StubOverrideStatusCache())
inj.provide(inj.RELEASE_STATUS_CACHE, stubs.StubReleaseStatusCache())
inj.provide(inj.PROFILE_MANAGER, stubs.StubProfileManager())
# By default set up an empty stub entitlement and product dir.
# Tests need to modify or create their own but nothing should hit
# the system.
self.ent_dir = stubs.StubEntitlementDirectory()
inj.provide(inj.ENT_DIR, self.ent_dir)
self.prod_dir = stubs.StubProductDirectory()
inj.provide(inj.PROD_DIR, self.prod_dir)
# Installed products manager needs PROD_DIR injected first
inj.provide(inj.INSTALLED_PRODUCTS_MANAGER, stubs.StubInstalledProductsManager())
self.stub_cp_provider = stubs.StubCPProvider()
self._release_versions = []
self.stub_cp_provider.content_connection.get_versions = self._get_release_versions
inj.provide(inj.CP_PROVIDER, self.stub_cp_provider)
inj.provide(inj.CERT_SORTER, stubs.StubCertSorter())
# setup and mock the plugin_manager
plugin_manager_mock = MagicMock(name='FixturePluginManagerMock')
plugin_manager_mock.runiter.return_value = iter([])
inj.provide(inj.PLUGIN_MANAGER, plugin_manager_mock)
inj.provide(inj.DBUS_IFACE, Mock(name='FixtureDbusIfaceMock'))
pooltype_cache = Mock()
inj.provide(inj.POOLTYPE_CACHE, pooltype_cache)
# don't use file based locks for tests
inj.provide(inj.ACTION_LOCK, RLock)
self.stub_facts = stubs.StubFacts()
inj.provide(inj.FACTS, self.stub_facts)
content_access_cache_mock = MagicMock(name='ContentAccessCacheMock')
inj.provide(inj.CONTENT_ACCESS_CACHE, content_access_cache_mock)
self.dbus_patcher = patch('subscription_manager.managercli.CliCommand._request_validity_check')
self.dbus_patcher.start()
# No tests should be trying to connect to any configure or test server
# so really, everything needs this mock. May need to be in __init__, or
# better, all test classes need to use SubManFixture
self.is_valid_server_patcher = patch("subscription_manager.managercli.is_valid_server_info")
is_valid_server_mock = self.is_valid_server_patcher.start()
is_valid_server_mock.return_value = True
# No tests should be trying to test the proxy connection
# so really, everything needs this mock. May need to be in __init__, or
# better, all test classes need to use SubManFixture
self.test_proxy_connection_patcher = patch("subscription_manager.managercli.CliCommand.test_proxy_connection")
test_proxy_connection_mock = self.test_proxy_connection_patcher.start()
test_proxy_connection_mock.return_value = True
self.files_to_cleanup = []
def mock_auctions_server(request, mocker):
params = getattr(request, 'param', {})
server_config_redis = params.get('server_config_redis', DEFAULT)
connection_limit = params.get('connection_limit', DEFAULT)
get_mapping = params.get('get_mapping', DEFAULT)
proxy_path = params.get('proxy_path', DEFAULT)
event_sources_pool = params.get('event_sources_pool', DEFAULT)
proxy_connection_pool = params.get('proxy_connection_pool', DEFAULT)
stream_proxy = params.get('stream_proxy', DEFAULT)
db = params.get('db', DEFAULT)
request_headers = params.get('request_headers', [])
request_url = params.get('request_url', DEFAULT)
redirect_url = params.get('redirect_url', DEFAULT)
abort = params.get('abort', DEFAULT)
class AuctionsServerAttributesContainer(object):
logger = NotImplemented
proxy_mappings = NotImplemented
config = NotImplemented
event_sources_pool = NotImplemented
proxy_connection_pool = NotImplemented
get_mapping = NotImplemented
db = NotImplemented
request_headers = NotImplemented
class Request(object):
headers = NotImplemented
environ = NotImplemented
url = NotImplemented
class Config(object):
__getitem__ = NotImplemented
def config_getitem(item):
if item == 'REDIS':
return server_config_redis
elif item == 'event_source_connection_limit':
return connection_limit
else:
raise KeyError
mock_path_info = MagicMock()
def environ_setitem(item, value):
if item == 'PATH_INFO':
mock_path_info(value)
return value
else:
raise KeyError
mocker.patch.object(auctions_server_module, 'get_mapping', get_mapping)
patch_pysse = mocker.patch.object(auctions_server_module, 'PySse',
spec_set=PySse)
patch_add_message = patch_pysse.return_value.add_message
patch_request = mocker.patch.object(auctions_server_module, 'request',
spec_set=Request)
patch_request.environ.__setitem__.side_effect = environ_setitem
patch_request.headers = request_headers
patch_request.url = request_url
patch_redirect = mocker.patch.object(auctions_server_module, 'redirect',
return_value=redirect_url)
patch_abort = mocker.patch.object(auctions_server_module, 'abort',
return_value=abort)
patch_StreamProxy = \
mocker.patch.object(auctions_server_module, 'StreamProxy',
return_value=stream_proxy)
auctions_server = NonCallableMock(spec_set=
AuctionsServerAttributesContainer)
logger = MagicMock(spec_set=frontend.logger)
proxy_mappings = MagicMock(spec_set=Memoizer({}))
proxy_mappings.get.return_value = proxy_path
config = MagicMock(spec_set=Config)
config.__getitem__.side_effect = config_getitem
auctions_server.logger = logger
auctions_server.proxy_mappings = proxy_mappings
auctions_server.config = config
auctions_server.event_sources_pool = event_sources_pool
auctions_server.proxy_connection_pool = proxy_connection_pool
auctions_server.db = db
mocker.patch.object(auctions_server_module, 'auctions_server',
auctions_server)
return {'server': auctions_server,
'proxy_mappings': proxy_mappings,
'mock_path_info': mock_path_info,
'patch_StreamProxy': patch_StreamProxy,
'patch_redirect': patch_redirect,
'patch_abort': patch_abort,
'patch_PySse': patch_pysse,
'patch_add_message': patch_add_message}
def setUp(self):
# By default mock that we are registered. Individual test cases
# can override if they are testing disconnected scenario.
id_mock = NonCallableMock(name='FixtureIdentityMock')
id_mock.exists_and_valid = Mock(return_value=True)
id_mock.uuid = 'fixture_identity_mock_uuid'
id_mock.name = 'fixture_identity_mock_name'
id_mock.cert_dir_path = "/not/a/real/path/to/pki/consumer/"
# Don't really care about date ranges here:
self.mock_calc = NonCallableMock()
self.mock_calc.calculate.return_value = None
# Avoid trying to read real /etc/yum.repos.d/redhat.repo
self.mock_repofile_path_exists_patcher = patch('subscription_manager.repolib.RepoFile.path_exists')
mock_repofile_path_exists = self.mock_repofile_path_exists_patcher.start()
mock_repofile_path_exists.return_value = True
inj.provide(inj.IDENTITY, id_mock)
inj.provide(inj.PRODUCT_DATE_RANGE_CALCULATOR, self.mock_calc)
inj.provide(inj.ENTITLEMENT_STATUS_CACHE, stubs.StubEntitlementStatusCache())
inj.provide(inj.PROD_STATUS_CACHE, stubs.StubProductStatusCache())
inj.provide(inj.OVERRIDE_STATUS_CACHE, stubs.StubOverrideStatusCache())
inj.provide(inj.RELEASE_STATUS_CACHE, stubs.StubReleaseStatusCache())
inj.provide(inj.PROFILE_MANAGER, stubs.StubProfileManager())
# By default set up an empty stub entitlement and product dir.
# Tests need to modify or create their own but nothing should hit
# the system.
self.ent_dir = stubs.StubEntitlementDirectory()
inj.provide(inj.ENT_DIR, self.ent_dir)
self.prod_dir = stubs.StubProductDirectory()
inj.provide(inj.PROD_DIR, self.prod_dir)
# Installed products manager needs PROD_DIR injected first
inj.provide(inj.INSTALLED_PRODUCTS_MANAGER, stubs.StubInstalledProductsManager())
self.stub_cp_provider = stubs.StubCPProvider()
self._release_versions = []
self.stub_cp_provider.content_connection.get_versions = self._get_release_versions
inj.provide(inj.CP_PROVIDER, self.stub_cp_provider)
inj.provide(inj.CERT_SORTER, stubs.StubCertSorter())
# setup and mock the plugin_manager
plugin_manager_mock = MagicMock(name='FixturePluginManagerMock')
plugin_manager_mock.runiter.return_value = iter([])
inj.provide(inj.PLUGIN_MANAGER, plugin_manager_mock)
inj.provide(inj.DBUS_IFACE, Mock(name='FixtureDbusIfaceMock'))
pooltype_cache = Mock()
inj.provide(inj.POOLTYPE_CACHE, pooltype_cache)
# don't use file based locks for tests
inj.provide(inj.ACTION_LOCK, RLock)
self.stub_facts = stubs.StubFacts()
inj.provide(inj.FACTS, self.stub_facts)
self.dbus_patcher = patch('subscription_manager.managercli.CliCommand._request_validity_check')
self.dbus_patcher.start()
# No tests should be trying to connect to any configure or test server
# so really, everything needs this mock. May need to be in __init__, or
# better, all test classes need to use SubManFixture
self.is_valid_server_patcher = patch("subscription_manager.managercli.is_valid_server_info")
is_valid_server_mock = self.is_valid_server_patcher.start()
is_valid_server_mock.return_value = True
# No tests should be trying to test the proxy connection
# so really, everything needs this mock. May need to be in __init__, or
# better, all test classes need to use SubManFixture
self.test_proxy_connection_patcher = patch("subscription_manager.managercli.CliCommand.test_proxy_connection")
test_proxy_connection_mock = self.test_proxy_connection_patcher.start()
test_proxy_connection_mock.return_value = True
self.files_to_cleanup = []
def test_simple_join(self):
room_id = "!foo:red"
user_id = "@bob:red"
user = self.hs.parse_userid(user_id)
target_user_id = "@bob:red"
content = {"membership": Membership.JOIN}
event = self.hs.get_event_factory().create_event(
etype=RoomMemberEvent.TYPE,
user_id=user_id,
state_key=target_user_id,
room_id=room_id,
membership=Membership.JOIN,
content=content,
)
joined = ["red", "green"]
self.state_handler.handle_new_event.return_value = defer.succeed(True)
def get_joined(*args):
return defer.succeed(joined)
self.datastore.get_joined_hosts_for_room.side_effect = get_joined
store_id = "store_id_fooo"
self.datastore.persist_event.return_value = defer.succeed(store_id)
self.datastore.get_room.return_value = defer.succeed(1) # Not None.
prev_state = NonCallableMock()
prev_state.membership = Membership.INVITE
prev_state.sender = "@foo:red"
self.datastore.get_room_member.return_value = defer.succeed(prev_state)
join_signal_observer = Mock()
self.distributor.observe("user_joined_room", join_signal_observer)
# Actual invocation
yield self.room_member_handler.change_membership(event)
self.state_handler.handle_new_event.assert_called_once_with(
event, self.snapshot
)
self.federation.handle_new_event.assert_called_once_with(
event, self.snapshot
)
self.assertEquals(
set(["red", "green"]),
set(event.destinations)
)
self.datastore.persist_event.assert_called_once_with(
event
)
self.notifier.on_new_room_event.assert_called_once_with(
event, extra_users=[user])
join_signal_observer.assert_called_with(
user=user, room_id=room_id)
def test_volume(self, mockrepo):
mockobj = NonCallableMock()
mockobj.pid = 'vol:1'
mockobj.title = 'Lecoq, the detective'
mockobj.volume = 'V.1'
mockobj.date = ['1801']
mockobj.creator = ['Gaboriau, Emile']
mockobj.book.dc.content.description_list = [
'Translation of: Monsieur Lecoq.',
'Victorian yellowbacks + paperbacks, 1849-1905'
]
mockobj.book.dc.content.publisher = 'London : Vizetelly'
mockobj.book.volume_set = [mockobj, NonCallableMock(pid='vol:2')]
mockobj.pdf_size = 1024
mockobj.has_pages = False
mockobj.is_a_volume = True
mockrepo.return_value.get_object.return_value = mockobj
# to support for last modified conditional
mockobj.ocr.created = datetime.now()
vol_url = reverse('books:volume', kwargs={'pid': mockobj.pid})
response = self.client.get(vol_url)
self.assertContains(response, mockobj.title,
msg_prefix='response should include title')
self.assertContains(response, mockobj.volume,
msg_prefix='response should include volume label')
self.assertContains(response, mockobj.date[0],
msg_prefix='response should include date')
self.assertContains(response, mockobj.creator[0],
msg_prefix='response should include creator')
for desc in mockobj.book.dc.content.description_list:
self.assertContains(response, desc,
msg_prefix='response should include dc:description')
self.assertContains(response, mockobj.book.dc.content.publisher,
msg_prefix='response should include publisher')
self.assertContains(response, reverse('books:pdf', kwargs={'pid': mockobj.pid}),
msg_prefix='response should include link to pdf')
# related volumes
self.assertContains(response, 'Related volumes',
msg_prefix='response should include related volumes when present')
self.assertContains(response,
reverse('books:volume', kwargs={'pid': mockobj.book.volume_set[0].pid}),
msg_prefix='response should link to related volumes')
# pdf size
self.assertContains(response, filesizeformat(mockobj.pdf_size),
msg_prefix='PDF size should be displayed in human-readable format')
# no pages loaded, should not include volume search or read online
self.assertNotContains(response, 'Read online',
msg_prefix='volume without pages loaded should not display read online option')
# NOTE: href needed to differentiate from cover url, which starts the same
self.assertNotContains(response, 'href="%s"' % reverse('books:pages', kwargs={'pid': mockobj.pid}),
msg_prefix='volume without pages loaded should not have link to read online')
self.assertNotContains(response, '<form id="volume-search" ',
msg_prefix='volume without pages loaded should not have volume search')
# annotation total passed to context
self.assert_('annotated_volumes' not in response.context,
'annotation count should not be set for volumes without pages')
# simulate volume with pages loaded
mockobj.has_pages = True
# to test annotation count
mockobj.get_absolute_url.return_value = '/books/vol:1/'
mockobj.annotation_count.return_value = 5
response = self.client.get(vol_url)
# *should* include volume search and read online
self.assertContains(response, 'Read online',
msg_prefix='volume with pages loaded should display read online option')
self.assertContains(response, reverse('books:pages', kwargs={'pid': mockobj.pid}),
msg_prefix='volume with pages loaded should have link to read online')
self.assertContains(response, '<form id="volume-search" ',
msg_prefix='volume without pages loaded should have volume search')
# annotation total passed to context
self.assertEqual({mockobj.get_absolute_url(): 5},
response.context['annotated_volumes'],
'annotation count should be set for volumes with pages')
mockobj.annotation_count.return_value = 0
response = self.client.get(vol_url)
self.assert_('annotated_volumes' not in response.context,
'annotation count should not be set in context when it is zero')
# non-existent should 404
mockobj.exists = False
response = self.client.get(vol_url)
expected, got = 404, response.status_code
self.assertEqual(expected, got,
'expected %s for %s when object does not exist, got %s' % \
(expected, vol_url, got))
# exists but isn't a volume - should also 404
mockobj.exists = True
mockobj.is_a_volume = False
response = self.client.get(vol_url)
expected, got = 404, response.status_code
self.assertEqual(expected, got,
'expected %s for %s when object is not a volume, got %s' % \
(expected, vol_url, got))
def test_search(self, mockqs_paginate, mocksolr_interface, mockpaginator):
mockpage = NonCallableMock()
search_url = reverse('books:search')
# NOTE: pagination now happens in django's class-based view,
# so must be mocked there
mockqs_paginate.return_value = (mockpaginator.return_value,
mockpage, [], False)
# no search terms - invalid form
response = self.client.get(search_url)
self.assertContains(response, 'Please enter one or more search terms')
mocksolr = mocksolr_interface.return_value
# simulate sunburnt's fluid interface
mocksolr.query.return_value = mocksolr.query
for method in ['query', 'facet_by', 'sort_by', 'field_limit',
'exclude', 'filter', 'join', 'paginate', 'results_as',
'facet_query']:
getattr(mocksolr.query, method).return_value = mocksolr.query
# set up mock results for collection query and facet counts
solr_result = NonCallableMagicMock(spec_set=['__iter__', 'facet_counts'])
# *only* mock iter, to avoid weirdness with django templates & callables
solr_result.__iter__.return_value = [
SolrVolume(**{'pid': 'vol:1', 'title': 'Lecoq, the detective', 'pdf_size': 1024}),
SolrVolume(**{'pid': 'vol:2', 'title': 'Mabel Meredith', 'pdf_size': 34665}),
]
mocksolr.query.__iter__.return_value = iter(solr_result)
mocksolr.count.return_value = 2
# mock facets
# solr_result.facet_counts.facet_fields = {
# 'collection_label_facet': [('Civil War Literature', 2), ('Yellowbacks', 4)]
# }
# use a noncallable for the pagination result that is used in the template
# because passing callables into django templates does weird things
mockpaginator.return_value.page.return_value = mockpage
results = NonCallableMagicMock(spec=['__iter__', 'facet_counts', '__len__'])
results.__iter__.return_value = iter(solr_result)
results.facet_counts.facet_fields = {
'collection_label_facet': [('Emory Yearbooks', 1), ('Yellowbacks', 4)]
}
results.__len__.return_value = 2
mockpage.object_list = results
mockpage.has_other_pages = False
mockpage.paginator.count = 2
mockpage.paginator.page_range = [1]
mockpaginator.return_value.count = 2
mockpaginator.return_value.page_range = [1]
mockqs_paginate.return_value = (mockpaginator.return_value, mockpage, results, True)
# query with search terms
response = self.client.get(search_url, {'keyword': 'yellowbacks'})
mocksolr.query.filter.assert_called_with(content_model=Volume.VOLUME_CMODEL_PATTERN)
# because of creator/title search boosting, actual query is a little difficult to test
mocksolr.Q.assert_any_call('yellowbacks')
mocksolr.Q.assert_any_call(creator='yellowbacks')
mocksolr.Q.assert_any_call(title='yellowbacks')
# not sure how to test query on Q|Q**3|Q**3
mocksolr.query.field_limit.assert_called_with(SolrVolume.necessary_fields,
score=True)
# check that unapi / zotero harvest is enabled
self.assertContains(response,
'<link rel="unapi-server" type="application/xml" title="unAPI" href="%s" />' % \
reverse('books:unapi'),
html=True,
msg_prefix='link to unAPI server URL should be specified in header')
# check that items are displayed
for item in solr_result:
self.assertContains(response, item['title'],
msg_prefix='title should be displayed')
self.assertContains(response, unquote(reverse('books:pdf', kwargs={'pid': item['pid']})),
msg_prefix='link to pdf should be included in response')
self.assertContains(response,
'<abbr class="unapi-id" title="%s"></abbr>' % item['pid'],
msg_prefix='unapi item id for %s should be included to allow zotero harvest' \
% item['pid'])
# pdf size
self.assertContains(response, filesizeformat(item['pdf_size']),
msg_prefix='PDF size should be displayed in human-readable format')
# check that collection facets are displayed / linked
for coll, count in results.facet_counts.facet_fields['collection_label_facet']:
self.assertContains(response, coll,
msg_prefix='collection facet label should be displayed on search results page')
# not a very definitive test, but at least check the number is displayed
self.assertContains(response, count,
msg_prefix='collection facet count should be displayed on search results page')
self.assertContains(response,
'?keyword=yellowbacks&collection=%s' % coll.replace(' ', '%20'),
msg_prefix='response should include link to search filtered by collection facet')
# multiple terms and phrase
response = self.client.get(search_url, {'keyword': 'yellowbacks "lecoq the detective" mystery'})
for term in ['yellowbacks', 'lecoq the detective', 'mystery']:
mocksolr.Q.assert_any_call(term)
# filtered by collection
response = self.client.get(search_url, {'keyword': 'lecoq', 'collection': 'Yellowbacks'})
mocksolr.query.query.assert_any_call(collection_label='"%s"' % 'Yellowbacks')
## annotation totals
# empty annotation total in context for anonymous user
self.assertEqual({}, response.context['annotated_volumes'])
# check that annotation total is retrieved for ONLY logged in users
with patch('readux.books.views.Volume') as mockvolclass:
response = self.client.get(search_url, {'keyword': 'lecoq', 'collection': 'Yellowbacks'})
mockvolclass.volume_annotation_count.assert_not_called()
User = get_user_model()
testuser = User.objects.get(username=self.user_credentials['user']['username'])
self.client.login(**self.user_credentials['user'])
response = self.client.get(search_url, {'keyword': 'lecoq', 'collection': 'Yellowbacks'})
mockvolclass.volume_annotation_count.assert_called_with(testuser)
class TestMeetmeServiceManager(unittest.TestCase):
def setUp(self):
self.mock_notifier = NonCallableMock(MeetmeServiceNotifier)
self.ami_class = Mock(xivo_ami.AMIClass)
self.manager = service_manager.MeetmeServiceManager(
self.mock_notifier,
self.ami_class,
)
self.mock_manager = NonCallableMock(MeetmeServiceManager)
context.register('meetme_service_notifier', self.mock_notifier)
context.register('meetme_service_manager', self.mock_manager)
def tearDown(self):
context.reset()
def test_invite(self):
inviter_id = 5
invitee_xid = 'user:xivo/3'
invitee_interface = 'SIP/abcdef'
meetme_context = 'myctx'
meetme_number = '4003'
meetme_caller_id = '"Conference My conf" <4003>'
dao.user = Mock(user_dao.UserDAO)
dao.meetme = Mock(meetme_dao.MeetmeDAO)
dao.user.get_line_identity.return_value = invitee_interface
dao.meetme.get_caller_id_from_context_number.return_value = meetme_caller_id
self.manager._find_meetme_by_line = Mock(return_value=(meetme_context, meetme_number))
response = self.manager.invite(inviter_id, invitee_xid)
expected_return = 'message', {'message': 'Command sent succesfully'}
self.assertEqual(response, expected_return)
self.ami_class.sendcommand.assert_called_once_with(
'Originate',
[('Channel', invitee_interface),
('Context', meetme_context),
('Exten', meetme_number),
('Priority', '1'),
('Async', 'true'),
('CallerID', meetme_caller_id)]
)
def test_find_meetme_by_line(self):
number = '4000'
context = 'myctx'
line_interface = 'SCCP/1234'
channel = '%s-24734893' % line_interface
self.manager._cache = {number: {'number': number,
'name': 'my-conf-name',
'pin_required': False,
'start_time': time.time(),
'context': context,
'members': {1: {'join_order': 1,
'join_time': time.time() - 5,
'number': '1002',
'name': 'Tester 1',
'channel': channel,
'muted': False}}}}
self.assertRaises(LookupError, self.manager._find_meetme_by_line, 'SIP/not-there')
result_context, result_number = self.manager._find_meetme_by_line(line_interface)
self.assertEqual(result_context, context)
self.assertEqual(result_number, number)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=True))
def test_parse_join(self):
channel = 'SIP/i7vbu0-00000001'
number = '800'
caller_id_name = 'Père Noël'
caller_id_number = '1000'
event = {'Event': 'MeetmeJoin',
'Privilege': 'call,all',
'Channel': channel,
'Uniqueid': '1338219287.2',
'Meetme': number,
'PseudoChan': 'DAHDI/pseudo-965958986',
'Admin': 'No',
'NoAuthed': 'No',
'Usernum': '1',
'CallerIDnum': caller_id_number,
'CallerIDname': caller_id_name,
'ConnectedLineNum': '<unknown>',
'ConnectedLineName': '<unknown>'}
service_manager.parse_join(event)
self.mock_manager.join.assert_called_once_with(channel,
number,
1,
caller_id_name,
caller_id_number)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=False))
def test_parse_join_paging(self):
channel = 'SIP/i7vbu0-00000001'
number = '8834759845'
caller_id_name = 'Père Noël'
caller_id_number = '1000'
event = {'Event': 'MeetmeJoin',
'Privilege': 'call,all',
'Channel': channel,
'Uniqueid': '1338219287.2',
'Meetme': number,
'PseudoChan': 'DAHDI/pseudo-965958986',
'Admin': 'No',
'NoAuthed': 'No',
'Usernum': '1',
'CallerIDnum': caller_id_number,
'CallerIDname': caller_id_name,
'ConnectedLineNum': '<unknown>',
'ConnectedLineName': '<unknown>'}
service_manager.parse_join(event)
self.assertEqual(self.mock_manager.join.call_count, 0)
@patch('xivo_dao.meetme_dao.get_config', Mock(return_value=(conf_room_name, conf_room_number, True, 'default')))
@patch('xivo_dao.meetme_dao.find_by_confno', Mock(return_value=5))
@patch('xivo_dao.meetme_dao.muted_on_join_by_number', Mock(return_value=True))
@patch('time.time')
def test_join(self, mock_time):
start = 12345.123
channel = 'SIP/mon_trunk-1234'
mock_time.return_value = start
self.manager.join(channel, conf_room_number, 1, 'Tester 1', '1002')
expected = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': start,
'context': 'default',
'members': {1: {'join_order': 1,
'join_time': start,
'number': '1002',
'name': 'Tester 1',
'channel': channel,
'muted': True}}}}
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
@patch('xivo_dao.meetme_dao.get_config', Mock(return_value=(conf_room_name, conf_room_number, True, 'test')))
@patch('xivo_dao.meetme_dao.find_by_confno', Mock(return_value=4))
@patch('xivo_dao.meetme_dao.muted_on_join_by_number', Mock(return_value=True))
@patch('time.time')
def test_join_second(self, mock_time):
start_time = 12345678.123
join_time = 12345699.123
phone_number = '4185551234'
channel = 'SIP/pcm_dev-0000005d'
mock_time.return_value = start_time
self.manager._cache = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': start_time,
'members': {1: {'join_order': 1,
'join_time': start_time,
'number': '1002',
'name': 'Tester 1',
'channel': '123',
'muted': False}}}}
mock_time.return_value = join_time
self.manager.join(channel, conf_room_number, 2, phone_number, phone_number)
expected = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': start_time,
'members': {1: {'join_order': 1,
'join_time': start_time,
'number': '1002',
'name': 'Tester 1',
'channel': '123',
'muted': False},
2: {'join_order': 2,
'join_time': join_time,
'number': phone_number,
'name': phone_number,
'channel': channel,
'muted': True}}}}
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
def test_build_member_status(self):
channel = 'SIP/kjsdfh-12356'
result = service_manager._build_member_status(1, 'Tester One', '666', channel, True)
expected = {'join_order': 1,
'join_time': -1,
'number': '666',
'name': 'Tester One',
'channel': channel,
'muted': True}
self.assertEqual(result, expected)
@patch('time.time')
def test_build_joining_member_status(self, mock_time):
channel = 'SIP/kjsdfh-12356'
join_time = 1234.1234
mock_time.return_value = join_time
result = service_manager._build_joining_member_status(1, 'Tester One', '666', channel, False)
expected = {'join_order': 1,
'join_time': join_time,
'number': '666',
'name': 'Tester One',
'channel': channel,
'muted': False}
self.assertEqual(result, expected)
@patch('xivo_dao.meetme_dao.get_config', Mock(return_value=(conf_room_name, conf_room_number, True, 'my_context')))
@patch('xivo_dao.meetme_dao.find_by_confno', Mock(return_value=2))
def test_set_room_config(self):
self.manager._set_room_config(conf_room_number)
result = self.manager._cache
expected = {conf_room_number: {'name': conf_room_name,
'number': conf_room_number,
'pin_required': True,
'start_time': 0,
'context': 'my_context',
'members': {}}}
self.assertEqual(result, expected)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=True))
def test_parse_leave(self):
event = {'Event': 'MeetmeLeave',
'Privilege': 'call,all',
'Channel': 'SIP/i7vbu0-00000000',
'Uniqueid': '1338219251.0',
'Meetme': '800',
'Usernum': '1',
'CallerIDNum': '1000',
'CallerIDName': 'Père Noël',
'ConnectedLineNum': '<unknown>',
'ConnectedLineName': '<unknown>',
'Duration': '31'}
service_manager.parse_leave(event)
self.mock_manager.leave.assert_called_once_with('800', 1)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=False))
def test_parse_leave_paging(self):
event = {'Event': 'MeetmeLeave',
'Privilege': 'call,all',
'Channel': 'SIP/i7vbu0-00000000',
'Uniqueid': '1338219251.0',
'Meetme': '0834758704',
'Usernum': '1',
'CallerIDNum': '1000',
'CallerIDName': 'Père Noël',
'ConnectedLineNum': '<unknown>',
'ConnectedLineName': '<unknown>',
'Duration': '31'}
service_manager.parse_leave(event)
self.assertEqual(self.mock_manager.leave.call_count, 0)
def test_leave(self):
start_time = 1234556.123
self.manager._cache = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': start_time,
'members': {1: {'join_order': 1,
'join_time': start_time,
'number': '1002',
'name': 'Tester 1',
'channel': 'SIP/jsdhfjd-124'},
2: {'join_order': 2,
'join_time': start_time + 10,
'number': '4181235555',
'name': '4181235555',
'channel': 'DAHDI/i1/4181235555-5'}}}}
self.manager.leave(conf_room_number, 1)
expected = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': start_time,
'members': {2: {'join_order': 2,
'join_time': start_time + 10,
'number': '4181235555',
'name': '4181235555',
'channel': 'DAHDI/i1/4181235555-5'}}}}
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
self.mock_notifier.reset_mock()
self.manager.leave(conf_room_number, 2)
expected = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': 0,
'members': {}}}
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
def test_leave_after_restart(self):
start_time = 1234556.123
self.manager._cache = {
conf_room_number: {
'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': start_time,
'members': {},
}
}
self.manager.leave(conf_room_number, 1)
self.assertEqual(self.mock_notifier.publish_meetme_update.call_count, 0)
def test_has_members(self):
self.manager._cache = {'800': {'members': {}}}
self.assertFalse(self.manager._has_members('800'))
self.manager._cache = {'800': {'number': '800',
'name': 'conf',
'pin_required': True,
'start_time': 12345.21,
'members': {2: {'join_order': 2,
'join_time': 1235.123,
'number': '4181235555',
'name': '4181235555',
'channel': 'DAHDI/i1/4181235555-5'}}}}
self.assertTrue(self.manager._has_members('800'))
@patch('xivo_dao.meetme_dao.get_config', Mock(return_value=(conf_room_name, conf_room_number, True, 'default')))
@patch('xivo_dao.meetme_dao.find_by_confno', Mock(return_value=2))
@patch('xivo_dao.meetme_dao.muted_on_join_by_number', Mock(return_value=False))
@patch('time.time')
def test_join_when_empty(self, mock_time):
channel = 'SIP/kljfh-1234'
join_time = 12345.654
mock_time.return_value = join_time
self.manager._cache = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': 0,
'members': {}}}
self.manager.join(channel, conf_room_number, 1, 'Tester 1', '1002')
expected = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': join_time,
'members': {1: {'join_order': 1,
'join_time': join_time,
'number': '1002',
'name': 'Tester 1',
'channel': channel,
'muted': False}}}}
self.assertEqual(self.manager._cache, expected)
@patch('xivo_dao.meetme_dao.get_configs')
def test_initial_state(self, mock_get_configs):
mock_get_configs.return_value = [('Conference1', '9000', True, 'default'),
('Conference2', '9001', False, 'test'),
('Conference3', '9002', False, 'test')]
self.manager.initialize()
expected = {'9000': {'number': '9000',
'name': 'Conference1',
'pin_required': True,
'start_time': 0,
'context': 'default',
'members': {}},
'9001': {'number': '9001',
'name': 'Conference2',
'pin_required': False,
'start_time': 0,
'context': 'test',
'members': {}},
'9002': {'number': '9002',
'name': 'Conference3',
'pin_required': False,
'start_time': 0,
'context': 'test',
'members': {}}}
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
def test_add_room(self):
self.manager._add_room('Conference1', '9000', True, 'ctx')
expected = {'9000': {'number': '9000',
'name': 'Conference1',
'pin_required': True,
'start_time': 0,
'context': 'ctx',
'members': {}}}
self.assertEqual(self.manager._cache, expected)
@patch('xivo_dao.meetme_dao.get_configs')
def test_initialize_configs_with_members(self, mock_get_configs):
mock_get_configs.return_value = [('Conference2', '9001', False, 'test'),
('Conference3', '9002', False, 'test')]
members_9001 = {1: {'join_order': 1,
'join_time': 1234.1235,
'number': '1002',
'name': 'Tester 1',
'channel': 'sip/123',
'muted': False}}
self.manager._cache = {'9000': {'number': '9000',
'name': 'Conference1',
'pin_required': True,
'start_time': 0,
'context': 'default',
'members': {}},
'9001': {'number': '9001',
'name': 'Conference2',
'pin_required': False,
'start_time': 0,
'context': 'test',
'members': members_9001}}
self.manager.initialize()
expected = {'9002': {'number': '9002',
'name': 'Conference3',
'pin_required': False,
'start_time': 0,
'context': 'test',
'members': {}},
'9001': {'number': '9001',
'name': 'Conference2',
'pin_required': False,
'start_time': 0,
'context': 'test',
'members': members_9001}}
self.assertEqual(self.manager._cache, expected)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=True))
def test_parse_meetmelist(self):
channel = 'SIP/pcm_dev-00000003'
event = {'Event': 'MeetmeList',
'Conference': '800',
'UserNumber': '1',
'CallerIDNum': '666',
'CallerIDName': 'My Name',
'ConnectedLineNum': '<unknown>',
'ConnectedLineName': '<noname>',
'Channel': channel,
'Admin': 'No',
'Role': 'Talkandlisten',
'MarkedUser': '******',
'Muted': 'No',
'Talking': 'Notmonitored'}
service_manager.parse_meetmelist(event)
self.mock_manager.refresh.assert_called_once_with(channel, '800', 1, 'My Name', '666', False)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=False))
def test_parse_meetmelist_paging(self):
channel = 'SIP/pcm_dev-00000003'
event = {'Event': 'MeetmeList',
'Conference': '800',
'UserNumber': '1',
'CallerIDNum': '666',
'CallerIDName': 'My Name',
'ConnectedLineNum': '<unknown>',
'ConnectedLineName': '<noname>',
'Channel': channel,
'Admin': 'No',
'Role': 'Talkandlisten',
'MarkedUser': '******',
'Muted': 'No',
'Talking': 'Notmonitored'}
service_manager.parse_meetmelist(event)
self.assertEqual(self.mock_manager.refresh.call_count, 0)
@patch('xivo_dao.meetme_dao.get_config', Mock(return_value=(conf_room_name, conf_room_number, False, 'dev')))
@patch('xivo_dao.meetme_dao.find_by_confno', Mock(return_value=1))
def test_refresh_empty(self):
channel = 'DAHDI/i1/5555555555-1'
name = 'First Testeur'
number = '5555555555'
self.manager.refresh(channel, conf_room_number, 1, name, number, is_muted=True)
expected = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': False,
'start_time': -1,
'context': 'dev',
'members': {1: {'join_order': 1,
'join_time': -1,
'number': number,
'name': name,
'channel': channel,
'muted': True}}}}
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
def test_refresh_already_there(self):
name, number = 'Tester One', '6666'
channel = 'SIP/khsdfjkld-1234'
self.manager._cache['800'] = {'number': '800',
'name': 'test',
'pin_required': False,
'start_time': 1238934.12342,
'members': {1: {'join_order': 1,
'join_time': 1238934.12342,
'number': number,
'name': name,
'channel': channel,
'muted': False}}}
expected = copy.deepcopy(self.manager._cache)
self.manager.refresh(channel, '800', 1, name, number, False)
self.assertEqual(self.manager._cache, expected)
def test_has_member(self):
self.assertFalse(self.manager._has_member('800', 1, 'Tester One', '1234'))
self.manager._cache = {'800': {'members': {1: {'name': 'Tester One',
'number': '1234'}}}}
self.assertTrue(self.manager._has_member('800', 1, 'Tester One', '1234'))
def test_muting(self):
self.manager.mute(conf_room_number, 1)
self.manager._cache = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': 1234.1234,
'members': {1: {'join_order': 1,
'join_time': 1234.1234,
'number': '1002',
'name': 'Tester 1',
'channel': 'SIP/jsdhfjd-124',
'muted': False},
2: {'join_order': 2,
'join_time': 1239.1234,
'number': '4181235555',
'name': '4181235555',
'channel': 'DAHDI/i1/4181235555-5',
'muted': False}}}}
expected = copy.deepcopy(self.manager._cache)
expected[conf_room_number]['members'][2]['muted'] = True
self.manager.mute(conf_room_number, 2)
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
def test_unmuting(self):
self.manager.unmute(conf_room_number, 1)
self.manager._cache = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': 1234.1234,
'members': {1: {'join_order': 1,
'join_time': 1234.1234,
'number': '1002',
'name': 'Tester 1',
'channel': 'SIP/jsdhfjd-124',
'muted': False},
2: {'join_order': 2,
'join_time': 1239.1234,
'number': '4181235555',
'name': '4181235555',
'channel': 'DAHDI/i1/4181235555-5',
'muted': True}}}}
expected = copy.deepcopy(self.manager._cache)
expected[conf_room_number]['members'][2]['muted'] = False
self.manager.unmute(conf_room_number, 2)
self.mock_notifier.publish_meetme_update.assert_called_once_with(expected)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=True))
def test_parse_mute(self):
event = {'Event': 'MeetmeMute',
'Privilege': 'call,all',
'Channel': 'SIP/pcm_dev-0000000b',
'Uniqueid': '1338379282.18',
'Meetme': '800',
'Usernum': '1',
'Status': 'on'}
service_manager.parse_meetmemute(event)
self.mock_manager.mute.assert_called_once_with('800', 1)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=False))
def test_parse_mute_paging(self):
event = {'Event': 'MeetmeMute',
'Privilege': 'call,all',
'Channel': 'SIP/pcm_dev-0000000b',
'Uniqueid': '1338379282.18',
'Meetme': '800',
'Usernum': '1',
'Status': 'on'}
service_manager.parse_meetmemute(event)
self.assertEquals(self.mock_manager.mute.call_count, 0)
@patch('xivo_dao.meetme_dao.is_a_meetme', Mock(return_value=True))
def test_parse_unmute(self):
event = {'Event': 'MeetmeMute',
'Privilege': 'call,all',
'Channel': 'SIP/pcm_dev-0000000b',
'Uniqueid': '1338379282.18',
'Meetme': '800',
'Usernum': '1',
'Status': 'off'}
service_manager.parse_meetmemute(event)
self.mock_manager.unmute.assert_called_once_with('800', 1)
@patch('xivo_dao.meetme_dao.muted_on_join_by_number', Mock(return_value=False))
@patch('xivo_dao.user_line_dao.get_cid_for_channel', Mock(return_value=('"Tester 1" <1002>', 'Tester 1', '1002')))
@patch('time.time')
def test_join_originate(self, mock_time):
channel = 'SIP/kljfh-1234'
join_time = 12345.654
mock_time.return_value = join_time
self.manager._cache = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': 0,
'members': {}}}
self.manager.join(channel, conf_room_number, 1, conf_room_number, conf_room_number)
expected = {conf_room_number: {'number': conf_room_number,
'name': conf_room_name,
'pin_required': True,
'start_time': join_time,
'members': {1: {'join_order': 1,
'join_time': join_time,
'number': '1002',
'name': 'Tester 1',
'channel': channel,
'muted': False}}}}
self.assertEqual(self.manager._cache, expected)
def MockEvent(**kwargs):
ev = NonCallableMock(spec_set=kwargs.keys())
ev.configure_mock(**kwargs)
return ev
def test_view(self, mockpaginator, mockrepo, mocksolr_interface, mocksolr_iface):
mocksolr = mocksolr_interface.return_value
mocksolr_iface.return_value = mocksolr
view_url = reverse('collection:view', kwargs={'pid': 'coll'})
mocksolr.query.return_value = mocksolr.query
for method in ['query', 'sort_by', 'results_as', 'field_limit',
'facet_query']:
getattr(mocksolr.query, method).return_value = mocksolr.query
# set no solr results for last-modified query
mocksolr.query.count.return_value = 0
# simulate 404
mockcoll = NonCallableMock()
mockrepo.return_value.get_object.return_value = mockcoll
# - doesn't exist
mockcoll.exists = False
response = self.client.get(view_url)
expected, got = 404, response.status_code
self.assertEqual(expected, got,
'expected status code %s but got %s for view collection when object doesn\'t exist' % \
(expected, got))
# - exists but is the wrong type
mockcoll.exists = True
mockcoll.has_requisite_content_models = False
response = self.client.get(view_url)
expected, got = 404, response.status_code
self.assertEqual(expected, got,
'expected status code %s but got %s for view collection when object has wrong cmodels' % \
(expected, got))
# simulate valid fedora object
mockcoll.has_requisite_content_models = True
mockcoll.short_label = 'Yellowbacks'
mockcoll.pid = 'coll:1'
mockcoll.dc.content.description = 'Cheap 19thc paperbacks, often bound in yellow.'
# simulate sunburnt's fluid interface
# set up mock results for display on template
solr_result = [
SolrVolume(**{'pid': 'vol:1', 'title': 'Asodecoan',
'creator': ['Atlanta-Southern Dental College.; Emory University Archives.']}),
SolrVolume(**{'pid': 'vol:2', 'title': 'Sugar Crop of Lousiana', 'label': 'ocm123_V.2',
'date': ['1831']}),
]
results = NonCallableMagicMock(spec=['__iter__', 'facet_counts'])
results.__iter__.return_value = iter(solr_result)
results.facet_counts.facet_queries = []
# - using a noncallable for the pagination result that is used in the template
# because passing callables into django templates does weird things
mockpage = NonCallableMock()
mockpaginator.return_value.page.return_value = mockpage
mockpage.object_list = results
mockpage.has_other_pages = False
mockpage.paginator.count = 2
mockpage.paginator.page_range = [1]
mockpaginator.return_value.count = 2
mockpaginator.return_value.page_range = [1]
response = self.client.get(view_url)
# inspect solr query
mocksolr.query.assert_called_with(content_model=Volume.VOLUME_CMODEL_PATTERN,
collection_id=mockcoll.pid)
mocksolr.query.sort_by.assert_any_call('title_exact')
mocksolr.query.sort_by.assert_any_call('label')
mocksolr.query.results_as.assert_called_with(SolrVolume)
# inspect html result
self.assertContains(response, mockcoll.short_label,
msg_prefix='collection short label should be displayed')
self.assertContains(response,
'<title>%s Collection | Readux</title>' % mockcoll.short_label,
html=True,
msg_prefix='collection label should be included in html title')
self.assertContains(response, mockcoll.dc.content.description,
msg_prefix='collection dc:description should be displayed')
self.assertContains(response, '2 volumes in this collection',
msg_prefix='total count of volumes in the collection should be displayed')
self.assertContains(response, solr_result[0]['title'],
msg_prefix='volume title %(title)s should be displayed' % solr_result[0])
self.assertContains(response, solr_result[1]['title'],
msg_prefix='volume title %(title)s should be displayed' % solr_result[1])
self.assertContains(response, '[V.2]',
msg_prefix='volume number should be displayed when present')
# date/creator
self.assertContains(response, '(%s)' % solr_result[1]['date'][0],
msg_prefix='volume date should be displayed when present')
self.assertContains(response, '%s' % solr_result[0]['creator'][0],
msg_prefix='volume author/creator should be displayed when present')
# check that unapi / zotero harvest is enabled
self.assertContains(response,
'<link rel="unapi-server" type="application/xml" title="unAPI" href="%s" />' % \
reverse('books:unapi'),
html=True,
msg_prefix='link to unAPI server URL should be specified in header')
self.assertContains(response,
'<abbr class="unapi-id" title="%s"></abbr>' % solr_result[0]['pid'],
msg_prefix='unapi item id for %s should be included to allow zotero harvest' % \
solr_result[0]['pid'])
self.assertContains(response,
'<abbr class="unapi-id" title="%s"></abbr>' % solr_result[1]['pid'],
msg_prefix='unapi item id for %s should be included to allow zotero harvest' % \
solr_result[1]['pid'])
self.assertFalse(response.has_header('last-modified'),
'last modified header should not be set when no results were found in solr')
# last-modified
mocksolr.query.count.return_value = 1
# set a timestamp to be returned for last-modified conditional processing
mocksolr.query.return_value.__getitem__.return_value = {'timestamp': datetime.now()}
response = self.client.get(view_url)
self.assertTrue(response.has_header('last-modified'),
'last modified header should be set')
## annotation totals
# empty annotation total in context for anonymous user
self.assertEqual({}, response.context['annotated_volumes'])
# check that annotation total is retrieved for ONLY logged in users
with patch('readux.collection.views.Volume') as mockvolclass:
self.client.get(view_url)
mockvolclass.volume_annotation_count.assert_not_called()
User = get_user_model()
credentials = {'username': '******', 'password': '******'}
testuser = User.objects.create_user(**credentials)
self.client.login(**credentials)
self.client.get(view_url)
mockvolclass.volume_annotation_count.assert_called_with(testuser)
