Пример #1
0
def get_logged_client(username=None, password=None):
    console_client = HttpClientFactory.get(
        ConsoleConfigurationProvider.get(username, password))
    client = HttpClientFactory.get(
        ServiceToolConfigurationProvider.get(url=config.hue_url))
    client.session = console_client.session
    client.request(method=HttpMethod.GET, path="", msg="login")
    return client
 def test_get_should_create_only_one_instance(self):
     # given
     configuration = self._get_configuration(HttpClientType.APPLICATION)
     self.assertNotIn(configuration, HttpClientFactory._INSTANCES,
                      "Invalid instance reference.")
     # when
     HttpClientFactory.get(configuration)
     HttpClientFactory.get(configuration)
     # then
     self.assertIn(configuration, HttpClientFactory._INSTANCES,
                   "Missing instance reference.")
     self.assertEqual(1, len(HttpClientFactory._INSTANCES),
                      "Invalid number of instances.")
 def test_app_endpoints(self):
     step("Retrieve apps, and services on the Platform")
     tested_apps = {
         a
         for a in self.platform_apps if a.name in self.TESTED_APP_NAMES
     }
     step("Send GET /health request to apps: {}".format(
         self.TESTED_APP_NAMES))
     for app in tested_apps:
         step("Testing app with name: {}".format(app.name))
         HttpClientFactory.get(
             ApplicationConfigurationProvider.get(app.urls[0])).request(
                 method=HttpMethod.GET, path="health")
Пример #4
0
 def change_password(self, old_password, new_password):
     data = {
         "oldPassword": old_password,
         "password": new_password,
     }
     HttpClientFactory.get(ConsoleConfigurationProvider.get(
         self._username, old_password
     )).request(
         method=HttpMethod.PUT,
         path="rest/users/current/password",
         data=json.dumps(data),
         headers={"Accept": "application/json", "Content-Type": "application/json;charset=UTF-8"},
         msg="Change password"
     )
def k8s_broker_update_secret(org_guid,
                             key_id,
                             username_b64=None,
                             password_b64=None):
    """PUT /rest/kubernetes/{org_id}/secret/{key}"""
    body = {
        "data": {},
        "metadata": {
            "name": key_id,
            "labels": {
                "managed_by": "TAP"
            }
        }
    }
    if username_b64 is not None:
        body["data"]["username"] = username_b64
    if password_b64 is not None:
        body["data"]["password"] = password_b64

    return HttpClientFactory.get(
        CloudFoundryConfigurationProvider.get(
            url=config.kubernetes_broker_url)).request(
                method=HttpMethod.PUT,
                body=body,
                path="rest/kubernetes/{org_guid}/secret/{key_id}",
                path_params={
                    'org_guid': org_guid,
                    'key_id': key_id
                },
                msg="K8S BROKER: update secret")
def k8s_broker_create_secret(org_guid, key_id, username_b64, password_b64):
    """POST /rest/kubernetes/{org_id}/secret/{key}"""
    body = {
        "apiVersion": "v1",
        "data": {
            "username": username_b64,
            "password": password_b64
        },
        "kind": "Secret",
        "metadata": {
            "name": key_id,
            "labels": {
                "managed_by": "TAP"
            }
        }
    }
    return HttpClientFactory.get(
        CloudFoundryConfigurationProvider.get(
            url=config.kubernetes_broker_url)).request(
                method=HttpMethod.POST,
                body=body,
                path="rest/kubernetes/{org_guid}/secret/{key_id}",
                path_params={
                    'org_guid': org_guid,
                    'key_id': key_id
                },
                msg="K8S BROKER: create secret")
