def created_subscription(step, server_id):
world.tenant_id = TENANT_ID
world.server_id = server_id
world.headers = HEADERS
world.rule_body = Rule_Utils.create_scale_specific_rule()
# Create the rule in Policy Manager
req = api_utils.create_rule(tenant_id=world.tenant_id, server_id=world.server_id, body=world.rule_body)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
# Save the Rule ID to obtain the Rule information after
world.rule_id = req.json()[RULE_ID]
req = api_utils.create_subscription(
tenant_id=world.tenant_id,
server_id=world.server_id,
rule_id=world.rule_id,
url=RULE_URL_DEFAULT,
headers=world.headers,
)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
print req.content
world.subscription_id = req.json()[SUBSCRIPTION_ID]
def created_subscription(context, server_id):
context.tenant_id = TENANT_ID
context.server_id = server_id
context.headers = HEADERS
context.rule_body = Rule_Utils.create_scale_specific_rule()
# Create the rule in Policy Manager
req = api_utils.create_rule(tenant_id=context.tenant_id,
server_id=context.server_id,
body=context.rule_body)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
# Save the Rule ID to obtain the Rule information after
context.rule_id = req.json()[RULE_ID]
req = api_utils.create_subscription(tenant_id=context.tenant_id,
server_id=context.server_id,
rule_id=context.rule_id,
url=RULE_URL_DEFAULT,
headers=context.headers)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
print(req.content)
context.subscription_id = req.json()[SUBSCRIPTION_ID]
def assert_rule_saved(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = world.req.json()
assert_equals(response[SERVER_ID], world.server_id, INCORRECT_SERVER_ID.format(world.server_id,
response[SERVER_ID]))
assert_in(RULE_ID, response.keys(), INVALID_JSON.format(response))
def assert_rule_saved(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = world.req.json()
assert_equals(response[SERVER_ID], world.server_id, INCORRECT_SERVER_ID.format(world.server_id,
response[SERVER_ID]))
assert_in(RULE_ID, response.keys(), INVALID_JSON.format(response))
def given_a_group1_of_servers_in_a_tenant(step, number_servers):
world.number_servers = int(number_servers)
world.servers_body = []
for x in range(world.number_servers):
world.rules = []
server_id = Utils.id_generator(size=6)
number_rules = random.randint(1, 5)
for rule in range(number_rules):
rule_body = Rule_Utils.create_scale_specific_rule()
req = api_utils.create_rule(world.tenant_id,
server_id,
body=rule_body)
assert_true(req.ok,
HTTP_CODE_NOT_OK.format(req.status_code, req.content))
rule_id = req.json()[RULE_ID]
world.rules.append(
Rule_Utils.create_rule_body(action=None,
rule_id=rule_id,
condition=None,
name=rule_body['name']))
server_dict = {SERVER_ID: server_id, RULES: world.rules}
world.servers_body.append(server_dict)
def assert_subscription_is_deleted(context):
assert_true(context.req.ok, HTTP_CODE_NOT_OK.format(context.req.status_code, context.req.content))
req = api_utils.retrieve_subscription(tenant_id=context.tenant_id, server_id=context.server_id,
subscription_id=context.subscription_id, headers=context.headers)
Utils.assert_error_code_error(response=req, expected_error_code='404',
expected_fault_element=ITEM_NOT_FOUND_ERROR)
def then_i_obtain_zero_results(step):
assert_true(
world.req.ok,
HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
assert_equals(response[SERVERS], [])
def then_i_obtain_the_server_list(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
for results in world.servers_body:
assert_in(results, response[SERVERS])
Utils.delete_all_rules_from_tenant()
def then_i_obtain_the_server_list(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
for results in world.servers_body:
assert_in(results, response[SERVERS])
Utils.delete_all_rules_from_tenant()
def assert_rule_is_deleted(context):
assert_true(context.req.ok, HTTP_CODE_NOT_OK.format(context.req.status_code, context.req.content))
req = api_utils.retrieve_rule(tenant_id=context.tenant_id, server_id=context.server_id, rule_id=context.rule_id,
headers=context.headers)
assert_equals(req.status_code, 404, ERROR_CODE_ERROR.format(req.status_code, 404))
def assert_subscription_created(context):
assert_true(
context.req.ok,
HTTP_CODE_NOT_OK.format(context.req.status_code, context.req.content))
response = Utils.assert_json_format(context.req)
assert_equals(response[SERVER_ID], context.server_id)
assert_in(SUBSCRIPTION_ID, response.keys())
def assert_subscription_information(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
assert_equals(response[RULE_URL], RULE_URL_DEFAULT)
assert_equals(response[SERVER_ID], world.server_id)
assert_equals(response[SUBSCRIPTION_ID], world.subscription_id)
assert_equals(response[RULE_ID], world.rule_id)
def assert_rule_information(step):
assert_true(
world.req.ok,
HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
Rule_Utils.assert_rule_information(response=response,
rule_id=world.rule_id,
body=world.rule_body)
def assert_subscription_information(context):
assert_true(
context.req.ok,
HTTP_CODE_NOT_OK.format(context.req.status_code, context.req.content))
response = Utils.assert_json_format(context.req)
assert_equals(response[RULE_URL], RULE_URL_DEFAULT)
assert_equals(response[SERVER_ID], context.server_id)
assert_equals(response[SUBSCRIPTION_ID], context.subscription_id)
assert_equals(response[RULE_ID], context.rule_id)
def given_group1_of_rules_created_in_group2(step, number_rules, server_id):
world.server_id = server_id
world.number_rules = int(number_rules)
for x in range(world.number_rules):
rule_body = Rule_Utils.create_notify_specific_rule()
req = api_utils.create_rule(world.tenant_id, world.server_id, body=rule_body)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
rule_id = req.json()[RULE_ID]
world.rules.append(rule_body)
def given_group1_of_rules_created_in_group2(step, number_rules, server_id):
world.server_id = server_id
world.number_rules = int(number_rules)
for x in range(world.number_rules):
rule_body = Rule_Utils.create_notify_specific_rule()
req = api_utils.create_rule(world.tenant_id, world.server_id, body=rule_body)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
rule_id = req.json()[RULE_ID]
world.rules.append(rule_body)
def assert_rule_information(context):
assert_true(
context.req.ok,
HTTP_CODE_NOT_OK.format(context.req.status_code, context.req.content))
response = Utils.assert_json_format(context.req)
Rule_Utils.assert_rule_information(response=response,
rule_id=context.rule_id,
body=context.rule_body)
def assert_subscription_is_deleted(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
req = api_utils.retrieve_subscription(
tenant_id=world.tenant_id,
server_id=world.server_id,
subscription_id=world.subscription_id,
headers=world.headers,
)
Utils.assert_error_code_error(response=req, expected_error_code="404", expected_fault_element=ITEM_NOT_FOUND_ERROR)
def assert_rule_is_deleted(step):
assert_true(
world.req.ok,
HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
req = api_utils.retrieve_rule(tenant_id=world.tenant_id,
server_id=world.server_id,
rule_id=world.rule_id,
headers=world.headers)
assert_equals(req.status_code, 404,
ERROR_CODE_ERROR.format(req.status_code, 404))
def created_rule(step, server_id):
world.server_id = server_id
world.rule_body = Rule_Utils.create_scale_specific_rule()
#Create the rule in Policy Manager
req = api_utils.create_rule(tenant_id=world.tenant_id, server_id=world.server_id, body=world.rule_body)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
#Save the Rule ID to obtain the Rule information after
world.rule_id = req.json()[RULE_ID]
def created_rule(step, server_id):
world.server_id = server_id
world.rule_body = Rule_Utils.create_scale_specific_rule()
#Create the rule in Policy Manager
req = api_utils.create_rule(tenant_id=world.tenant_id, server_id=world.server_id, body=world.rule_body)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
#Save the Rule ID to obtain the Rule information after
world.rule_id = req.json()[RULE_ID]
def assert_subscription_is_deleted(context):
assert_true(
context.req.ok,
HTTP_CODE_NOT_OK.format(context.req.status_code, context.req.content))
req = api_utils.retrieve_subscription(
tenant_id=context.tenant_id,
server_id=context.server_id,
subscription_id=context.subscription_id,
headers=context.headers)
Utils.assert_error_code_error(response=req,
expected_error_code='404',
expected_fault_element=ITEM_NOT_FOUND_ERROR)
def create_rule(api_utils, tenant_id=TENANT_ID, server_id=None, rule_body=None, headers=HEADERS):
"""Method to subscribe a server to a specific rule not created.
:param server_id: Server unique identifier
:param headers: HTTP headers for the requests including authentication
:param tenant_id: Tenant unique identifier
:returns subscription_id: Subscription unique identifier
"""
#Create the rule in Policy Manager
req = api_utils.create_rule(tenant_id=tenant_id, server_id=server_id, body=rule_body, headers=headers)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code))
rule_id = req.json()[RULE_ID]
return rule_id
def create_rule(api_utils, tenant_id=TENANT_ID, server_id=None, rule_body=None, headers=HEADERS):
"""Method to subscribe a server to a specific rule not created.
:param server_id: Server unique identifier
:param headers: HTTP headers for the requests including authentication
:param tenant_id: Tenant unique identifier
:returns subscription_id: Subscription unique identifier
"""
# Create the rule in Policy Manager
req = api_utils.create_rule(tenant_id=tenant_id, server_id=server_id, body=rule_body, headers=headers)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code))
rule_id = req.json()[RULE_ID]
return rule_id
def given_a_group1_of_servers_in_a_tenant(step, number_servers):
world.number_servers = int(number_servers)
world.servers_body = []
for x in range(world.number_servers):
world.rules = []
server_id = Utils.id_generator(size=6)
number_rules = random.randint(1, 5)
for rule in range(number_rules):
rule_body = Rule_Utils.create_scale_specific_rule()
req = api_utils.create_rule(world.tenant_id, server_id, body=rule_body)
assert_true(req.ok, HTTP_CODE_NOT_OK.format(req.status_code, req.content))
rule_id = req.json()[RULE_ID]
world.rules.append(Rule_Utils.create_rule_body(action=None, rule_id=rule_id, condition=None,
name=rule_body['name']))
server_dict = {SERVER_ID: server_id,
RULES: world.rules}
world.servers_body.append(server_dict)
def assert_rule_information(context):
assert_true(context.req.ok, HTTP_CODE_NOT_OK.format(context.req.status_code, context.req.content))
response = Utils.assert_json_format(context.req)
Rule_Utils.assert_rule_information(response=response, rule_id=context.rule_id, body=context.rule_body)
def then_i_obtain_zero_results(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
assert_equals(response[SERVERS], [])
def assert_rule_information(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
Rule_Utils.assert_rule_information(response=response, rule_id=world.rule_id, body=world.rule_body)
def assert_subscription_created(step):
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code, world.req.content))
response = Utils.assert_json_format(world.req)
assert_equals(response[SERVER_ID], world.server_id)
assert_in(SUBSCRIPTION_ID, response.keys())
def then_the_context_is_updated(step):
print world.req.content
assert_true(world.req.ok, HTTP_CODE_NOT_OK.format(world.req.status_code))
