def test_get_one_by_id(self):
user = User(
first_name = "Joe",
last_name = "Doe",
username = "******",
email = "*****@*****.**",
password = "******"
)
user.save()
namespace_entity = Namespace_Entity()
namespace = namespace_entity.insert_one({
"name": "kevin",
"is_public": True,
"user_id": user.pk
})
self.assertTrue(namespace)
self.assertTrue(namespace.id > 0)
endpoint_entity = Endpoint_Entity();
entity = endpoint_entity.insert_one({
"route": "/",
"method": Endpoint_Entity.GET,
"target": Endpoint_Entity.DEBUG,
"route_rules": "{}",
"headers_rules": "{}",
"body_rules": "{}",
"namespace_id": namespace.id
})
entity = endpoint_entity.get_one_by_id(entity.id)
self.assertEqual("get/debug", entity.method + entity.route + entity.target)
def entity_pk(self):
regex = re.compile('^[0-9]+$')
if not bool(regex.match(self.__input)):
return False
endpoint_entity = Endpoint_Entity()
return endpoint_entity.get_one_by_id(self.__input) != False
def test_insert_many(self):
user = User(
first_name = "Joe",
last_name = "Doe",
username = "******",
email = "*****@*****.**",
password = "******"
)
user.save()
namespace_entity = Namespace_Entity()
namespace = namespace_entity.insert_one({
"name": "kevin",
"is_public": True,
"user_id": user.pk
})
self.assertTrue(namespace)
self.assertTrue(namespace.id > 0)
endpoint_entity = Endpoint_Entity();
self.assertTrue(endpoint_entity.insert_many([
{"route": "/", "method": Endpoint_Entity.GET, "target": Endpoint_Entity.DEBUG, "route_rules": "{}", "headers_rules": "{}", "body_rules": "{}","namespace_id": namespace.id},
{"route": "/", "method": Endpoint_Entity.POST, "target": Endpoint_Entity.VALIDATE, "route_rules": "{}", "headers_rules": "{}", "body_rules": "{}","namespace_id": namespace.id},
{"route": "/{id}", "method": Endpoint_Entity.GET, "target": Endpoint_Entity.DYNAMIC, "route_rules": "{}", "headers_rules": "{}", "body_rules": "{}","namespace_id": namespace.id},
]))
def test_update_one_by_id(self):
user = User(first_name="Joe",
last_name="Doe",
username="******",
email="*****@*****.**",
password="******")
user.save()
namespace_entity = Namespace_Entity()
endpoint_entity = Endpoint_Entity()
request_entity = Request_Entity()
namespace = namespace_entity.insert_one({
"name": "kevin",
"is_public": True,
"user_id": user.pk
})
endpoint = endpoint_entity.insert_one({
"route": "/",
"method": Endpoint_Entity.GET,
"target": Endpoint_Entity.DEBUG,
"route_rules": "{}",
"headers_rules": "{}",
"body_rules": "{}",
"namespace_id": namespace.id
})
self.assertTrue(namespace)
self.assertTrue(namespace.id > 0)
endpoint_entity = Endpoint_Entity()
self.assertTrue(
endpoint_entity.insert_one({
"route": "/",
"method": Endpoint_Entity.GET,
"target": Endpoint_Entity.DEBUG,
"route_rules": "{}",
"headers_rules": "{}",
"body_rules": "{}",
"namespace_id": namespace.id
}))
request = request_entity.insert_one({
"uri": "/",
"method": Request_Entity.GET,
"headers": "{}",
"body": "{}",
"status": Request_Entity.DEBUG,
"endpoint_id": endpoint.id
})
self.assertTrue(request)
self.assertTrue(request.id > 0)
self.assertTrue(
request_entity.update_one_by_id(request.id, {"uri": "/new"}))
request = request_entity.get_one_by_id(request.id)
self.assertEqual("get/newdebug",
request.method + request.uri + request.status)
class Namespace():
__helpers = Helpers()
__logger = None
__namespace_entity = Namespace_Entity()
__endpoint_entity = Endpoint_Entity()
def __init__(self):
self.__logger = self.__helpers.get_logger(__name__)
def user_owns(self, namespace_id, user_id):
return self.__namespace_entity.user_owns(namespace_id, user_id)
def delete_namespace(self, namespace_id):
return self.__namespace_entity.delete_one_by_id(namespace_id)
def slug_used(self, slug):
return (self.__namespace_entity.get_one_by_slug(slug) != False)
def slug_used_elsewhere(self, namespace_id, slug):
namespace = self.__namespace_entity.get_one_by_slug(slug)
return False if namespace == False or namespace.id == namespace_id else True
def insert_one(self, namespace):
return self.__namespace_entity.insert_one(namespace)
def update_one_by_id(self, namespace_id, new_data):
return self.__namespace_entity.update_one_by_id(namespace_id, new_data)
def get_one_by_slug(self, slug):
return self.__namespace_entity.get_one_by_slug(slug)
def get_many_by_user(self, user_id, order_by="created_at", asc=False):
namespaces = self.__namespace_entity.get_many_by_user(
user_id, order_by, asc)
for namespace in namespaces:
namespace.endpoints_count = self.__endpoint_entity.count_by_namespace(
namespace.id)
return namespaces
def test_insert_many(self):
user = User(first_name="Joe",
last_name="Doe",
username="******",
email="*****@*****.**",
password="******")
user.save()
namespace_entity = Namespace_Entity()
endpoint_entity = Endpoint_Entity()
request_entity = Request_Entity()
namespace = namespace_entity.insert_one({
"name": "kevin",
"is_public": True,
"user_id": user.pk
})
endpoint = endpoint_entity.insert_one({
"route": "/",
"method": Endpoint_Entity.GET,
"target": Endpoint_Entity.DEBUG,
"route_rules": "{}",
"headers_rules": "{}",
"body_rules": "{}",
"namespace_id": namespace.id
})
self.assertTrue(namespace)
self.assertTrue(namespace.id > 0)
endpoint_entity = Endpoint_Entity()
self.assertTrue(
endpoint_entity.insert_one({
"route": "/",
"method": Endpoint_Entity.GET,
"target": Endpoint_Entity.DEBUG,
"route_rules": "{}",
"headers_rules": "{}",
"body_rules": "{}",
"namespace_id": namespace.id
}))
request = request_entity.insert_many([{
"uri": "/",
"method": Request_Entity.GET,
"headers": "{}",
"body": "{}",
"status": Request_Entity.DEBUG,
"endpoint_id": endpoint.id
}, {
"uri": "/",
"method": Request_Entity.POST,
"headers": "{}",
"body": "{}",
"status": Request_Entity.DEBUG,
"endpoint_id": endpoint.id
}, {
"uri": "/{id}",
"method": Request_Entity.GET,
"headers": "{}",
"body": "{}",
"status": Request_Entity.DEBUG,
"endpoint_id": endpoint.id
}, {
"uri": "/{id}",
"method": Request_Entity.PUT,
"headers": "{}",
"body": "{}",
"status": Request_Entity.DEBUG,
"endpoint_id": endpoint.id
}])
self.assertTrue(request)
class Request():
__helpers = Helpers()
__logger = None
__namespace_entity = Namespace_Entity()
__endpoint_entity = Endpoint_Entity()
__request_entity = Request_Entity()
def __init__(self):
self.__logger = self.__helpers.get_logger(__name__)
def insert_one(self, request):
return self.__request_entity.insert_one(request)
def user_owns(self, request_id, user_id):
return self.__request_entity.user_owns(request_id, user_id)
def delete_request(self, request_id):
return self.__request_entity.delete_one_by_id(request_id)
def get_many_by_endpoint(self, endpoint_id, order_by, asc):
requests = self.__request_entity.get_many_by_endpoint(
endpoint_id, order_by, asc)
for request in requests:
data = []
try:
data = json.loads(request.headers)
except Exception as e:
self.delete_request(request.id)
request.headers = data
if request.body != '':
try:
request.body = json.loads(request.body)
request.body = json.dumps(request.body, indent=4)
except Exception as e:
request.body = ''
return requests
def store_request(self, request_data):
try:
request_data["body"] = json.loads(request_data["body"])
except Exception as e:
request_data["body"] = ''
headers = []
for key, value in request_data["headers"].items():
if key == "KVN-Auth-Token":
continue
headers.append({"key": key, "value": request_data["headers"][key]})
endpoints = self.__endpoint_entity.get_many_by_namespace(
request_data["namespace"].id, "created_at", True)
result = 0
for endpoint in endpoints:
if not self.__validate_method(endpoint.method,
request_data["method"]):
continue
if not self.__validate_uri(endpoint.route, request_data["uri"]):
continue
if endpoint.target == "debug":
self.__request_entity.insert_one({
"uri":
"/" + request_data["uri"],
"method":
request_data["method"].lower(),
"headers":
json.dumps(headers),
"body":
'{}' if request_data["body"] == '' else json.dumps(
request_data["body"]),
"status":
"debug",
"endpoint_id":
endpoint.id
})
result += 1
elif endpoint.target == "validate":
if not self.__validate_body(endpoint.body_rules,
equest_data["body"]):
continue
if not self.__validate_headers(endpoint.headers_rules,
headers):
continue
self.__request_entity.insert_one({
"uri":
"/" + request_data["uri"],
"method":
request_data["method"].lower(),
"headers":
json.dumps(headers),
"body":
json.dumps(request_data["body"]),
"status":
"debug",
"endpoint_id":
endpoint.id
})
result += 1
return result
def __validate_uri(self, endpoint_uri, request_uri):
return re.match("^" + endpoint_uri + "$", "/" + request_uri) != None
def __validate_method(self, endpoint_method, request_method):
return endpoint_method.lower() == "any" or endpoint_method.lower(
) == request_method.lower()
def __validate_body(self, endpoint_body, request_body):
return True
def __validate_headers(self, endpoint_headers, request_headers):
return True
class Endpoint():
__helpers = Helpers()
__logger = None
__namespace_entity = Namespace_Entity()
__endpoint_entity = Endpoint_Entity()
__request_entity = Request_Entity()
def get_one_by_id(self, endpoint_id):
endpoint = self.__endpoint_entity.get_one_by_id(endpoint_id)
if endpoint != False:
try:
endpoint.header_rule_obj = json.loads(endpoint.headers_rules)
except Exception as e:
endpoint.header_rule_obj = []
return endpoint
i = 2
j = 0
for item in endpoint.header_rule_obj:
endpoint.header_rule_obj[j]["index"] = i
i += 1
j += 1
return endpoint
return False
def count_by_target(self, target, namespace_id):
return self.__endpoint_entity.count_by_target(target, namespace_id)
def get_many_by_namespace_id(self,
namespace_id,
order_by="created_at",
asc=False):
endpoints = self.__endpoint_entity.get_many_by_namespace(
namespace_id, order_by, asc)
for endpoint in endpoints:
if endpoint.target == 'validate':
endpoint.status = self.__request_entity.get_latest_status(
endpoint.id)
elif endpoint.target == 'dynamic':
endpoint.status = "dynamic"
else:
endpoint.status = "debug"
return endpoints
def user_owns(self, endpoint_id, user_id):
endpoint = self.__endpoint_entity.get_one_by_id(endpoint_id)
if endpoint == False:
return False
return self.__namespace_entity.user_owns(endpoint.namespace.id,
user_id)
def delete_endpoint(self, endpoint_id):
return self.__endpoint_entity.delete_one_by_id(endpoint_id)
def insert_one(self, endpoint):
return self.__endpoint_entity.insert_one(endpoint)
def update_one_by_id(self, endpoint_id, new_data):
return self.__endpoint_entity.update_one_by_id(endpoint_id, new_data)
class NamespacesStatistics():
__helpers = Helpers()
__logger = None
__namespace_entity = Namespace_Entity()
__endpoint_entity = Endpoint_Entity()
__request_entity = Request_Entity()
def __init__(self):
self.__logger = self.__helpers.get_logger(__name__)
def overall_count_chart(self, user_id=None):
public_count = self.__namespace_entity.count_by_visibility(
True, user_id)
private_count = self.__namespace_entity.count_by_visibility(
False, user_id)
total_count = public_count + private_count
if total_count > 0:
public_percent = round((public_count / total_count) * 100)
private_percent = round((private_count / total_count) * 100)
else:
public_percent = 0
private_percent = 0
return {"public": public_percent, "private": private_percent}
def count_over_time_chart(self, days_num, user_id=None):
data = {
"public":
self.__namespace_entity.count_by_visibility_date(
True, str(days_num), user_id),
"private":
self.__namespace_entity.count_by_visibility_date(
False, str(days_num), user_id),
"public_list": {},
"private_list": {},
"final": {
"public": [],
"private": [],
"total": []
}
}
for item in data["public"]:
data["public_list"][str(item.count_date)] = item.id
for item in data["private"]:
data["private_list"][str(item.count_date)] = item.id
days_count = days_num
while days_count > -1:
current_date = timezone.now().date() - timedelta(days_count)
current_date = str(current_date)
if current_date in data["public_list"]:
current_public = data["public_list"][current_date]
data["final"]["public"].append(current_public)
else:
current_public = 0
data["final"]["public"].append(current_public)
if current_date in data["private_list"]:
current_private = data["private_list"][current_date]
data["final"]["private"].append(current_private)
else:
current_private = 0
data["final"]["private"].append(current_private)
data["final"]["total"].append(current_private + current_public)
days_count -= 1
data["final"]["private"] = ",".join(
str(x) for x in data["final"]["private"])
data["final"]["public"] = ",".join(
str(x) for x in data["final"]["public"])
data["final"]["total"] = ",".join(
str(x) for x in data["final"]["total"])
return {
"private": data["final"]["private"],
"public": data["final"]["public"],
"total": data["final"]["total"]
}
def count_endpoints_by_target(self, namespace_id):
debug_count = self.__endpoint_entity.count_by_target(
Endpoint_Entity.DEBUG, namespace_id)
validate_count = self.__endpoint_entity.count_by_target(
Endpoint_Entity.VALIDATE, namespace_id)
dynamic_count = self.__endpoint_entity.count_by_target(
Endpoint_Entity.DYNAMIC, namespace_id)
total_count = debug_count + validate_count + dynamic_count
if total_count > 0:
debug_percent = round((debug_count / total_count) * 100)
validate_percent = round((validate_count / total_count) * 100)
dynamic_percent = round((dynamic_count / total_count) * 100)
else:
debug_percent = 0
validate_percent = 0
dynamic_percent = 0
return {
"debug": debug_percent,
"validate": validate_percent,
"dynamic": dynamic_percent
}
def count_requests_over_time_chart(self, days_num, namespace_id):
data = {"requests_list": {}, "requests": []}
endpoins_in_namespace = self.__endpoint_entity.get_many_ids_by_namespace(
namespace_id)
items = self.__request_entity.count_by_endpoint_date(
days_num, endpoins_in_namespace)
for item in items:
data["requests_list"][str(item.count_date)] = item.id
days_count = days_num
while days_count > -1:
current_date = timezone.now().date() - timedelta(days_count)
current_date = str(current_date)
if current_date in data["requests_list"]:
requests = data["requests_list"][current_date]
data["requests"].append(requests)
else:
requests = 0
data["requests"].append(requests)
days_count -= 1
data["requests"] = ",".join([str(x) for x in data["requests"]])
return {"requests": data["requests"]}