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