def test_it_injects_headers(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.GET
a_request.headers = [Header(name="some_header", value="some_value")]
task = Task("some_task", a_request)
action = task.as_locust_action()
assert "some_value" in action
def test_it_returns_a_task_using_post_given_a_post_http_method(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.POST
a_request.post_data = {}
task = Task("some_task", a_request)
action = task.as_locust_action()
assert action.startswith("response = self.client.post(")
def test_records_global_code_blocks_from_tasks(self):
t1_blocks = {"t1-1": ["abc"], "t1-2": ["def"]}
t1 = Task("t1", request=MagicMock(), global_code_blocks=t1_blocks)
t2 = Task("t2", request=MagicMock())
t3_blocks = {"t3-1": ("xyz",)}
t3 = Task("t3", request=MagicMock(), global_code_blocks=t3_blocks)
scenario = Scenario("scenario", [t1, t2, t3], origin=None)
assert scenario.global_code_blocks == {**t1_blocks, **t3_blocks}
def test_it_encodes_data_in_task_for_text_mime(self):
decoded_value = '{"formatted": "54,95 €"}'
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.POST
a_request.post_data = {"text": decoded_value}
task = Task("some_task", a_request)
action = task.as_locust_action()
assert str(decoded_value.encode()) in action
def test_it_returns_a_task_using_delete_given_a_delete_http_method(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.DELETE
a_request.url = urlparse(
"http://www.some.web.site/?some_name=some_value")
task = Task("some_task", a_request)
action = task.as_locust_action()
assert action.startswith("response = self.client.delete(")
assert "?some_name=some_value" in action
def test_it_returns_a_task_using_put_given_a_put_http_method(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.PUT
a_request.post_data = {"text": "{'some key': 'some value'}"}
a_request.query = [QueryPair(name="some name", value="some value")]
task = Task("some_task", a_request)
action = task.as_locust_action()
assert action.startswith("response = self.client.put(")
assert "params={'some name': 'some value'}" in action
assert "data=b\"{'some key': 'some value'}\"" in action
def test_post_processing_returns_an_indented_string_given_an_indentation(
self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.GET
task = Task("some_task", a_request)
new_post_processings = (*task.locust_postprocessing,
"def some_function():")
task = task._replace(locust_postprocessing=new_post_processings)
action = task.as_locust_action(indentation=2)
assert " def some_function():" in action
def test_group_records_global_code_blocks_from_scenarios(self):
t1_blocks = {"t1-1": ["abc"], "t1-2": ["def"]}
t1 = Task("t1", request=MagicMock(), global_code_blocks=t1_blocks)
t2 = Task("t2", request=MagicMock())
t3_blocks = {"t3-1": ("xyz",)}
t3 = Task("t3", request=MagicMock(), global_code_blocks=t3_blocks)
s1 = Scenario("s1", [t1, t2], origin=None)
s2 = Scenario("s2", [t3], origin=None)
sg = Scenario("sg", [s1, s2], origin=None)
assert sg.global_code_blocks == {**t1_blocks, **t3_blocks}
def test_it_encodes_data_in_task_for_json_mime(self):
decoded_value = '{"formatted": "54,95 €"}'
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.POST
a_request.post_data = {
"text": decoded_value,
"mimeType": "application/json"
}
task = Task("some_task", a_request)
action = task.as_locust_action()
assert str(json.loads(decoded_value)) in action
def test_it_returns_a_task_using_options_given_an_options_http_method(
self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.OPTIONS
a_request.headers = [
Header(name="Access-Control-Request-Method", value="POST")
]
task = Task("some_task", a_request)
action = task.as_locust_action()
assert action.startswith("response = self.client.options(")
assert "headers={'Access-Control-Request-Method': 'POST'" in action
def test_it_respects_sub_indentation_levels(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.GET
task = Task("some_task", a_request)
new_pre_processings = (
*task.locust_preprocessing,
"\n def function():\n if True:\n print(True)",
)
task = task._replace(locust_preprocessing=new_pre_processings)
action = task.as_locust_action(indentation=1)
assert action.startswith(
" \n def function():\n if True:\n print(True)")
def test_it_returns_action_from_locust_request(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.GET
locust_request = LocustRequest(method=HttpMethod.GET,
url=repr("http://locust-task"),
headers={})
task = Task("some_task",
request=a_request,
locust_request=locust_request)
action = task.as_locust_action()
assert action.startswith(
"response = self.client.get(url='http://locust-task'")
def test_it_returns_a_task_with_the_replaced_url(self):
locust_request = LocustRequest(
method=MagicMock(), url=MagicMock(), headers=MagicMock()
)
task = Task(
name="some name", request=MagicMock(), locust_request=locust_request
)
expected_url = 'f"http://a.b.c/{some.value}/"'
modified_task = Task.replace_url(task, expected_url)
assert modified_task.locust_request.url == expected_url
def test_it_applies_indentation_to_all_pre_processings(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.GET
task = Task("some_task", a_request)
new_pre_processings = (
*task.locust_preprocessing,
"def some_function():",
"def some_other_function():",
)
task = task._replace(locust_preprocessing=new_pre_processings)
action = task.as_locust_action(indentation=2)
assert action.startswith(
" def some_function():\n\n def some_other_function():")
def test_it_returns_a_task_with_the_injected_headers(self):
locust_request = LocustRequest(method=MagicMock(),
url=MagicMock(),
headers={"x-forwarded-for": ""})
task = Task(name="some name",
request=MagicMock(),
locust_request=locust_request)
expected_headers = {"x-forwarded-for": "1.2.3.4"}
modified_task = Task.inject_headers(task, headers=expected_headers)
assert isinstance(modified_task, Task)
headers = modified_task.locust_request.headers
assert len(headers) == 1
assert headers == expected_headers
def from_har_file(
cls,
path: Path,
plugins: Sequence[Plugin],
ts_plugins: Sequence[Plugin],
short_name: bool,
blacklist: Blacklist,
) -> "Scenario":
"""
Creates a Scenario given a HAR file.
:raise SkippableScenarioError: if path is unreadable or not a HAR file
"""
try:
with path.open() as file:
har = json.load(file)
requests = Request.all_from_har(har)
tasks = Task.from_requests(requests, blacklist)
# TODO: Remove this when Contract.OnTaskSequence is removed.
tasks = plug.apply(ts_plugins, tasks)
# TODO: Remove Task-to-Task2 conversion once both are merged.
tasks = tuple(
plug.apply(plugins, Task2.from_task(t)) for t in tasks)
return Scenario(
name=to_identifier(
path.with_suffix("").name if short_name else str(path)),
children=tuple(tasks),
origin=path,
weight=cls.weight_from_path(path),
)
except (OSError, json.JSONDecodeError, UnicodeDecodeError) as err:
raise SkippableScenarioError(path, err)
def test_it_creates_a_task_if_the_path_not_host_is_on_the_blacklist(
self, mock_open):
mock_open.return_value = io.StringIO("search\namazon")
request = MagicMock()
request.url = urlparse("https://www.google.com/search?&q=amazon")
task = Task.from_requests([request])
assert len(list(task)) == 1
def test_it_returns_a_task(self):
request = MagicMock()
request.timestamp = 1
second_request = MagicMock()
second_request.timestamp = 2
assert all(
isinstance(t, Task)
for t in Task.from_requests([request, second_request]))
def test_it_doesnt_create_a_task_if_the_url_is_on_the_blacklist(
self, mock_open):
mock_open.return_value = io.StringIO("amazon")
request = MagicMock()
request.url = MagicMock()
request.url.netloc = "www.amazon.com"
task = Task.from_requests([request])
assert len(list(task)) == 0
def test_it_renders_a_locustfile_template(self):
a_name = "some_task"
a_request = MagicMock(spec=Request)
a_request.method = HttpMethod.GET
a_request.url = MagicMock(spec=SplitResult)
a_request.url.scheme = "some_scheme"
a_request.url.hostname = "some_hostname"
a_request.url.path = "some_path"
a_request.url.geturl()
a_request.url.geturl.return_value = "some_url"
a_request.headers = {"a": "b"}
a_request.name = None
task = Task(a_name, a_request)
scenario = Scenario(name="SomeScenario", children=[task], origin=None)
scenario_group = Scenario(name="ScenarioGroup",
children=[scenario],
weight=2,
origin=None)
script = locustfile([scenario_group])
expected = string.Template(f"""
# File automatically generated by Transformer v{__version__}:
# https://github.com/zalando-incubator/Transformer
import re
from distutils.version import LooseVersion
from locust import __version__
LOCUST_MAJOR_VERSION = LooseVersion(__version__).version[0]
if LOCUST_MAJOR_VERSION >= 1:
from locust import HttpUser
from locust import SequentialTaskSet
from locust import TaskSet
from locust import task
HttpLocust = HttpUser
TaskSequence = SequentialTaskSet
def seq_task(_):
return task
else:
from locust import HttpLocust
from locust import TaskSequence
from locust import TaskSet
from locust import seq_task
from locust import task
class ScenarioGroup(TaskSet):
@task(1)
class SomeScenario(TaskSequence):
@seq_task(1)
def some_task(self):
response = self.client.get(url='some_url', name='some_url', timeout=$TIMEOUT, allow_redirects=False, headers={{'a': 'b'}})
class LocustForScenarioGroup(HttpLocust):
if LOCUST_MAJOR_VERSION >= 1:
tasks = [ScenarioGroup]
else:
task_set = ScenarioGroup
weight = 2
min_wait = 0
max_wait = 10
""").safe_substitute({"TIMEOUT": TIMEOUT})
assert expected.strip() == script.strip()
def test_group_records_global_code_blocks_uniquely(self):
common_blocks = {"x": ["a", "b"]}
t1 = Task(
"t1",
request=MagicMock(),
global_code_blocks={**common_blocks, "t1b": ["uvw"]},
)
t2 = Task(
"t2",
request=MagicMock(),
global_code_blocks={**common_blocks, "t2b": ["xyz"]},
)
s1 = Scenario("s1", [t1], origin=None)
s2 = Scenario("s2", [t2], origin=None)
sg = Scenario("sg", [s1, s2], origin=None)
assert sg.global_code_blocks == {
**common_blocks,
"t1b": ["uvw"],
"t2b": ["xyz"],
}
def test_it_converts_post_params_to_post_text(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.POST
a_request.post_data = {
"mimeType":
"application/json",
"params": [
{
"name": "username",
"value": "some user"
},
{
"name": "password",
"value": "some password"
},
],
}
task = Task("some task", a_request)
action = task.as_locust_action()
assert "'username': '******'" in action
assert "'password': '******'" in action
def test_without_locust_request_it_proxies_the_request(self):
req = Mock(spec_set=Request)
task = Task(name="T", request=req)
task2 = Task2.from_task(task)
assert task2.name == "T"
assert task2.request == req
assert len(task2.statements) == 1
assign = task2.statements[0]
assert isinstance(assign, py.Assignment)
assert assign.lhs == "response"
assert isinstance(assign.rhs, py.ExpressionView)
assert assign.rhs.target() == task2.request
assert assign.rhs.converter is req_to_expr
def test_it_renders_a_locustfile_template(self):
a_name = "some_task"
a_request = MagicMock()
a_request.method = HttpMethod.GET
a_request.url.scheme = "some_scheme"
a_request.url.hostname = "some_hostname"
a_request.url.path = "some_path"
a_request.url.geturl()
a_request.url.geturl.return_value = "some_url"
task = Task(a_name, a_request)
scenario = Scenario(name="SomeScenario", children=[task], origin=None)
scenario_group = Scenario(name="ScenarioGroup",
children=[scenario],
weight=2,
origin=None)
script = locustfile([scenario_group])
expected = string.Template("""
# File automatically generated by Transformer:
# https://github.bus.zalan.do/TIP/transformer
import re
from locust import HttpLocust
from locust import TaskSequence
from locust import TaskSet
from locust import seq_task
from locust import task
class ScenarioGroup(TaskSet):
@task(1)
class SomeScenario(TaskSequence):
@seq_task(1)
def some_task(self):
response = self.client.get(url='some_url', name='some_url', headers={}, timeout=$TIMEOUT, allow_redirects=False)
class LocustForScenarioGroup(HttpLocust):
task_set = ScenarioGroup
weight = 2
min_wait = 0
max_wait = 10
""").safe_substitute({"TIMEOUT": TIMEOUT})
assert expected.strip() == script.strip()
def test_it_provides_timeout_to_requests(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.GET
task = Task("some_task", a_request)
action = task.as_locust_action()
assert f"timeout={TIMEOUT}" in action
def test_it_creates_a_locust_request_when_there_is_none(self):
task = Task(name="some name", request=MagicMock())
modified_task = Task.inject_headers(task, {})
assert modified_task.locust_request
def test_it_creates_a_locust_request_when_there_is_none(self):
task = Task(name="some name", request=MagicMock())
modified_task = Task.replace_url(task, "")
assert modified_task.locust_request
def test_it_returns_an_error_given_an_unsupported_http_method(self):
a_request_with_an_unsupported_http_method = MagicMock()
task = Task("some_task", a_request_with_an_unsupported_http_method)
with pytest.raises(ValueError):
task.as_locust_action()
def test_it_returns_a_string(self):
a_request = MagicMock(spec_set=Request)
a_request.method = HttpMethod.GET
task = Task("some_task", a_request)
assert isinstance(task.as_locust_action(), str)
