def test_dest_returns_unparseable_json_response(mock_server):
with open("tests/resources/circrequests/valid_src_response.json") as file:
valid_src_response = file.read()
with open(
"tests/resources/circrequests/unparseable_json_dest_response.json"
) as file:
unparseable_json_dest_response = file.read()
# Set up mock server with required behavior
imposter = Imposter([
Stub(Predicate(path="/src"), Response(body=valid_src_response)),
Stub(Predicate(path="/dest", method="POST"),
Response(body=unparseable_json_dest_response)),
])
# Create a temporary file to use as last success lookup
try:
[temp_file_handle, temp_success_filename] = tempfile.mkstemp()
with open(temp_success_filename, 'w') as f:
f.write('etc/items_FIRST.json')
with tempfile.TemporaryDirectory() as temp_storage_dir, mock_server(
imposter) as server:
setup_environment(imposter, temp_storage_dir,
temp_success_filename)
start_time = '20200521132905'
args = []
with pytest.raises(JSONDecodeError):
command = Command()
result = command(start_time, args)
assert result.was_successful() is False
files_in_storage_dir = [
f for f in listdir(temp_storage_dir)
if isfile(join(temp_storage_dir, f))
]
expected_file_regex = re.compile('.*\\.dest_response_body\\..*')
# There should be a "dest_circrequests_response_body" file, even
# though the JSON was unparseable
if not any(
expected_file_regex.match(x)
for x in files_in_storage_dir):
pytest.fail(
f"Expected file matching '#{expected_file_regex.pattern}' was not found."
)
# There should have been three requests to the server
assert 2 == len(server.get_actual_requests()[imposter.port])
assert_that(server,
had_request().with_path("/src").and_method("GET"))
assert_that(server,
had_request().with_path("/dest").and_method("POST"))
finally:
# Clean up the temporary file
os.close(temp_file_handle)
os.remove(temp_success_filename)
def test_add_stubs_to_running_impostor(mock_server):
impostor = Imposter(
Stub(Predicate(path="/test0"), Response(body="response0")),
default_response=HttpResponse(body="default"),
)
with mock_server(impostor):
responses = [requests.get(f"{impostor.url}/test{i}") for i in range(3)]
assert_that(
responses,
contains_exactly(
is_response().with_body("response0"),
is_response().with_body("default"),
is_response().with_body("default"),
),
)
impostor.add_stubs(
[
Stub(Predicate(path="/test1"), Response(body="response1")),
]
)
responses = [requests.get(f"{impostor.url}/test{i}") for i in range(3)]
assert_that(
responses,
contains_exactly(
is_response().with_body("response0"),
is_response().with_body("response1"),
is_response().with_body("default"),
),
)
def test_query_all_imposters(mock_server):
imposter1 = Imposter(
Stub(Predicate(path="/test1"), Response(body="sausages")))
imposter2 = Imposter(Stub(Predicate(path="/test2"), Response(body="egg")))
with mock_server([imposter1, imposter2]) as server:
actual = list(server.query_all_imposters())
assert_that(
actual,
contains_inanyorder(
has_identical_properties_to(
imposter1,
ignoring={
"host", "url", "server_url", "configuration_url",
"attached"
},
),
has_identical_properties_to(
imposter2,
ignoring={
"host", "url", "server_url", "configuration_url",
"attached"
},
),
),
)
def test_dest_returns_denied_key(mock_server):
with open("tests/resources/circrequests/valid_src_response.json") as file:
valid_src_response = file.read()
with open(
"tests/resources/circrequests/valid_dest_response_denied_key.json"
) as file:
valid_dest_response_denied_key = file.read()
# Set up mock server with required behavior
imposter = Imposter([
Stub(Predicate(path="/src"), Response(body=valid_src_response)),
Stub(Predicate(path="/dest", method="POST"),
Response(body=valid_dest_response_denied_key)),
])
try:
# Create a temporary file to use as last success lookup
[temp_success_file_handle, temp_success_filename] = tempfile.mkstemp()
with open(temp_success_filename, 'w') as f:
f.write('etc/circrequests_FIRST.json')
# Create a temporary file to use as denied keys file
[temp_denied_keys_file_handle,
temp_denied_keys_filename] = tempfile.mkstemp()
with open(temp_denied_keys_filename, 'w') as f:
f.write('{}')
with tempfile.TemporaryDirectory() as temp_storage_dir, mock_server(
imposter) as server:
setup_environment(imposter, temp_storage_dir,
temp_success_filename, temp_denied_keys_filename)
start_time = '20200521132905'
args = []
command = Command()
result = command(start_time, args)
assert result.was_successful() is True
assert_that(server,
had_request().with_path("/src").and_method("GET"))
assert_that(server,
had_request().with_path("/dest").and_method("POST"))
finally:
# Clean up the temporary files
os.close(temp_success_file_handle)
os.remove(temp_success_filename)
os.close(temp_denied_keys_file_handle)
# Verify that "denied keys" file contains denied entry
with open(temp_denied_keys_filename) as file:
denied_keys = json.load(file)
denied_item_time = datetime.datetime.strptime(
start_time, '%Y%m%d%H%M%S').isoformat()
assert denied_keys == {'31430023550355': denied_item_time}
os.remove(temp_denied_keys_filename)
def test_multiple_responses(mock_server):
imposter = Imposter(Stub(responses=[Response(body="sausages"), Response(body="egg")]))
with mock_server(imposter):
r1 = requests.get(imposter.url)
r2 = requests.get(imposter.url)
r3 = requests.get(imposter.url)
assert_that(r1, is_response().with_body("sausages"))
assert_that(r2, is_response().with_body("egg"))
assert_that(r3, is_response().with_body("sausages"))
def test_multiple_imposters(mock_server):
imposters = [
Imposter(Stub(Predicate(path="/test1"), Response("sausages"))),
Imposter([Stub([Predicate(path="/test2")], [Response("chips", status_code=201)])]),
]
with mock_server(imposters):
r1 = requests.get("{0}/test1".format(imposters[0].url))
r2 = requests.get("{0}/test2".format(imposters[1].url))
assert_that(r1, is_response().with_status_code(200).and_body("sausages"))
assert_that(r2, is_response().with_status_code(201).and_body("chips"))
def test_query_all_imposters(mock_server):
imposter1 = Imposter(
Stub(Predicate(path="/test1"), Response(body="sausages")))
imposter2 = Imposter(Stub(Predicate(path="/test2"), Response(body="egg")))
with mock_server([imposter1, imposter2]) as server:
actual = server.query_all_imposters()
assert_that(
actual,
contains_inanyorder(has_identical_properties_to(imposter1),
has_identical_properties_to(imposter2)),
)
def test_remove_and_replace_impostor_from_running_server(mock_server):
# Set up server
with mock_server([
Imposter(Stub(Predicate(path="/test"), Response(body="sausage")),
name="sausage"),
Imposter(Stub(Predicate(path="/test"), Response(body="egg")),
name="egg"),
Imposter(Stub(Predicate(path="/test"), Response(body="chips")),
name="chips"),
]) as server:
# Retrieve impostor details from running server, and check they work
initial = server.query_all_imposters()
responses = [requests.get(f"{initial[i].url}/test") for i in range(3)]
assert_that(
responses,
contains_inanyorder(
is_response().with_body("sausage"),
is_response().with_body("egg"),
is_response().with_body("chips"),
),
)
# Delete one impostor, make sure it's gone, and that the rest still work
egg_impostor = [i for i in initial if i.name == "egg"][0]
other_impostors = [i for i in initial if i.name != "egg"]
server.delete_impostor(egg_impostor)
with pytest.raises(requests.exceptions.ConnectionError):
requests.get(f"{egg_impostor.url}/test")
responses = [requests.get(f"{i.url}/test") for i in other_impostors]
assert_that(
responses,
contains_inanyorder(
is_response().with_body("sausage"),
is_response().with_body("chips"),
),
)
# Reset the server from the initial impostors, and check it's back to normal
server.delete_imposters()
server.add_imposters(initial)
responses = [requests.get(f"{initial[i].url}/test") for i in range(3)]
assert_that(
responses,
contains_inanyorder(
is_response().with_body("sausage"),
is_response().with_body("egg"),
is_response().with_body("chips"),
),
)
def test_successful_job(mock_server):
with open("tests/resources/items/valid_src_response.json") as file:
valid_src_response = file.read()
with open("tests/resources/items/valid_dest_new_items_response.json"
) as file:
valid_dest_new_items_response = file.read()
with open("tests/resources/items/valid_dest_updated_items_response.json"
) as file:
valid_dest_updated_items_response = file.read()
# Set up mock server with required behavior
imposter = Imposter([
Stub(Predicate(path="/src"), Response(body=valid_src_response)),
Stub(Predicate(path="/dest/new", method="POST"),
Response(body=valid_dest_new_items_response)),
Stub(Predicate(path="/dest/updated", method="POST"),
Response(body=valid_dest_updated_items_response)),
])
# Create a temporary file to use as last success lookup
try:
[temp_file_handle, temp_success_filename] = tempfile.mkstemp()
with open(temp_success_filename, 'w') as f:
f.write('etc/items_FIRST.json')
with tempfile.TemporaryDirectory() as temp_storage_dir, mock_server(
imposter) as server:
setup_environment(imposter, temp_storage_dir,
temp_success_filename)
start_time = '20200521132905'
args = []
command = Command()
result = command(start_time, args)
assert result.was_successful() is True
assert_that(server,
had_request().with_path("/src").and_method("GET"))
assert_that(
server,
had_request().with_path("/dest/new").and_method("POST"))
assert_that(
server,
had_request().with_path("/dest/updated").and_method("POST"))
finally:
# Clean up the temporary file
os.close(temp_file_handle)
os.remove(temp_success_filename)
def test_import_impostor_from_running_server(mock_server):
# Set up server
with mock_server([
Imposter(Stub(Predicate(path="/test"), Response(body="sausage")),
name="sausage"),
Imposter(Stub(Predicate(path="/test"), Response(body="egg")),
name="egg"),
Imposter(Stub(Predicate(path="/test"), Response(body="chips")),
name="chips"),
]) as server:
initial = server.query_all_imposters()
server.import_running_imposters()
after = server.get_running_imposters()
assert str(initial) == str(after)
def test_regex_copy(mock_server):
imposter = Imposter(
Stub(responses=Response(
status_code="${code}",
headers={"X-Test": "${header}"},
body="Hello, ${name}!",
copy=[
Copy("path", "${code}", UsingRegex("\\d+")),
Copy({"headers": "X-Request"}, "${header}", UsingRegex(".+")),
Copy({"query": "name"}, "${name}",
UsingRegex("AL\\w+", ignore_case=True)),
],
)))
with mock_server(imposter):
response = requests.get(imposter.url / str(456),
params={"name": "Alice"},
headers={"X-REQUEST": "Header value"})
assert_that(
response,
is_response().with_status_code(456).with_body(
"Hello, Alice!").with_headers(
has_entry("X-Test", "Header value")),
)
def test_send_updated_items_to_dest_valid_response(mock_server):
with open("tests/resources/items/valid_dest_updated_items_response.json") as file:
valid_dest_response = file.read()
# Set up mock server with required behavior
imposter = Imposter(Stub(Predicate(path="/items/updates", method="POST"),
Response(body=valid_dest_response)))
with mock_server(imposter) as server:
config = {
'dest_updates_url': f"{imposter.url}/items/updates",
'storage_dir': '/tmp',
'last_success_lookup': 'tests/storage/items/items_last_success.txt',
'caiasoft_api_key': "SOME_SECRET_KEY"
}
job_config = ItemsJobConfig(config, 'test')
# Override dest_updated_items_request_body_filepath
job_config["dest_updated_items_request_body_filepath"] = \
"tests/resources/items/valid_dest_updated_items_request.json"
with tempfile.TemporaryDirectory() as temp_storage_dir:
job_config["dest_updated_items_response_body_filepath"] = \
temp_storage_dir + "/dest_updated_items_response.json"
send_updated_items_to_dest = SendUpdatedItemsToDest(job_config)
step_result = send_updated_items_to_dest.execute()
assert step_result.was_successful() is True
assert os.path.exists(job_config["dest_updated_items_response_body_filepath"])
assert_that(server, had_request().with_path("/items/updates").and_method("POST"))
assert valid_dest_response == step_result.get_result()
def test_404_response_from_server(mock_server):
# Set up mock server with required behavior
imposter = Imposter(
Stub(Predicate(path="/holds"), Response(status_code=404)))
with mock_server(imposter) as server:
config = {
'source_url':
f"{imposter.url}/holds",
'storage_dir':
'/tmp',
'last_success_lookup':
'tests/storage/circrequests/circrequests_last_success.txt',
'denied_keys_filepath':
'tests/storage/circrequests/circrequests_denied_keys.json'
}
job_config = CircrequestsJobConfig(config, 'test')
query_source_url = QuerySourceUrl(job_config)
step_result = query_source_url.execute()
assert step_result.was_successful() is False
assert_that(server,
had_request().with_path("/holds").and_method("GET"))
assert f"Retrieval of '{imposter.url}/holds' failed with a status code of 404" in \
step_result.get_errors()
def test_valid_response_from_server(mock_server):
with open("tests/resources/circrequests/valid_src_response.json") as file:
valid_src_response = file.read()
# Set up mock server with required behavior
imposter = Imposter(
Stub(Predicate(path="/holds"), Response(body=valid_src_response)))
with mock_server(imposter) as server:
config = {
'source_url':
f"{imposter.url}/holds",
'storage_dir':
'/tmp',
'last_success_lookup':
'tests/storage/circrequests/circrequests_last_success.txt',
'denied_keys_filepath':
'tests/storage/circrequests/circrequests_denied_keys.json'
}
job_config = CircrequestsJobConfig(config, 'test')
query_source_url = QuerySourceUrl(job_config)
step_result = query_source_url.execute()
assert step_result.was_successful() is True
assert_that(server,
had_request().with_path("/holds").and_method("GET"))
assert valid_src_response == step_result.get_result()
def test_and_predicate_and_query_strings(mock_server):
imposter = Imposter(
Stub(
Predicate(query={"foo": "bar"})
& Predicate(query={"dinner": "chips"}),
Response(body="black pudding"),
))
with mock_server(imposter) as s:
logger.debug("server: %s", s)
r1 = requests.get(f"{imposter.url}/",
params={
"dinner": "chips",
"foo": "bar"
})
r2 = requests.get(f"{imposter.url}/", params={"dinner": "chips"})
assert_that(
r1,
is_response().with_status_code(200).and_body("black pudding"))
assert_that(
r2,
not_(
is_response().with_status_code(200).and_body("black pudding")))
def test_decorate_response(mock_server):
imposter = Imposter(Stub(responses=Response(body="Hello ${NAME}.", decorate=JS)))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_response().with_body("Hello World."))
def test_jsonpath_copy(mock_server):
imposter = Imposter(
Stub(responses=Response(body="Have you read BOOK?",
copy=Copy("body", "BOOK",
UsingJsonpath("$..title")))))
with mock_server(imposter):
response = requests.post(
imposter.url,
json={
"books": [
{
"book": {
"title": "Game of Thrones",
"summary": "Dragons and political intrigue",
}
},
{
"book": {
"title": "Harry Potter",
"summary": "Dragons and a boy wizard"
}
},
{
"book": {
"title": "The Hobbit",
"summary": "A dragon and short people"
}
},
]
},
)
assert_that(response,
is_response().with_body("Have you read Game of Thrones?"))
def test_cloud_api_timeout(mock_server):
imposter = Imposter(
Stub(Predicate(path="/hub/lan_ip"),
Response(body='[ "127.0.0.1" ]', wait=6000)))
with pytest.raises(ConnectionError) as e_info:
with mock_server(imposter):
cloud_api.lan_ip(base=imposter.url)
def test_multiple_imposters(mock_server):
imposters = [
Imposter(Stub(Predicate(path="/test1"), Response("sausages"))),
Imposter([
Stub([Predicate(path="/test2")],
[Response("chips", status_code=201)])
]),
]
with mock_server(imposters) as s:
logger.debug("server: %s", s)
r1 = requests.get("{0}/test1".format(imposters[0].url))
r2 = requests.get("{0}/test2".format(imposters[1].url))
assert_that(r1, response_with(status_code=200, body="sausages"))
assert_that(r2, response_with(status_code=201, body="chips"))
def test_status(mock_server):
imposter = Imposter(Stub(responses=Response(status_code=204)))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_(response_with(status_code=204)))
def test_binary_mode(mock_server):
imposter = Imposter(Stub(responses=Response(mode=Response.Mode.BINARY, body=b"c2F1c2FnZXM=")))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_response().with_content(b"sausages"))
def test_body(mock_server):
imposter = Imposter(Stub(responses=Response(body="sausages")))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_(response_with(body="sausages")))
def test_lookup(mock_server):
datasource_path = str(
Path("tests") / "integration" / "behaviors" / "test_data" /
"values.csv")
imposter = Imposter(
Stub(responses=Response(
status_code="${row}['code']",
body=
"Hello ${row}['Name'], have you done your ${row}['jobs'] today?",
headers={"X-Tree": "${row}['tree']"},
lookup=Lookup(Key("path", UsingRegex("/(.*)$"), 1),
datasource_path, "Name", "${row}"),
)))
with mock_server(imposter):
response = requests.get(imposter.url / "liquid")
assert_that(
response,
is_(
response_with(
status_code=400,
body="Hello liquid, have you done your farmer today?",
headers=has_entry("X-Tree", "mango"),
)),
)
def test_wait(mock_server):
imposter = Imposter(Stub(responses=Response(wait=100)))
with mock_server(imposter), Timer() as timer:
requests.get(imposter.url)
assert_that(timer.elapsed, between(0.1, 0.25))
def test_multiple_stubs(mock_server):
imposter = Imposter(
[
Stub(Predicate(path="/test1"), Response(body="sausages")),
Stub(Predicate(path="/test2"), Response(body="chips")),
],
port=4567,
name="bill",
)
with mock_server(imposter) as s:
logger.debug("server: %s", s)
r1 = requests.get("{0}/test1".format(imposter.url))
r2 = requests.get("{0}/test2".format(imposter.url))
assert_that(r1, is_response().with_body("sausages"))
assert_that(r2, is_response().with_body("chips"))
def test_imposter_had_request_matcher(mock_server):
imposter = Imposter(Stub(Predicate(path="/test"), Response(body="sausages")))
with mock_server(imposter):
response = requests.get(f"{imposter.url}/test")
assert_that(response, is_response().with_status_code(200).and_body("sausages"))
assert_that(imposter, had_request().with_path("/test").and_method("GET"))
def test_attach_to_existing(mock_server):
imposter = Imposter(
Stub(Predicate(path="/test"), Response(body="sausages")))
with MountebankServer(port=mock_server.server_port)(imposter):
response = requests.get("{0}/test".format(imposter.url))
assert_that(response,
is_response().with_status_code(200).and_body("sausages"))
def test_decorate(mock_server):
imposter = Imposter(Stub(responses=Response(body="The time is ${TIME}.", decorate=JS)))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(
response, is_response().with_body(matches_regexp(r"The time is \d\d:\d\d:\d\d\."))
)
def test_cloud_api_requestlogin(mock_server, tmp_cloud):
imposter = Imposter(
Stub(
Predicate(method=Predicate.Method.POST)
& Predicate(path="/user/requestlogin")
& Predicate(query={"email": tmp_cloud.email}),
Response(body='null')))
with mock_server(imposter):
cloud_api.requestlogin(email=tmp_cloud.email, base=imposter.url)
def test_cloud_api_emaillogin(mock_server, tmp_cloud):
imposter = Imposter(
Stub(Predicate(path="/user/emaillogin"),
Response(body=tmp_cloud.token)))
with mock_server(imposter):
token = cloud_api.emaillogin(email=tmp_cloud.email,
otp='42',
base=imposter.url)
assert isinstance(token, str)
