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