release 1.1 for euphrates

Change-Id: Iddc0e0148db7c72458b7fcdfcb7664e4aa609be0
Signed-off-by: Koren Lev <korenlev@gmail.com>

1 files changed, 169 insertions, 0 deletions

diff --git a/app/api/responders/resource/connection_tests.py b/app/api/responders/resource/connection_tests.py
new file mode 100644
index 0000000..8f8ab94
--- /dev/null
+++ b/app/api/responders/resource/connection_tests.py
@@ -0,0 +1,169 @@
+###############################################################################
+# Copyright (c) 2017 Koren Lev (Cisco Systems), Yaron Yogev (Cisco Systems)   #
+# and others                                                                  #
+#                                                                             #
+# All rights reserved. This program and the accompanying materials            #
+# are made available under the terms of the Apache License, Version 2.0       #
+# which accompanies this distribution, and is available at                    #
+# http://www.apache.org/licenses/LICENSE-2.0                                  #
+###############################################################################
+import datetime
+
+from bson import ObjectId
+
+from api.responders.resource.environment_configs import EnvironmentConfigs
+from api.responders.responder_base import ResponderBase
+from api.validation.data_validate import DataValidate
+
+
+class ConnectionTests(ResponderBase):
+
+    COLLECTION = "connection_tests"
+    ID = "_id"
+    TARGETS = "test_targets"
+    RESULTS = "test_results"
+    CONFIGURATIONS = "targets_configuration"
+    STATUSES = ["request", "response"]
+
+    def __init__(self):
+        super().__init__()
+        self.PROJECTION = {
+            self.ID: True,
+            self.TARGETS: True,
+            self.RESULTS: True
+        }
+        self.allowed_targets = \
+            self.get_constants_by_name("configuration_targets")
+
+    def build_query(self, filters):
+        query = {}
+
+        self.update_query_with_filters(filters, ["status"], query)
+
+        if 'id' in filters:
+            query[self.ID] = filters['id']
+        elif 'env_name' in filters:
+            query['environment'] = filters['env_name']
+        else:
+            self.bad_request(message="Either 'id' or 'env_name' "
+                                     "field is required")
+
+        return query
+
+    def on_get(self, req, resp):
+        self.log.debug("Getting a connection test")
+        filters = self.parse_query_params(req)
+
+        filters_requirements = {
+            'env_name': self.require(str, mandatory=True),
+            'id': self.require(ObjectId, convert_to_type=True),
+            'status': self.require(str,
+                                   requirement=self.STATUSES),
+            self.TARGETS: self.require([list, str],
+                                       validate=DataValidate.LIST,
+                                       requirement=self.allowed_targets),
+            self.RESULTS: self.require(bool, convert_to_type=True),
+            'page': self.require(int, convert_to_type=True),
+            'page_size': self.require(int, convert_to_type=True)
+        }
+
+        self.validate_query_data(filters, filters_requirements)
+
+        query = self.build_query(filters)
+
+        if self.ID in query:
+            result = self.get_object_by_id(collection=self.COLLECTION,
+                                           query=query,
+                                           stringify_types=[ObjectId,
+                                                            datetime.datetime],
+                                           id=self.ID)
+
+            test_targets = result.get(self.TARGETS, [])
+            targets_config = result.get(self.CONFIGURATIONS, [])
+            test_results = result.get(self.RESULTS, {})
+
+            # Filter data by target names
+            targets_filter = filters.get(self.TARGETS)
+            if targets_filter:
+                test_targets = [target
+                                for target in test_targets
+                                if target in targets_filter]
+                targets_config = [config
+                                  for config in targets_config
+                                  if config['name'] in targets_filter]
+                test_results = {target: result
+                                for target, result in test_results.items()
+                                if target in targets_filter}
+
+            # Filter data by test results (success/failure)
+            results_filter = filters.get(self.RESULTS)
+            if results_filter is not None:
+                test_results = {target: result
+                                for target, result in test_results.items()
+                                if result == results_filter}
+
+                results_keys = test_results.keys()
+                test_targets = [target
+                                for target in test_targets
+                                if target in results_keys]
+                targets_config = [config
+                                  for config in targets_config
+                                  if config['name'] in results_keys]
+
+            result[self.TARGETS] = test_targets
+            result[self.CONFIGURATIONS] = targets_config
+            result[self.RESULTS] = test_results
+
+            self.set_successful_response(resp, result)
+        else:
+            page, page_size = self.get_pagination(filters)
+            tests_ids = self.get_objects_list(collection=self.COLLECTION,
+                                              query=query,
+                                              page=page,
+                                              page_size=page_size,
+                                              projection=self.PROJECTION)
+            self.set_successful_response(resp, {"connection_tests": tests_ids})
+
+    def on_post(self, req, resp):
+        self.log.debug("Posting a new connection test")
+        error, connection_test = self.get_content_from_request(req)
+        if error:
+            self.bad_request(error)
+
+        conn_test_requirements = {
+            "environment": self.require(str, mandatory=True),
+            self.TARGETS: self.require(list,
+                                       mandatory=True,
+                                       validate=DataValidate.LIST,
+                                       requirement=self.allowed_targets),
+            self.CONFIGURATIONS: self.require(list, mandatory=True)
+        }
+        self.validate_query_data(connection_test, conn_test_requirements)
+
+        test_targets = connection_test[self.TARGETS]
+        targets_configuration = connection_test[self.CONFIGURATIONS]
+        env_name = connection_test["environment"]
+
+        env_configs = EnvironmentConfigs()
+        config_validation = env_configs.validate_environment_config(
+            connection_test[self.CONFIGURATIONS],
+            require_mandatory=False
+        )
+        if not config_validation['passed']:
+            self.bad_request(config_validation['error_message'])
+
+        for test_target in test_targets:
+            if not env_configs.get_configuration_by_name(test_target,
+                                                         targets_configuration):
+                self.bad_request("targets_configuration should contain "
+                                 "an entry for target '{}'".format(test_target))
+
+        connection_test['submit_timestamp'] = datetime.datetime.now()
+
+        result = self.write(connection_test, self.COLLECTION)
+        self.set_successful_response(resp,
+                                     {"id": str(result.inserted_id),
+                                      "message": "Created a new connection test"
+                                                 " for environment {0}"
+                                                 .format(env_name)},
+                                     "201")