aswi2021jmsd-gitlab4/tests/integration_tests/services/conftest.py @ 7ad820d0

import os
import sqlite3
from sqlite3 import Connection

import pytest

from src.config.configuration import test_configuration, Configuration
from src.config.connection_provider import ConnectionProvider
from src.dao.certificate_repository import CertificateRepository
from src.dao.private_key_repository import PrivateKeyRepository
from src.model.subject import Subject
from src.services.certificate_service import CertificateService
from src.services.crl_ocsp.crl_ocsp_service import CrlOcspService
from src.services.cryptography import CryptographyService
from src.services.key_service import KeyService


# scope="module" means that this fixture is run once per module
@pytest.fixture(scope="module")
def connection():
    return ConnectionProvider().connect(test_configuration())


# scope defaults to "function" which means that the fixture is run once per test (function)
@pytest.fixture
def certificate_repository(connection):
    return CertificateRepository(connection)


@pytest.fixture
def private_key_repository(connection):
    return PrivateKeyRepository(connection)


@pytest.fixture
def cryptography_service():
    return CryptographyService()


@pytest.fixture
def configuration():
    return Configuration()


@pytest.fixture
def private_key_service(private_key_repository, cryptography_service):
    return KeyService(cryptography_service, private_key_repository)


@pytest.fixture
def certificate_service(certificate_repository, cryptography_service, configuration):
    return CertificateService(cryptography_service, certificate_repository, configuration)


@pytest.fixture
def connection_unique():
    return ConnectionProvider().connect(test_configuration())


@pytest.fixture
def sample_private_key(private_key_service):
    return private_key_service.create_new_key()


@pytest.fixture
def sample_certificate(certificate_service, sample_private_key):
    return certificate_service.create_root_ca(sample_private_key, Subject("Foo"))


# scope defaults to "function" which means that the fixture is run once per test (function)
@pytest.fixture
def certificate_repository_unique(connection_unique):
    return CertificateRepository(connection_unique)


@pytest.fixture
def private_key_repository_unique(connection_unique):
    return PrivateKeyRepository(connection_unique)


@pytest.fixture
def private_key_service_unique(private_key_repository_unique, cryptography_service):
    return KeyService(cryptography_service, private_key_repository_unique)


@pytest.fixture
def certificate_service_unique(certificate_repository_unique, cryptography_service, configuration):
    return CertificateService(cryptography_service, certificate_repository_unique, configuration)


@pytest.fixture
def crl_service_unique(certificate_repository_unique, private_key_repository_unique, cryptography_service):
    return CrlOcspService(certificate_repository_unique, private_key_repository_unique, cryptography_service)