def test_get_involved_users_org(self, list_comments_mock): datarequest_id = 'dr1' follower1 = MagicMock() follower2 = MagicMock() follower1.user_id = 'user-2' follower2.user_id = 'user-3' list_comments_mock.return_value = [{'user_id': 'user-1'}, {'user_id': 'user-2'}] actions.db.DataRequestFollower.get.return_value = [follower1, follower2] self.context['auth_user_obj'].id = 'user-7' datarequest = { 'id': datarequest_id, 'user_id': 'user-1', 'organization': {'users': [{'id': 'user-3'}, {'id': 'user-4'}]} } result = actions._get_datarequest_involved_users(self.context, datarequest) self.assertEquals(set(['user-1', 'user-2', 'user-3', 'user-4']), result) actions.db.DataRequestFollower.get.assert_called_once_with(datarequest_id=datarequest_id) list_comments_mock.assert_called_once_with({'ignore_auth': True, 'model': self.context['model']}, {'datarequest_id': datarequest_id})
def test_public_exists_events(self): status = rd_instance.ServiceStatuses.BUILDING.api_status instance, service_status = self.build_db_instance( status, task_status=InstanceTasks.BUILDING) server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, instance, server, service_status) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' notifier = MagicMock() with patch.object(rpc, 'get_notifier', return_value=notifier): with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): self.assertThat(self.context.auth_token, Is('some_secret_password')) with patch.object(notifier, 'info', return_value=None): # invocation mgmtmodels.publish_exist_events( mgmtmodels.NovaNotificationTransformer( context=self.context), self.context) # assertion notifier.info.assert_any_call(self.context, 'trove.instance.exists', ANY) self.assertThat(self.context.auth_token, Is(None)) self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_flavor_cache(self): status = rd_instance.ServiceStatuses.BUILDING.api_status instance, service_status = self.build_db_instance( status, InstanceTasks.BUILDING) server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, instance, server, service_status) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): transformer() payloads = transformer() self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(1)) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertIn(status.lower(), [db['state'] for db in payloads]) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) # ensure cache was used to get flavor second time self.flavor_mgr.get.assert_any_call('flavor_1') self.addCleanup(self.do_cleanup, instance, service_status)
def test_organic_topk_coldstart(self): """PrecomputedUserTopkBlueprintInterpreter test cold starts. """ self._train_task() topk_req = MagicMock() topk_req.user_id = ['Foobar'] topk_req.known_items = False topk_req.n_items = 20 topk_req.threshold = None request = Request(scoring_data=topk_req) vertex = MagicMock() vertex.steps = [[self.task]] vertex_data = {'vertex_object': vertex} model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) model.vertex_factory = MagicMock() model.vertex_factory.get.return_value = vertex_data out = model.predict() self.assertEqual(len(out), len(topk_req.user_id)) self.assertEqual(out[0][0], topk_req.user_id[0]) topk = self.task.topk_[(-1, -1)] desired_items = map(lambda iid: topk.item_inv_map[iid], topk.coldstart_items[:topk_req.n_items]) np.testing.assert_array_equal(out[0][1], desired_items) np.testing.assert_array_equal(out[0][2], topk.coldstart_ratings[:topk_req.n_items]) # check if all output item ids are in training set item_set = set(np.unique(self.df['item_id'])) items = out[0][1] for eid in items: self.assertTrue(eid in item_set)
def test_organic_topk_smoke(self): """PrecomputedUserTopkBlueprintInterpreter smoke test. """ self._train_task() topk_req = MagicMock() topk_req.user_id = ['UID-1'] topk_req.known_items = False topk_req.n_items = 20 topk_req.threshold = None request = Request(scoring_data=topk_req) vertex = MagicMock() vertex.steps = [[self.task]] vertex_data = {'vertex_object': vertex} model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) model.vertex_factory = MagicMock() model.vertex_factory.get.return_value = vertex_data out = model.predict() self.assertEqual(len(out), len(topk_req.user_id)) self.assertEqual(out[0][0], topk_req.user_id[0]) # check if all output item ids are in training set item_set = set(np.unique(self.df['item_id'])) items = out[0][1] for eid in items: self.assertTrue(eid in item_set)
def test_tranformer_shutdown_instance(self): status = rd_instance.ServiceStatuses.SHUTDOWN.api_status db_instance = self.build_db_instance(status) server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, db_instance, server, None) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' with patch.object(Backup, 'running', return_value=None): self.assertThat(mgmt_instance.status, Equals('SHUTDOWN')) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): # invocation transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) payloads = transformer() # assertion that SHUTDOWN instances are not reported self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(0))
def test_on_taskrun_submit_event(self, mock_update_feed, mock_add_user, mock_is_task, mock_update_task, mock_create_result, mock_push): """Test on_taskrun_submit is called.""" conn = MagicMock() target = MagicMock() target.id = 1 target.project_id = 1 target.task_id = 2 target.user_id = 3 tmp = Project(id=1, name='name', short_name='short_name', info=dict(container=1, thumbnail="avatar.png"), published=True, webhook='http://localhost.com') conn.execute.return_value = [tmp] on_taskrun_submit(None, conn, target) obj = tmp.to_public_json() obj['action_updated'] = 'TaskCompleted' mock_add_user.assert_called_with(conn, target.user_id, obj) mock_update_task.assert_called_with(conn, target.task_id) mock_update_feed.assert_called_once_with(obj) obj_with_webhook = tmp.to_public_json() obj_with_webhook['webhook'] = tmp.webhook obj_with_webhook['action_updated'] = 'TaskCompleted' mock_push.assert_called_with(obj_with_webhook, target.task_id, 1)
def test_regular(self): sender = MagicMock() detect = MagicMock() context = MagicMock() suggest = Mock() target = Target(sender, detect, context, suggest) target.json_decode = MagicMock(return_value={"_rev": "context_revision_value"}) target.context_responder.unsupported_entities = MagicMock() response = Mock() response.body = "response_body_value" handler = MagicMock() handler.user_id = "user_id_value" handler.application_id = "application_id_value" handler.session_id = "session_id_value" handler.locale = "locale_value" target.get_context_callback(response, handler, "message_value") target.json_decode.assert_called_once_with("response_body_value") target.context_responder.unsupported_entities.assert_called_once_with( handler, {"_rev": "context_revision_value"} ) self.assertEqual(1, suggest.post_suggest.call_count) self.assertEqual("user_id_value", suggest.post_suggest.call_args_list[0][0][0]) self.assertEqual("application_id_value", suggest.post_suggest.call_args_list[0][0][1]) self.assertEqual("session_id_value", suggest.post_suggest.call_args_list[0][0][2]) self.assertEqual("locale_value", suggest.post_suggest.call_args_list[0][0][3]) self.assertDictEqual({"_rev": "context_revision_value"}, suggest.post_suggest.call_args_list[0][0][4])
def test_tranformer_flavor_cache(self): status = rd_instance.ServiceStatuses.BUILDING.api_status db_instance = MockMgmtInstanceTest.build_db_instance( status, InstanceTasks.BUILDING) server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, db_instance, server, None) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) transformer() # call twice ensure client.flavor invoked once payloads = transformer() self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(1)) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertThat(payload['state'], Equals(status.lower())) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) # ensure cache was used to get flavor second time self.flavor_mgr.get.assert_any_call('flavor_1')
def test_public_exists_events(self): status = rd_instance.ServiceStatuses.BUILDING.api_status instance, service_status = self.build_db_instance( status, task_status=InstanceTasks.BUILDING) server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, instance, server, service_status) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' notifier = MagicMock() with patch.object(rpc, 'get_notifier', return_value=notifier): with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): self.assertThat(self.context.auth_token, Is('some_secret_password')) with patch.object(notifier, 'info', return_value=None): # invocation mgmtmodels.publish_exist_events( mgmtmodels.NovaNotificationTransformer( context=self.context), self.context) # assertion notifier.info.assert_any_call( self.context, 'trove.instance.exists', ANY) self.assertThat(self.context.auth_token, Is(None)) self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_shutdown_instance(self): status = rd_instance.ServiceStatuses.SHUTDOWN.api_status instance, service_status = self.build_db_instance(status) service_status.set_status(rd_instance.ServiceStatuses.SHUTDOWN) server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, instance, server, service_status) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) with patch.object(Backup, 'running', return_value=None): self.assertThat(mgmt_instance.status, Equals('SHUTDOWN')) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): payloads = transformer() # assertion that SHUTDOWN instances are not reported self.assertIsNotNone(payloads) self.assertNotIn(status.lower(), [db['status'] for db in payloads]) self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer(self): status = rd_instance.ServiceStatuses.BUILDING.api_status instance, service_status = self.build_db_instance( status, InstanceTasks.BUILDING) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' server = MagicMock(spec=Server) server.user_id = 'test_user_id' transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, instance, server, service_status) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): payloads = transformer() self.assertIsNotNone(payloads) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertThat(payload['state'], Not(Is(None))) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) self.assertThat(payload['service_id'], Equals('123')) self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_invalid_datastore_manager(self): status = rd_instance.ServiceStatuses.BUILDING.api_status db_instance = MockMgmtInstanceTest.build_db_instance( status, task_status=InstanceTasks.BUILDING) server = MagicMock(spec=Server) server.user_id = 'test_user_id' stub_datastore_version = MagicMock() stub_datastore_version.id = "stub_datastore_version" stub_datastore_version.manager = "m0ng0" stub_datastore = MagicMock() stub_datastore.default_datastore_version = "stub_datastore_version" flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' with patch.object(datastore_models.DatastoreVersion, 'load', return_value=stub_datastore_version): with patch.object(datastore_models.DatastoreVersion, 'load_by_uuid', return_value=stub_datastore_version): with patch.object(datastore_models.Datastore, 'load', return_value=stub_datastore): mgmt_instance = mgmtmodels.SimpleMgmtInstance( self.context, db_instance, server, None) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): # invocation transformer = ( mgmtmodels.NovaNotificationTransformer( context=self.context)) payloads = transformer() # assertions self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(1)) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertThat(payload['state'], Equals(status.lower())) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) self.assertThat(payload['service_id'], Equals('unknown-service-id-error'))
def test_tranformer_invalid_datastore_manager(self): status = rd_instance.ServiceStatuses.BUILDING.api_status db_instance = MockMgmtInstanceTest.build_db_instance( status, task_status=InstanceTasks.BUILDING) server = MagicMock(spec=Server) server.user_id = 'test_user_id' stub_datastore_version = MagicMock() stub_datastore_version.id = "stub_datastore_version" stub_datastore_version.manager = "m0ng0" stub_datastore = MagicMock() stub_datastore.default_datastore_version = "stub_datastore_version" flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' with patch.object(datastore_models.DatastoreVersion, 'load', return_value=stub_datastore_version): with patch.object(datastore_models.DatastoreVersion, 'load_by_uuid', return_value=stub_datastore_version): with patch.object(datastore_models.Datastore, 'load', return_value=stub_datastore): mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, db_instance, server, None) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): # invocation transformer = ( mgmtmodels.NovaNotificationTransformer( context=self.context) ) payloads = transformer() # assertions self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(1)) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertThat(payload['state'], Equals(status.lower())) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) self.assertThat(payload['service_id'], Equals('unknown-service-id-error'))
def _generate_basic_comment(id=COMMENT_ID, user_id='example_uuidv4_user', comment='Example Comment', datarequest_id='example_dr_id'): comment = MagicMock() comment.id = id comment.user_id = user_id comment.comment = comment comment.datarequest_id = datarequest_id comment.time = datetime.datetime.now() return comment
def test_tranformer(self): status = rd_instance.ServiceStatuses.BUILDING.api_status db_instance = MockMgmtInstanceTest.build_db_instance( status, task_status=InstanceTasks.BUILDING) stub_dsv_db_info = MagicMock(spec=datastore_models.DBDatastoreVersion) stub_dsv_db_info.id = "test_datastore_version" stub_dsv_db_info.datastore_id = "mysql_test_version" stub_dsv_db_info.name = "test_datastore_name" stub_dsv_db_info.image_id = "test_datastore_image_id" stub_dsv_db_info.packages = "test_datastore_pacakges" stub_dsv_db_info.active = 1 stub_dsv_db_info.manager = "mysql" stub_datastore_version = datastore_models.DatastoreVersion( stub_dsv_db_info) flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' server = MagicMock(spec=Server) server.user_id = 'test_user_id' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, db_instance, server, None) with patch.object(DatabaseModelBase, 'find_by', return_value=stub_datastore_version): with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): # invocation transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) payloads = transformer() # assertions self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(1)) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertThat(payload['state'], Equals(status.lower())) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) self.assertThat(payload['service_id'], Equals('123'))
def _generate_basic_comment( id=COMMENT_ID, user_id="example_uuidv4_user", comment="Example Comment", datarequest_id="example_dr_id", ): comment = MagicMock() comment.id = id comment.user_id = user_id comment.comment = comment comment.datarequest_id = datarequest_id comment.time = datetime.datetime.utcnow() return comment
def _generate_basic_datarequest(id=DATAREQUEST_ID, user_id='example_uuidv4_user', title='This is a title', description='This is a basic description', organization_id='example_uuidv4_organization', closed=False): datarequest = MagicMock() datarequest.id = id datarequest.user_id = user_id datarequest.title = title datarequest.description = description datarequest.organization_id = organization_id datarequest.open_time = datetime.datetime.now() datarequest.closed = closed datarequest.close_time = None datarequest.accepted_dataset_id = None datarequest.accepted_dataset = {'test': 'test1', 'test2': 'test3'} return datarequest
def test_coldstart_threshold(self, mock_task_func): """Threshold applies to coldstart. """ mock_task = MagicMock() mock_task.topk_ = {(-1, -1): self.topk} mock_task_func.return_value = mock_task topk_req = MagicMock() topk_req.user_id = ['UID-666'] topk_req.known_items = False topk_req.n_items = 20 topk_req.threshold = 3.1 request = Request(scoring_data=topk_req) model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) out = model.predict() self.assertEqual(out, [('UID-666', [], tuple())])
def test_threshold_known_items(self, mock_task_func): """Filter by threshold & known items - corner case with 0 items returned""" mock_task = MagicMock() mock_task.topk_ = {(-1, -1): self.topk} mock_task_func.return_value = mock_task topk_req = MagicMock() topk_req.user_id = ['UID-1'] topk_req.known_items = False topk_req.n_items = 20 topk_req.threshold = 1.0 request = Request(scoring_data=topk_req) model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) out = model.predict() self.assertEqual(out, [('UID-1', [], tuple())])
def test_coldstart_known(self, mock_task_func): """Known does not apply to coldstarts. """ mock_task = MagicMock() mock_task.topk_ = {(-1, -1): self.topk} mock_task_func.return_value = mock_task topk_req = MagicMock() topk_req.user_id = ['UID-666'] topk_req.known_items = False topk_req.n_items = 20 topk_req.threshold = 3.0 request = Request(scoring_data=topk_req) model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) out = model.predict() self.assertEqual(out, [('UID-666', ['IID-0', 'IID-1', 'IID-2'], (3.0, 3.0, 3.0))])
def test_known_items(self, mock_task_func): """Filter by known items""" mock_task = MagicMock() mock_task.topk_ = {(-1, -1): self.topk} mock_task_func.return_value = mock_task topk_req = MagicMock() topk_req.user_id = ['UID-1'] topk_req.known_items = False topk_req.n_items = 20 topk_req.threshold = None request = Request(scoring_data=topk_req) model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) out = model.predict() self.assertEqual(out, [('UID-1', ['IID-2'], (0.1, ))])
def _base_dependency_setup(self, manager_def_mock, user_mock, ngouserprofile_def_mock, project_mock): manager_mock = MagicMock(spec=DatabaseManager) manager_def_mock.return_value = manager_mock user_saved_mock = MagicMock(spec=User) user_saved_mock.username = '******' user_mock.objects.create_user.return_value = user_saved_mock user_mock.objects.get.return_value = user_saved_mock ngo_user_profile_mock = MagicMock(spec=NGOUserProfile) ngo_user_profile_mock.org_id = 'SLX364903' ngo_user_profile_mock.user_id = 1 ngouserprofile_def_mock.return_value = ngo_user_profile_mock ngouserprofile_def_mock.objects.get.return_value = ngo_user_profile_mock questionnaire_mock = MagicMock(spec=Project) project_mock.get.return_value = questionnaire_mock return manager_mock, user_saved_mock, ngo_user_profile_mock, questionnaire_mock
def test_threshold(self, mock_task_func): """Filter by threshold (filter out item IID-2)""" mock_task = MagicMock() mock_task.topk_ = {(-1, -1): self.topk} mock_task_func.return_value = mock_task topk_req = MagicMock() topk_req.user_id = ['UID-1'] topk_req.known_items = True topk_req.n_items = 20 topk_req.threshold = 1.0 request = Request(scoring_data=topk_req) model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) out = model.predict() self.assertEqual(out, [('UID-1', ['IID-0', 'IID-1'], (4.3, 2.3))])
def test_smoke(self, mock_task_func): """Smoke test for PrecomputedUserTopkBlueprintInterpreter. """ mock_task = MagicMock() mock_task.topk_ = {(-1, -1): self.topk} mock_task_func.return_value = mock_task # smoke test - get topk for UID-1 topk_req = MagicMock() topk_req.user_id = ['UID-1'] topk_req.known_items = True topk_req.n_items = 20 topk_req.threshold = None request = Request(scoring_data=topk_req) model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) out = model.predict() self.assertEqual(out, [('UID-1', ['IID-0', 'IID-1', 'IID-2'], (4.3, 2.3, 0.1))])
def test_transformer_invalid_datastore_manager(self, mock_logging): status = rd_instance.ServiceStatuses.BUILDING.api_status instance, service_status = self.build_db_instance( status, InstanceTasks.BUILDING) version = datastore_models.DBDatastoreVersion.get_by( id=instance.datastore_version_id) version.update(manager='something invalid') server = MagicMock(spec=Server) server.user_id = 'test_user_id' flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, instance, server, service_status) transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): payloads = transformer() # assertions self.assertIsNotNone(payloads) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertIn(status.lower(), [db['state'] for db in payloads]) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) self.assertThat(payload['service_id'], Equals('unknown-service-id-error')) version.update(manager='mysql') self.addCleanup(self.do_cleanup, instance, service_status)
def test_tranformer_invalid_datastore_manager(self): status = rd_instance.ServiceStatuses.BUILDING.api_status instance, service_status = self.build_db_instance( status, InstanceTasks.BUILDING) version = datastore_models.DBDatastoreVersion.get_by( id=instance.datastore_version_id) version.update(manager='something invalid') server = MagicMock(spec=Server) server.user_id = 'test_user_id' flavor = MagicMock(spec=Flavor) flavor.name = 'db.small' mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context, instance, server, service_status) transformer = mgmtmodels.NovaNotificationTransformer( context=self.context) with patch.object(mgmtmodels, 'load_mgmt_instances', return_value=[mgmt_instance]): with patch.object(self.flavor_mgr, 'get', return_value=flavor): payloads = transformer() # assertions self.assertIsNotNone(payloads) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertIn(status.lower(), [db['state'] for db in payloads]) self.assertThat(payload['instance_type'], Equals('db.small')) self.assertThat(payload['instance_type_id'], Equals('flavor_1')) self.assertThat(payload['user_id'], Equals('test_user_id')) self.assertThat(payload['service_id'], Equals('unknown-service-id-error')) version.update(manager='mysql') self.addCleanup(self.do_cleanup, instance, service_status)
def test_multiple_coldstart(self, mock_task_func): """Retrieve multiple user ids. """ mock_task = MagicMock() mock_task.topk_ = {(-1, -1): self.topk} mock_task_func.return_value = mock_task topk_req = MagicMock() topk_req.user_id = ['UID-1', 'UID-666'] topk_req.known_items = True topk_req.n_items = 20 topk_req.threshold = None request = Request(scoring_data=topk_req) model = PrecomputedUserTopkBlueprintInterpreter(MagicMock(), MagicMock(), request=request) out = model.predict() self.assertEqual(out, [('UID-1', ['IID-0', 'IID-1', 'IID-2'], (4.3, 2.3, 0.1)), ('UID-666', ['IID-0', 'IID-1', 'IID-2'], (3.0, 3.0, 3.0))])
def _generate_basic_datarequest( id=DATAREQUEST_ID, user_id="example_uuidv4_user", title="This is a title", description="This is a basic description", organization_id="example_uuidv4_organization", closed=False, ): datarequest = MagicMock() datarequest.id = id datarequest.user_id = user_id datarequest.title = title datarequest.description = description datarequest.organization_id = organization_id datarequest.open_time = datetime.datetime.utcnow() datarequest.closed = closed datarequest.close_time = None datarequest.accepted_dataset_id = None datarequest.accepted_dataset = {"test": "test1", "test2": "test3"} return datarequest
def test_on_taskrun_submit_gold_and_published_projects(self, mock_is_task, mock_add_user, mock_get_project_scheduler): """Test on_taskrun_submit only set exported = False for published projects""" task = TaskFactory.create(id=3, exported=True, n_answers=1, calibration=1) project = Project(id=1, name='name', short_name='short_name', info=dict(container=1, thumbnail="avatar.png"), published=True, webhook='http://localhost.com') mock_get_project_scheduler.return_value = 'default' mock_task_run = MagicMock() mock_task_run.user_id = 42 mock_task_run.exported = task.exported mock_task_run.task_id = task.id mock_task_run.calibration = task.calibration conn = MagicMock() conn.execute.return_value = [project] on_taskrun_submit(None, conn, mock_task_run) assert not mock_is_task.called expected_sql_query = ("""UPDATE task SET exported=False \ WHERE id=%s;""") % (task.id) conn.execute.assert_called_with(expected_sql_query)
def test_regular_has_entities(self): sender = MagicMock() context = MagicMock() suggest = Mock() target = Target(sender, context, suggest) target.json_decode = MagicMock( return_value={ "entities": [ { "source": "non_detection" } ], "_rev": "_context_rev_value" } ) handler = MagicMock() handler.user_id = "user_id_value" handler.application_id = "application_id_value" handler.session_id = "session_id_value" handler.locale = "locale_value" response = MagicMock() response.body = "response_value" target.get_context_callback(response, handler, "message_value") self.assertEqual(1, suggest.post_suggest.call_count) self.assertEqual("user_id_value", suggest.post_suggest.call_args_list[0][0][0]) self.assertEqual("application_id_value", suggest.post_suggest.call_args_list[0][0][1]) self.assertEqual("session_id_value", suggest.post_suggest.call_args_list[0][0][2]) self.assertEqual("locale_value", suggest.post_suggest.call_args_list[0][0][3]) self.assertDictEqual({'_rev': '_context_rev_value', 'entities': [{'source': 'non_detection'}]}, suggest.post_suggest.call_args_list[0][0][4]) target.json_decode.assert_called_once_with('response_value') self.assertDictEqual({'_rev': '_context_rev_value', 'entities': [{'source': 'non_detection'}]}, handler.context) self.assertEqual("_context_rev_value", handler.context_rev)
def test_regular(self): sender = MagicMock() detect = MagicMock() context = MagicMock() suggest = Mock() target = Target(sender, detect, context, suggest) target.json_decode = MagicMock( return_value={"_rev": "context_revision_value"}) target.context_responder.unsupported_entities = MagicMock() response = Mock() response.body = "response_body_value" handler = MagicMock() handler.user_id = "user_id_value" handler.application_id = "application_id_value" handler.session_id = "session_id_value" handler.locale = "locale_value" target.get_context_callback(response, handler, "message_value") target.json_decode.assert_called_once_with("response_body_value") target.context_responder.unsupported_entities.assert_called_once_with( handler, {'_rev': 'context_revision_value'}) self.assertEqual(1, suggest.post_suggest.call_count) self.assertEqual("user_id_value", suggest.post_suggest.call_args_list[0][0][0]) self.assertEqual("application_id_value", suggest.post_suggest.call_args_list[0][0][1]) self.assertEqual("session_id_value", suggest.post_suggest.call_args_list[0][0][2]) self.assertEqual("locale_value", suggest.post_suggest.call_args_list[0][0][3]) self.assertDictEqual({'_rev': 'context_revision_value'}, suggest.post_suggest.call_args_list[0][0][4])
def test_keystone_auth(self): """Test password authentication with keystone only""" conf = {'auth': {'keystone': TEST_KEYSTONE_AUTH, }, } driver = self._load_auth_plugin('Password', conf) # assert the driver has loaded only one plugin self.assertEqual(1, len(driver.plugins)) self.assertEqual('KeystoneAuthPlugin', driver.plugins[0].__class__.__name__) # test valid user auth_context = {'username': '******', 'password': '******'} expected = {'login': '******', 'email': '', 'name': 'openstack', 'ssh_keys': [], 'external_auth': {'domain': TEST_KEYSTONE_AUTH['auth_url'], 'external_id': 1234}} with patch('keystoneclient.client.Client') as c: client = MagicMock() client.authenticate.return_value = True client.user_id = 1234 c.return_value = client authenticated = driver.authenticate(**auth_context) self.assertEqual(expected, authenticated, "Got %r" % authenticated) # test wrong user auth_context = {'username': '******', 'password': '******'} with patch('keystoneclient.client.Client') as c: client = MagicMock() client.authenticate.side_effect = k_exc.Unauthorized c.return_value = client with self.assertRaises(base.UnauthenticatedError): driver.authenticate(**auth_context)