def test_record(vcr_service, cassette, call, mock_server): allow(cassette).can_replay.and_return(False) expect(cassette).record.with_args( VCRProxy.Request( serviceName='service', endpoint='endpoint', headers='headers', body='body', hostPort=mock_server.hostport, ), VCRProxy.Response(0, 'response headers', 'response body'), ) mock_server.expect_call('endpoint').and_write( headers='response headers', body='response body', ).once() response = yield call( service='service', endpoint='endpoint', headers='headers', body='body', ) assert response.headers == 'response headers' assert response.body == 'response body'
def test_user_not_found(http_client, base_url): mock_service = gen_mock_service() expect(mock_service).get.and_raise(ResourceNotFoundError, ) response = yield http_client.fetch( base_url + '/api/users/a9ab843d-4300-4ade-8c57-f5669b5bad31') assert response.body == '{"status": "failed", "errorMessage": "Not found."}' assert response.code == httplib.OK
def test_get_tag(http_client, base_url): title_entity = Title( title_id='titleId', title='title', video_path='video_path', file_names=['file_names'], description='description', maker='maker', video_size=1000000, stars=[], rate=4.2, length=121, published_date='2011-01-29', ) title = yield TitleService().create_with_entity(title_entity) mock_service = gen_mock_service() expect(mock_service).get.and_return_future(title) response = yield http_client.fetch(base_url + '/api/titles/' + title.uuid) result_object = json.loads(response.body) assert result_object['status'] == 'ok' assert result_object['title'] == title.to_dict() assert response.code == httplib.OK
def test_add_title_already_exists(http_client, base_url): mock_service = gen_mock_service() expect(mock_service).create_with_entity.and_raise( EntityAlreadyExistsError, ) response = yield http_client.fetch(base_url + '/test/add_title') assert response.body == 'ABC-123 already exists' assert response.code == httplib.OK
def test_add_user_already_exists(http_client, base_url): mock_service = gen_mock_service() expect(mock_service).create_with_entity.and_raise( EntityAlreadyExistsError, ) response = yield http_client.fetch(base_url + '/add_user') assert response.body == 'User name fg exist.' assert response.code == httplib.OK
def test_expect_passes(): test_object = TestClass() expect(test_object).method.with_args( any_string.containing('bob') ) test_object.method('bob barker')
def test_get_training_data_noise(self): problem_name = 'test_problem_noise' training_name = 'test' bounds_domain = [[1, 100]] expect(JSONFile).read.and_return(None) training_data = \ TrainingDataService.get_training_data(problem_name, training_name, bounds_domain, n_training=1, noise=True, n_samples=5) np.random.seed(DEFAULT_RANDOM_SEED) points = [list(np.random.uniform(1, 100, 1))] noise = np.random.normal(0, 1, 5) eval = points[0] + noise evaluations = [np.mean(eval)] var = [np.var(eval) / 25.0] npt.assert_almost_equal(training_data['points'], points) npt.assert_almost_equal(training_data['var_noise'], var) npt.assert_almost_equal(training_data['evaluations'], evaluations) training_data_ = \ TrainingDataService.get_training_data(problem_name, training_name, bounds_domain, n_training=1, noise=True, n_samples=5, parallel=False) assert np.all(training_data['points'] == training_data_['points']) assert np.all( training_data['var_noise'] == training_data_['var_noise']) assert np.all( training_data['evaluations'] == training_data_['evaluations'])
def test_training_data_from_dict(self): problem_name = 'test_problem' training_name = 'test' bounds_domain = [[1, 100]] expect(JSONFile).read.and_return(None) np.random.seed(DEFAULT_RANDOM_SEED) points = \ [[42.2851784656], [72.3121248508], [1.0113231069], [30.9309246906], [15.5288331909]] dict = { 'problem_name': problem_name, 'training_name': training_name, 'bounds_domain': bounds_domain, 'n_training': 5, 'points': points, 'noise': False, 'n_samples': 0, 'random_seed': 1, 'parallel': True, 'type_bounds': [0], } training_data = TrainingDataService.from_dict(dict) len(training_data) == 3 assert training_data['var_noise'] == [] assert np.all(training_data['evaluations'] == [i[0] for i in points]) assert np.all(training_data['points'] == points)
def test_get_training_data(self): problem_name = 'test_problem' training_name = 'test' bounds_domain = [[1, 100]] expect(JSONFile).read.and_return(None) training_data = \ TrainingDataService.get_training_data(problem_name, training_name, bounds_domain) np.random.seed(DEFAULT_RANDOM_SEED) points = \ [[42.2851784656], [72.3121248508], [1.0113231069], [30.9309246906], [15.5288331909]] evaluations = [i[0] for i in points] assert training_data['var_noise'] == [] npt.assert_almost_equal(training_data['evaluations'], evaluations) npt.assert_almost_equal(training_data['points'], points) training_data_ = \ TrainingDataService.get_training_data(problem_name, training_name, bounds_domain, parallel=False) assert training_data['var_noise'] == training_data_['var_noise'] assert np.all( training_data['evaluations'] == training_data_['evaluations']) assert np.all(training_data['points'] == training_data_['points']) with patch('os.path.exists', new=MagicMock(return_value=False)): os.mkdir = MockMkdir() training_data_ = \ TrainingDataService.get_training_data(problem_name, training_name, bounds_domain, parallel=False) assert training_data['var_noise'] == training_data_['var_noise'] assert np.all( training_data['evaluations'] == training_data_['evaluations']) assert np.all(training_data['points'] == training_data_['points'])
def test_user_dislike_title(http_client, base_url): user_entity = User(user_name='fg_dislike_video', password='******', email='fgdsb@fgdsb') user = yield UserService().create_with_entity(user_entity) title_entity = Title( title_id='dislike', title='test title 1', video_path='test', file_names=['test file'], description='test des', stars=[str(uuid.uuid4())], video_size=1000000000, rate=8, ) title = yield TitleService().create_with_entity(title_entity) mock_service = gen_mock_service() expect(mock_service).like_title.with_args(user.uuid, title.uuid, False).and_return_future(None) response = yield http_client.fetch(base_url + '/api/users/' + user.uuid + '/like_titles/' + title.uuid + '?like=n') assert response.body == '{"status": "ok"}' assert response.code == httplib.OK
def test_users(http_client, base_url): mock_service = gen_mock_service() expect(mock_service).get_all.and_return_future([]) response = yield http_client.fetch(base_url + '/api/users') assert response.body == '{"status": "ok", "users": []}' assert response.code == httplib.OK
def test_record(vcr_service, cassette, call, mock_server, use_known_peers): allow(cassette).can_replay.and_return(False) expect(cassette).record.with_args( proxy.Request( serviceName='service', endpoint='endpoint', headers='headers', body='body', knownPeers=[mock_server.hostport] if use_known_peers else [], hostPort='' if use_known_peers else mock_server.hostport, ), proxy.Response( code=0, headers='response headers', body='response body', ), ) mock_server.expect_call('endpoint').and_write( headers='response headers', body='response body', ).once() response = yield call( service='service', endpoint='endpoint', headers='headers', body='body', ) assert response.body.headers == 'response headers' assert response.body.body == 'response body'
def test_get_title_by_id(http_client, base_url): title_entity = Title( title_id='titleId02', title='title', video_path='video_path', file_names=['file_names'], description='description', maker='maker', video_size=1000000, stars=[], rate=4.2, length=121, published_date='2011-01-29', ) title = yield TitleService().create_with_entity(title_entity) mock_service = gen_mock_service() expect(mock_service).get_by_id.with_args( title.title_id).and_return_future(title) response = yield http_client.fetch(base_url + '/api/titles?id=' + title.title_id) assert json.loads(response.body) == { "status": "ok", "title": title.to_dict() } assert response.code == httplib.OK
def test_title_remove_tag(http_client, base_url): title_entity = Title( title_id='RemoveTag', title='title', video_path='video_path', file_names=['file_names'], description='description', maker='maker', video_size=1000000, stars=[], rate=4.2, length=121, published_date='2011-01-29', ) title = yield TitleService().create_with_entity(title_entity) tag_entity = Tag(name='PUZ', ) tag = yield TagService().create_with_entity(tag_entity) mock_service = gen_mock_service() expect(mock_service).add_tag.with_args(title.uuid, tag.uuid, False).and_return_future(None) response = yield http_client.fetch(base_url + '/api/titles/' + title.uuid + '/add_tag/' + tag.uuid + '?add=n') assert response.body == '{"status": "ok"}' assert response.code == httplib.OK
def test_issue_update(self, get_issue): allow(config.Config).auth expect(requests).put.and_return(support.MockResponse(204)) runner = CliRunner() result = runner.invoke( cli.cli, ['issue', 'DEV-101', 'update', 'reporter.name', 'james']) assert result.exit_code == 0 assert result.output == u'\x1b(0lqqqqqqqqqqqqqqqqqqqqqqqwqqqqqqqqqqqqqqqqqqqqwqqqqqqqqqqqqqqqqqqqqqqqwqqqqqqqqqqqqqqqqqqqqqqqqqqqqqwqqqqqqqqqqqqk\x1b(B\n\x1b(0x\x1b(B assignee_display_name \x1b(0x\x1b(B description \x1b(0x\x1b(B reporter_display_name \x1b(0x\x1b(B status_status_category_name \x1b(0x\x1b(B summary \x1b(0x\x1b(B\n\x1b(0tqqqqqqqqqqqqqqqqqqqqqqqnqqqqqqqqqqqqqqqqqqqqnqqqqqqqqqqqqqqqqqqqqqqqnqqqqqqqqqqqqqqqqqqqqqqqqqqqqqnqqqqqqqqqqqqu\x1b(B\n\x1b(0x\x1b(B Jack Shepard \x1b(0x\x1b(B example bug report \x1b(0x\x1b(B John Locke \x1b(0x\x1b(B In Progress \x1b(0x\x1b(B Bug report \x1b(0x\x1b(B\n\x1b(0mqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqqqqqqqqqqqqqqqqqqvqqqqqqqqqqqqj\x1b(B\n'
def test_domain_from_dict(self): expect(DomainService).load_discretization.never() DomainService.from_dict(self.spec) expect(DomainService).load_discretization.once().and_return([]) self.spec['number_points_each_dimension'] = [5] self.spec['problem_name'] = 'test' DomainService.from_dict(self.spec)
def test_replay(cassette, call): allow(cassette).can_replay.and_return(True) expect(cassette).replay.and_return(VCRProxy.Response(code=0, headers="{key: value}", body="response body")) response = yield call("endpoint", "request body") assert response.code == 0 assert response.headers == "{key: value}" assert response.body == "response body"
def test_read(self): some_rw = InstanceDouble('tchannel.rw.ReadWriter') delegated_rw = self._mk_rw(some_rw) stream = BytesIO() expect(some_rw).read.with_args(stream) delegated_rw.read(stream)
def test_add_user(http_client, base_url): fake_uuid = '05bf9bc2-a418-404b-9b15-c8670407a8bf' mock_service = gen_mock_service() expect(mock_service).create_with_entity.and_return_future( mock.Mock(uuid=fake_uuid), ) response = yield http_client.fetch(base_url + '/add_user') assert response.body == 'Added {}'.format(fake_uuid) assert response.code == httplib.OK
def test_write(self): some_rw = InstanceDouble('tchannel.rw.ReadWriter') delegated_rw = self._mk_rw(some_rw) stream = BytesIO() expect(some_rw).write.with_args("foo", stream) delegated_rw.write("foo", stream)
def test_get_with_valid_token(self, api_client): pending_action = PendingActionFactory(category=ActionCategory.CONFIRM_EMAIL.value) allow(AuthService).confirm_email.and_return(True) expect(AuthService).confirm_email.once() response = api_client.get(self.make_confirm_email_url(pending_action.token)) assert response.status_code == status.HTTP_200_OK
def test_cached_get_training_data(self): problem_name = 'test_problem' training_name = 'test' bounds_domain = [[1, 100]] expect(JSONFile).read.and_return(0) training_data = \ TrainingDataService.get_training_data(problem_name, training_name, bounds_domain) assert training_data == 0
def test_send_sms_mock(): sms_gateway = SmsGateway() user = User() view = View(user, sms_gateway) # user2 = User("1") # view = View(user2, sms_gateway) # expect(sms_gateway).send_sms expect(sms_gateway).send_sms(user, "welcome") view.send_sms("welcome")
def test_tags(http_client, base_url): mock_service = gen_mock_service() expect(mock_service).get_all.and_return_future([]) response = yield http_client.fetch(base_url + '/api/tags') data = json.loads(response.body) assert data['tags'] == [] assert data['status'] == 'ok' assert response.code == httplib.OK
def test_titles_recent(http_client, base_url): mock_service = gen_mock_service() expect(mock_service).get_recentlly_added_titles.and_return_future([]) response = yield http_client.fetch(base_url + '/api/titles/recent') result_object = json.loads(response.body) assert result_object['titles'] == [] assert result_object['status'] == 'ok' assert response.code == httplib.OK
def test_replay_action(self): kwargs = {'key': 'a'} action = Action({ 'type_': KeyboardActionType.KEY_DOWN.name, 'timestamp': 0, 'kwargs': kwargs, }) expect(output_controller.actuators['keyboard']).press(**kwargs) output_controller.replay_action(action)
def test_replay_actions(self): kwargs = {'key': 'a'} action = Action({ 'type_': KeyboardActionType.KEY_DOWN.name, 'timestamp': 0, 'kwargs': kwargs, }) expect(output_controller).replay_action(action) output_controller.replay_actions([action], 1)
def test_gradient_respect_parameters(self): expect(GradientLSMatern52).gradient_respect_parameters_ls.once( ).and_return({'a': 0}) expect(self.matern52).cov.once().and_return(1.0) assert self.matern52.gradient_respect_parameters(self.inputs) == { 'a': 0, 'sigma2': 1.0 / 3 }
def test_grad_respect_point_2(self): expect(GradientLSMatern52).gradient_respect_distance_cross.once( ).and_return(np.array([[1, 0], [0, 1]])) expect(Distances).gradient_distance_length_scale_respect_point.once( ).and_return(1.0) comparisons = GradientLSMatern52.grad_respect_point(self.length_scale, self.inputs, self.inputs) == \ np.array([[1, 0], [0, 1]]) assert np.all(comparisons)
def test_gradient_respect_parameters(self): expect(GradientTasksKernel).gradient_respect_parameters.once().and_return( {0: np.array([[0]])}) gradient = {} gradient['lower_triang'] = {} gradient['lower_triang'][0] = np.array([[0]]) assert self.task_kernel.gradient_respect_parameters(self.inputs) == gradient
def test_replay(cassette, call): allow(cassette).can_replay.and_return(True) expect(cassette).replay.and_return( proxy.Response(code=0, headers='{key: value}', body='response body')) response = yield call('endpoint', 'request body') assert response.body.code == 0 assert response.body.body == 'response body' assert response.body.headers == '{key: value}'
def test_user_like_star_user_not_existed(http_client, base_url): fake_uuid = 'a9ab843d-4300-4ade-8c57-f5669b5bad31' mock_service = gen_mock_service() expect(mock_service).like_star.and_raise(ResourceNotFoundError, ) response = yield http_client.fetch(base_url + '/api/users/' + fake_uuid + '/like_stars/' + fake_uuid + '?like=y') assert response.body == '{"status": "failed", "errorMessage": "User not found."}' assert response.code == httplib.OK
def test_protocol_error(vcr_service, cassette, call, mock_server): allow(cassette).can_replay.and_return(False) expect(cassette).record.never() mock_server.expect_call("endpoint").and_raise(TChannelError.from_code(1, description="great sadness")) with pytest.raises(VCRProxy.RemoteServiceError) as exc_info: yield call("endpoint", "body") assert "great sadness" in str(exc_info) assert exc_info.value.code == 1
def test_replay(cassette, call): allow(cassette).can_replay.and_return(True) expect(cassette).replay.and_return( VCRProxy.Response( code=0, headers='{key: value}', body='response body' ) ) response = yield call('endpoint', 'request body') assert response.code == 0 assert response.headers == '{key: value}' assert response.body == 'response body'
def test_protocol_error(vcr_service, cassette, call, mock_server): allow(cassette).can_replay.and_return(False) expect(cassette).record.never() mock_server.expect_call('endpoint').and_error( ProtocolError(code=1, description='great sadness') ) with pytest.raises(VCRProxy.RemoteServiceError) as exc_info: yield call('endpoint', 'body') assert 'great sadness' in str(exc_info) assert exc_info.value.code == 1
def test_record(vcr_service, cassette, call, mock_server, use_known_peers): allow(cassette).can_replay.and_return(False) expect(cassette).record.with_args( VCRProxy.Request( serviceName="service", endpoint="endpoint", headers="headers", body="body", knownPeers=[mock_server.hostport] if use_known_peers else [], hostPort="" if use_known_peers else mock_server.hostport, ), VCRProxy.Response(0, "response headers", "response body"), ) mock_server.expect_call("endpoint").and_write(headers="response headers", body="response body").once() response = yield call(service="service", endpoint="endpoint", headers="headers", body="body") assert response.headers == "response headers" assert response.body == "response body"
def test_write_calls_write_page(page): expect(page.writer).write.once() page.write()
def test_tax(self): expect(self.calculator).calculate_tax.once() self.order.tax()
def test_calling_twice(self): expect(doubles.testing).top_level_function clear(doubles.testing) clear(doubles.testing)
def test_finalise(self): expect(self.calculator).add_tax.once() self.order.finalise()
def test_build_receipt(self): expect(self.order).finalise.once() expect(self.builder).run.once()
def test_submits_reciept(self): expect(self.receipt).print_receipt.once() self.till.print_receipt
def test_add_item_adds_to_order(self): expect(self.order).add.once() self.till.add("Item")
def test_does_not_raise_expectation_errors(self): expect(doubles.testing).top_level_function clear(doubles.testing)
def test_width(self): some_rw = InstanceDouble('tchannel.rw.ReadWriter') delegated_rw = self._mk_rw(some_rw) expect(some_rw).width.with_no_args() delegated_rw.width()