def test_resource_in_discovery_container_after_get_patch_delete(self):
with mock.patch('requests.get') as requests_get_mock:
resource = {"@odata.id": "odata.id", "something": "irrelevant"}
get_response = Mock()
get_response.status_code = ReturnCodes.OK
get_response.headers = {}
get_response.text = json.dumps(resource)
requests_get_mock.return_value = get_response
discovery_container = DiscoveryContainer()
self.api_caller.get_resource("/resource", discovery_container)
self.assertEqual(discovery_container["http://{API_ENDPOINT}/resource".format(
API_ENDPOINT=API_ENDPOINT)].body,
resource)
patched_resource = {"@odata.id": "odata.id", "something": "relevant"}
get_response.text = json.dumps(patched_resource)
with mock.patch('requests.patch') as requests_patch_mock:
patch_response = Mock()
patch_response.status_code = ReturnCodes.OK
patch_response.headers = {}
patch_response.text = "{}"
requests_patch_mock.return_value = patch_response
_, _, _, _ = self.api_caller.patch_resource("/resource", discovery_container)
self.assertEqual(discovery_container["http://{API_ENDPOINT}/resource".format(
API_ENDPOINT=API_ENDPOINT)].body, patched_resource)
with mock.patch('requests.delete') as requests_delete_mock:
delete_response = Mock()
delete_response.status_code = ReturnCodes.NO_CONTENT
delete_response.headers = {}
delete_response.text = ""
requests_delete_mock.return_value = delete_response
_, _, _, _ = self.api_caller.delete_resource("/resource", discovery_container)
self.assertNotIn("/resource", discovery_container)
def get_mock():
ysc = youtube_status_code
yu = youtube_url
yc = youtube_cookies
yt = youtube_text
yh = youtube_headers
yosc = youtube_oembed_status_code
you = youtube_oembed_url
yoh = youtube_oembed_headers
yot = youtube_oembed_text
mock_obj_1 = Mock()
mock_obj_1.status_code = ysc
mock_obj_1.url = yu
mock_obj_1.headers = yh
mock_obj_1.cookies = yc
mock_obj_1.text = yt
mock_obj_1.json = lambda: json.loads(mock_obj_1.text)
mock_obj_2 = Mock()
mock_obj_2.status_code = 200
mock_obj_2.url = you
mock_obj_2.headers = yoh
mock_obj_2.text = yot
mock_obj_2.json = lambda: json.loads(mock_obj_2.text)
return [mock_obj_1, mock_obj_1, mock_obj_2]
def test_list_resources(self, get_mock):
response_caps = Mock()
response_caps.text = (
'# This is just a test\n'
'ivo://cadc.nrc.ca/serv1 = '
'http://www.cadc.nrc.gc.ca/serv1/capabilities\n'
'ivo://cadc.nrc.ca/serv2 = '
'http://www.cadc.nrc.gc.ca/serv2/capabilities\n')
response_serv1 = Mock()
response_serv1.text = (
'<vosi:capabilities xmlns:vosi='
'"http://www.ivoa.net/xml/VOSICapabilities/v1.0" '
'xmlns:vs="http://www.ivoa.net/xml/VODataService/v1.1" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\n'
'<capability standardID="ivo://ivoa.net/std/VOSI#capabilities">\n'
'<interface xsi:type="vs:ParamHTTP" role="std">\n'
'<accessURL use="full">'
'http://www.cadc.hia.nrcgc..ca/serv1/capabilities</accessURL>\n'
'</interface>\n'
'</capability>\n'
'<capability standardID="ivo://ivoa.net/std/VOSI#availability">\n'
'<interface xsi:type="vs:ParamHTTP" role="std">\n'
'<accessURL use="full">'
'http://www.cadc.nrc.gc.ca/serv1/availability</accessURL>\n'
'</interface>\n'
'</capability>\n'
'</vosi:capabilities>\n')
response_serv2 = Mock()
response_serv2.text = (
'<vosi:capabilities xmlns:vosi='
'"http://www.ivoa.net/xml/VOSICapabilities/v1.0" '
'xmlns:vs="http://www.ivoa.net/xml/VODataService/v1.1" '
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\n'
'<capability standardID="ivo://ivoa.net/std/VOSI#capabilities">\n'
'<interface xsi:type="vs:ParamHTTP" role="std">\n'
'<accessURL use="full">'
'http://www.cadc.hia.nrcgc..ca/serv2/capabilities</accessURL>\n'
'</interface>\n'
'</capability>\n'
'<capability standardID="ivo://ivoa.net/std/VOSI#tables-1.1">\n'
'<interface xsi:type="vs:ParamHTTP" role="std">\n'
'<accessURL use="full">'
'http://www.cadc.nrc.gc.ca/serv2/availability</accessURL>\n'
'</interface>\n'
'</capability>\n'
'</vosi:capabilities>\n')
get_mock.side_effect = [response_caps, response_serv1, response_serv2]
self.maxDiff = None
usage = \
('ivo://cadc.nrc.ca/serv1 '
'(http://www.cadc.nrc.gc.ca/serv1/capabilities) - '
'Capabilities: ivo://ivoa.net/std/VOSI#availability, '
'ivo://ivoa.net/std/VOSI#capabilities\n\n'
'ivo://cadc.nrc.ca/serv2 '
'(http://www.cadc.nrc.gc.ca/serv2/capabilities) - '
'Capabilities: ivo://ivoa.net/std/VOSI#capabilities, '
'ivo://ivoa.net/std/VOSI#tables-1.1')
with patch('sys.stdout', new_callable=StringIO) as stdout_mock:
ws.list_resources()
self.assertEqual(usage, stdout_mock.getvalue().strip())
def test_rpilcdmenu_render_multiple_items_rewind_menu(LCDHwdMock):
LCDHwdMockInstance = MagicMock()
LCDHwdMock.return_value = LCDHwdMockInstance
menu = RpiLCDMenu()
item1Mock = Mock()
item1Mock.text = "item1"
item2Mock = Mock()
item2Mock.text = "item2"
item3Mock = Mock()
item3Mock.text = "item3"
menu.append_item(item1Mock)
menu.append_item(item2Mock)
menu.append_item(item3Mock)
menu.processDown()
menu.processDown()
LCDHwdMockInstance.reset_mock()
menu.render()
assert LCDHwdMockInstance.write4bits.mock_calls == [call(LCDHwdMock.LCD_CLEARDISPLAY)] + [
call(ord(char), True) for char in ">item3"
] + [call(0xC0)] + [
call(ord(char), True) for char in " item1"
]
def get_only_imds_v2_is_supported(url, headers, *args, **kwargs):
"""
Mock result, when we try to get metadata using GET method against
AWS metadata provider. This mock is for the case, when only IMDSv2
is supported by instance.
:param url: URL
:param headers: HTTP headers
:param args: other position argument
:param kwargs: other keyed argument
:return: Mock with result
"""
if 'X-aws-ec2-metadata-token' in headers.keys():
if headers['X-aws-ec2-metadata-token'] == AWS_TOKEN:
if url == aws.AWSCloudCollector.CLOUD_PROVIDER_METADATA_URL:
mock_result = Mock()
mock_result.status_code = 200
mock_result.text = AWS_METADATA
elif url == aws.AWSCloudCollector.CLOUD_PROVIDER_SIGNATURE_URL:
mock_result = Mock()
mock_result.status_code = 200
mock_result.text = AWS_SIGNATURE
else:
mock_result = Mock()
mock_result.status_code = 400
mock_result.text = 'Error: Invalid URL'
else:
mock_result = Mock()
mock_result.status_code = 400
mock_result.text = 'Error: Invalid metadata token provided'
else:
mock_result = Mock()
mock_result.status_code = 400
mock_result.text = 'Error: IMDSv1 is not supported on this instance'
return mock_result
def test_get_product_unit_price(self):
'''Should return None if unit_price could not be retrieved or if it is in bad shape.'''
# Could not get unit price (case 1):
self.li_mock1.xpath.return_value = []
self.assertEqual(
sainsburys_webpage_scraper.get_product_unit_price(self.li_mock1),
None)
self.assertTrue(len(self.logging_mock.error.call_args_list) == 1)
self.logging_mock.reset_mock()
div_mock_1 = Mock() # <div class="pricingAndTrolleyOptions">
div_mock_2 = Mock() # <div id="addItem_****">
div_mock_2.get.return_value = 'priceTab activeContainer priceTabContainer' # to pass the second assert()
p_mock = Mock() # <p class="pricePerUnit">
# Could not get unit price (case 2):
div_mock_1.getchildren.return_value = []
self.li_mock1.xpath.return_value = [div_mock_1]
self.assertEqual(
sainsburys_webpage_scraper.get_product_unit_price(self.li_mock1),
None)
self.assertTrue(len(self.logging_mock.error.call_args_list) == 1)
self.logging_mock.reset_mock()
with patch('sainsburys_webpage_scraper.isinstance') as isinstance_mock:
# Could not get unit price (case 3):
isinstance_mock.return_value = True
div_mock_1.getchildren.return_value = [
Mock(), Mock()
] # more than 1 element in list after filter
self.assertEqual(
sainsburys_webpage_scraper.get_product_unit_price(
self.li_mock1), None)
self.assertTrue(len(self.logging_mock.error.call_args_list) == 1)
self.logging_mock.reset_mock()
# Could not get unit price (case 4):
div_mock_1.getchildren.return_value = [div_mock_2]
div_mock_2.xpath.return_value = []
self.assertEqual(
sainsburys_webpage_scraper.get_product_unit_price(
self.li_mock1), None)
self.assertTrue(len(self.logging_mock.error.call_args_list) == 1)
self.logging_mock.reset_mock()
# unit_price retrieved but is in bad shape:
div_mock_2.xpath.return_value = [p_mock]
p_mock.text = '£abc1.23'
self.assertEqual(
sainsburys_webpage_scraper.get_product_unit_price(
self.li_mock1), None)
self.assertTrue(len(self.logging_mock.error.call_args_list) == 1)
# Normal scenario:
p_mock.text = '£1.23'
self.assertEqual(
sainsburys_webpage_scraper.get_product_unit_price(
self.li_mock1), '1.23')
def _MockGet(url: str) -> Mock:
response = Mock()
if "node/5617" in url:
response.text = REPORTS_YEAR_2019
elif "node/4036" in url:
response.text = REPORTS_YEAR_2015
else:
response.text = REPORTS_LANDING_HTML
return response
def test_check_status():
r = Mock()
r.status_code = 429
r.text = ''
with pytest.raises(exceptions.TooManyRequests):
utils.check_status(r)
r.text = 'exceeded QUOTA dude'
with pytest.raises(exceptions.OverQuota):
utils.check_status(r)
def test_create_index(caps_get_mock, base_get_mock, base_post_mock):
caps_get_mock.return_value = BASE_URL
client = CadcTapClient(net.Subject())
response1 = Mock()
response1.status_code = 303
job_location = 'http://go.here'
response1.headers = {'Location': job_location}
base_post_mock.return_value = response1
response2 = Mock()
response2.status_code = 200
response2.text = "EXECUTING"
base_get_mock.side_effect = [response2]
response3 = Mock()
response3.status_code = 200
response3.text = "COMPLETED"
base_get_mock.side_effect = [response2, response3]
client.create_index('schema.sometable', 'col1', unique=True)
# expected post calls
post_calls = [
call((TABLE_UPDATE_CAPABILITY_ID, None),
allow_redirects=False,
data={
'table': 'schema.sometable',
'unique': 'true',
'index': 'col1'
}),
call('{}/phase'.format(job_location), data={'PHASE': 'RUN'})
]
base_post_mock.assert_has_calls(post_calls)
# expected get calls
get_calls = [
call('{}/phase'.format(job_location), data={'WAIT': 1}),
call('{}/phase'.format(job_location), data={'WAIT': 1})
]
base_get_mock.assert_has_calls(get_calls)
# error cases
with pytest.raises(AttributeError):
client.create_index(None, 'col1')
with pytest.raises(AttributeError):
client.create_index('sometable', None)
response4 = Mock()
response4.status_code = 200
response4.text = 'ABORTED'
base_get_mock.side_effect = [response4, response4]
client = CadcTapClient(net.Subject())
with pytest.raises(RuntimeError):
client.create_index('sometable', 'col1')
response5 = Mock()
response5.status_code = 500
base_get_mock.side_effect = [response1, response4, response4]
client = CadcTapClient(net.Subject())
with pytest.raises(RuntimeError):
client.create_index('sometable', 'col1')
def test_check_status():
r = Mock()
r.status_code = 429
r.text = ''
with pytest.raises(exceptions.TooManyRequests):
utils.check_status(r)
r.text = 'exceeded QUOTA dude'
with pytest.raises(exceptions.OverQuota):
utils.check_status(r)
def _MockGet(url):
response = Mock()
if 'node/5617' in url:
response.text = REPORTS_YEAR_2019
elif 'node/4036' in url:
response.text = REPORTS_YEAR_2015
else:
response.text = REPORTS_LANDING_HTML
return response
def mock_response(fixture=None, status=200):
response = Mock()
if fixture is None:
response.text = ''
elif isinstance(fixture, dict):
response.text = str(fixture)
else:
response.text = load_fixture(fixture)
response.status_code = status
return response
def mock_response(fixture=None, status=200):
response = Mock()
if fixture is None:
response.text = ''
elif isinstance(fixture, dict):
response.text = str(fixture)
else:
response.text = load_fixture(fixture)
response.status_code = status
return response
def fake_request_session_send(request, **kwargs):
rv = Mock()
if request.url == 'http://example.com/root.wtml':
rv.text = ROOT_XML_STRING
elif request.url == 'http://example.com/child1.wtml':
rv.text = CHILD1_XML_STRING
else:
raise Exception(f'unexpected URL to fake requests.Session.send(): {request.url}')
return rv
def test_get_ha_rgs(self):
self.device.get_rpc_equivalent = Mock(return_value="</>")
rg0 = Mock(spec=etree._Element)
rg0.text = "0"
rg1 = Mock(spec=etree._Element)
rg1.text = "1"
mock_element = Mock(spec=etree._Element)
mock_element.findall.side_effect = [[rg0, rg1], []]
self.device.execute_rpc().response.return_value = mock_element
self.assertRaises(Exception, self.ha.get_ha_rgs)
self.assertEqual(self.ha.get_ha_rgs(device=self.device), ["0", "1"])
self.assertFalse(self.ha2.get_ha_rgs())
def mock_get_recording(p_url, timeout=0, stream=False):
result = Mock()
result.__enter__ = Mock(return_value=result)
result.__exit__ = Mock()
result.iter_content = Mock(return_value='0')
result.status_code = 200
result.headers = {'content-length': fetchtv.MAX_OCTET}
response_dir = os.path.dirname(
__file__) + os.path.sep + 'responses' + os.path.sep
if p_url.endswith('cds.xml'):
result.text = get_file(response_dir + 'fetch_cds.xml')
else:
result.text = get_file(response_dir + 'fetch_info.xml')
return result
def test_json_schema_test_response_does_not_follow_schema(self):
from smoketest.tests import (JSONSchemaTest)
with open(self.json_schema_filename, 'w') as f:
f.write(
json.dumps({
"type": "object",
"properties": {
"foo": {
"type": "string"
}
},
"required": ["foo"]
}))
response = Mock()
response.text = '{}'
json_schema_test = JSONSchemaTest(self.json_schema_filename)
json_schema_test_result = json_schema_test.get_result(response)
self.assertFalse(bool(json_schema_test_result))
self.assertEqual(
"Response did not obey {0}: {1} is a required property".format(
self.json_schema_filename,
repr(u'foo'),
),
json_schema_test_result.description,
)
def test_get_hash_success(self, m_get):
mock_resp = Mock()
mock_resp.ok = True
mock_resp.text = "the_hash"
m_get.return_value = mock_resp
result = util.get_gitbuilder_hash()
assert result == "the_hash"
def get_mock_session(page_text):
page_obj = Mock()
page_obj.text = page_text
page_obj.raise_for_status = Mock()
session = requests.Session()
session.get = Mock(return_value=page_obj)
return page_obj, session
def test_version_strip_v(self):
resp = Mock()
resp.ok = True
resp.text = "v0.90.0"
self.m_get_response.return_value = resp
super(TestGitbuilderProject, self)\
.test_get_package_version_found()
def test_o365_url_return_value(mock_requests, mock_azure_network):
mock_http_response = Mock(spec=requests.Response)
mock_http_response.status_code = 200
mock_http_response.text = json.dumps([{
"id":
10,
"serviceArea":
"Exchange",
"serviceAreaDisplayName":
"Exchange Online",
"urls": ["*.mail.protection.outlook.com"],
"ips": [
"40.92.0.0/15", "40.107.0.0/16", "52.100.0.0/14", "104.47.0.0/17",
"2a01:111:f400::/48", "2a01:111:f403::/48"
],
"tcpPorts":
"25",
"expressRoute":
True,
"category":
"Allow"
}])
mock_requests.return_value = mock_http_response
result = mock_azure_network.get_o365_smtp_ipv4_cidrs()
assert result == {
'40.92.0.0/15', '40.107.0.0/16', '104.47.0.0/17', '52.100.0.0/14'
}
def testGetAllUrls(self, mockget: Mock) -> None:
mock_landing = Mock()
mock_landing.text = fixtures.as_string("aggregate/regions/ma",
"reports_landing.html")
mock_year = Mock()
mock_year.text = fixtures.as_string("aggregate/regions/ma",
"year_page.html")
mockget.side_effect = [mock_landing, mock_year]
url1 = "https://www.mass.gov/doc/weekly-inmate-count-12252017/download"
expected_urls = {url1}
urls = ma_aggregate_site_scraper.get_urls_to_download()
self.assertEqual(expected_urls, urls)
def test_submit_job(self, mock_g, mock_n, mock_k, mock_session_post):
# Mock OpenStack clients and response to POST
mock_image = {"name": test_image_name, "id": test_image_id}
mock_gclient = Mock()
mock_gclient.images = Mock()
mock_gclient.images.list = Mock(return_value=[mock_image])
mock_g.return_value = mock_gclient
mock_flavor = Mock()
mock_flavor.name = test_flavor_name
mock_flavor.id = test_flavor_id
mock_nclient = Mock()
mock_nclient.flavors = Mock()
mock_nclient.flavors.list = Mock(return_value=[mock_flavor])
mock_n.return_value = mock_nclient
mock_response = Mock()
mock_response.text = test_job_id
mock_response.status_code = 200
mock_session_post.return_value = mock_response
c = ProcClient(test_auth, host=test_host)
# good submission using image and flavor names
c.submit_job(test_job_works, test_image_name, test_flavor_name)
mock_session_post.assert_called_once_with(test_job_url, params=test_params_works, files=test_files_works)
mock_session_post.reset_mock()
# good submission using image and flavor UUIDs
c.submit_job(test_job_works, test_image_id, test_flavor_id)
mock_session_post.assert_called_once_with(test_job_url, params=test_params_works, files=test_files_works)
mock_session_post.reset_mock()
# With nopost we should not do a POST
c.submit_job(test_job_works, test_image_name, test_flavor_name, nopost=True)
self.assertEqual(mock_session_post.call_count, 0)
# failed submission due to bad image name
with self.assertRaises(ValueError):
c.submit_job(test_job_works, "bad_image", test_flavor_name)
self.assertEqual(mock_session_post.call_count, 0)
# failed submission due to bad flavor name
with self.assertRaises(ValueError):
c.submit_job(test_job_works, test_image_name, "yucky")
self.assertEqual(mock_session_post.call_count, 0)
# failed submission because no Executable line in job file
with self.assertRaises(ValueError):
c.submit_job(test_job_fails, test_image_name, test_flavor_name)
self.assertEqual(mock_session_post.call_count, 0)
# works without Executable by specifying jobscriptonvm
c.submit_job(test_job_fails, test_image_name, test_flavor_name, jobscriptonvm=test_script_on_vm)
mock_session_post.assert_called_once_with(test_job_url, params=test_params_on_vm, files=test_files_on_vm)
mock_session_post.reset_mock()
def test_fail_max_retry(self):
# this tests the read function when HTTP requests keep returning 503s
# read call fails when it reaches the maximum number of retries, in
# this case set to 2
# mock the 503 responses
mock_resp = Mock(name="503 resp")
mock_resp.status_code = 503
mock_resp.content = "Testing"
headers = {'Content-Length': 10,
'X-CADC-Content-Length': 5, 'Retry-After': 4}
def getheader(name, default):
return headers[name]
mock_resp.headers = MagicMock()
mock_resp.headers.get.side_effect = getheader
mock_resp.text = 'Try again later'
conn = Connection()
conn.session.send = Mock(return_value=mock_resp)
vofile = vos.VOFile(["Some URL"], conn, "GET")
req = requests.Request("GET", "http://some/url")
vofile.request = req.prepare()
# set number of retries to 1 and check the OSError was thrown
vofile.maxRetries = 1
with self.assertRaises(OSError):
vofile.read()
mock_resp.headers.get.assert_called_with('Retry-After', 5)
def test_get_enrollment_data(self, datetime_now_mock,
_get_course_list_mock, get_user_mock):
"""Test _get_enrollment_data method."""
data = {
'user_email': '*****@*****.**',
'is_active': True,
}
course_settings = {
'external_course_run_id': 'course_id+10',
}
expected_data = u'08-04-2020 10:50:34, John Doe, John, Doe, [email protected], course_id+10, true\n'
expected_data += u'08-04-2020 10:50:34, Mary Brown, Mary, Brown, [email protected], course_id+10, true\n'
user = Mock()
user.first_name = 'Mary'
user.last_name = 'Brown'
user.email = '*****@*****.**'
user.profile.name = 'Mary Brown'
get_user_mock.return_value = (user, '')
datetime_now_mock.now.return_value.strftime.return_value = '08-04-2020 10:50:34'
dropbox_response = Mock()
dropbox_response.text = u'08-04-2020 10:50:34, John Doe, John, Doe, [email protected], course_id+10, true\n'
_get_course_list_mock.return_value = dropbox_response
self.assertEqual(
self.base._get_enrollment_data(data, course_settings), # pylint: disable=protected-access
expected_data,
)
def default_args():
args = Mock()
args.conf_file = ".lamvery.yml"
args.text = "foo"
args.secret_name = "bar"
args.store = False
return args
def mock_response(self, status_code, headers, data):
mock_response = Mock()
mock_response.status_code = status_code
mock_response.headers = headers
mock_response.text = json.dumps(data)
self.request_mock.return_value = mock_response
def build_response_mock(status_code, json_body=None, headers=None,
add_content_length=True, **kwargs):
real_response = requests.Response()
real_response.status_code = status_code
text = None
if json_body is not None:
text = json.dumps(json_body)
if add_content_length and headers is not {}:
real_response.headers['content-length'] = len(text)
if headers is not None:
for k, v in headers.items():
real_response.headers[k] = v
for k, v in kwargs.items():
setattr(real_response, k, v)
response = Mock(wraps=real_response, autospec=True)
if text:
response.text = text
# for some reason, wraps cannot handle attributes which are dicts
# and accessed by key
response.headers = real_response.headers
response.content = text
return response
def test_get_api_pod_parse_error(self, m_json_load, m_session):
# Set up driver.
self.driver.pod_name = 'pod-1'
self.driver.namespace = 'a'
pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'
api_root = "http://kubernetesapi:8080/api/v1/"
self.driver.api_root = api_root
# Set up mock objects
self.driver.auth_token = 'TOKEN'
m_json_load.side_effect = TypeError
get_obj = Mock()
get_obj.status_code = 200
get_obj.text = pod1
m_session_obj = Mock()
m_session_obj.headers = Mock()
m_session_obj.get.return_value = get_obj
m_session.return_value = m_session_obj
m_session_obj.__enter__ = Mock(return_value=m_session_obj)
m_session_obj.__exit__ = Mock(return_value=False)
# Call method under test
assert_raises(ApplyProfileError, self.driver._get_api_pod)
def test_get_api_pod_with_client_certs(self, m_json_load, m_session):
# Set up driver.
self.driver.pod_name = 'pod-1'
self.driver.namespace = 'a'
pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'
api_root = "http://kubernetesapi:8080/api/v1/"
self.driver.api_root = api_root
self.driver.client_certificate = "cert.pem"
self.driver.client_key = "key.pem"
self.driver.certificate_authority = "ca.pem"
get_obj = Mock()
get_obj.status_code = 200
get_obj.text = pod1
m_session_obj = Mock()
m_session_obj.headers = Mock()
m_session_obj.get.return_value = get_obj
m_session.return_value = m_session_obj
m_session_obj.__enter__ = Mock(return_value=m_session_obj)
m_session_obj.__exit__ = Mock(return_value=False)
# Call method under test
self.driver._get_api_pod()
# Assert correct data in calls.
m_session_obj.get.assert_called_once_with(
api_root + 'namespaces/a/pods/pod-1',
verify="ca.pem", cert=("cert.pem", "key.pem"))
m_json_load.assert_called_once_with(pod1)
def test_load_post(self, RequestsGetMock):
# set up a mock response with stubbed json to simulate the API
def read_post_json():
with open(os.path.join(os.path.dirname(__file__), "data", "post.json")) as post_json_file:
return json.load(post_json_file)
mock_response = Mock(Response)
mock_response.ok = True
mock_response.text = "some text"
mock_response.json = read_post_json
RequestsGetMock.return_value = mock_response
# call we're testing
post = self.loader.load_post(1)
# some validations
self.assertIsInstance(post, Post)
self.assertEqual(post.wp_id, 1)
self.assertEqual(post.title, "This is a Test Post")
self.assertEqual(post.author.name, "testauthor")
self.assertEqual(post.categories.first().name, "News")
self.assertEqual(post.tags.first().name, "Testing")
self.assertEqual(post.attachments.first().url, "https://test.local/testpost.jpg")
def _mock_response(status=200,
content="CONTENT",
json_data=None,
headers=None,
raise_for_status=None,
iter_content=None):
'''
Mocking get requests response.
'''
mock_resp = Mock()
# mock raise_for_status call w/optional error
mock_resp.raise_for_status = Mock()
if raise_for_status:
mock_resp.raise_for_status.side_effect = raise_for_status
# set status code and content
mock_resp.status_code = status
mock_resp.content = content
mock_resp.text = content
mock_resp.headers = headers
mock_resp.iter_content = MagicMock()
mock_resp.iter_content.__iter__.return_value = iter_content
# add json data if provided
if json_data:
mock_resp.json = Mock(return_value=json_data)
return mock_resp
def post(url, data, verify=True):
response = Mock()
if not post.called:
response.status_code = 404
post.called = True
response.text = 'I AINT NO JSON, FOOL!'
return response
def _verify(self, requests, response_text="", assertion=EXPIRED_ASSERTION, status_code=200):
response = Mock()
response.text = response_text
response.status_code = status_code
requests.request.return_value = response
return self.verifier.verify(assertion)
def test_get_package_sha1_fetched_found(self):
resp = Mock()
resp.ok = True
resp.text = "the_sha1"
self.m_get.return_value = resp
super(TestGitbuilderProject, self)\
.test_get_package_sha1_fetched_found()
def test_fail_max_retry(self):
# this tests the read function when HTTP requests keep returning 503s
# read call fails when it reaches the maximum number of retries, in
# this case set to 2
# mock the 503 responses
mock_resp = Mock(name="503 resp")
mock_resp.status_code = 503
mock_resp.content = "Testing"
headers = {
'Content-Length': 10,
'X-CADC-Content-Length': 5,
'Retry-After': 4
}
def getheader(name, default):
return headers[name]
mock_resp.headers = MagicMock()
mock_resp.headers.get.side_effect = getheader
mock_resp.text = 'Try again later'
conn = Connection()
conn.session.send = Mock(return_value=mock_resp)
vofile = vos.VOFile(["Some URL"], conn, "GET")
req = requests.Request("GET", "http://some/url")
vofile.request = req.prepare()
# set number of retries to 1 and check the OSError was thrown
vofile.maxRetries = 1
with self.assertRaises(OSError) as cm:
vofile.read()
mock_resp.headers.get.assert_called_with('Retry-After', 5)
def test_get_api_pod_with_client_certs(self, m_json_load, m_session):
# Set up driver.
self.driver.pod_name = 'pod-1'
self.driver.namespace = 'a'
pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'
api_root = "http://kubernetesapi:8080/api/v1/"
self.driver.api_root = api_root
self.driver.client_certificate = "cert.pem"
self.driver.client_key = "key.pem"
self.driver.certificate_authority = "ca.pem"
get_obj = Mock()
get_obj.status_code = 200
get_obj.text = pod1
m_session_obj = Mock()
m_session_obj.headers = Mock()
m_session_obj.get.return_value = get_obj
m_session.return_value = m_session_obj
m_session_obj.__enter__ = Mock(return_value=m_session_obj)
m_session_obj.__exit__ = Mock(return_value=False)
# Call method under test
self.driver._get_api_pod()
# Assert correct data in calls.
m_session_obj.get.assert_called_once_with(api_root +
'namespaces/a/pods/pod-1',
verify="ca.pem",
cert=("cert.pem", "key.pem"))
m_json_load.assert_called_once_with(pod1)
def test_registration(self):
"""
Test handle registration and subsequent checks.
"""
client = self.portal.handle_client
response = Mock()
response.status_code = 201
response.headers = {"location": self.handle_url}
client.session.post = Mock(return_value=response)
view = self.portal.page.restrictedTraverse('hasHandle')
self.assertEqual(view.create(), self.handle_url)
self.assertTrue(view.hasHandle())
self.assertEqual(view.handle(), self.handle)
response.status_code = 204
response.text = ''
client.session.get = Mock(return_value=response)
client.session.put = Mock(return_value=response)
client.session.delete = Mock(return_value=response)
self.assertEqual(view.read(), self.handle_url)
self.assertEqual(view.update(), self.handle_url)
self.assertTrue(view.hasDeletePermission())
self.assertEqual(view.delete(), None)
def test_get_hash_success(self, m_get):
mock_resp = Mock()
mock_resp.ok = True
mock_resp.text = "the_hash"
m_get.return_value = mock_resp
result = util.get_gitbuilder_hash()
assert result == "the_hash"
def test_error_message(self):
"""Error messages are populated properly in the exception"""
r = Mock()
r.text = json.dumps({'error_description': 'oh no'})
u = UAAError(r)
assert str(u) == 'oh no'
def test_unexpected_response(self):
response = Mock()
response.status_code = 422
response.text = '{"message": "Unprocessable Entity"}'
exception = UnexpectedResponse(response)
self.assertEqual("%s" % exception, "Unexpected response from server (Error code: 422, Message: Unprocessable Entity)")
def test_get_package_sha1_fetched_found(self):
resp = Mock()
resp.ok = True
resp.text = "the_sha1"
self.m_get.return_value = resp
super(TestGitbuilderProject, self)\
.test_get_package_sha1_fetched_found()
def mock_xml_element():
mock_element = Mock(spec=xml.etree.ElementTree.Element)
mock_text = Mock()
mock_text.text = 'string'
mock_element.find.return_value = mock_text
mock_element.tag.return_value = 'Listings'
return mock_element
def test_body_assertion_var_failed(self):
# Given
response_body = 'Unexpected value'
expected = 'Expected var value'
config = Config.from_dict(
{'host': 'host', 'vars': {'some_var': expected}},
__file__,
)
spec = {
'type': 'body',
'value': {'type': 'ref', 'var': 'some_var'},
}
assertion = BodyAssertion.from_dict(spec)
case = MockTestCase()
response = Mock()
response.text = response_body
# When
assertion.run(config, 'url', case, response)
# Then
self.assertEqual(case.assertEqual.call_count, 1)
call = case.assertEqual.call_args
args, kwargs = call
self.assertEqual(args, (response_body, expected))
self.assertIn('msg', kwargs)
def __one_bad_two_ok(*args):
response = Mock()
response.ok = args[0] == 'http://example.com/oembed2'
response.text = 'hello, world'
response.headers = {'content-type': 'application/json'}
return response
def test_package_version_for_hash(self, m_get):
mock_resp = Mock()
mock_resp.ok = True
mock_resp.text = "the_version"
m_get.return_value = mock_resp
result = util.package_version_for_hash("hash")
assert result == "the_version"
def test_get_api_pod(self, m_json_load, m_session):
# Set up driver.
self.driver.pod_name = 'pod-1'
self.driver.namespace = 'a'
pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'
api_root = "http://kubernetesapi:8080/api/v1/"
self.driver.api_root = api_root
# Set up mock objects
self.driver.auth_token = 'TOKEN'
get_obj = Mock()
get_obj.status_code = 200
get_obj.text = pod1
m_session_obj = Mock()
m_session_obj.headers = Mock()
m_session_obj.get.return_value = get_obj
m_session.return_value = m_session_obj
m_session_obj.__enter__ = Mock(return_value=m_session_obj)
m_session_obj.__exit__ = Mock(return_value=False)
# Call method under test
self.driver._get_api_pod()
# Assert correct data in calls.
m_session_obj.headers.update.assert_called_once_with(
{'Authorization': 'Bearer ' + 'TOKEN'})
m_session_obj.get.assert_called_once_with(
api_root + 'namespaces/a/pods/pod-1',
verify=False)
m_json_load.assert_called_once_with(pod1)
def test_package_version_for_hash(self, m_get):
mock_resp = Mock()
mock_resp.ok = True
mock_resp.text = "the_version"
m_get.return_value = mock_resp
result = util.package_version_for_hash("hash")
assert result == "the_version"
def test_autoCreateSensor(self):
sensorNotFound = Mock()
sensorNotFound.status_code = 404
sensorNotFound.text = '{"errorcode": "404-001", "message": ""}'
created = Mock()
created.status_code = 201
ok = Mock()
ok.status_code = 200
request = Mock()
request.side_effect = [authRequest(), sensorNotFound, created, ok]
sensorcloud.webrequest.Requests.Request = request
device = sensorcloud.Device("FAKE", "fake")
sensor = device.sensor("sensor")
self.assertTrue("channel" in sensor)
calls = [
mock.call('GET', 'https://dsx.sensorcloud.microstrain.com/SensorCloud/devices/FAKE/sensors/sensor/channels/channel/attributes/', mock.ANY),
mock.call('PUT', 'https://dsx.sensorcloud.microstrain.com/SensorCloud/devices/FAKE/sensors/sensor/', mock.ANY),
mock.call('GET', 'https://dsx.sensorcloud.microstrain.com/SensorCloud/devices/FAKE/sensors/sensor/channels/channel/attributes/', mock.ANY)
]
request.assert_has_calls(calls)
def get_mock_session(page_text):
page_obj = Mock()
page_obj.text = page_text
page_obj.raise_for_status = Mock()
session = requests.Session()
session.get = Mock(return_value=page_obj)
return page_obj, session
def test_parse_response(self):
""" Valid apicall """
resp = Mock(name="Mock Response")
resp.text = '{"id":"FOO", "result":"pong", "error":null}'
resp.status_code = 200
result = self.c._parse_resp("FOO", resp)
self.assertEqual(dict(result="pong", error=None), result)
def test_version_strip_v(self):
resp = Mock()
resp.ok = True
resp.text = "v0.90.0"
self.m_get_response.return_value = resp
super(TestGitbuilderProject, self)\
.test_get_package_version_found()
def test_parse_response_500(self):
""" Deal gracefully with 500 errors """
resp = Mock(name="Mock Response")
resp.text = 'A Server error occurred. Please contact the administrator.'
resp.status_code = 500
with self.assertRaises(exceptions.RemoteError):
self.c._parse_resp("FOO", resp)
def test_get_api_pod(self, m_json_load, m_session):
# Set up driver.
self.driver.pod_name = 'pod-1'
self.driver.namespace = 'a'
pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'
api_root = "http://kubernetesapi:8080/api/v1/"
self.driver.api_root = api_root
# Set up mock objects
self.driver.auth_token = 'TOKEN'
get_obj = Mock()
get_obj.status_code = 200
get_obj.text = pod1
m_session_obj = Mock()
m_session_obj.headers = Mock()
m_session_obj.get.return_value = get_obj
m_session.return_value = m_session_obj
m_session_obj.__enter__ = Mock(return_value=m_session_obj)
m_session_obj.__exit__ = Mock(return_value=False)
# Call method under test
self.driver._get_api_pod()
# Assert correct data in calls.
m_session_obj.headers.update.assert_called_once_with(
{'Authorization': 'Bearer ' + 'TOKEN'})
m_session_obj.get.assert_called_once_with(api_root +
'namespaces/a/pods/pod-1',
verify=False)
m_json_load.assert_called_once_with(pod1)
def test_parse_response_invalid_json(self):
""" Deal gracefully with an invaldi JSON response """
resp = Mock(name="Mock Response")
resp.text = 'A Server error occurred. Please contact the administrator.'
resp.status_code = 200
with self.assertRaises(exceptions.IndecipherableResponseError):
self.c._parse_resp("FOO", resp)
def test_get_api_pod_parse_error(self, m_json_load, m_session):
# Set up driver.
self.driver.pod_name = 'pod-1'
self.driver.namespace = 'a'
pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}'
api_root = "http://kubernetesapi:8080/api/v1/"
self.driver.api_root = api_root
# Set up mock objects
self.driver.auth_token = 'TOKEN'
m_json_load.side_effect = TypeError
get_obj = Mock()
get_obj.status_code = 200
get_obj.text = pod1
m_session_obj = Mock()
m_session_obj.headers = Mock()
m_session_obj.get.return_value = get_obj
m_session.return_value = m_session_obj
m_session_obj.__enter__ = Mock(return_value=m_session_obj)
m_session_obj.__exit__ = Mock(return_value=False)
# Call method under test
assert_raises(ApplyProfileError, self.driver._get_api_pod)
def test_wrong_id(self):
""" Raise due to wrong ID """
resp = Mock(name="Mock Response")
resp.text = '{"id":"FOO", "result":"pong", "error":null}'
resp.status_code = 200
with self.assertRaises(exceptions.IdError):
self.c._parse_resp("FOO2", resp)
def build_response_mock(status_code,
json_body=None,
headers=None,
add_content_length=True,
**kwargs):
real_response = requests.Response()
real_response.status_code = status_code
text = None
if json_body is not None:
text = json.dumps(json_body)
if add_content_length and headers is not {}:
real_response.headers['content-length'] = len(text)
if headers is not None:
for k, v in headers.items():
real_response.headers[k] = v
for k, v in kwargs.items():
setattr(real_response, k, v)
response = Mock(wraps=real_response, autospec=True)
if text:
response.text = text
# for some reason, wraps cannot handle attributes which are dicts
# and accessed by key
response.headers = real_response.headers
response.content = text
response.json = lambda: json_body
return response
def __one_bad_two_ok(*args):
response = Mock()
response.ok = args[0] == 'http://example.com/oembed2'
response.text = 'hello, world'
response.headers = {'content-type': 'application/json'}
return response
