def test_ingredient_add(self):
""" Tests the add ingredient method. """
widget = RecipeTableWidget()
ingredient_name_0 = random_string()
energy_value_0 = random_energy_value()
ingredient_mass_0 = "100"
ingredient_name_1 = random_string()
energy_value_1 = random_energy_value()
ingredient_mass_1 = "100"
widget.add_ingredient(ingredient_name_0, energy_value_0,
ingredient_mass_0)
self.assertEqual(widget.rowCount(), 1)
self._assert_table_row(widget, 0, ingredient_name_0, energy_value_0,
ingredient_mass_0)
widget.add_ingredient(ingredient_name_1, energy_value_1,
ingredient_mass_1)
self.assertEqual(widget.rowCount(), 2)
self._assert_table_row(widget, 0, ingredient_name_0, energy_value_0,
ingredient_mass_0)
self._assert_table_row(widget, 1, ingredient_name_1, energy_value_1,
ingredient_mass_1)
def test_post_authorized_with_description(client):
# Init data
user = _create_user(client)
headers = create_headers(
access_token=generate_access_token(user['id'])
)
category_id = 1
data = {
'name': 'My Item {}'.format(random_string(10)),
'description': '{}'.format(random_string(100))
}
# Create item
response = client.post(
'/categories/{}/items'.format(category_id),
headers=headers,
data=json.dumps(data)
)
resp = json_response(response)
# Check if server returns 200
assert response.status_code == 200
# Check if each dict contains these keys
assert all(
key in resp
for key in ['id', 'name', 'description', 'updated', 'created']
) is True
# Check if newly created item is has the same name
assert resp['name'] == data['name']
assert resp['description'] == data['description']
def test_post_unauthorized(client):
headers = create_headers()
category_id = 1
data = {
'name': 'My Item ({})'.format(random_string(10))
}
# Create item
response = client.post(
'/categories/{}/items'.format(category_id),
headers=headers,
data=json.dumps(data)
)
resp = json_response(response)
# Check if server returns 401
assert response.status_code == 401
# Check if each dict contains these keys
assert all(
key in resp
for key in ['message', 'error_code']
) is True
def test_post_authorized_invalid_input(client):
# Init data
user = _create_user(client)
headers = create_headers(
access_token=generate_access_token(user['id'])
)
category_id = 1
combine_data = {
'name': [None, '', '{}'.format(random_string(100))],
'description': [None, '', 'ABC']
}
combinations = itertools.product(*combine_data.values())
num_valid_combine = 0
for combination in combinations:
data = dict((k, v) for k, v in zip(combine_data.keys(), combination))
# Create item
response = client.post(
'/categories/{}/items'.format(category_id),
headers=headers,
data=json.dumps(data)
)
num_valid_combine += 1 if response.status_code != 400 else 0
# Check if valid combination counter always equals to 0 (all cases are invalid)
assert num_valid_combine <= 1
def test_put_authorized_not_owned_valid_data(client):
# Init data
category_id = 1
user = _create_user(client)
user2 = _create_user(client)
headers = create_headers(
access_token=generate_access_token(user['id'])
)
headers2 = create_headers(
access_token=generate_access_token(user2['id'])
)
item = _create_item_in_category(client, headers, category_id)
item_id = item['id']
data = {
'name': 'New Item Name ({})'.format(random_string(10))
}
# Update item
response = client.put(
'/categories/{}/items/{}'.format(category_id, item_id),
headers=headers2,
data=json.dumps(data)
)
# Check if server returns 403
assert response.status_code == 403
def test_post_authorized_unrecognized_field(client):
# Init data
user = _create_user(client)
headers = create_headers(
access_token=generate_access_token(user['id'])
)
category_id = 1
data = {
'id': 100,
'name': 'My Item {}'.format(random_string(10))
}
# Create item
response = client.post(
'/categories/{}/items'.format(category_id),
headers=headers,
data=json.dumps(data)
)
resp = json_response(response)
# Check if server returns 400
assert response.status_code == 400
# Check if each dict contains these keys
assert all(
key in resp
for key in ['error_code', 'message']
) is True
def test_put_authorized_invalid_data(client):
# Init data
category_id = 1
user = _create_user(client)
headers = create_headers(
access_token=generate_access_token(user['id'])
)
item = _create_item_in_category(client, headers, category_id)
item_id = item['id']
data = {
'name': 'New Item Name ({})'.format(random_string(100))
}
# Update item
response = client.put(
'/categories/{}/items/{}'.format(category_id, item_id),
headers=headers,
data=json.dumps(data)
)
resp = json_response(response)
# Check if server returns 400
assert response.status_code == 400
# Check if each dict contains these keys
assert all(
key in resp
for key in ['error_code', 'message']
) is True
def test_should_build_configuration_using_given_file_when_is_provided(
self, mock_open):
expected_file_name = random_string(20)
mock_open.return_value = self.file_pointer
ConfigurationFactory.build(expected_file_name)
mock_open.assert_called_with(expected_file_name, 'r')
async def test_trigger_empty_from_loop(awx_client, pub: Client, sub: Client):
await sub.subscribe(awx_client.TOPICS.changes)
await asyncio.sleep(.2)
template_name = random_string()
await pub.publish(awx_client._params.topic_in, f'{template_name};{1}')
response = await sub.get(5)
no_template = {
'source': 'awx_api',
'error': NO_TEMPLATE_PATTERN.format(template_name)
}
assert json.loads(response) == no_template
def test_recipe_name(self):
""" Tests the name method. """
widget = RecipeNameWidget()
input_data = random_string()
for char in input_data:
QTest.keyPress(widget.widget, char)
QTest.keyRelease(widget.widget, char)
self.assertEqual(widget.name(), input_data)
def test_recipe_get_text(self):
""" Tests the get text method. """
widget = RecipeTextWidget()
input_data = [random_string(50) for _ in range(10)]
for line in input_data:
for char in line:
QTest.keyPress(widget.widget, char)
QTest.keyRelease(widget.widget, char)
QTest.keyPress(widget.widget, Qt.Key.Key_Enter)
QTest.keyRelease(widget.widget, Qt.Key.Key_Enter)
self.assertEqual(widget.get_text(), "\n".join(input_data) + "\n")
def alerta_service():
return random_string(10)
def alerta_api_key():
return random_string(30)
def awx_auth_token():
return random_string(30)
def influx_password():
return random_string(30)
async def test_get_not_existing_scenario(awx_client):
_filter = single_template_filter(random_string())
single = await awx_client.get_templates(_filter)
assert single == []
def test_should_throw_an_exception_when_structure_from_raw_input_is_not_valid(
self):
initial_time = random_string(5)
with self.assertRaises(ValidationException):
PaymentsConfigurationEntry('%s - 23:59 25 USD' % initial_time)
command = parse_command(message)
assert command == expected
@pytest.mark.parametrize('message', [
'/status awx Destroy test host 5',
'/status awx Scenario 1.5',
'/status awx "Scenario 1" 2 some other arguments',
])
def test_parse_err(message):
"""Testing of handling exceptions during parsing command arguments"""
with pytest.raises(CommandParsingError):
parse_command(message)
@pytest.mark.parametrize('target', ['', random_string()])
@pytest.mark.asyncio
async def test_bot_status_awx(patched_bot, sub: Client, chat_id, target):
await sub.subscribe(AWXApiSource.params().topic_in)
await asyncio.sleep(.05)
message_text = f'/status awx {target}'
await patched_bot.handle_status(
Message(text=message_text, chat=Chat(id=chat_id)))
data = await sub.get(.1)
assert data == f'{target};1'
def patched_message(text, chat_id):
resp_queue = Queue()
message = Message(text=text, chat=chat_id)
def test_should_raise_a_validation_exception_when_provided_value_is_not_valid(
self):
invalid_value = random_string(5)
with self.assertRaises(ValidationException):
DayTime(invalid_value)
