SelfPrivacy/selfprivacy-rest-api
1
0
Fork 0
mirror of https://git.selfprivacy.org/SelfPrivacy/selfprivacy-rest-api.git synced 2024-11-25 05:21:28 +00:00
Code Issues Projects Releases Wiki Activity

chore: Disable monitoring tests for now

Browse source
This commit is contained in:
Inex Code 2024-07-29 18:26:15 +03:00
parent f83f5e840b
commit d0d3cdacca
1 changed files with 201 additions and 201 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

402
tests/test_graphql/test_api_monitoring.py
View file

@ -2,252 +2,252 @@
# pylint: disable=unused-argument # pylint: disable=unused-argument
# pylint: disable=missing-function-docstring # pylint: disable=missing-function-docstring
from dataclasses import dataclass # from dataclasses import dataclass
from datetime import datetime # from datetime import datetime
from typing import List, Dict # from typing import List, Dict
import pytest # import pytest
from tests.test_graphql.common import ( # from tests.test_graphql.common import (
assert_empty, # assert_empty,
get_data, # get_data,
) # )
MOCK_VALUES = [ # MOCK_VALUES = [
[1720135748, "3.75"], # [1720135748, "3.75"],
[1720135808, "4.525000000139698"], # [1720135808, "4.525000000139698"],
[1720135868, "4.541666666433841"], # [1720135868, "4.541666666433841"],
[1720135928, "4.574999999798209"], # [1720135928, "4.574999999798209"],
[1720135988, "4.579166666759804"], # [1720135988, "4.579166666759804"],
[1720136048, "3.8791666664959195"], # [1720136048, "3.8791666664959195"],
[1720136108, "4.5458333333954215"], # [1720136108, "4.5458333333954215"],
[1720136168, "4.566666666651145"], # [1720136168, "4.566666666651145"],
[1720136228, "4.791666666666671"], # [1720136228, "4.791666666666671"],
[1720136288, "4.720833333364382"], # [1720136288, "4.720833333364382"],
[1720136348, "3.9624999999068677"], # [1720136348, "3.9624999999068677"],
[1720136408, "4.6875"], # [1720136408, "4.6875"],
[1720136468, "4.404166666790843"], # [1720136468, "4.404166666790843"],
[1720136528, "4.31666666680637"], # [1720136528, "4.31666666680637"],
[1720136588, "4.358333333317816"], # [1720136588, "4.358333333317816"],
[1720136648, "3.7083333334885538"], # [1720136648, "3.7083333334885538"],
[1720136708, "4.558333333116025"], # [1720136708, "4.558333333116025"],
[1720136768, "4.729166666511446"], # [1720136768, "4.729166666511446"],
[1720136828, "4.75416666672875"], # [1720136828, "4.75416666672875"],
[1720136888, "4.624999999844775"], # [1720136888, "4.624999999844775"],
[1720136948, "3.9041666667132375"], # [1720136948, "3.9041666667132375"],
] # ]
@dataclass # @dataclass
class DumbResponse: # class DumbResponse:
status_code: int # status_code: int
json_data: dict # json_data: dict
def json(self): # def json(self):
return self.json_data # return self.json_data
def generate_prometheus_response(result_type: str, result: List[Dict]): # def generate_prometheus_response(result_type: str, result: List[Dict]):
return DumbResponse( # return DumbResponse(
status_code=200, # status_code=200,
json_data={"data": {"resultType": result_type, "result": result}}, # json_data={"data": {"resultType": result_type, "result": result}},
) # )
MOCK_SINGLE_METRIC_PROMETHEUS_RESPONSE = generate_prometheus_response( # MOCK_SINGLE_METRIC_PROMETHEUS_RESPONSE = generate_prometheus_response(
"matrix", [{"values": MOCK_VALUES}] # "matrix", [{"values": MOCK_VALUES}]
) # )
MOCK_MULTIPLE_METRIC_DEVICE_PROMETHEUS_RESPONSE = generate_prometheus_response( # MOCK_MULTIPLE_METRIC_DEVICE_PROMETHEUS_RESPONSE = generate_prometheus_response(
"matrix", # "matrix",
[ # [
{"metric": {"device": "a"}, "values": MOCK_VALUES}, # {"metric": {"device": "a"}, "values": MOCK_VALUES},
{"metric": {"device": "b"}, "values": MOCK_VALUES}, # {"metric": {"device": "b"}, "values": MOCK_VALUES},
{"metric": {"device": "c"}, "values": MOCK_VALUES}, # {"metric": {"device": "c"}, "values": MOCK_VALUES},
], # ],
) # )
# def generate_mock_metrics(name: str): # # def generate_mock_metrics(name: str):
# return { # # return {
# "data": { # # "data": {
# "monitoring": { # # "monitoring": {
# f"{name}": { # # f"{name}": {
# "resultType": "matrix", # # "resultType": "matrix",
# "result": [ # # "result": [
# { # # {
# "metric": {"instance": "127.0.0.1:9002"}, # # "metric": {"instance": "127.0.0.1:9002"},
# "values": , # # "values": ,
# } # # }
# ], # # ],
# } # # }
# } # # }
# } # # }
# } # # }
# MOCK_CPU_USAGE_RESPONSE = generate_mock_metrics("cpuUsage") # # MOCK_CPU_USAGE_RESPONSE = generate_mock_metrics("cpuUsage")
# MOCK_DISK_USAGE_RESPONSE = generate_mock_metrics("diskUsage") # # MOCK_DISK_USAGE_RESPONSE = generate_mock_metrics("diskUsage")
# MOCK_MEMORY_USAGE_RESPONSE = generate_mock_metrics("memoryUsage") # # MOCK_MEMORY_USAGE_RESPONSE = generate_mock_metrics("memoryUsage")
def generate_mock_query(name): # def generate_mock_query(name):
return f""" # return f"""
query Query {{ # query Query {{
monitoring {{ # monitoring {{
{name} {{ resultType, result }} # {name} {{ resultType, result }}
}} # }}
}} # }}
""" # """
def generate_mock_query_with_options(name): # def generate_mock_query_with_options(name):
return f""" # return f"""
query Query($start: DateTime, $end: DateTime, $step: Int) {{ # query Query($start: DateTime, $end: DateTime, $step: Int) {{
monitoring {{ # monitoring {{
{name}(start: $start, end: $end, step: $step) {{ resultType, result }} # {name}(start: $start, end: $end, step: $step) {{ resultType, result }}
}} # }}
}} # }}
""" # """
def prometheus_result_from_dict(dict): # def prometheus_result_from_dict(dict):
# return MonitoringQueryResult(result_type=dict["resultType"], result=dict["result"]) # # return MonitoringQueryResult(result_type=dict["resultType"], result=dict["result"])
return dict # return dict
@pytest.fixture # @pytest.fixture
def mock_cpu_usage(mocker): # def mock_cpu_usage(mocker):
mock = mocker.patch( # mock = mocker.patch(
"selfprivacy_api.utils.prometheus.PrometheusQueries._send_query", # "selfprivacy_api.utils.prometheus.PrometheusQueries._send_query",
return_value=MOCK_CPU_USAGE_RESPONSE["data"]["monitoring"]["cpuUsage"], # return_value=MOCK_CPU_USAGE_RESPONSE["data"]["monitoring"]["cpuUsage"],
) # )
return mock # return mock
@pytest.fixture # @pytest.fixture
def mock_memory_usage(mocker): # def mock_memory_usage(mocker):
mock = mocker.patch( # mock = mocker.patch(
"selfprivacy_api.utils.prometheus.PrometheusQueries._send_query", # "selfprivacy_api.utils.prometheus.PrometheusQueries._send_query",
return_value=prometheus_result_from_dict( # return_value=prometheus_result_from_dict(
MOCK_MEMORY_USAGE_RESPONSE["data"]["monitoring"]["memoryUsage"] # MOCK_MEMORY_USAGE_RESPONSE["data"]["monitoring"]["memoryUsage"]
), # ),
) # )
return mock # return mock
@pytest.fixture # @pytest.fixture
def mock_disk_usage(mocker): # def mock_disk_usage(mocker):
mock = mocker.patch( # mock = mocker.patch(
"selfprivacy_api.utils.prometheus.PrometheusQueries._send_query", # "selfprivacy_api.utils.prometheus.PrometheusQueries._send_query",
return_value=prometheus_result_from_dict( # return_value=prometheus_result_from_dict(
MOCK_DISK_USAGE_RESPONSE["data"]["monitoring"]["diskUsage"] # MOCK_DISK_USAGE_RESPONSE["data"]["monitoring"]["diskUsage"]
), # ),
) # )
return mock # return mock
def test_graphql_get_disk_usage(client, authorized_client, mock_disk_usage): # def test_graphql_get_disk_usage(client, authorized_client, mock_disk_usage):
response = authorized_client.post( # response = authorized_client.post(
"/graphql", # "/graphql",
json={"query": generate_mock_query("diskUsage")}, # json={"query": generate_mock_query("diskUsage")},
) # )
data = get_data(response) # data = get_data(response)
assert data == MOCK_DISK_USAGE_RESPONSE["data"] # assert data == MOCK_DISK_USAGE_RESPONSE["data"]
def test_graphql_get_disk_usage_with_options( # def test_graphql_get_disk_usage_with_options(
client, authorized_client, mock_disk_usage # client, authorized_client, mock_disk_usage
): # ):
response = authorized_client.post( # response = authorized_client.post(
"/graphql", # "/graphql",
json={ # json={
"query": generate_mock_query_with_options("diskUsage"), # "query": generate_mock_query_with_options("diskUsage"),
"variables": { # "variables": {
"start": datetime.fromtimestamp(1720136108).isoformat(), # "start": datetime.fromtimestamp(1720136108).isoformat(),
"end": datetime.fromtimestamp(1720137319).isoformat(), # "end": datetime.fromtimestamp(1720137319).isoformat(),
"step": 90, # "step": 90,
}, # },
}, # },
) # )
data = get_data(response) # data = get_data(response)
assert data == MOCK_DISK_USAGE_RESPONSE["data"] # assert data == MOCK_DISK_USAGE_RESPONSE["data"]
def test_graphql_get_disk_usage_unauthorized(client): # def test_graphql_get_disk_usage_unauthorized(client):
response = client.post( # response = client.post(
"/graphql", # "/graphql",
json={"query": generate_mock_query("diskUsage")}, # json={"query": generate_mock_query("diskUsage")},
) # )
assert_empty(response) # assert_empty(response)
def test_graphql_get_memory_usage(client, authorized_client, mock_memory_usage): # def test_graphql_get_memory_usage(client, authorized_client, mock_memory_usage):
response = authorized_client.post( # response = authorized_client.post(
"/graphql", # "/graphql",
json={"query": generate_mock_query("memoryUsage")}, # json={"query": generate_mock_query("memoryUsage")},
) # )
data = get_data(response) # data = get_data(response)
assert data == MOCK_MEMORY_USAGE_RESPONSE["data"] # assert data == MOCK_MEMORY_USAGE_RESPONSE["data"]
def test_graphql_get_memory_usage_with_options( # def test_graphql_get_memory_usage_with_options(
client, authorized_client, mock_memory_usage # client, authorized_client, mock_memory_usage
): # ):
response = authorized_client.post( # response = authorized_client.post(
"/graphql", # "/graphql",
json={ # json={
"query": generate_mock_query_with_options("memoryUsage"), # "query": generate_mock_query_with_options("memoryUsage"),
"variables": { # "variables": {
"start": datetime.fromtimestamp(1720136108).isoformat(), # "start": datetime.fromtimestamp(1720136108).isoformat(),
"end": datetime.fromtimestamp(1720137319).isoformat(), # "end": datetime.fromtimestamp(1720137319).isoformat(),
"step": 90, # "step": 90,
}, # },
}, # },
) # )
data = get_data(response) # data = get_data(response)
assert data == MOCK_MEMORY_USAGE_RESPONSE["data"] # assert data == MOCK_MEMORY_USAGE_RESPONSE["data"]
def test_graphql_get_memory_usage_unauthorized(client): # def test_graphql_get_memory_usage_unauthorized(client):
response = client.post( # response = client.post(
"/graphql", # "/graphql",
json={"query": generate_mock_query("memoryUsage")}, # json={"query": generate_mock_query("memoryUsage")},
) # )
assert_empty(response) # assert_empty(response)
def test_graphql_get_cpu_usage(client, authorized_client, mock_cpu_usage): # def test_graphql_get_cpu_usage(client, authorized_client, mock_cpu_usage):
response = authorized_client.post( # response = authorized_client.post(
"/graphql", # "/graphql",
json={"query": generate_mock_query("cpuUsage")}, # json={"query": generate_mock_query("cpuUsage")},
) # )
data = get_data(response) # data = get_data(response)
assert data == MOCK_CPU_USAGE_RESPONSE["data"] # assert data == MOCK_CPU_USAGE_RESPONSE["data"]
def test_graphql_get_cpu_usage_with_options(client, authorized_client, mock_cpu_usage): # def test_graphql_get_cpu_usage_with_options(client, authorized_client, mock_cpu_usage):
response = authorized_client.post( # response = authorized_client.post(
"/graphql", # "/graphql",
json={ # json={
"query": generate_mock_query_with_options("cpuUsage"), # "query": generate_mock_query_with_options("cpuUsage"),
"variables": { # "variables": {
"start": datetime.fromtimestamp(1720136108).isoformat(), # "start": datetime.fromtimestamp(1720136108).isoformat(),
"end": datetime.fromtimestamp(1720137319).isoformat(), # "end": datetime.fromtimestamp(1720137319).isoformat(),
"step": 90, # "step": 90,
}, # },
}, # },
) # )
data = get_data(response) # data = get_data(response)
assert data == MOCK_CPU_USAGE_RESPONSE["data"] # assert data == MOCK_CPU_USAGE_RESPONSE["data"]
def test_graphql_get_cpu_usage_unauthorized(client): # def test_graphql_get_cpu_usage_unauthorized(client):
response = client.post( # response = client.post(
"/graphql", # "/graphql",
json={"query": generate_mock_query("cpuUsage")}, # json={"query": generate_mock_query("cpuUsage")},
) # )
assert_empty(response) # assert_empty(response)