selfprivacy-rest-api/tests/test_graphql/test_api_services.py

import pytest


def get_service_by_id_return_none_mock():
    return None


def get_service_by_id_mock():
    return "nextcloud"


def service_to_graphql_service_mock():
    pass


class NextcloudMock:
    def __init__(self, args, **kwargs):
        self.args = args
        self.kwargs = kwargs

    def enable(self):
        pass

    def disable(self):
        pass

    def stop(self):
        pass

    returncode = 0


@pytest.fixture
def mock_service_to_graphql_service(mocker):
    mock = mocker.patch(
        "selfprivacy_api.graphql.common_types.service.service_to_graphql_service",
        autospec=True,
        return_value=service_to_graphql_service_mock,
    )
    return mock


@pytest.fixture
def mock_nextcloud(mocker):
    mock = mocker.patch(
        "selfprivacy_api.services.nextcloud.__init__.Nextcloud",
        autospec=True,
        return_value=NextcloudMock,
    )
    return mock


@pytest.fixture
def mock_get_service_by_id_return_none(mocker):
    mock = mocker.patch(
        "selfprivacy_api.services.__init__.get_service_by_id",
        autospec=True,
        return_value=mock_get_service_by_id_return_none,
    )
    return mock


@pytest.fixture
def mock_get_service_by_id(mocker):
    mock = mocker.patch(
        "selfprivacy_api.services.__init__.get_service_by_id",
        autospec=True,
        return_value=mock_get_service_by_id,
    )
    return mock


####################################################################


API_ENABLE_SERVICE_MUTATION = """
mutation enableService($service_id: String!) {
    enableService(service_id: $service_id) {
        success
        message
        code
    }
}
"""