def app_broker_bind_service_instance(instance_guid, application_guid):
    """PUT /v$/service_instances/:instanceId/service_bindings/:app_guid"""
    return HttpClientFactory.get(BrokerConfigurationProvider.get(TapComponent.application_broker)).request(
        method=HttpMethod.PUT,
        path="service_instances/{}/service_bindings/{}".format(instance_guid, application_guid),
        msg="APP BROKER: bind service instance to app",
    )
    def test_6_add_collection(self):
        """
        <b>Description:</b>
        Check that new collections and documents can be added.

        <b>Input data:</b>
        No input data.

        <b>Expected results:</b>
        Test passes if new collection can be created and populated with new documents.

        <b>Steps:</b>
        1. Create new collection.
        2. Add new documents to the created collection.
        3. Check that collection was created and contains added documents.
        """
        client = HttpClientFactory.get(ServiceToolConfigurationProvider.get(url=self.mongodb_app.urls[0]))
        step("Create test collection")
        client.request(HttpMethod.POST, path="collections", headers=self.JSON_HEADERS,
                       body={"new_collection": self.TEST_COLLECTION_NAME})
        step("Add documents to test collection")
        client.request(HttpMethod.POST, path="collections/{}/documents".format(self.TEST_COLLECTION_NAME),
                       headers=self.JSON_HEADERS, body={"data": self.TEST_DATA})
        step("Check collection was created properly")
        document = client.request(HttpMethod.GET, path="collections/{}/documents".format(self.TEST_COLLECTION_NAME),
                                  headers=self.JSON_HEADERS)["rows"][0]
        assert all([x in document.items() for x in self.TEST_DATA.items()]),\
            "Document: {}, expected: {}".format(document, self.TEST_DATA)
    def test_1_send_message_to_gateway_instance(self, test_org_user_client):
        """
        <b>Description:</b>
        Check that it's possible to send messages to gateway instance.

        <b>Input data:</b>
        1. gateway app

        <b>Expected results:</b>
        Test passes when message is sent to gateway instance without errors.

        <b>Steps:</b>
        1. Expose service instance url.
        2. Send message to gateway instance.
        3. Check that no error is raised.
        """
        step("Expose service instance url")
        urls = ServiceInstance.expose_urls(service_id=self.gateway_instance.id,
                                           client=test_org_user_client)
        ServiceInstance.ensure_responding(url=urls[0])
        step("Retrieve oauth token")
        http_client = HttpClientFactory.get(ServiceConfigurationProvider.get())
        token = http_client._auth._token_header
        step("Check communication with gateway instance")
        header = {"Authorization": "{}".format(token)}
        ws_url = "{}/ws".format(urls[0].replace("http", WebsocketClient.WS))
        try:
            ws = WebsocketClient(ws_url, headers=header)
            ws.send("test")
            ws.close()
        except Exception as e:
            raise AssertionError(str(e))
def app_broker_get_catalog():
    """GET /v$/catalog"""
    return HttpClientFactory.get(BrokerConfigurationProvider.get(TapComponent.application_broker)).request(
        method=HttpMethod.GET,
        path="catalog",
        msg="APP BROKER: get catalog"
    )
def app_broker_delete_service_instance(instance_guid):
    """DELETE /v$/service_instances/:instanceId"""
    return HttpClientFactory.get(BrokerConfigurationProvider.get(TapComponent.application_broker)).request(
        method=HttpMethod.DELETE,
        path="service_instances/{}".format(instance_guid),
        msg="APP BROKER: delete service instance",
    )
Пример #12
0
def test_push_db_app_and_check_response(sample_db_app):
    """
    <b>Description:</b>
    Checks if application pushed to the platform with postgres or mysql database service bound work.

    <b>Input data:</b>
    1. Application names.
    2. Application gzip paths.
    3. Application manifest paths.

    <b>Expected results:</b>
    Test passes when application with postgres or mysql database service bound are in RUNNING state and returns OK
    status to HTTP GET request.

    <b>Steps:</b>
    1. Create HTTP client.
    2. Send GET request with the client.
    3. Verify response is not None and response status code equals 200.
    """
    client = HttpClientFactory.get(
        ApplicationConfigurationProvider.get(sample_db_app.urls[0]))
    response = client.request(method=HttpMethod.GET,
                              path="",
                              timeout=10,
                              raw_response=True)
    assert response is not None
    assert response.status_code == 200
Пример #13
0
def test_push_sample_app_and_check_response(sample_app):
    """
    <b>Description:</b>
    Checks if sample python and java applications pushed to the platform work.

    <b>Input data:</b>
    1. Application names.
    2. Application gzip paths.
    3. Application manifest paths.

    <b>Expected results:</b>
    Test passes when python and java applications are in RUNNING state and return OK status to HTTP GET request.

    <b>Steps:</b>
    1. Create HTTP client.
    2. Send GET request with the client.
    3. Verify response is not None and response status code equals 200.
    """
    client = HttpClientFactory.get(
        ApplicationConfigurationProvider.get(sample_app.urls[0]))
    step("Check response for HTTP GET to the endpoint")
    response = client.request(method=HttpMethod.GET,
                              path="",
                              timeout=10,
                              raw_response=True)
    assert response is not None
    assert response.status_code == 200
