def test_failed_instance_creation_event(self, org, space, events_before):
step("Trigger failed instance creation")
with pytest.raises(AssertionError):
ServiceInstance.api_create_with_plan_name(
org.guid,
space.guid,
ServiceLabels.SCORING_ENGINE,
service_plan_name=ServicePlan.SIMPLE_ATK)
step(
"Retrieve latest events. Check there are two new events related to failed instance creation"
)
events_after = LatestEvent.api_get_latest_events(org_guid=org.guid)
assert len(events_after) == len(events_before) + 2
self._assert_event_is_correct(
events_after[1],
category=EventCategory.service_creation,
org_guid=org.guid,
message=EventMessage.create_service_started.format(
Urls.test_transfer_link))
self._assert_event_is_correct(
events_after[0],
category=EventCategory.service_creation,
org_guid=org.guid,
message=EventMessage.create_service_failed.format(
Urls.test_transfer_link))
def test_successful_instance_creation_event(self, context, org, space, events_before, test_data_urls):
step("Create example instance")
ServiceInstance.api_create_with_plan_name(context, org.guid, space.guid, ServiceLabels.ATK,
service_plan_name=ServicePlan.SIMPLE_ATK)
step("Retrieve latest events. Check there are two new events related to successful instance creation")
events_after = LatestEvent.api_get_latest_events(org_guid=org.guid)
assert len(events_after) == len(events_before) + 2
self._assert_event_is_correct(events_after[1], category=EventCategory.service_creation, org_guid=org.guid,
message=EventMessage.create_service_started.format(test_data_urls.test_transfer.url))
self._assert_event_is_correct(events_after[0], category=EventCategory.service_creation, org_guid=org.guid,
message=EventMessage.create_service_succeded)
def test_1_create_mongodb_clustered_instance(self, class_context, test_org, test_space):
"""
<b>Description:</b>
Check that mongodb instance can be created with plan clustered.
<b>Input data:</b>
1. Test organization.
<b>Expected results:</b>
Test passes if mongodb service instance is created.
<b>Steps:</b>
1. Create mongodb service instance with plan clustered.
2. Check that created service instance is present in service instance list.
"""
step("Create new mongodb clustered service")
self.__class__.mongodb_instance = ServiceInstance.api_create_with_plan_name(
context=class_context,
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=self.MONGODB_SERVICE_LABEL,
service_plan_name=ServicePlan.CLUSTERED
)
self.mongodb_instance.ensure_created()
step("Check that the mongodb clustered is on the instances list")
instances = ServiceInstance.api_get_list(space_guid=test_space.guid)
assert self.mongodb_instance in instances
def __init__(self, context, org_uuid, space_uuid, tap_http_client):
self.service_instance = ServiceInstance.api_create_with_plan_name(
context,
org_uuid,
space_uuid,
ServiceLabels.SEAHORSE,
name=generate_test_object_name(short=True,
prefix=ServiceLabels.SEAHORSE),
service_plan_name=ServicePlan.FREE)
self.service_instance.ensure_running()
self.seahorse_url = "{}-{}.{}".format(
self.service_instance.name.replace("_", "-"),
self.service_instance.guid, self.tap_domain)
self.seahorse_http_url = "https://{}".format(self.seahorse_url)
http_client_configuration = HttpClientConfiguration(
client_type=HttpClientType.NO_AUTH,
url="https://{}".format(self.seahorse_url),
username=self.username,
password=self.password)
self.http_client = HttpClientFactory.get(http_client_configuration)
self.http_client.session = tap_http_client.session
self._ensure_seahorse_accessible()
self._ensure_authorized()
self._ensure_wm_accessible()
self._ensure_sm_accessible()
self._ws = None
def test_0_create_mysql_clustered_service(self, class_context, test_org,
test_space):
"""
<b>Description:</b>
Check that mysql service instance can be created with plan clustered.
<b>Input data:</b>
1. test organization
<b>Expected results:</b>
Test passes if mysql service instance is successfully created and in state running.
<b>Steps:</b>
1. Get marketplace offering list.
2. Check that mysql offering is present in marketplace.
3. Create mysql service instance.
4. Check that created mysql service instance is in state running.
"""
marketplace = ServiceOffering.get_list()
self.__class__.k8s_service = next(
(s for s in marketplace if s.label == self.service_label), None)
assert self.k8s_service is not None, "{} not available".format(
self.service_label)
self.__class__.instance = ServiceInstance.api_create_with_plan_name(
class_context,
test_org.guid,
test_space.guid,
self.service_label,
service_plan_name=ServicePlan.CLUSTERED)
self.instance.ensure_running()
def instance(self, org_space):
instance = ServiceInstance.api_create_with_plan_name(
org_guid=org_space[0].guid,
space_guid=org_space[1].guid,
service_label=ServiceLabels.KAFKA,
service_plan_name=ServicePlan.SHARED)
return instance
def test_cannot_create_service_instance_with_name_of_an_existing_instance(
self):
existing_name = generate_test_object_name()
self.step("Create service instance")
instance = ServiceInstance.api_create_with_plan_name(
org_guid=TestData.test_org.guid,
space_guid=TestData.test_space.guid,
service_label=ServiceLabels.KAFKA,
name=existing_name,
service_plan_name=ServicePlan.SHARED)
service_list = ServiceInstance.api_get_list(
space_guid=TestData.test_space.guid)
self.step("Check that the instance was created")
self.assertIn(instance, service_list, "Instance was not created")
errors = []
for service_type in self.marketplace:
plan_guid = next(iter(service_type.service_plan_guids))
self.step("Try to create {} service instance".format(
service_type.label))
with self.assertRaises(UnexpectedResponseError) as e:
ServiceInstance.api_create(TestData.test_org.guid,
TestData.test_space.guid,
service_type.label,
existing_name,
service_plan_guid=plan_guid)
if e is None or e.exception.status != HttpStatus.CODE_CONFLICT:
errors.append(
"Service '{}' failed to respond with given error status.".
format(service_type.label))
assert_no_errors(errors)
self.assertUnorderedListEqual(
service_list,
ServiceInstance.api_get_list(space_guid=TestData.test_space.guid),
"Some new services were created")
def instance(self, request, test_org, test_space):
instance = ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.KAFKA,
service_plan_name=ServicePlan.SHARED)
request.addfinalizer(
lambda: fixtures.delete_or_not_found(instance.cleanup))
return instance
def kerberos_instance(self, class_context, request, test_org, test_space):
step("Create kerberos instance")
instance = ServiceInstance.api_create_with_plan_name(
context=class_context,
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.KERBEROS,
name=self.KERBEROS_INSTANCE_NAME,
service_plan_name=ServicePlan.SHARED)
return instance
def hdfs_instance(cls, request, test_org, test_space):
step("Create Hdfs encrypted instance.")
instance = ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.HDFS,
service_plan_name=ServicePlan.ENCRYPTED
)
request.addfinalizer(instance.cleanup)
return instance
def kerberos_instance(self, request, test_org, test_space):
step("Create kerberos instance")
instance = ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.KERBEROS,
name=self.KERBEROS_INSTANCE_NAME,
service_plan_name=ServicePlan.SHARED
)
request.addfinalizer(lambda: instance.cleanup())
return instance
def hive_instance(self, class_context, request, test_org, test_space):
step("Create hive instance")
instance = ServiceInstance.api_create_with_plan_name(
context=class_context,
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.HIVE,
name=generate_test_object_name(),
service_plan_name=ServicePlan.SHARED
)
return instance
def test_instance(request, test_org, test_space):
step("Create test instance")
instance = ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.MONGO_DB,
service_plan_name=ServicePlan.FREE)
def fin():
fixtures.delete_or_not_found(instance.cleanup)
request.addfinalizer(fin)
return instance
def setup_kafka_zookeeper_hdfs_instances(self, request, test_org, test_space):
step("Create instances for kafka, zookeeper, hdfs and kerberos")
kafka = ServiceInstance.api_create_with_plan_name(org_guid=test_org.guid, space_guid=test_space.guid,
service_label=ServiceLabels.KAFKA,
name=self.KAFKA_INSTANCE_NAME,
service_plan_name=ServicePlan.SHARED)
zookeeper = ServiceInstance.api_create_with_plan_name(org_guid=test_org.guid, space_guid=test_space.guid,
service_label=ServiceLabels.ZOOKEEPER,
name=self.ZOOKEEPER_INSTANCE_NAME,
service_plan_name=ServicePlan.SHARED)
hdfs = ServiceInstance.api_create_with_plan_name(org_guid=test_org.guid, space_guid=test_space.guid,
service_label=ServiceLabels.HDFS,
name=self.HDFS_INSTANCE_NAME,
service_plan_name=ServicePlan.SHARED)
kerberos = ServiceInstance.api_create_with_plan_name(org_guid=test_org.guid, space_guid=test_space.guid,
service_label=ServiceLabels.KERBEROS,
name=self.KERBEROS_INSTANCE_NAME,
service_plan_name=ServicePlan.SHARED)
instances = [kafka, zookeeper, hdfs, kerberos]
request.addfinalizer(lambda: fixtures.tear_down_test_objects(instances))
def test_0_create_gateway_instance(self):
self.step("Create gateway instance")
gateway_instance = ServiceInstance.api_create_with_plan_name(
TestData.test_org.guid,
TestData.test_space.guid,
ServiceLabels.GATEWAY,
service_plan_name=ServicePlan.SIMPLE_ATK,
client=self.space_developer_client)
validator = ApplicationStackValidator(gateway_instance)
validator.validate(expected_bindings=[ServiceLabels.KAFKA])
self.__class__.gateway_instance = gateway_instance
self.__class__.gateway_app = validator.application
self.__class__.kafka_instance = validator.application_bindings[
ServiceLabels.KAFKA]
def test_1_create_instance(self, test_org, test_space, space_users_clients, class_context):
self.__class__.client = space_users_clients["developer"]
step("Create scoring engine instance")
self.__class__.instance = ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.SCORING_ENGINE,
service_plan_name=ServicePlan.SIMPLE_ATK,
params={"uri": self.atk_model_uri},
client=self.client,
context=class_context
)
step("Check instance is on the instance list")
instances_list = ServiceInstance.api_get_list(test_space.guid, client=self.client)
assert self.instance in instances_list, "Scoring Engine was not found on the instance list"
def test_0_create_atk_instance(self, test_org, test_space, add_admin_to_test_org):
step("Check that atk service is available in Marketplace")
marketplace = ServiceType.api_get_list_from_marketplace(test_space.guid)
atk_service = next((s for s in marketplace if s.label == ServiceLabels.ATK), None)
assert atk_service is not None, "No atk service found in marketplace."
step("Create atk service instance")
atk_instance_name = generate_test_object_name()
atk_instance = ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.ATK,
name=atk_instance_name,
service_plan_name=ServicePlan.SIMPLE_ATK
)
validator = ApplicationStackValidator(atk_instance)
validator.validate()
self.__class__.atk_url = validator.application.urls[0]
def test_0_create_kerberos_instance(self, class_context, test_org,
test_space):
step("Check kerberos in marketplace")
service_label = ServiceLabels.KERBEROS
marketplace = ServiceOffering.get_list()
kerberos = next(
(service
for service in marketplace if service.label == service_label),
None)
assert kerberos is not None, "{} not available".format(service_label)
step("Create instance of kerberos")
self.__class__.kerberos_instance = ServiceInstance.api_create_with_plan_name(
context=class_context,
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=service_label,
service_plan_name=ServicePlan.SHARED)
self.kerberos_instance.ensure_created()
step("Check that the kerberos is on the instances list")
instances = ServiceInstance.api_get_list(space_guid=test_space.guid)
assert self.kerberos_instance in instances
def __init__(self, org_uuid, space_uuid, tap_http_client):
self.service_instance = ServiceInstance.api_create_with_plan_name(
org_uuid, space_uuid,
ServiceLabels.SEAHORSE,
service_plan_name=ServicePlan.FREE
)
self.service_instance.ensure_created()
self.seahorse_url = "{}-{}.{}".format(self.service_instance.name, self.service_instance.guid, self.tap_domain)
http_client_configuration = HttpClientConfiguration(
client_type=HttpClientType.SERVICE_TOOL,
url="https://{}".format(self.seahorse_url),
username=self.username,
password=self.password
)
self.http_client = HttpClientFactory.get(http_client_configuration)
self.http_client.session = tap_http_client.session
self._ensure_seahorse_accessible()
self._ensure_wm_accessible()
self._ensure_sm_accessible()
self._ws = None
def test_mqtt_demo(self, test_org, test_space, login_to_cf, class_context):
step("Clone repository")
mqtt_demo_sources = AppSources.from_github(
repo_name=self.REPO_NAME,
repo_owner=self.SOURCES_OWNER,
gh_auth=config.github_credentials())
step("Compile the sources")
mqtt_demo_sources.compile_mvn()
step("Create required service instances.")
ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.INFLUX_DB,
name=self.INFLUX_INSTANCE_NAME,
service_plan_name=ServicePlan.FREE)
ServiceInstance.api_create_with_plan_name(
org_guid=test_org.guid,
space_guid=test_space.guid,
service_label=ServiceLabels.MOSQUITTO,
name=self.MQTT_INSTANCE_NAME,
service_plan_name=ServicePlan.FREE)
step("Push mqtt app to cf")
mqtt_demo_app = Application.push(
class_context,
source_directory=mqtt_demo_sources.path,
space_guid=test_space.guid)
step("Retrieve credentials for mqtt service instance")
self.credentials = mqtt_demo_app.get_credentials(
service_name=ServiceLabels.MOSQUITTO)
mqtt_port = self.credentials.get("port")
assert mqtt_port is not None
mqtt_username = self.credentials.get("username")
assert mqtt_username is not None
mqtt_pwd = self.credentials.get("password")
assert mqtt_pwd is not None
step("Connect to mqtt app with mqtt client")
mqtt_client = mqtt.Client()
mqtt_client.username_pw_set(mqtt_username, mqtt_pwd)
mqtt_client.tls_set(self.SERVER_CERTIFICATE,
tls_version=ssl.PROTOCOL_TLSv1_2)
mqtt_server_address = mqtt_demo_app.urls[0]
mqtt_client.connect(mqtt_server_address, int(mqtt_port), 20)
with open(self.TEST_DATA_FILE) as f:
expected_data = f.read().split("\n")
step("Start reading logs")
logs = subprocess.Popen(["cf", "logs", "mqtt-demo"],
stdout=subprocess.PIPE)
time.sleep(5)
step("Send {0} data vectors to {1}:{2} on topic {3}".format(
len(expected_data), mqtt_server_address, mqtt_port,
self.MQTT_TOPIC_NAME))
for line in expected_data:
mqtt_client.publish(self.MQTT_TOPIC_NAME, line)
step("Stop reading logs. Retrieve vectors from log content.")
grep = subprocess.Popen(["grep", "message:"],
stdin=logs.stdout,
stdout=subprocess.PIPE)
logs.stdout.close()
time.sleep(50)
os.kill(logs.pid, signal.SIGTERM)
cut = subprocess.Popen("cut -d ':' -f7 ",
stdin=grep.stdout,
stdout=subprocess.PIPE,
shell=True)
grep.stdout.close()
step("Check that logs display all the vectors sent")
log_result = cut.communicate()[0].decode().split("\n")
log_result = [
item.strip() for item in log_result if item not in (" ", "")
]
self.maxDiff = None # allows for full diff to be displayed
assert log_result == expected_data, "Data in logs do not match sent data"
