def _fake_popen(self, stdout, stderr, sleeptime):
def wait_stdout(self):
import time
for line in stdout.splitlines():
time.sleep(sleeptime)
yield line
def wait_stderr(self):
import time
for line in stderr.splitlines():
time.sleep(sleeptime)
yield line
m = Mock(spec=subprocess.Popen)
sout = Mock()
sout.read = stdout
sout.__iter__ = wait_stdout
serr = Mock()
serr.read = stderr
serr.__iter__ = wait_stderr
m.return_value.stdout = sout
m.return_value.stderr = serr
return m
def _fake_popen( self, stdout, stderr, sleeptime ):
def wait_stdout( self ):
import time
for line in stdout.splitlines():
time.sleep(sleeptime)
yield line
def wait_stderr( self ):
import time
for line in stderr.splitlines():
time.sleep(sleeptime)
yield line
m = Mock(spec=subprocess.Popen)
sout = Mock()
sout.read = stdout
sout.__iter__ = wait_stdout
serr = Mock()
serr.read = stderr
serr.__iter__ = wait_stderr
m.return_value.stdout = sout
m.return_value.stderr = serr
return m
def sideEffect(filePath, _mode):
mockFile = Mock()
if filePath == masterChangeSetFilePath:
mockFile.read = Mock(return_value=mockMasterYaml)
else:
self.assertEqual('migrations/include1.yml', filePath)
mockFile.read = Mock(return_value=mockIncludedYaml)
return mockFile
def side_effect(filePath, mode):
mockFile = Mock()
if filePath == masterChangeSetFilePath:
mockFile.read = Mock(return_value=mockMasterYaml)
else:
self.assertEqual('migrations/include1.yml', filePath)
mockFile.read = Mock(return_value=mockIncludedYaml)
return mockFile
def test_run(self, mock_execute):
# Ensure execute returns a sensible result
result = Mock()
result.read = Mock(return_value=json.dumps({'result': 'ok'}))
mock_execute.return_value = result
# Invoke run
self.session.run('foo/bar')
self.assertTrue(mock_execute.called)
# Sanity check
self.assertTrue(self.session.access_token is not None)
# Verify call args
args = mock_execute.call_args[0]
self.assertEqual(args[0], 'foo/bar')
self.assertEqual(args[1], None)
self.assertTrue(args[2].has_key('User-Agent'))
self.assertTrue(args[2].has_key('Authorization'))
# Invoke run
data = {'one': 1}
headers = {'two': 2}
self.session.run('foo/bar', data, headers)
self.assertTrue(mock_execute.called)
args = mock_execute.call_args[0]
self.assertEqual(args[0], 'foo/bar')
self.assertEqual(args[1], data)
self.assertTrue(args[2].has_key('two'))
# Unset asset_token and verify that the 'Authorization'
# header is not added to the request.
self.session.access_token = None
self.session.auth = None
self.session.run('foo/bar')
self.assertTrue(mock_execute.called)
args = mock_execute.call_args[0]
self.assertFalse(args[2].has_key('Authorization'))
# Verify that the run method will retry if execute returns
# an expired_token response.
result.read = Mock(return_value=json.dumps({'error': 'expired_token'}))
mock_execute.return_value = result
with patch.object(Session,
'renew_access_token') as mock_renew_access_token:
self.session.run('foo/bar')
self.assertTrue(mock_renew_access_token.called)
def test_run(self, mock_execute):
# Ensure execute returns a sensible result
result = Mock()
result.read = Mock(return_value=json.dumps({'result': 'ok'}))
mock_execute.return_value = result
# Invoke run
self.session.run('foo/bar')
self.assertTrue(mock_execute.called)
# Sanity check
self.assertTrue(self.session.access_token is not None)
# Verify call args
args = mock_execute.call_args[0]
self.assertEqual(args[0], 'foo/bar')
self.assertEqual(args[1], None)
self.assertTrue(args[2].has_key('User-Agent'))
self.assertTrue(args[2].has_key('Authorization'))
# Invoke run
data = {'one': 1}
headers = {'two': 2}
self.session.run('foo/bar', data, headers)
self.assertTrue(mock_execute.called)
args = mock_execute.call_args[0]
self.assertEqual(args[0], 'foo/bar')
self.assertEqual(args[1], data)
self.assertTrue(args[2].has_key('two'))
# Unset asset_token and verify that the 'Authorization'
# header is not added to the request.
self.session.access_token = None
self.session.auth = None
self.session.run('foo/bar')
self.assertTrue(mock_execute.called)
args = mock_execute.call_args[0]
self.assertFalse(args[2].has_key('Authorization'))
# Verify that the run method will retry if execute returns
# an expired_token response.
result.read = Mock(return_value=json.dumps({'error': 'expired_token'}))
mock_execute.return_value = result
with patch.object(Session, 'renew_access_token') as mock_renew_access_token:
self.session.run('foo/bar')
self.assertTrue(mock_renew_access_token.called)
def test_load_data(self):
cached = {"prod1": "Product 1", "prod2": "Product 2"}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.mgr._load_data(mock_file)
self.assertEquals(data, cached)
def test_create_html_email(self, mock_urlopen):
html = '''<html><body>
<p>First paragraph</p>
<p><img src='http://localhost/firstimage.jpg'></p>
<p>Third paragraph</p>
<p><img src='http://localhost/secondimage.jpg'></p>
<p>Final paragraph</p>
</body></html>
'''
mini_jpeg = (
b'\xff\xd8\xff\xdb\x00C\x00\x03\x02\x02\x02\x02\x02\x03\x02\x02'
b'\x02\x03\x03\x03\x03\x04\x06\x04\x04\x04\x04\x04\x08\x06\x06\x05'
b'\x06\t\x08\n\n\t\x08\t\t\n\x0c\x0f\x0c\n\x0b\x0e'
b'\x0b\t\t\r\x11\r\x0e\x0f\x10\x10\x11\x10\n\x0c\x12\x13'
b'\x12\x10\x13\x0f\x10\x10\x10\xff\xc9\x00\x0b\x08\x00\x01\x00\x01'
b'\x01\x01\x11\x00\xff\xcc\x00\x06\x00\x10\x10\x05\xff\xda\x00\x08'
b'\x01\x01\x00\x00?\x00\xd2\xcf \xff\xd9')
mock_httpresponse = Mock()
mock_httpresponse.getheader = Mock()
mock_httpresponse.read = Mock()
mock_httpresponse.getheader.side_effect = ['image/jpeg', 'image/jpeg']
mock_httpresponse.read.side_effect = [mini_jpeg, mini_jpeg]
mock_urlopen.return_value.__enter__.return_value = mock_httpresponse
msg = create_html_mail('A test mail', html)
msg.recipientlist = ('*****@*****.**',)
msg.send()
self.assertEquals(len(mail.outbox), 1, 'should have one message')
msg = mail.outbox[0]
self.assertEquals(msg.alternatives[0][1], 'text/html')
self.assertEquals(len(msg.attachments), 2, 'has two attachments')
soup = BeautifulSoup(msg.alternatives[0][0], 'lxml')
for img in soup.findAll('img'):
cid = img['src'].split(':')[1]
att = self.find_attachment_by_content_id(msg, cid)
self.assertIsNotNone(att, 'image tag has a matching attachment')
def test_crawl():
html =\
"""<html>
<head>
<title>Python is fun!</title>
</head>
<body>
<div>Python is similar to Ruby, but different.</div>
</body>
</html>"""
response_mock = Mock(url="http://expanded_url.com")
response_mock.read = Mock(return_value=html)
urllib2.urlopen = Mock(return_value=response_mock)
url = "http://a.com"
input_queue = Mock()
input_queue.get = Mock(return_value=url)
output_queue = Queue()
crawler = Crawler()
crawler.crawl(input_queue, output_queue)
expected_result = {'CONTENT': html,
'EXPANDED_URL': 'http://expanded_url.com',
'STATUS': 'OK',
'URL': 'http://a.com'}
eq_(expected_result, output_queue.get())
def test_load_task(self, mock_messagebox):
mock_messagebox.return_value = mock_messagebox
customizer = MainWindowCustomizer(self.gui.get_main_window(),
MagicMock())
customizer._load_new_task_from_definition = Mock()
task_path = os.path.join(self.path, "file.gt")
f = Mock()
f.read.return_value = '[{"key": "value"}]'
with patch('__builtin__.open') as mock_open:
mock_open.return_value = f
customizer._load_task(task_path)
assert mock_open.called
assert f.close.called
assert not mock_messagebox.exec_.called
assert customizer._load_new_task_from_definition.called
def _raise(*_):
raise Exception
f.read = _raise
customizer._load_new_task_from_definition.called = False
with patch('__builtin__.open') as mock_open:
mock_open.return_value = f
customizer._load_task(task_path)
assert mock_open.called
assert f.close.called
assert mock_messagebox.exec_.called
assert not customizer._load_new_task_from_definition.called
def _mock_pkg_profile(packages, repo_file, enabled_modules):
"""
Turn a list of package objects into an RPMProfile object.
"""
dict_list = []
for pkg in packages:
dict_list.append(pkg.to_dict())
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(dict_list))
mock_rpm_profile = RPMProfile(from_file=mock_file)
mock_enabled_repos_profile = EnabledReposProfile(repo_file=repo_file)
mock_module_profile = ModulesProfile()
mock_module_profile.collect = Mock(return_value=enabled_modules)
mock_profile = {
"rpm": mock_rpm_profile,
"enabled_repos": mock_enabled_repos_profile,
"modulemd": mock_module_profile
}
return mock_profile
def test_not_validated_returned(self, mock_open):
document = {}
message = 'hello'
key_path = '/etc/pki/pulp/consumer/server/rsa_pub.pem'
key = RSA.load_key_bio(BIO.MemoryBuffer(RSA_KEY))
test_conf = {'server': {'rsa_pub': key_path}}
self.plugin.pulp_conf.update(test_conf)
mock_fp = Mock()
mock_fp.read = Mock(return_value=RSA_PUB)
mock_open.return_value = mock_fp
# test
try:
patcher = patch('pulp.agent.gofer.pulpplugin.RSA')
rsa = patcher.start()
rsa.load_pub_key_bio.return_value.verify.return_value = False
authenticator = self.plugin.Authenticator()
self.assertRaises(ValidationFailed, authenticator.validate,
document, message, key.sign(message))
finally:
if patcher:
patcher.stop()
# validation
mock_open.assert_called_with(key_path)
mock_fp.close.assert_called_with()
def empty_sagemaker_session():
ims = Mock(name="sagemaker_session")
ims.default_bucket = Mock(name="default_bucket", return_value=BUCKET_NAME)
ims.sagemaker_runtime_client = Mock(name="sagemaker_runtime")
ims.sagemaker_client.describe_endpoint = Mock(return_value=ENDPOINT_DESC)
ims.sagemaker_client.describe_endpoint_config = Mock(
return_value=ENDPOINT_CONFIG_DESC)
ims.sagemaker_runtime_client.invoke_endpoint_async = Mock(
name="invoke_endpoint_async",
return_value={
"OutputLocation": ASYNC_OUTPUT_LOCATION,
},
)
response_body = Mock("body")
response_body.read = Mock("read", return_value=RETURN_VALUE)
response_body.close = Mock("close", return_value=None)
ims.s3_client = Mock(name="s3_client")
ims.s3_client.get_object = Mock(
name="get_object",
return_value={"Body": response_body},
)
ims.s3_client.put_object = Mock(name="put_object")
return ims
def context_sagemaker_session(summaries=True):
ims = Mock(name="sagemaker_session")
ims.sagemaker_client.describe_endpoint = Mock(return_value=ENDPOINT_DESC)
ims.sagemaker_client.describe_endpoint_config = Mock(
return_value=ENDPOINT_CONFIG_DESC)
if summaries:
ims.sagemaker_client.list_contexts = Mock(
return_value={"ContextSummaries": [{
"ContextName": "bar"
}]})
else:
ims.sagemaker_client.list_contexts = Mock(
return_value={"ContextSummaries": []})
ims.sagemaker_client.describe_context = Mock(return_value={
"ContextArn": "foo",
"ContextName": "bar",
})
response_body = Mock("body")
response_body.read = Mock("read", return_value=json.dumps([RETURN_VALUE]))
response_body.close = Mock("close", return_value=None)
ims.sagemaker_runtime_client.invoke_endpoint = Mock(
name="invoke_endpoint",
return_value={
"Body": response_body,
"ContentType": "application/json"
},
)
return ims
def testFlickrWrapperGetUrls(self, mock_urlopen):
response = {'photos': {'photo': [
{'id': 'id1', 'secret': 'secret1', 'server': 'server1', 'farm': 1},
{'id': 'id2', 'secret': 'secret2', 'server': 'server2', 'farm': 2}
]}}
response = json.dumps(response)
m = Mock()
m.read = Mock(return_value=response)
mock_urlopen.return_value = m
api_key = 'key'
tag = 'tag'
wrapper = FlickrWrapper(api_key)
result = wrapper.get_urls(tag)
self.assertEqual(2, len(result))
self.assertTrue('farm1' in result[0])
self.assertTrue('id1' in result[0])
self.assertTrue('secret1' in result[0])
self.assertTrue('server1' in result[0])
self.assertTrue('farm2' in result[1])
self.assertTrue('id2' in result[1])
self.assertTrue('secret2' in result[1])
self.assertTrue('server2' in result[1])
def _mock_pkg_profile(packages, repo_file, enabled_modules):
"""
Turn a list of package objects into an RPMProfile object.
"""
dict_list = []
for pkg in packages:
dict_list.append(pkg.to_dict())
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(dict_list))
mock_rpm_profile = RPMProfile(from_file=mock_file)
mock_enabled_repos_profile = EnabledReposProfile(repo_file=repo_file)
mock_module_profile = ModulesProfile()
mock_module_profile.collect = Mock(return_value=enabled_modules)
mock_profile = {
"rpm": mock_rpm_profile,
"enabled_repos": mock_enabled_repos_profile,
"modulemd": mock_module_profile
}
return mock_profile
def test_should_not_update_state_if_unaavailable(self):
# Set
app = NewrelicApp('1111','777')
headers = {"X-Api-Key":'1111'}
url ='/v2/applications/777.json'
# Mocks
connection_obj = Mock()
response_obj = Mock()
httplib.HTTPConnection = Mock(return_value=connection_obj)
response_obj.status = 500 # Error
response_obj.read = Mock(return_value='')
connection_obj.connect = Mock()
connection_obj.request = Mock()
connection_obj.getresponse = Mock(return_value=response_obj)
# Assertion
app.update_state()
connection_obj.connect.assert_called_once()
connection_obj.request.assert_called_once_with('GET', url, '', headers)
connection_obj.getresponse.assert_called_once()
self.assertFalse(app.reachable)
def test_create_html_email(self, mock_urlopen):
html = """<html><body>
<p>First paragraph</p>
<p><img src='http://localhost/firstimage.jpg'></p>
<p>Third paragraph</p>
<p><img src='http://localhost/secondimage.jpg'></p>
<p>Final paragraph</p>
</body></html>
"""
mini_jpeg = (
b"\xff\xd8\xff\xdb\x00C\x00\x03\x02\x02\x02\x02\x02\x03\x02\x02"
b"\x02\x03\x03\x03\x03\x04\x06\x04\x04\x04\x04\x04\x08\x06\x06\x05"
b"\x06\t\x08\n\n\t\x08\t\t\n\x0c\x0f\x0c\n\x0b\x0e"
b"\x0b\t\t\r\x11\r\x0e\x0f\x10\x10\x11\x10\n\x0c\x12\x13"
b"\x12\x10\x13\x0f\x10\x10\x10\xff\xc9\x00\x0b\x08\x00\x01\x00\x01"
b"\x01\x01\x11\x00\xff\xcc\x00\x06\x00\x10\x10\x05\xff\xda\x00\x08"
b"\x01\x01\x00\x00?\x00\xd2\xcf \xff\xd9")
mock_httpresponse = Mock()
mock_httpresponse.getheader = Mock()
mock_httpresponse.read = Mock()
mock_httpresponse.getheader.side_effect = ["image/jpeg", "image/jpeg"]
mock_httpresponse.read.side_effect = [mini_jpeg, mini_jpeg]
mock_urlopen.return_value.__enter__.return_value = mock_httpresponse
msg = create_html_mail("A test mail", html)
msg.recipientlist = ("*****@*****.**", )
msg.send()
self.assertEqual(len(mail.outbox), 1, "should have one message")
msg = mail.outbox[0]
self.assertEqual(msg.alternatives[0][1], "text/html")
self.assertEqual(len(msg.attachments), 2, "has two attachments")
soup = BeautifulSoup(msg.alternatives[0][0], "lxml")
for img in soup.findAll("img"):
cid = img["src"].split(":")[1]
att = self.find_attachment_by_content_id(msg, cid)
self.assertIsNotNone(att, "image tag has a matching attachment")
def test_retrieve_of_json_data_from_api(self):
json_response = json.dumps({"steps": ["step 1", "step 2"]})
response_mock = Mock()
response_mock.read = Mock(return_value=json_response)
self.cache.get_authorized_response = Mock(return_value=response_mock)
self.assertListEqual(self.cache.get_steps_information(), ["step 1", "step 2"])
def test_load_data(self):
cached = {'prod1': 'Product 1', 'prod2': 'Product 2'}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.mgr._load_data(mock_file)
self.assertEquals(data, cached)
def setUp(self):
self.memory_map = {0: bytearray([0, 1])}
def _read(addresses):
data_ = {}
for address in addresses:
data_[address] = self.memory_map[
address.page][address.offset:address.offset +
address.length]
return data_
def _write(data_map):
for address, data_ in data_map.items():
for index, data_byte in enumerate(data_):
self.memory_map[address.page][address.offset +
index] = data_byte
memory_file_mock = Mock(MemoryFile)
memory_file_mock.read = _read
memory_file_mock.write = _write
SetUpTestInjections(
memory_files={MemoryTypes.EEPROM: memory_file_mock})
# Remove read-only flags from device_type for testing purposes below
if hasattr(OutputModuleConfiguration, '_device_type'):
OutputModuleConfiguration._device_type._read_only = False
else:
OutputModuleConfiguration.device_type._read_only = False
def empty_s3_client():
s3_client = Mock(name="s3-client")
client_other_error = ClientError(
error_response={
"Error": {
"Code": "SomeOtherError",
"Message": "some-error-message"
}
},
operation_name="client-other-error",
)
client_error = ClientError(
error_response={"Error": {
"Code": "NoSuchKey"
}},
operation_name="async-inference-response-test",
)
response_body = Mock("body")
response_body.read = Mock("read", return_value=RETURN_VALUE)
response_body.close = Mock("close", return_value=None)
s3_client.get_object = Mock(
name="get_object",
side_effect=[
client_other_error, client_error, {
"Body": response_body
}
],
)
return s3_client
def test_not_validated_returned(self, mock_open):
document = {}
message = 'hello'
key_path = '/etc/pki/pulp/consumer/server/rsa_pub.pem'
key = RSA.load_key_bio(BIO.MemoryBuffer(RSA_KEY))
test_conf = {'server': {'rsa_pub': key_path}}
self.plugin.pulp_conf.update(test_conf)
mock_fp = Mock()
mock_fp.read = Mock(return_value=RSA_PUB)
mock_open.return_value = mock_fp
# test
try:
patcher = patch('pulp.agent.gofer.pulpplugin.RSA')
rsa = patcher.start()
rsa.load_pub_key_bio.return_value.verify.return_value = False
authenticator = self.plugin.Authenticator()
self.assertRaises(
ValidationFailed, authenticator.validate, document, message, key.sign(message))
finally:
if patcher:
patcher.stop()
# validation
mock_open.assert_called_with(key_path)
mock_fp.close.assert_called_with()
def create_file_context_manager(*args, **kwargs):
path = args[0]
file_mock = Mock()
file_mock.read = Mock(return_value=file_map[path])
cm = Mock()
cm.__enter__ = Mock(return_value=file_mock)
cm.__exit__ = Mock()
return cm
def create_file_context_manager(*args, **kwargs):
path = args[0]
file_mock = Mock()
file_mock.read = Mock(return_value=file_map[path])
cm = Mock()
cm.__enter__ = Mock(return_value=file_mock)
cm.__exit__ = Mock()
return cm
def test_getNode(self):
"""
@return:
"""
uri = "vos://foo.com!vospace/bar"
nodes = (' <vos:nodes>\n'
'<vos:node uri="vos://cadc.nrc.ca!vospace/mydir/file123" '
'xs:type="vos:DataNode">\n'
' <vos:properties>\n'
' <vos:property '
'uri="ivo://ivoa.net/vospace/core#date">2016-05-10T09:52:13'
'</vos:property>\n'
' </vos:properties>\n'
'</vos:node>\n'
'<vos:node uri="vos://cadc.nrc.ca!vospace/mydir/file456" '
'xs:type="vos:DataNode">\n'
' <vos:properties>\n'
' <vos:property uri="ivo://ivoa.net/vospace/core#date">'
'2016-05-19T09:52:14</vos:property>\n'
' </vos:properties>\n'
'</vos:node>\n'
'</vos:nodes>\n')
mock_vofile = Mock()
client = Client()
client.open = Mock(return_value=mock_vofile)
mock_vofile.read = Mock(
return_value=NODE_XML.format(uri, '').encode('UTF-8'))
my_node = client.get_node(uri, limit=0, force=False)
self.assertEqual(uri, my_node.uri)
self.assertEqual(len(my_node.node_list), 0)
mock_vofile.read = Mock(
return_value=NODE_XML.format(uri, nodes).encode('UTF-8'))
my_node = client.get_node(uri, limit=2, force=True)
self.assertEqual(uri, my_node.uri)
self.assertEqual(len(my_node.node_list), 2)
my_node = client.get_node(uri, limit=2, force=False)
self.assertEqual(uri, my_node.uri)
self.assertEqual(len(my_node.node_list), 2)
def test_getNode(self):
"""
@return:
"""
uri = "vos://foo.com!vospace/bar"
nodes = (' <vos:nodes>\n'
'<vos:node uri="vos://cadc.nrc.ca!vospace/mydir/file123" '
'xs:type="vos:DataNode">\n'
' <vos:properties>\n'
' <vos:property '
'uri="ivo://ivoa.net/vospace/core#date">2016-05-10T09:52:13'
'</vos:property>\n'
' </vos:properties>\n'
'</vos:node>\n'
'<vos:node uri="vos://cadc.nrc.ca!vospace/mydir/file456" '
'xs:type="vos:DataNode">\n'
' <vos:properties>\n'
' <vos:property uri="ivo://ivoa.net/vospace/core#date">'
'2016-05-19T09:52:14</vos:property>\n'
' </vos:properties>\n'
'</vos:node>\n'
'</vos:nodes>\n')
mock_vofile = Mock()
client = Client()
client.open = Mock(return_value=mock_vofile)
mock_vofile.read = Mock(
return_value=NODE_XML.format(uri, '').encode('UTF-8'))
my_node = client.get_node(uri, limit=0, force=False)
self.assertEqual(uri, my_node.uri)
self.assertEqual(len(my_node.node_list), 0)
mock_vofile.read = Mock(
return_value=NODE_XML.format(uri, nodes).encode('UTF-8'))
my_node = client.get_node(uri, limit=2, force=True)
self.assertEqual(uri, my_node.uri)
self.assertEqual(len(my_node.node_list), 2)
my_node = client.get_node(uri, limit=2, force=False)
self.assertEqual(uri, my_node.uri)
self.assertEqual(len(my_node.node_list), 2)
def test_raise_error_with_no_data(self):
response = Mock()
response.status = 400
response.reason = 'Bad Request'
response.getheader = Mock(return_value='')
response.read = Mock(return_value='')
con = Urllib3HttpConnection()
self.assertRaises(BadRequestError, con._raise_error, response)
def test_command_fails_and_the_execution_does_not_stop(self):
error_mocked = Mock()
error_mocked.read = Mock(return_value='test')
ssh_lib_mocked = Mock()
ssh_lib_mocked.connect = Mock(return_value=True)
ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], error_mocked))
ssh_lib_mocked.close = Mock(return_value=True)
assert 'test ' == SSHClient(ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test')
def empty_sagemaker_session():
ims = Mock(name='sagemaker_session')
ims.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME)
ims.sagemaker_runtime_client = Mock(name='sagemaker_runtime')
response_body = Mock('body')
response_body.read = Mock('read', return_value=RETURN_VALUE)
response_body.close = Mock('close', return_value=None)
ims.sagemaker_runtime_client.invoke_endpoint = Mock(name='invoke_endpoint', return_value={'Body': response_body})
return ims
def test_get_export(self):
m = Mock()
m.read = Mock(return_value='{"foo": "bar"}')
self.client._api.get_export = Mock(return_value={'body': m})
eq_(self.client.get_export(None, 'baz'), {})
eq_(self.client.get_export('baz', 'qux'), {'foo': 'bar'})
self.client._api.get_export = Mock(
side_effect=botocore.exceptions.ClientError({'Error': {}}, 'bar'))
eq_(self.client.get_export('baz', 'qux'), {})
def test_call_helper(self, transport):
getresponse_mock = Mock()
transport.return_value = getresponse_mock
read_mock = Mock()
read_mock.read = Mock(return_value='data!')
getresponse_mock.getresponse = Mock(return_value=read_mock)
s = HttpLibHttpService('host', 42, 'path')
r = s._call('body', {})
self.assertIsInstance(r, tuple)
self.assertEqual(len(r), 3)
def _dummy_send(*args, **kwargs):
dummy_response = Mock()
dummy_response.headers = {}
dummy_response.getheaders = Mock(return_value={})
dummy_response.status = status_code
dummy_response.read = Mock(return_value=response_body)
dummy_response.request = args[0]
dummy_response.cookies = {}
_dummy_send.call_args = (args, kwargs)
return dummy_response
def test_load_data(self):
cached = {
'prod1': 'Product 1',
'prod2': 'Product 2'
}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.mgr._load_data(mock_file)
self.assertEquals(data, cached)
def empty_sagemaker_session():
ims = Mock(name='sagemaker_session')
ims.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME)
ims.sagemaker_runtime_client = Mock(name='sagemaker_runtime')
response_body = Mock('body')
response_body.read = Mock('read', return_value=RETURN_VALUE)
response_body.close = Mock('close', return_value=None)
ims.sagemaker_runtime_client.invoke_endpoint = Mock(name='invoke_endpoint', return_value={'Body': response_body})
return ims
def test_print_debug_info(self, m_isfile, m_isdir, m_popen, m_open):
m_isfile.return_value = True
m_isdir.return_value = True
m_popen.return_value = Mock()
cmdline = Mock()
cmdline.find = Mock(return_value=0)
m1 = Mock()
m2 = Mock()
m2.read = Mock(return_value=cmdline)
m_open.side_effect = [m1, m2]
ls.print_debug_info("the_job", "job/dir", "some/archive/dir")
def test_load_s3_schema(self):
mocked_json = '{"survey": "some_survey"}'
mocked_connection = Mock()
with patch('boto3.resource', Mock(return_value=mocked_connection)):
mocked_file = Mock()
mocked_file.read = Mock(return_value=mocked_json.encode())
mocked_object = Mock()
mocked_connection.Object = Mock(return_value=mocked_object)
mocked_object.get.return_value = {"Body": mocked_file}
self.assertEqual(json.loads(mocked_json), load_s3_schema_file("ignored_filename.json"))
def test_receive_state(self):
mi = Mock()
mi.read = self.response
interface = StateInterface(mi)
device = InterfaceDevice(address=None,
devices=interface,
initial_state=State.UNKNOWN)
self.assertEqual(device.state, State.UNKNOWN)
self._response = State.ON
time.sleep(2)
self.assertEqual(device.state, State.ON)
def test_request_metrics(self, mock_rest_request):
data = {"key1": "value1", "key2": "value2"}
mock_rest_request_response = Mock()
mock_read = Mock()
mock_read.return_value = json.dumps(data)
mock_rest_request_response.read = mock_read
mock_rest_request.return_value = mock_rest_request_response
expected_response = data
actual_response = self.agent.request_metrics("http://host", "/path")
self.assertDictEqual(actual_response, expected_response)
def test_exec_command_and_wait_input_lines_scoket_timeout(self):
yum_cmd = "yum clean all"
configurator = ssh_utilities.RemoteConnection(self.hostname, self.user,
self.passwd,
ssh_client=self.ssh_client)
stdout = Mock()
stdout.channel.recv_exit_status = Mock(return_value=1)
stdout.read = Mock(side_effect=socket.timeout)
self.ssh_client.exec_command.return_value = (Mock(), stdout, Mock())
self.assertRaises(socket.timeout, configurator.exec_command_and_wait,
yum_cmd, input_lines="tee my.log")
def test_receive_state(self):
mi = Mock()
mi.read = self.response
interface = StateInterface(mi)
device = InterfaceDevice(address=None,
devices=interface,
initial_state=State.UNKNOWN)
self.assertEqual(device.state, State.UNKNOWN)
self._response = State.ON
time.sleep(2)
self.assertEqual(device.state, State.ON)
def ret_csv_sagemaker_session():
ims = Mock(name='sagemaker_session')
ims.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME)
ims.sagemaker_runtime_client = Mock(name='sagemaker_runtime')
response_body = Mock('body')
response_body.read = Mock('read', return_value=CSV_RETURN_VALUE)
response_body.close = Mock('close', return_value=None)
ims.sagemaker_runtime_client.invoke_endpoint = Mock(name='invoke_endpoint',
return_value={'Body': response_body,
'ContentType': CSV_CONTENT_TYPE})
return ims
class TestAPI(unittest.TestCase):
def setUp(self):
mapper = Mock()
self.db = Mock()
self.input = Mock()
self.input.read.return_value = b'{"name":"test","period":1800}'
self.req = { "CONTENT_TYPE": "application/json",
"CONTENT_LENGTH": len(self.input.read()),
"wsgi.input": self.input, }
self.res = Mock()
fuse.api.log = Mock()
self.api = fuse.api.APIWrapper(config, self.db, mapper)
def test_exec_command_and_wait_input_lines(self):
yum_cmd = "yum clean all"
configurator = ssh_utilities.RemoteConnection(self.hostname, self.user,
self.passwd,
ssh_client=self.ssh_client)
stdout = Mock()
stdout.channel.recv_exit_status = Mock(return_value=1)
stdout.read = Mock(return_value="validoutput")
self.ssh_client.exec_command.return_value = (Mock(), stdout, Mock())
exit_code, stdout_data, stderr_data = configurator.\
exec_command_and_wait(yum_cmd, input_lines="tee my.log")
self.assertEquals(stdout_data, "validoutput")
def ret_csv_sagemaker_session():
ims = Mock(name='sagemaker_session')
ims.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME)
ims.sagemaker_runtime_client = Mock(name='sagemaker_runtime')
response_body = Mock('body')
response_body.read = Mock('read', return_value=CSV_RETURN_VALUE)
response_body.close = Mock('close', return_value=None)
ims.sagemaker_runtime_client.invoke_endpoint = Mock(name='invoke_endpoint',
return_value={'Body': response_body,
'ContentType': CSV_CONTENT_TYPE})
return ims
def test_exec_command_and_wait_raise_on_exit(self):
yum_cmd = "yum clean all"
configurator = ssh_utilities.RemoteConnection(self.hostname, self.user,
self.passwd,
ssh_client=self.ssh_client)
stdout = Mock()
stdout.channel.recv_exit_status = Mock(return_value=1)
stdout.read = Mock(return_value="error")
self.ssh_client.exec_command.return_value = (Mock(), stdout, Mock())
self.assertRaises(Exception, configurator.exec_command_and_wait,
yum_cmd, input_lines="tee my.log",
raise_on_exit_not_0=True)
def _set_up_mock_httplib(self, desired_response):
mock_file = Mock()
mock_file.read = Mock(return_value=desired_response)
mock_r = Mock()
mock_getresponse = Mock(return_value=mock_file)
mock_r.getresponse = mock_getresponse
mock_httplib = Mock(spec=httplib)
mock_httplib.HTTPSConnection = Mock(return_value=mock_r)
return mock_httplib
def test_delete_shell_shell_not_found_raises_error(self, mock_delete, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
mock_delete.return_value = Response()
mock_delete.return_value.status_code = 400 # Bad Request
# Act Assert
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
self.assertRaises(ShellNotFoundException, client.delete_shell, 'shell')
def test_login(self, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
# Act
PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
# Assert
self.assertTrue(mock_opener.open.called, 'open should be called')
def test_command_fails_and_execution_is_stopped(self):
error_mocked = Mock()
error_mocked.read = Mock(return_value='test')
ssh_lib_mocked = Mock()
ssh_lib_mocked.connect = Mock(return_value=True)
ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], error_mocked))
ssh_lib_mocked.close = Mock(return_value=True)
with pytest.raises(RuntimeError) as runtime_error:
SSHClient(ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test', True)
assert 'test' == str(runtime_error.value)
def test_load_data(self):
cached = {
'pools': {
'pool1': 'Pool 1',
'pool2': 'Pool 2'
},
'tags': ['p1', 'p2']
}
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(cached))
data = self.pool_status_cache._load_data(mock_file)
self.assertEqual(data, cached)
def test_command_fails_and_the_execution_does_not_stop(self):
error_mocked = Mock()
error_mocked.read = Mock(return_value='test')
ssh_lib_mocked = Mock()
ssh_lib_mocked.connect = Mock(return_value=True)
ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'],
error_mocked))
ssh_lib_mocked.close = Mock(return_value=True)
assert 'test ' == SSHClient(
ssh_lib_mocked,
self.__generate_test_logger()).exec_command('ls', 'unit', 'test')
def _mock_pkg_profile(packages):
"""
Turn a list of package objects into an RPMProfile object.
"""
dict_list = []
for pkg in packages:
dict_list.append(pkg.to_dict())
mock_file = Mock()
mock_file.read = Mock(return_value=json.dumps(dict_list))
mock_profile = RPMProfile(from_file=mock_file)
return mock_profile
def test_return_value(monkeypatch):
"""
Check the return value of doWebRequest.
"""
# Setup the mocks.
response = Mock()
response.read.return_value = 'test content'
mock_urlopen = Mock(return_value=response)
# Patch urlopen so that we do not make an http request.
monkeypatch.setattr('urllib2.urlopen', mock_urlopen)
return_value = util.doWebRequest('http://exmple.com/foo/bar')
assert return_value == (response, response.read())
def test_loadFile(self, file_mock):
rp_name = 'reportName'
full_rp_path = '/path/to/test_zp/Reports/SomeReports/reportName.rpt'
report_txt = "some report data"
#mock build in file method and its instance read method
file_read = Mock()
file_read.read = Mock(return_value=report_txt)
file_mock.return_value = file_read
root = Mock()
root._setObject = Mock()
rp = self.rp_load.loadFile(root, rp_name, full_rp_path)
self.assertIsInstance(rp, Report)
self.assertEqual(rp.id, rp_name)
root._setObject.assert_called_once_with(rp_name, rp)
def test_call_paypal(self, urllib2_mock):
mixin = PayPalFormMixin()
response_mock = Mock()
response_mock.read = Mock(return_value=self.paypal_response)
urllib2_mock.urlopen.return_value = response_mock
response = mixin.call_paypal(API_URL, {})
self.assertEqual(response['ACK'], ['Success'], msg=(
'Should parse the response from paypal and return it as a dict'))
with patch.object(mixin, 'log_error') as log_error_mock:
urllib2_mock.urlopen = PropertyMock(side_effect=HTTPException)
mixin.call_paypal(API_URL, {})
self.assertEqual(log_error_mock.call_count, 1, msg=(
'Should log an error if calling the PayPal API fails.'))
def _irregular_reader(self, items):
def item_read(read_length):
try:
item = items.pop(0)
except IndexError:
# If no more items, the buffer is empty and would return empty string
return ''
return item.read(read_length)
mock_fh = Mock()
mock_fh.read = Mock()
mock_fh.read.side_effect = item_read
return mock_fh
def test_load(self, mock_open):
mock_fp = Mock()
mock_fp.read = Mock(return_value=RSA_KEY)
mock_fp.__enter__ = Mock(return_value=mock_fp)
mock_fp.__exit__ = Mock()
mock_open.return_value = mock_fp
# test
authenticator = Authenticator()
authenticator.load()
# validation
self.assertTrue(mock_fp.__exit__.called)
self.assertTrue(isinstance(authenticator.rsa_key, RSA.RSA))
def setUpResponse(self, headers, body, status_code=200):
if not headers:
headers = {'Content-Type': 'application/json'}
def decode_content():
pass
response = Response()
response.status_code = status_code
response.headers = headers
stream = Mock()
stream.read = Mock()
stream.read.side_effect = [body, None]
response.raw = stream
return response