Пример #14
0
    def test_1_create_and_get_table_content(self, dataset_target_uri, expected_transfer_content):
        """
        <b>Description:</b>
        Check that table can be created in hive and content can be retrieved from it.

        <b>Input data:</b>
        1. hdfs hive demo application

        <b>Expected results:</b>
        Test passes when table is created using hive and data can be retrieved from it.

        <b>Steps:</b>
        1. Create hdfs hive client.
        2. Create table.
        3. Retrieve content from table.
        4. Check that retrieved content is as expected.
        """
        self.__class__.hive_client = HttpClientFactory.get(
            CloudFoundryConfigurationProvider.get(url="http://{}/rest/hive".format(self.hdfs_reader_app.urls[0])))
        dir_path = dataset_target_uri[:dataset_target_uri.rfind("/")]
        step("Create hive table with csv data")
        self.hive_client.request(method=HttpMethod.POST, path=self.TABLE_NAME,
                                 params={"fullHdfsDirPath": dir_path, "headerFilePath": dataset_target_uri})

        step("Get hive table content")
        hive_table_content = self.hive_client.request(method=HttpMethod.GET, path=self.TABLE_NAME)
        hive_table_content = [i.strip().split(" ") for i in hive_table_content.split("\n") if i]
        step("Check both are the same")
        assert hive_table_content == expected_transfer_content
Пример #15
0
    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
Пример #16
0
def demiurge_create_cluster(cluster_name):
    """PUT /clusters/{cluster_name}"""
    return HttpClientFactory.get(
        BrokerConfigurationProvider.get(TapComponent.demiurge)).request(
            method=HttpMethod.PUT,
            path="clusters/{}".format(cluster_name),
            msg="DEMIURGE: create cluster")
 def _assertHttpClientInstance(self, client_type, auth: ClientAuthBase):
     configuration = self._get_configuration(client_type)
     client = HttpClientFactory.get(configuration)
     self.assertIsInstance(client, HttpClient, "Invalid client class.")
     self.assertIsInstance(client._auth, auth, "Invalid auth class.")
     self.assertIn(configuration, HttpClientFactory._INSTANCES,
                   "Missing instance reference.")
Пример #18
0
    def test_8_space_shuttle_anomaly_detection(self,
                                               space_shuttle_application):
        """
        <b>Description:</b>
        Checks if space-shuttle-demo application anomalies are detected correctly.

        <b>Input data:</b>
        1. space-shuttle-demo application
        2. space-shuttle client

        <b>Expected results:</b>
        Anomalies are detected correctly.

        <b>Steps:</b>
        1. Post samples.
        2. Verify the anomalies.
        """
        step('Check if anomalies are detected')
        client = HttpClientFactory.get(
            ApplicationConfigurationProvider.get(
                url=space_shuttle_application.urls[0]))
        sample_data = client.request(method=HttpMethod.GET,
                                     path="rest/space-shuttle/chart",
                                     params={
                                         "groupBy": "1m",
                                         "since": "1h"
                                     })
        assert len(sample_data) > 0
Пример #19
0
def demiurge_get_clusters():
    """GET /clusters"""
    return HttpClientFactory.get(
        BrokerConfigurationProvider.get(TapComponent.demiurge)).request(
            method=HttpMethod.GET,
            path="clusters",
            msg="DEMIURGE: get list of clusters")
Пример #20
0
def k8s_broker_delete_secret(org_guid, key_id):
    """DELETE /rest/kubernetes/{org_id}/secret/{key}"""
    return HttpClientFactory.get(
        KubernetesBrokerTokenConfigurationProvider.get()).request(
            method=HttpMethod.DELETE,
            path="rest/kubernetes/{}/secret/{}".format(org_guid, key_id),
            msg="K8S BROKER: delete secret")
