def test_external_tools_should_have_no_url(self):
tools = [t for t in self.tools_list if not t.should_have_url]
errors = []
for tool in tools:
if tool.url is not None:
errors.append("Tool '{}' has URL specified.".format(tool.name))
assert_no_errors(errors)
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 test_add_space(self):
step("Try to add new space using every client type.")
errors = []
for client in self.user_clients:
try:
space_list = Space.api_get_list_in_org(
org_guid=TestData.test_org.guid)
if self.SPACE_PERMISSION[client]:
new_space = Space.api_create(
TestData.test_org, client=self.user_clients[client])
space_list = Space.api_get_list()
assert new_space in space_list, "Space was not created."
else:
assert_raises_http_exception(
HttpStatus.CODE_FORBIDDEN,
HttpStatus.MSG_FORBIDDEN,
Space.api_create,
TestData.test_org,
client=self.user_clients[client])
assert Space.api_get_list_in_org(
org_guid=TestData.test_org.guid
) == space_list, "Space was created"
except Exception as e:
errors.append(e)
assert_no_errors(errors)
def test_service_instances(self):
tested_service_types = [st for st in self.marketplace_services if st.label in self.TESTED_APP_NAMES]
errors = []
for service_type in tested_service_types:
for plan in service_type.service_plans:
try:
self._create_instance(plan, service_type)
except Exception as e:
errors.append(e)
assert_no_errors(errors)
def test_create_gearpump_service_instance_and_keys(self):
label = ServiceLabels.GEARPUMP
gearpump = next(s for s in self.marketplace if s.label == label)
errors = []
for plan in gearpump.service_plans:
try:
self._create_and_delete_service_instance_and_keys(
TestData.test_org.guid, TestData.test_space.guid, label,
plan["guid"])
except Exception as e:
errors.append(e)
assert_no_errors(errors)
def test_external_tools_should_be_available(self):
tools = [
t for t in self.tools_list
if t.should_have_url and t.url and t.available
]
errors = []
for tool in tools:
try:
tool.send_request()
except UnexpectedResponseError:
errors.append(
"Tool '{}' failed to respond with OK status.".format(
tool.name))
assert_no_errors(errors)
def test_create_h2o_service_instance_and_keys(self):
label = ServiceLabels.H2O
h2o = next((s for s in self.marketplace if s.label == label), None)
if h2o is None:
self.skipTest("h2o is not available in Marketplace")
errors = []
for plan in h2o.service_plans:
try:
self._create_and_delete_service_instance_and_keys(
TestData.test_org.guid, TestData.test_space.guid, label,
plan["guid"])
except Exception as e:
errors.append(e)
assert_no_errors(errors)
def test_apps_have_the_same_details_in_cf_and_on_platform(self):
only_expected_platform_apps = {
app
for app in self.platform_apps
if app.name in self.expected_app_names
}
errors = []
for app in only_expected_platform_apps:
self.step(
"Check that details of app {} are the same in cf and on the Platform"
.format(app.name))
cf_details = app.cf_api_get_summary()
platform_details = app.api_get_summary()
if cf_details != platform_details:
errors.append("Different details for {}".format(app.name))
assert_no_errors(errors)
def test_create_and_delete_service_instance_and_keys(self):
errors = []
for service_type in self.marketplace:
if service_type.label in self.SERVICES_TESTED_SEPARATELY:
continue
for plan in service_type.service_plans:
if ParametrizedService.is_parametrized(
label=service_type.label, plan_name=plan["name"]):
continue
try:
self._create_and_delete_service_instance_and_keys(
TestData.test_org.guid, TestData.test_space.guid,
service_type.label, plan["guid"])
except Exception as e:
errors.append(e)
assert_no_errors(errors)
def test_spring_services_dont_expose_sensitive_endpoints(self):
SENSITIVE_ENDPOINTS = [
"actuator",
"autoconfig",
"beans",
"configprops",
"docs",
"dump",
"env",
"flyway",
"info",
"liquidbase",
"logfile",
"metrics",
"mappings",
"shutdown",
"trace",
]
errors = []
for url in [
a.urls[0] for a in self.platform_apps
if a.name in self.expected_app_names -
self.SENSITIVE_ENDPOINTS_EXCLUDED_APPS
]:
client = HttpClientFactory.get(
ApplicationConfigurationProvider.get(url))
app_name = url.split(".")[0]
try:
client.request(method=HttpMethod.GET, path="health")
except UnexpectedResponseError:
logger.info("Not checking {} service".format(app_name))
continue
self.step("Check that the sensitive endpoints are not enabled.")
enabled_endpoints = []
for endpoint in SENSITIVE_ENDPOINTS:
try:
client.request(method=HttpMethod.GET,
path="{}".format(endpoint))
except UnexpectedResponseError:
continue
else:
enabled_endpoints.append(endpoint)
if enabled_endpoints:
errors.append("{} exposes {}".format(app_name,
enabled_endpoints))
assert_no_errors(errors)
def test_cannot_create_instance_as_non_space_developer(self):
test_clients = {
"space_auditor": self.space_auditor_client,
"space_manager": self.space_manager_client
}
errors = []
for service_type, (name, client) in itertools.product(
self.marketplace, test_clients.items()):
for plan in service_type.service_plans:
with self.assertRaises(UnexpectedResponseError) as e:
ServiceInstance.api_create(TestData.test_org.guid,
TestData.test_space.guid,
service_type.label,
service_plan_guid=plan["guid"],
client=client)
if e is None or e.exception.status != HttpStatus.CODE_FORBIDDEN:
errors.append(
"Service '{}' failed to respond with given error status."
.format(service_type.label))
assert_no_errors(errors)
def test_delete_space(self):
step("Try to delete space using every client type.")
errors = []
for client in self.user_clients:
try:
new_space = Space.api_create(TestData.test_org)
if self.SPACE_PERMISSION[client]:
new_space.api_delete(client=self.user_clients[client])
assert_not_in_with_retry(new_space, Space.api_get_list)
else:
assert_raises_http_exception(
HttpStatus.CODE_FORBIDDEN,
HttpStatus.MSG_FORBIDDEN,
new_space.api_delete,
client=self.user_clients[client])
space_list = Space.api_get_list_in_org(
org_guid=TestData.test_org.guid)
assert new_space in space_list, "Space was not deleted"
except Exception as e:
errors.append(e)
assert_no_errors(errors)
