def test_fetch_expenses_spreadsheetid_not_exists(mocker):
# RequestMockBuilderがMockなのに認証情報が必要になっているので回避するためのもの
# 使い方が間違ってるのか？
mocker.patch("google.auth.default", return_value=(None, None))
# driver用
mocker.patch(
"google.oauth2.service_account.Credentials.from_service_account_file")
mocker.patch("os.path.open")
mocker.patch("pickle.dump")
mocker.patch("pickle.load")
requestBuilder = RequestMockBuilder(
{
"sheets.spreadsheets.get": (
httplib2.Response({
"status": 404,
"reason": "Requested entity was not found."
}),
b"{}",
)
},
check_unexpected=True,
)
service = googleapiclient.discovery.build("sheets",
"v4",
requestBuilder=requestBuilder)
driver = SheetDriverImpl()
driver.spreadsheets = service.spreadsheets()
with pytest.raises(Exception):
driver.fetch_expenses("1234")
def test_fetch_google_scores(self):
"""
Scenario: Evaluate GoogleApiClient#fetch_google_scores() method for a
valid request
Given a list of terms of type List[str]
And start date in ISO format
And end date in ISO format
Then client retrieves a JSON object with an element "lines" inside
"""
http = HttpMock(datafile('trends_discovery.json'), {'status': '200'})
response = b'{"lines": [ { "term" : "a flu" , "points" : [] } ]}'
request_builder = RequestMockBuilder(
{'trends.getTimelinesForHealth': (None, response)})
with patch.object(GoogleApiClient, '__init__', lambda x: None):
instance = GoogleApiClient()
instance.service = build(serviceName=SERVICE_NAME,
version=SERVICE_VERSION,
http=http,
developerKey='APIKEY',
requestBuilder=request_builder,
cache_discovery=False,
static_discovery=False)
instance.block_until = None
terms = ['flu']
start = date.today() - timedelta(days=5)
end = start + timedelta(days=1)
result = instance.fetch_google_scores(terms, start, end)
self.assertEqual(len(result), 1)
self.assertIn('term', result[0])
self.assertIn('points', result[0])
def test_preserve_an_existing_static_external_ip(self, *mocks):
request_builder = RequestMockBuilder({
"compute.addresses.insert": (self.alreadyExistsResponse, b''),
"compute.regionOperations.get":
(self.successResponse, '{"status":"DONE"}')
})
compute = build("compute",
"v1",
self.http,
requestBuilder=request_builder)
original_instance_template = read_json_file(
"sample_instance_template.json")
original_network_interface = original_instance_template[
"networkInterfaces"][0]
new_network_interface = preserve_ip_addresses_handler(
compute, self.project, self.new_instance, self.new_network_info,
original_network_interface, self.region, True)
self.assertEqual(new_network_interface["network"],
self.new_network_info["network"])
self.assertEqual(new_network_interface["subnetwork"],
self.new_network_info["subnetwork"])
# external IP is unchanged
self.assertEqual(new_network_interface["accessConfigs"],
original_network_interface["accessConfigs"])
# internal IP is ephemeral
self.assertFalse("networkIP" in new_network_interface)
def test_backend_error(self):
"""
Scenario: Evaluate behaviour when Google API returns http/500 (Backend Error)
Given a list of terms of type List[str]
And start date in ISO format
And end date in ISO format
When Google API returns HTTP 403
Then GoogleApiClient#fetch_google_scores() logs the HttpError
"""
http = HttpMock(datafile('trends_discovery.json'), {'status': '200'})
error_bytes = b'{"error" : { ' \
b'"code" : 500, ' \
b'"message" : "Backend Error", ' \
b'"errors" : [{ "reason" : "backendError" }] } }'
response = Response({'status': 500})
request_builder = RequestMockBuilder(
{'trends.getTimelinesForHealth': (response, error_bytes)})
with patch.object(GoogleApiClient, '__init__', lambda x: None):
instance = GoogleApiClient()
instance.service = build(serviceName=SERVICE_NAME,
version=SERVICE_VERSION,
http=http,
developerKey='APIKEY',
requestBuilder=request_builder,
cache_discovery=False,
static_discovery=False)
instance.block_until = None
terms = ['flu']
start = date.today() - timedelta(days=5)
end = start + timedelta(days=1)
with self.assertLogs(level='WARNING') as logContext:
instance.fetch_google_scores(terms, start, end)
self.assertListEqual(logContext.output, [
'WARNING:root:<HttpError 500 when requesting None returned "Backend Error". Details: "Backend Error">'
])
def test_other_http_error(self):
# No error raises, and the original external IP will be used
# in the new instance template
request_builder = RequestMockBuilder({
"compute.addresses.insert": (self.otherErrorResponse, b''),
"compute.regionOperations.get":
(self.successResponse, '{"status":"DONE"}')
})
compute = build("compute",
"v1",
self.http,
requestBuilder=request_builder)
original_instance_template = read_json_file(
"sample_instance_template.json")
original_network_interface = original_instance_template[
"networkInterfaces"][0]
new_network_interface = preserve_ip_addresses_handler(
compute, self.project, self.new_instance, self.new_network_info,
original_network_interface, self.region, True)
self.assertEqual(new_network_interface["network"],
self.new_network_info["network"])
self.assertEqual(new_network_interface["subnetwork"],
self.new_network_info["subnetwork"])
# external IP is ephemeral
self.assertFalse("accessConfigs" in new_network_interface)
# internal IP is ephemeral
self.assertFalse("networkIP" in new_network_interface)
def test_default_response(self):
requestBuilder = RequestMockBuilder({})
plus = build('plus',
'v1',
http=self.http,
requestBuilder=requestBuilder)
activity = plus.activities().get(activityId='tag:blah').execute()
self.assertEqual({}, activity)
def test_simple_response(self):
requestBuilder = RequestMockBuilder({
'plus.activities.get': (None, '{"foo": "bar"}')
})
plus = build('plus', 'v1', http=self.http, requestBuilder=requestBuilder)
activity = plus.activities().get(activityId='tag:blah').execute()
self.assertEqual({"foo": "bar"}, activity)
def mock_build(*args, **kwargs):
response = open(datafile("youtube3_resp.json")).read()
requestBuilder = RequestMockBuilder({'youtube.search.list': (None, response)}) # noqa: E501
mockb = googleapiclient.discovery.build_from_document(
api_discovery_json, developerKey="dummy",
requestBuilder=requestBuilder)
return mockb
def test_default_response(self):
requestBuilder = RequestMockBuilder({})
plus = build("plus",
"v1",
http=self.http,
requestBuilder=requestBuilder,
static_discovery=False)
activity = plus.activities().get(activityId="tag:blah").execute()
self.assertEqual({}, activity)
def test_check_network_auto_mode_failure(self):
request_builder = RequestMockBuilder(
{
"compute.networks.get": (
self.errorResponse, b"{Invalid resource}")})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(HttpError):
check_network_auto_mode(compute, self.project, self.zone)
def test_unexpected_call(self):
requestBuilder = RequestMockBuilder({}, check_unexpected=True)
plus = build('plus', 'v1', http=self.http, requestBuilder=requestBuilder)
try:
plus.activities().get(activityId='tag:blah').execute()
self.fail('UnexpectedMethodError should have been raised')
except UnexpectedMethodError:
pass
def test_simple_response(self):
requestBuilder = RequestMockBuilder(
{"plus.activities.get": (None, '{"foo": "bar"}')})
plus = build("plus",
"v1",
http=self.http,
requestBuilder=requestBuilder)
activity = plus.activities().get(activityId="tag:blah").execute()
self.assertEqual({"foo": "bar"}, activity)
def test_check_network_auto_mode_success(self):
request_builder = RequestMockBuilder(
{
"compute.networks.get": (
self.successResponse, '{"autoCreateSubnetworks": true}')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
auto_mode_status = check_network_auto_mode(compute, self.project,
self.zone)
self.assertEqual(auto_mode_status, True)
def test_delete_instance_failure(self):
request_builder = RequestMockBuilder(
{
"compute.instances.delete": (
self.errorResponse, b"{Invalid resource}")})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(HttpError):
delete_instance(compute, self.project, self.zone,
self.instance_template)
def test_simple_matching_dict_body(self):
requestBuilder = RequestMockBuilder({
'zoo.animals.insert': (None, '{"data": {"foo": "bar"}}',
{'data': {'foo': 'bar'}})
})
zoo = build('zoo', 'v1', http=self.zoo_http, requestBuilder=requestBuilder)
activity = zoo.animals().insert(
body={'data': {'foo': 'bar'}}).execute()
self.assertEqual({'foo': 'bar'}, activity)
def test_wait_for_region_operation_failure(self):
request_builder = RequestMockBuilder(
{
"compute.regionOperations.get": (
self.errorResponse, b'Invalid Resource')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(HttpError):
wait_for_region_operation(compute, self.project, self.region, {})
def test_preserve_external_ip_failure(self):
request_builder = RequestMockBuilder(
{
"compute.addresses.insert": (
self.errorResponse, b"{Invalid resource}")})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(HttpError):
preserve_external_ip_address(compute, self.project, self.region,
self.external_ip_address_body)
def test_attach_disk_failure(self):
request_builder = RequestMockBuilder(
{
"compute.instances.attachDisk": (
self.errorResponse, b"{Invalid resource}")})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(HttpError):
attach_disk(compute, self.project, self.zone, self.instance,
self.boot_disk)
def test_simple_expected_body(self):
requestBuilder = RequestMockBuilder({
'zoo.animals.insert': (None, '{"data": {"foo": "bar"}}', '{}')
})
zoo = build('zoo', 'v1', http=self.zoo_http, requestBuilder=requestBuilder)
try:
zoo.animals().insert(body='').execute()
self.fail('UnexpectedBodyError should have been raised')
except UnexpectedBodyError:
pass
def test_basic_region_waiting(self):
request_builder = RequestMockBuilder(
{
"compute.regionOperations.get": (
self.successResponse,
'{"status":"RUNNING"}')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(StopIteration):
wait_for_region_operation(compute, self.project,
self.region, {})
def test_error_in_region_waiting(self):
request_builder = RequestMockBuilder(
{
"compute.regionOperations.get": (
self.successResponse,
'{"status":"DONE", "error":"something wrong"}')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(RegionOperationsError):
wait_for_region_operation(compute, self.project,
self.region, {})
def test_get_zone_success(self):
request_builder = RequestMockBuilder(
{
"compute.zones.get": (
self.successResponse, '{"foo": "bar"}')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
get_zone_operation = get_zone(compute, self.project, self.zone)
self.assertEqual(
get_zone_operation,
{
"foo": "bar"}
)
def test_simple_expected_body(self):
requestBuilder = RequestMockBuilder(
{"zoo.animals.insert": (None, '{"data": {"foo": "bar"}}', "{}")})
zoo = build("zoo",
"v1",
http=self.zoo_http,
requestBuilder=requestBuilder)
try:
zoo.animals().insert(body="").execute()
self.fail("UnexpectedBodyError should have been raised")
except UnexpectedBodyError:
pass
def test_errors(self):
errorResponse = httplib2.Response({'status': 500, 'reason': 'Server Error'})
requestBuilder = RequestMockBuilder({
'plus.activities.list': (errorResponse, '{}')
})
plus = build('plus', 'v1', http=self.http, requestBuilder=requestBuilder)
try:
activity = plus.activities().list(collection='public', userId='me').execute()
self.fail('An exception should have been thrown')
except HttpError, e:
self.assertEqual('{}', e.content)
self.assertEqual(500, e.resp.status)
self.assertEqual('Server Error', e.resp.reason)
def test_unexpected_call(self):
requestBuilder = RequestMockBuilder({}, check_unexpected=True)
plus = build("plus",
"v1",
http=self.http,
requestBuilder=requestBuilder,
static_discovery=False)
try:
plus.activities().get(activityId="tag:blah").execute()
self.fail("UnexpectedMethodError should have been raised")
except UnexpectedMethodError:
pass
def test_auto_mode_network(self):
target_network_information = read_json_file(
"sample_auto_mode_network.json")
target_network = target_network_information["name"]
request_builder = RequestMockBuilder(
{
"compute.networks.get": (
self.successResponse,
json.dumps(target_network_information))})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
auto_mode = check_network_auto_mode(compute, self.project,
target_network)
self.assertEqual(auto_mode, True)
def test_stop_instance_success(self):
request_builder = RequestMockBuilder(
{
"compute.instances.stop": (
self.successResponse, '{"foo": "bar"}')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
stop_instance_operation = stop_instance(compute, self.project,
self.zone, self.instance)
self.assertEqual(
stop_instance_operation,
{
"foo": "bar"}
)
def test_get_network_success(self):
request_builder = RequestMockBuilder(
{
"compute.networks.get": (
self.successResponse, '{"foo": "bar"}')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
network_get_operation = get_network(compute, self.project,
self.target_network)
self.assertEqual(
network_get_operation,
{
"foo": "bar"}
)
def test_preserve_external_ip_success(self):
request_builder = RequestMockBuilder(
{
"compute.addresses.insert": (
self.successResponse, '{"foo": "bar"}')})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
preserve_external_ip_address_operation = preserve_external_ip_address(
compute, self.project, self.region, self.external_ip_address_body)
self.assertEqual(
preserve_external_ip_address_operation,
{
"foo": "bar"}
)
def test_change_to_legacy_network(self):
target_legacy_network_information = read_json_file(
"sample_legacy_network.json")
target_legacy_network = target_legacy_network_information["name"]
request_builder = RequestMockBuilder(
{
"compute.networks.get": (
self.successResponse,
json.dumps(target_legacy_network_information))})
compute = build("compute", "v1", self.http,
requestBuilder=request_builder)
with self.assertRaises(InvalidTargetNetworkError):
check_network_auto_mode(compute, self.project,
target_legacy_network)