def test_graphql_enable_service_unathorized_client(
    client, mock_get_service_by_id_return_none, mock_nextcloud
):
    response = client.post(
        "/graphql",
        json={
            "query": API_ENABLE_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is None


def test_graphql_enable_not_found_service(
    authorized_client, mock_get_service_by_id_return_none, mock_nextcloud
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_ENABLE_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["enableService"]["code"] == 404
    assert response.json()["data"]["enableService"]["message"] is not None
    assert response.json()["data"]["enableService"]["success"] is False


def test_graphql_enable_service(
    authorized_client, mock_get_service_by_id, mock_nextcloud
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_ENABLE_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["enableService"]["code"] == 200
    assert response.json()["data"]["enableService"]["message"] is not None
    assert response.json()["data"]["enableService"]["success"] is True


API_DISABLE_SERVICE_MUTATION = """
mutation disableService($service_id: String!) {
    disableService(service_id: $service_id) {
        success
        message
        code
    }
}
"""


def test_graphql_disable_service_unathorized_client(
    client, mock_get_service_by_id_return_none, mock_nextcloud
):
    response = client.post(
        "/graphql",
        json={
            "query": API_DISABLE_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is None


def test_graphql_disable_not_found_service(
    authorized_client, mock_get_service_by_id_return_none, mock_nextcloud
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_DISABLE_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["disableService"]["code"] == 404
    assert response.json()["data"]["disableService"]["message"] is not None
    assert response.json()["data"]["disableService"]["success"] is False


def test_graphql_disable_services(
    authorized_client, mock_get_service_by_id, mock_nextcloud
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_DISABLE_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["disableService"]["code"] == 200
    assert response.json()["data"]["disableService"]["message"] is not None
    assert response.json()["data"]["disableService"]["success"] is True


API_STOP_SERVICE_MUTATION = """
mutation stopService($service_id: String!) {
    stopService(service_id: $service_id) {
        success
        message
        code
    }
}
"""


def test_graphql_stop_service_unathorized_client(
    client,
    mock_get_service_by_id_return_none,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = client.post(
        "/graphql",
        json={
            "query": API_STOP_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is None


def test_graphql_stop_not_found_service(
    authorized_client,
    mock_get_service_by_id_return_none,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_STOP_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["stopService"]["code"] == 404
    assert response.json()["data"]["stopService"]["message"] is not None
    assert response.json()["data"]["stopService"]["success"] is False


def test_graphql_stop_services(
    authorized_client,
    mock_get_service_by_id,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_STOP_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["stopService"]["code"] == 200
    assert response.json()["data"]["stopService"]["message"] is not None
    assert response.json()["data"]["stopService"]["success"] is True


API_START_SERVICE_MUTATION = """
mutation startService($service_id: String!) {
    startService(service_id: $service_id) {
        success
        message
        code
    }
}
"""


def test_graphql_start_service_unathorized_client(
    client,
    mock_get_service_by_id_return_none,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = client.post(
        "/graphql",
        json={
            "query": API_START_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is None


def test_graphql_start_not_found_service(
    authorized_client,
    mock_get_service_by_id_return_none,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_START_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["startService"]["code"] == 404
    assert response.json()["data"]["startService"]["message"] is not None
    assert response.json()["data"]["startService"]["success"] is False


def test_graphql_start_services(
    authorized_client,
    mock_get_service_by_id,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_START_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["startService"]["code"] == 200
    assert response.json()["data"]["startService"]["message"] is not None
    assert response.json()["data"]["startService"]["success"] is True


API_RESTART_SERVICE_MUTATION = """
mutation restartService($service_id: String!) {
    restartService(service_id: $service_id) {
        success
        message
        code
    }
}
"""


def test_graphql_restart_service_unathorized_client(
    client,
    mock_get_service_by_id_return_none,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = client.post(
        "/graphql",
        json={
            "query": API_RESTART_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is None


def test_graphql_restart_not_found_service(
    authorized_client,
    mock_get_service_by_id_return_none,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_RESTART_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["restartService"]["code"] == 404
    assert response.json()["data"]["restartService"]["message"] is not None
    assert response.json()["data"]["restartService"]["success"] is False


def test_graphql_restart_services(
    authorized_client,
    mock_get_service_by_id,
    mock_nextcloud,
    mock_service_to_graphql_service,
):
    response = authorized_client.post(
        "/graphql",
        json={
            "query": API_RESTART_SERVICE_MUTATION,
            "variables": {"service_id": "nextcloud"},
        },
    )
    assert response.status_code == 200
    assert response.json().get("data") is not None

    assert response.json()["data"]["restartService"]["code"] == 200
    assert response.json()["data"]["restartService"]["message"] is not None
    assert response.json()["data"]["restartService"]["success"] is True


# API_MOVE_SERVICE_MUTATION = """
# mutation moveService($input: MoveServiceInput!) {
#     moveService(input: $input) {
#         success
#         message
#         code
#     }
# }
# """


# def test_graphql_restart_service_unathorized_client(
#     client,
#     mock_get_service_by_id_return_none,
#     mock_nextcloud,
#     mock_service_to_graphql_service,
# ):
#     response = client.post(
#         "/graphql",
#         json={
#             "query": API_MOVE_SERVICE_MUTATION,
#             "variables": {
#                 "input": {
#                     "service_id": "nextcloud",
#                     "location": "sdx"
#                 },
#             },
#         },
#     )
#     assert response.status_code == 200
#     assert response.json().get("data") is None


# def test_graphql_restart_not_found_service(
#     authorized_client,
#     mock_get_service_by_id_return_none,
#     mock_nextcloud,
#     mock_service_to_graphql_service,
# ):
#     response = authorized_client.post(
#         "/graphql",
#         json={
#             "query": API_MOVE_SERVICE_MUTATION,
#             "variables": {
#                 "input": {
#                     "service_id": "nextcloud",
#                     "location": "sdx"
#                 },
#             },
#         },
#     )
#     assert response.status_code == 200
#     assert response.json().get("data") is not None

#     assert response.json()["data"]["moveService"]["code"] == 404
#     assert response.json()["data"]["moveService"]["message"] is not None
#     assert response.json()["data"]["moveService"]["success"] is False


# def test_graphql_restart_services(
#     authorized_client,
#     mock_get_service_by_id,
#     mock_nextcloud,
#     mock_service_to_graphql_service,
# ):
#     response = authorized_client.post(
#         "/graphql",
#         json={
#             "query": API_MOVE_SERVICE_MUTATION,
#             "variables": {
#                 "input": {
#                     "service_id": "nextcloud",
#                     "location": "sdx"
#                 },
#             },
#         },
#     )
#     assert response.status_code == 200
#     assert response.json().get("data") is not None

#     assert response.json()["data"]["moveService"]["code"] == 200
#     assert response.json()["data"]["moveService"]["message"] is not None
#     assert response.json()["data"]["moveService"]["success"] is True