Пример #21
0
def k8s_broker_update_secret(org_guid,
                             key_id,
                             username_b64=None,
                             password_b64=None):
    """PUT /rest/kubernetes/{org_id}/secret/{key}"""
    body = {
        "data": {},
        "metadata": {
            "name": key_id,
            "labels": {
                "managed_by": "TAP"
            }
        }
    }
    if username_b64 is not None:
        body["data"]["username"] = username_b64
    if password_b64 is not None:
        body["data"]["password"] = password_b64

    return HttpClientFactory.get(
        KubernetesBrokerTokenConfigurationProvider.get()).request(
            method=HttpMethod.PUT,
            body=body,
            path="rest/kubernetes/{}/secret/{}".format(org_guid, key_id),
            msg="K8S BROKER: update secret")
Пример #22
0
def k8s_broker_get_service_status(org_guid, service_id):
    """GET /v$/:org_id/service/:instance_id/status"""
    return HttpClientFactory.get(
        BrokerConfigurationProvider.get(
            TapComponent.kubernetes_broker)).request(
                method=HttpMethod.GET,
                path="{}/service/{}/status".format(org_guid, service_id),
                msg="K8S BROKER: get instance status")
 def test_get_should_create_two_different_instances(self):
     # given
     url_first = "first.sample.url"
     url_second = "second.sample.url"
     configuration_first = self._get_configuration(HttpClientType.BROKER,
                                                   url_first)
     configuration_second = self._get_configuration(HttpClientType.BROKER,
                                                    url_second)
     # when
     client_first = HttpClientFactory.get(configuration_first)
     client_second = HttpClientFactory.get(configuration_second)
     # then
     self.assertEqual(client_first.url, url_first)
     self.assertEqual(client_second.url, url_second)
     self.assertNotEqual(client_first.url, client_second.url)
     self.assertEqual(2, len(HttpClientFactory._INSTANCES),
                      "Invalid number of instances.")
def get_databases(app_url):
    """GET listDatabases"""
    configuration = HttpClientConfiguration(client_type=HttpClientType.BROKER,
                                            url=app_url)
    return HttpClientFactory.get(configuration).request(
        method=HttpMethod.GET,
        path="listDatabases",
        msg="OrientDB-dashboard: get list of databases")
Пример #25
0
 def __init__(self, username, password):
     self.username = username
     self.password = password
     self.client = HttpClientFactory.get(ApplicationConfigurationProvider.get(
         url=config.console_login_url,
         username=self.username,
         password=self.password
     ))
Пример #26
0
def k8s_broker_get_instance_list(org_guid, space_guid):
    """GET /rest/kubernetes/{org_guid}/{space_guid}/services"""
    response = HttpClientFactory.get(
        KubernetesBrokerTokenConfigurationProvider.get()).request(
            method=HttpMethod.GET,
            path="rest/kubernetes/{}/{}/services".format(org_guid, space_guid),
            msg="K8S BROKER: get instance list")
    return response
Пример #27
0
def k8s_broker_get_catalog():
    """GET /v$/catalog"""
    return HttpClientFactory.get(
        BrokerConfigurationProvider.get(
            TapComponent.kubernetes_broker)).request(
                method=HttpMethod.GET,
                path="catalog",
                msg="K8S BROKER: get catalog")
def k8s_broker_delete_instance(instance_guid):
    """DELETE /v$/service_instances/:instanceId"""
    return HttpClientFactory.get(
        BrokerConfigurationProvider.get(
            TapComponent.kubernetes_broker)).request(
                method=HttpMethod.DELETE,
                path="service_instances/{instance_guid}",
                path_params={'instance_guid': instance_guid},
                msg="K8S BROKER: delete instance")
Пример #29
0
 def _send_request(self, url):
     configuration = HttpClientConfiguration(
         client_type=HttpClientType.BROKER, url=url)
     response = HttpClientFactory.get(configuration).request(
         method=HttpMethod.GET,
         path="",
         raw_response=True,
         raise_exception=False)
     assert response.status_code == ContainerBrokerHttpStatus.CODE_OK
     return response
 def create_client(host=" ", port=DEFAULT_PORT):
     url = "{}:{}".format(host, str(port))
     client_configuration = HttpClientConfiguration(HttpClientType.WEBHDFS,
                                                    url=url,
                                                    username=host,
                                                    password=str(port))
     client = HttpClientFactory.get(client_configuration)
     if "webhdfs" not in client.url:
         client.url = "http://{}/webhdfs/v1".format(client.url)
     return client