Newer
Older
from typing import Any, List
from unittest.mock import MagicMock
import pytest
from pyramid.config import Configurator
from pyramid.testing import DummyRequest, setUp, tearDown
from workspaces.capability.enums import CapabilityRequestState
from workspaces.capability.helpers import Parameter
from workspaces.capability.schema import (
Capability,
CapabilityRequest,
CapabilityVersion,
)
from workspaces.capability.schema_interfaces import CapabilityRequestIF
from workspaces.products.schema import FutureProduct
@pytest.fixture(scope="module")
def test_config() -> Configurator:
"""
Returns a dummy Configurator object for testing purposes with set up and teardown
:return: Dummy Configurator
"""
request = DummyRequest()
config = setUp(request=request)
config.add_request_method(
lambda lookup: MagicMock(),
"capability_info",
reify=True,
)
yield config
tearDown()
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
class MockCapabilityInfo(MagicMock):
capabilities = [
Capability(
name="null",
steps="test",
max_jobs=2,
),
Capability(
name="error",
steps="error",
max_jobs=-1,
),
]
capability_requests = [
CapabilityRequest(
id=0,
state="Created",
capability_name="null",
parameters="-g",
versions=[],
)
]
def edit_capability(
self, name: str, steps: str = None, max_jobs: int = None, enabled: bool = None
) -> bool:
if name == "error":
# This is here to mimic the case where an update fails to happen
return False
for capability in self.capabilities:
if name == capability.name:
if steps:
capability.steps = steps
if max_jobs:
capability.max_jobs = max_jobs
if enabled:
capability.enabled = enabled
return True
return False
def lookup_capability(self, capability_name: str) -> Capability:
for capability in self.capabilities:
if capability_name == capability.name:
return capability
return None
def lookup_capability_request(self, request_id: int) -> CapabilityRequest:
for capability_request in self.capability_requests:
if request_id == capability_request.id:
return capability_request
return None
def save_entity(self, entity: Any):
if type(entity) is Capability:
self.capabilities.append(entity)
elif type(entity) is CapabilityRequest:
entity.id = len(self.capability_requests)
self.capability_requests.append(entity)
class MockCapabilityService(MagicMock):
def __init__(self, capability_info: MockCapabilityInfo):
super().__init__()
self.capability_info = capability_info
def create_request(
self,
capability_name: str,
parameters: List[Parameter] = None,
products: List[FutureProduct] = None,
) -> CapabilityRequestIF:
"""
Mocked version of the corresponding `CapabilityService.create_request` method
:param capability_name: Name of capability
:param parameters: Parameters for request
:param products: Product that the request will give back
:return: Newly created request
"""
capability = self.capability_info.lookup_capability(capability_name)
request = CapabilityRequest(
state=CapabilityRequestState.Ready.name,
capability=capability,
capability_name=capability_name,
parameters=str(parameters),
# a trick here is to ensure that we always have a first version, with the original parameters
versions=[CapabilityVersion(version_number=1, parameters=str(parameters))],
)
self.capability_info.save_entity(request)
return request
@pytest.fixture(scope="module")
def request_null_capability() -> DummyRequest:
"""
Returns a dummy request object with a mocked capability_info
:return: DummyRequest with configured mock CapabilityInfo
"""
mock_capability_info = MockCapabilityInfo()
request = DummyRequest(
capability_info=mock_capability_info,
capabilities=MockCapabilityService(mock_capability_info),
)
return request