def test_update(self):
self.server_mock.request.return_value = 201, {}
kwargs = {
OPTION_CONSUMER_ID.keyword: 'test-consumer',
OPTION_NAME.keyword: 'Test Consumer',
OPTION_DESCRIPTION.keyword: 'Consumer for testing',
OPTION_NOTES.keyword: {
'a': 'a',
'b': 'b'
}
}
self.command.run(**kwargs)
self.assertEqual(self.server_mock.request.call_count, 1)
self.assertEqual(self.server_mock.request.call_args[0][0], 'PUT')
url = self.server_mock.request.call_args[0][1]
self.assertTrue(url.find('test-consumer') > 0)
body = json.loads(self.server_mock.request.call_args[0][2])
self.assertEqual(body['delta']['display_name'], 'Test Consumer')
self.assertEqual(body['delta']['description'], 'Consumer for testing')
self.assertEqual(body['delta']['notes'], {'a': 'a', 'b': 'b'})
def test_run(self):
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
fake_progress_report = {'steps' : [('name', 'status')], 'details' : {}}
sim.add_task_state('1', STATE_FINISHED, progress_report=fake_progress_report)
self.server_mock.request.return_value = 201, POSTPONED_TASK
kwargs = {OPTION_CONSUMER_ID.keyword: 'test-consumer',
consumer_content.OPTION_CONTENT_TYPE_ID.keyword: 'rpm',
consumer_content.OPTION_CONTENT_UNIT.keyword: []}
self.command.run(**kwargs)
self.assertEqual(self.server_mock.request.call_count, 1)
self.assertEqual(self.server_mock.request.call_args[0][0], 'POST')
url = self.server_mock.request.call_args[0][1]
self.assertTrue(url.find('test-consumer') > 0)
body = json.loads(self.server_mock.request.call_args[0][2])
self.assertEqual(body['units'], [])
def test_run(self):
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
fake_progress_report = {"steps": [("name", "status")], "details": {}}
sim.add_task_state("1", STATE_FINISHED, progress_report=fake_progress_report)
self.server_mock.request.return_value = 201, POSTPONED_TASK
kwargs = {
OPTION_CONSUMER_ID.keyword: "test-consumer",
consumer_content.OPTION_CONTENT_TYPE_ID.keyword: "rpm",
consumer_content.OPTION_CONTENT_UNIT.keyword: [],
}
self.command.run(**kwargs)
self.assertEqual(self.server_mock.request.call_count, 1)
self.assertEqual(self.server_mock.request.call_args[0][0], "POST")
url = self.server_mock.request.call_args[0][1]
self.assertTrue(url.find("test-consumer") > 0)
body = json.loads(self.server_mock.request.call_args[0][2])
self.assertEqual(body["units"], [])
def test_handle_event(self, mock_create):
# Setup
notifier_config = {"url": "https://localhost/api/", "username": "******", "password": "******"}
event = Event("type-1", {"k1": "v1"})
mock_connection = mock.Mock()
mock_response = mock.Mock()
mock_response.status = httplib.OK
mock_connection.getresponse.return_value = mock_response
mock_create.return_value = mock_connection
# Test
http.handle_event(notifier_config, event)
time.sleep(0.5) # handle works in a thread so give it a bit to finish
# Verify
self.assertEqual(1, mock_create.call_count)
self.assertEqual(1, mock_connection.request.call_count)
request_args = mock_connection.request.call_args[0]
self.assertEqual("POST", request_args[0])
self.assertEqual("/api/", request_args[1])
expected_body = {"event_type": event.event_type, "payload": event.payload, "call_report": None}
request_kwargs = mock_connection.request.call_args[1]
parsed_body = json.loads(request_kwargs["body"])
self.assertEqual(parsed_body, expected_body)
headers = request_kwargs["headers"]
self.assertTrue("Authorization" in headers)
def test_run(self):
# Setup
sim = TaskSimulator()
sim.install(self.bindings)
fake_progress_report = {'steps': [('name', 'status')], 'details': {}}
sim.add_task_state('1',
STATE_FINISHED,
progress_report=fake_progress_report)
self.server_mock.request.return_value = 201, POSTPONED_TASK
kwargs = {
OPTION_CONSUMER_ID.keyword: 'test-consumer',
consumer_content.OPTION_CONTENT_TYPE_ID.keyword: 'rpm',
consumer_content.OPTION_CONTENT_UNIT.keyword: []
}
self.command.run(**kwargs)
self.assertEqual(self.server_mock.request.call_count, 1)
self.assertEqual(self.server_mock.request.call_args[0][0], 'POST')
url = self.server_mock.request.call_args[0][1]
self.assertTrue(url.find('test-consumer') > 0)
body = json.loads(self.server_mock.request.call_args[0][2])
self.assertEqual(body['units'], [])
def params(self):
"""
JSON decode the objects in the requests body and return them
@return: dict of parameters passed in through the body
"""
data = web.data()
if not data:
return {}
return json.loads(data)
def params(self):
"""
JSON decode the objects in the requests body and return them
@return: dict of parameters passed in through the body
"""
data = web.data()
if not data:
return {}
deserialized_data = json.loads(data)
return self._ensure_input_encoding(deserialized_data)
def params(self):
"""
JSON decode the objects in the requests body and return them
@return: dict of parameters passed in through the body
"""
data = web.data()
if not data:
return {}
deserialized_data = json.loads(data)
return self._ensure_input_encoding(deserialized_data)
def fetch(self):
"""
Fetch referenced content unit from the units file.
:return: The json decoded unit.
:rtype: dict
:raise IOError: on I/O errors.
:raise ValueError: json decoding errors
"""
with open(self.path) as fp:
fp.seek(self.offset)
json_unit = fp.read(self.length)
return json.loads(json_unit)
def fetch(self):
"""
Fetch referenced content unit from the units file.
:return: The json decoded unit.
:rtype: dict
:raise IOError: on I/O errors.
:raise ValueError: json decoding errors
"""
with open(self.path) as fp:
fp.seek(self.offset)
json_unit = fp.read(self.length)
return json.loads(json_unit)
def request(self, method, path, body=None):
try:
body = json.dumps(body, default=json_util.default)
except:
pass
self.http.request(method, path, body=body, headers=self.auth.header())
response = self.http.getresponse()
body = response.read()
try:
body = json.loads(body)
except:
pass
return (response.status, body)
def get_units(path):
with open(path) as fp:
while True:
begin = fp.tell()
json_unit = fp.readline()
end = fp.tell()
if json_unit:
unit = json.loads(json_unit)
length = (end - begin)
ref = UnitRef(path, begin, length)
yield (unit, ref)
else:
break
def get_units(path):
with open(path) as fp:
while True:
begin = fp.tell()
json_unit = fp.readline()
end = fp.tell()
if json_unit:
unit = json.loads(json_unit)
length = (end - begin)
ref = UnitRef(path, begin, length)
yield (unit, ref)
else:
break
def decode(string):
"""
Decode the specified json encoded string.
:param string: A json string.
:type string: str
:return: A python object.
:raise DecodingError: on error.
"""
try:
return json.loads(string)
except (TypeError, ValueError), de:
reason = str(de)
raise DecodingError(reason)
def decode(string):
"""
Decode the specified json encoded string.
:param string: A json string.
:type string: str
:return: A python object.
:raise DecodingError: on error.
"""
try:
return json.loads(string)
except (TypeError, ValueError), de:
reason = str(de)
raise DecodingError(reason)
def test_email_enabled(self, mock_smtp, mock_getbool):
mail.handle_event(self.notifier_config, self.event)
#verify
self.assertEqual(mock_smtp.call_count, 2)
mock_sendmail = mock_smtp.return_value.sendmail
self.assertEqual(mock_sendmail.call_args[0][0],
config.get('email', 'from'))
self.assertTrue(mock_sendmail.call_args[0][1] in self.notifier_config['addresses'])
# verify message attributes
message = Parser().parsestr(mock_sendmail.call_args[0][2])
self.assertEqual(json.loads(message.get_payload()), self.event.payload)
self.assertEqual(message.get('Subject', None), self.notifier_config['subject'])
self.assertEqual(message.get('From', None), config.get('email', 'from'))
self.assertTrue(message.get('To', None) in self.notifier_config['addresses'])
def test_email_enabled(self, mock_smtp, mock_getbool):
mail.handle_event(self.notifier_config, self.event)
# verify
self.assertEqual(mock_smtp.call_count, 2)
mock_sendmail = mock_smtp.return_value.sendmail
self.assertEqual(mock_sendmail.call_args[0][0],
config.get('email', 'from'))
self.assertTrue(mock_sendmail.call_args[0][1] in self.notifier_config['addresses'])
# verify message attributes
message = Parser().parsestr(mock_sendmail.call_args[0][2])
self.assertEqual(json.loads(message.get_payload()), self.event.payload)
self.assertEqual(message.get('Subject', None), self.notifier_config['subject'])
self.assertEqual(message.get('From', None), config.get('email', 'from'))
self.assertTrue(message.get('To', None) in self.notifier_config['addresses'])
def get_units(path):
fp = gzip.open(path)
try:
while True:
begin = fp.tell()
json_unit = fp.readline()
end = fp.tell()
if json_unit:
unit = json.loads(json_unit)
length = (end - begin)
ref = UnitRef(path, begin, length)
yield (unit, ref)
else:
break
finally:
fp.close()
def request(self, method, path, body=None):
try:
body = json.dumps(body, default=json_util.default)
except:
pass
self.http.request(
method,
path,
body=body,
headers=self.auth.header())
response = self.http.getresponse()
body = response.read()
try:
body = json.loads(body)
except:
pass
return (response.status, body)
def test_handle_event(self, mock_create, mock_task_ser):
# Setup
notifier_config = {
'url': 'https://localhost/api/',
'username': '******',
'password': '******',
}
event = Event('type-1', {'k1': 'v1'})
mock_connection = mock.Mock()
mock_response = mock.Mock()
mock_task_ser.return_value = None
mock_response.status = httplib.OK
mock_connection.getresponse.return_value = mock_response
mock_create.return_value = mock_connection
# Test
http.handle_event(notifier_config, event)
time.sleep(.5) # handle works in a thread so give it a bit to finish
# Verify
self.assertEqual(1, mock_create.call_count)
self.assertEqual(1, mock_connection.request.call_count)
request_args = mock_connection.request.call_args[0]
self.assertEqual('POST', request_args[0])
self.assertEqual('/api/', request_args[1])
expected_body = {
'event_type': event.event_type,
'payload': event.payload,
'call_report': None
}
request_kwargs = mock_connection.request.call_args[1]
parsed_body = json.loads(request_kwargs['body'])
self.assertEqual(parsed_body, expected_body)
headers = request_kwargs['headers']
self.assertTrue('Authorization' in headers)
def test_run(self):
self.server_mock.request.return_value = 201, POSTPONED_TASK
kwargs = {OPTION_CONSUMER_ID.keyword: 'test-consumer',
consumer_content.OPTION_CONTENT_TYPE_ID.keyword: 'rpm',
consumer_content.OPTION_CONTENT_UNIT.keyword: []}
self.command.run(**kwargs)
self.assertEqual(self.server_mock.request.call_count, 1)
self.assertEqual(self.server_mock.request.call_args[0][0], 'POST')
url = self.server_mock.request.call_args[0][1]
self.assertTrue(url.find('test-consumer') > 0)
body = json.loads(self.server_mock.request.call_args[0][2])
self.assertEqual(body['units'], [])
def test_handle_event(self, mock_create, mock_task_ser):
# Setup
notifier_config = {
'url': 'https://localhost/api/',
'username': '******',
'password': '******',
}
event = Event('type-1', {'k1': 'v1'})
mock_connection = mock.Mock()
mock_response = mock.Mock()
mock_task_ser.return_value = None
mock_response.status = httplib.OK
mock_connection.getresponse.return_value = mock_response
mock_create.return_value = mock_connection
# Test
http.handle_event(notifier_config, event)
time.sleep(.5) # handle works in a thread so give it a bit to finish
# Verify
self.assertEqual(1, mock_create.call_count)
self.assertEqual(1, mock_connection.request.call_count)
request_args = mock_connection.request.call_args[0]
self.assertEqual('POST', request_args[0])
self.assertEqual('/api/', request_args[1])
expected_body = {'event_type': event.event_type,
'payload': event.payload,
'call_report': None}
request_kwargs = mock_connection.request.call_args[1]
parsed_body = json.loads(request_kwargs['body'])
self.assertEqual(parsed_body, expected_body)
headers = request_kwargs['headers']
self.assertTrue('Authorization' in headers)
def test_bind(self):
self.server_mock.request.return_value = 201, {}
kwargs = {
OPTION_CONSUMER_ID.keyword: 'test-consumer',
OPTION_REPO_ID.keyword: 'test-repo',
consumer_bind.OPTION_DISTRIBUTOR_ID.keyword: 'yum-distributor'}
self.command.run(**kwargs)
self.assertEqual(self.server_mock.request.call_count, 1)
self.assertEqual(self.server_mock.request.call_args[0][0], 'POST')
url = self.server_mock.request.call_args[0][1]
self.assertTrue(url.find('test-consumer') > 0)
body = json.loads(self.server_mock.request.call_args[0][2])
self.assertEqual(body['repo_id'], 'test-repo')
self.assertEqual(body['distributor_id'], 'yum-distributor')
def test_update(self):
self.server_mock.request.return_value = 201, {}
kwargs = {OPTION_CONSUMER_ID.keyword: 'test-consumer',
OPTION_NAME.keyword: 'Test Consumer',
OPTION_DESCRIPTION.keyword: 'Consumer for testing',
OPTION_NOTES.keyword: ['a=a', 'b=b']}
self.command.run(**kwargs)
self.assertEqual(self.server_mock.request.call_count, 1)
self.assertEqual(self.server_mock.request.call_args[0][0], 'PUT')
url = self.server_mock.request.call_args[0][1]
self.assertTrue(url.find('test-consumer') > 0)
body = json.loads(self.server_mock.request.call_args[0][2])
self.assertEqual(body['delta']['display_name'], 'Test Consumer')
self.assertEqual(body['delta']['description'], 'Consumer for testing')
self.assertEqual(body['delta']['notes'], {'a': 'a', 'b': 'b'})
