def test_can_form_expected_support_path(self, env: MilMoveEnv,
endpoint: str,
expected_path: str) -> None:
request_preparer = MilMoveRequestPreparer(env=env)
assert request_preparer.form_support_path(
endpoint=endpoint) == expected_path
def test_raises_implementation_error_if_invalid_local_port_is_passed_in(
self, invalid_port: str) -> None:
request_preparer = MilMoveRequestPreparer(env=MilMoveEnv.LOCAL)
with pytest.raises(
ImplementationError,
match="The local port must be a string of 4 digits."):
request_preparer.form_base_domain(local_port=invalid_port)
def test_returns_expected_request_kwargs(
self, env: MilMoveEnv, certs_required: bool, endpoint_name: str,
expected_kwargs: RequestKwargsType) -> None:
request_preparer = MilMoveRequestPreparer(env=env)
assert (request_preparer.get_request_kwargs(
certs_required=certs_required,
endpoint_name=endpoint_name) == expected_kwargs)
def test_can_form_expected_internal_path(
self,
env: MilMoveEnv,
endpoint: str,
include_prefix: bool,
expected_path: str,
) -> None:
request_preparer = MilMoveRequestPreparer(env=env)
assert request_preparer.form_internal_path(
endpoint=endpoint, include_prefix=include_prefix) == expected_path
def test_returns_values_needed_for_making_a_support_request(
self,
env: MilMoveEnv,
endpoint: str,
endpoint_name: str,
expected_path: str,
expected_headers: RequestKwargsType,
) -> None:
request_preparer = MilMoveRequestPreparer(env=env)
assert request_preparer.prep_support_request(
endpoint=endpoint, endpoint_name=endpoint_name) == (
expected_path,
expected_headers,
)
def test_returns_expected_base_domain_for_each_env(
self,
env: MilMoveEnv,
deployed_subdomain: str,
local_port: str,
local_protocol: str,
local_subdomain: str,
expected_base_domain: str,
) -> None:
request_preparer = MilMoveRequestPreparer(env=env)
assert (request_preparer.form_base_domain(
deployed_subdomain=deployed_subdomain,
local_port=local_port,
local_protocol=local_protocol,
local_subdomain=local_subdomain,
) == expected_base_domain)
def test_returns_values_needed_for_making_an_internal_request(
self,
env: MilMoveEnv,
endpoint: str,
endpoint_name: str,
include_prefix: bool,
expected_path: str,
expected_headers: RequestKwargsType,
) -> None:
request_preparer = MilMoveRequestPreparer(env=env)
assert request_preparer.prep_internal_request(
endpoint=endpoint,
endpoint_name=endpoint_name,
include_prefix=include_prefix) == (
expected_path,
expected_headers,
)
def create_user(request_preparer: MilMoveRequestPreparer, session: Session,
user_type: UserType) -> bool:
"""
Creates a user. Since this works with sessions, the session should have the cookies set in it
for follow-up requests.
:param request_preparer: Initialized request preparer, needed to form proper urls.
:param session: Session to use and store cookies in, e.g. self.client or requests.Session()
:param user_type: UserType to log in as.
:return: boolean indicating if user creation was successful or not.
"""
# Hacky workaround for now...not sure if this should really be added to the
# MilMoveRequestPreparer class since it's only needed for this.
endpoint = "/devlocal-auth/login"
if user_type == UserType.MILMOVE:
url = request_preparer.form_internal_path(endpoint=endpoint,
include_prefix=False)
else:
url = request_preparer.form_ghc_path(endpoint=endpoint,
include_prefix=False)
session.get(url=url)
csrf_token = session.cookies.get("masked_gorilla_csrf")
session.headers.update({"x-csrf-token": csrf_token})
payload = {
"userType": user_type.value,
"gorilla.csrf.Token": csrf_token,
}
endpoint = "/devlocal-auth/create"
if user_type == UserType.MILMOVE:
url = request_preparer.form_internal_path(endpoint=endpoint,
include_prefix=False)
else:
url = request_preparer.form_ghc_path(endpoint=endpoint,
include_prefix=False)
resp = session.post(url=url, data=payload)
return resp.status_code == HTTPStatus.OK
def test_sets_csrf_token_in_headers(self) -> None:
mock_session = MagicMock()
request_preparer = MilMoveRequestPreparer(env=MilMoveEnv.LOCAL)
create_user(request_preparer=request_preparer,
session=mock_session,
user_type=UserType.MILMOVE)
mock_session.headers.update.assert_called_once_with(
{"x-csrf-token": mock_session.cookies.get.return_value})
def test_returns_bool_indicating_success_based_on_status_code(
self, status_code: int, expected_result: bool) -> None:
mock_session = MagicMock()
mock_session.post.return_value.status_code = status_code
request_preparer = MilMoveRequestPreparer(env=MilMoveEnv.LOCAL)
success = create_user(request_preparer=request_preparer,
session=mock_session,
user_type=UserType.MILMOVE)
assert success == expected_result
def test_makes_expected_requests(self, user_type: UserType,
base_domain: str) -> None:
mock_session = MagicMock()
request_preparer = MilMoveRequestPreparer(env=MilMoveEnv.LOCAL)
create_user(request_preparer=request_preparer,
session=mock_session,
user_type=user_type)
mock_session.get.assert_called_once_with(
url=f"{base_domain}/devlocal-auth/login")
mock_session.post.assert_called_once_with(
url=f"{base_domain}/devlocal-auth/create",
data={
"userType": user_type.value,
"gorilla.csrf.Token": mock_session.cookies.get.return_value,
},
)
def test_sets_up_request_preparer_on_init(self, user_host: str,
env: MilMoveEnv) -> None:
# All task sets need to be initialized with a parent (user or another task set).
mock_user = MagicMock()
mock_user.host = user_host
class SampleTaskSet(MilMoveRequestMixin, TaskSet):
"""
User to use for unit tests
"""
user = mock_user
assert not hasattr(SampleTaskSet, "request_preparer")
user = SampleTaskSet(parent=mock_user)
assert hasattr(user, "request_preparer")
assert user.request_preparer == MilMoveRequestPreparer(env=env)
def test_set_default_mto_ids(self):
"""
Tests the process of setting the default MTO IDs for creating new moves.
This function loops through a list of MTOs that must have "id" values, and then it calls the Support API
getMoveTaskOrder endpoint to get further details on the move. It repeats this process for as many of the listed
moves as necessary to get a complete set of valid IDs to use with the createMoveTaskOrder endpoint.
"""
# Set up some mock functions and classes for our test:
mock_locust_env = MagicMock()
class MyUser(HttpUser):
host = "local"
user = MyUser(environment=mock_locust_env)
milmove_env = MilMoveEnv(MyUser.host)
local_request_preparer = MilMoveRequestPreparer(env=milmove_env)
class PrimeSessionStorage1(PrimeDataStorageMixin, RestTaskSet):
pass
class PrimeSessionStorage2(PrimeDataStorageMixin, RestTaskSet):
pass
# Set up our test data and expected results:
test_moves = [
{
"id": "0", # the fake move ID
"status": 200,
"json": {
"contractorID": "contractor0"
},
},
{
"id": "X",
"status":
404, # should just be skipped, won't interrupt processing
"json": {
"error": "not found"
}, # format doesn't matter, this is a completely fake/mocked response
},
{
"id": "1",
"status": 200,
"json": {
"order": {
"uploadedOrdersID": "upload1",
"destinationDutyLocationID":
"", # purposefully blank, will not count for end of loop
"originDutyLocationID": "origin1",
},
},
},
{
"id": "2",
"status": 200,
"json": {
"order": {
"destinationDutyLocationID": "destination2",
"originDutyLocationID": "origin2",
}
},
},
{
"id": "3",
"status": 200,
"json": {
# these values should not be used because they all should have been set previously
"contractorID": "contractor3",
"order": {
"uploadedOrdersID": "upload3",
},
},
},
]
# Mock the API calls for each of these moves:
for test_move in test_moves:
url = local_request_preparer.form_support_path(
endpoint=f"/move-task-orders/{test_move['id']}")
responses.add(
responses.GET,
url,
json=test_move["json"],
status=test_move["status"],
)
expected_ids = {
"contractorID": "contractor0",
"destinationDutyLocationID": "destination2",
"originDutyLocationID": "origin2",
"uploadedOrdersID": "upload1",
}
# Random list to use after first run, none of these values will be used after the default IDs are initially set:
test_moves_after = [{
"id": "101",
"status": 200,
"json": {
"order": {
"uploadedOrdersID": "upload101",
"destinationDutyLocationID": "destination101",
"originDutyLocationID": "origin101",
},
},
}]
# Test set_default_mto_ids:
session_storage1 = PrimeSessionStorage1(parent=user)
session_storage2 = PrimeSessionStorage2(parent=user)
for move in test_moves:
session_storage1.set_default_mto_ids(move["id"])
assert session_storage1.default_mto_ids == expected_ids
assert session_storage1.default_mto_ids == session_storage2.default_mto_ids
assert len(responses.calls) == 4
# Call func again with new list, but all values should stay the same as before:
for move in test_moves_after:
session_storage2.set_default_mto_ids(move["id"])
assert session_storage1.default_mto_ids == expected_ids
assert session_storage1.default_mto_ids == session_storage2.default_mto_ids
assert len(responses.calls) == 4 # no additional API calls
def test_can_override_base_domain_with_env_var_regardless_of_env(
self, env: MilMoveEnv) -> None:
request_preparer = MilMoveRequestPreparer(env=env)
assert request_preparer.form_base_domain() == "https://localhost:8080/"
def __init__(self, milmove_env: MilMoveEnv, user: Optional[User]) -> None:
self.request_preparer = MilMoveRequestPreparer(env=milmove_env)
self.user = user
class FlowSessionManager(object):
request_preparer: MilMoveRequestPreparer
def __init__(self, milmove_env: MilMoveEnv, user: Optional[User]) -> None:
self.request_preparer = MilMoveRequestPreparer(env=milmove_env)
self.user = user
def internal_api_client(self,
user_type: UserType) -> LocustInternalApiClient:
session = requests.Session()
if not create_user(self.request_preparer, session, user_type):
raise Exception(f"Cannot create user: {user_type}")
host = self.request_preparer.form_internal_path("")
req = requests.Request("GET", host)
cookie = requests.cookies.get_cookie_header(session.cookies, req)
configuration = internal_client.Configuration(host=host)
api_client = LocustInternalApiClient(configuration, cookie=cookie)
for k, v in session.headers.items():
api_client.set_default_header(k, v)
api_client.rest_client.pool_manager = self.new_pool_manager()
return api_client
def ghc_api_client(self, user_type: UserType) -> LocustGHCApiClient:
session = requests.Session()
if not create_user(self.request_preparer, session, user_type):
raise Exception(f"Cannot create user: {user_type}")
host = self.request_preparer.form_ghc_path("")
req = requests.Request("GET", host)
cookie = requests.cookies.get_cookie_header(session.cookies, req)
configuration = internal_client.Configuration(host=host)
api_client = LocustGHCApiClient(configuration, cookie=cookie)
for k, v in session.headers.items():
api_client.set_default_header(k, v)
api_client.rest_client.pool_manager = self.new_pool_manager()
return api_client
def prime_api_client(self) -> LocustPrimeApiClient:
session = requests.Session()
host = self.request_preparer.form_prime_path("")
req = requests.Request("GET", host)
cookie = requests.cookies.get_cookie_header(session.cookies, req)
configuration = internal_client.Configuration(host=host)
api_client = LocustPrimeApiClient(configuration, cookie=cookie)
api_client.rest_client.pool_manager = self.new_pool_manager(
certs_required=True)
return api_client
def new_pool_manager(self, certs_required=False) -> PoolManager:
rkwargs = self.request_preparer.get_request_kwargs(
certs_required=certs_required)
cert_reqs = ssl.CERT_REQUIRED
cert_file = None
key_file = None
ssl_ca_cert = None
if "verify" in rkwargs and not rkwargs["verify"]:
cert_reqs = ssl.CERT_NONE
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
if "cert" in rkwargs:
if isinstance(rkwargs["cert"], str):
cert_file = rkwargs["cert"]
elif isinstance(rkwargs["cert"], tuple):
cert_file = rkwargs["cert"][0]
key_file = rkwargs["cert"][1]
# defaults from the generated internal client
pools_size = 4
maxsize = 4
pool_manager = urllib3.PoolManager(
num_pools=pools_size,
maxsize=maxsize,
cert_reqs=cert_reqs,
ca_certs=ssl_ca_cert,
cert_file=cert_file,
key_file=key_file,
)
return LocustOpenAPIPoolManager(self.user, pool_manager)
