locust 2.29.2.dev32__py3-none-any.whl → 2.29.2.dev42__py3-none-any.whl

locust/test/test_http.py

@@ -1,325 +0,0 @@
-from locust.clients import HttpSession
-from locust.exception import LocustError, ResponseError
-from locust.user.users import HttpUser
-
-import time
-
-from requests.exceptions import InvalidSchema, InvalidURL, MissingSchema, RequestException
-
-from .testcases import WebserverTestCase
-
-
-class TestHttpSession(WebserverTestCase):
-    def get_client(self, base_url=None):
-        if base_url is None:
-            base_url = "http://127.0.0.1:%i" % self.port
-        return HttpSession(
-            base_url=base_url,
-            request_event=self.environment.events.request,
-            user=None,
-        )
-
-    def test_get(self):
-        s = self.get_client()
-        r = s.get("/ultra_fast")
-        self.assertEqual(200, r.status_code)
-
-    def test_connection_error(self):
-        s = self.get_client(base_url="http://localhost:1")
-        r = s.get("/", timeout=0.1)
-        self.assertEqual(r.status_code, 0)
-        self.assertEqual(None, r.content)
-        self.assertRaises(RequestException, r.raise_for_status)
-
-    def test_wrong_url(self):
-        for url, exception in (
-            ("http://\x94", InvalidURL),
-            ("telnet://127.0.0.1", InvalidSchema),
-            ("127.0.0.1", MissingSchema),
-        ):
-            s = self.get_client(base_url=url)
-            try:
-                self.assertRaises(exception, s.get, "/")
-            except KeyError:
-                self.fail(f"Invalid URL {url} was not propagated")
-
-    def test_streaming_response(self):
-        """
-        Test a request to an endpoint that returns a streaming response
-        """
-        s = self.get_client()
-        r = s.get("/streaming/30")
-
-        # verify that the time reported includes the download time of the whole streamed response
-        self.assertGreater(self.runner.stats.get("/streaming/30", method="GET").avg_response_time, 250)
-        self.runner.stats.clear_all()
-
-        # verify that response time does NOT include whole download time, when using stream=True
-        r = s.get("/streaming/30", stream=True)
-        self.assertGreater(self.runner.stats.get("/streaming/30", method="GET").avg_response_time, 0)
-        self.assertLess(self.runner.stats.get("/streaming/30", method="GET").avg_response_time, 250)
-
-        # download the content of the streaming response (so we don't get an ugly exception in the log)
-        _ = r.content
-
-    def test_slow_redirect(self):
-        s = self.get_client()
-        url = "/redirect?url=/redirect&delay=0.5"
-        s.get(url)
-        stats = self.runner.stats.get(url, method="GET")
-        self.assertEqual(1, stats.num_requests)
-        self.assertGreater(stats.avg_response_time, 500)
-
-    def test_post_redirect(self):
-        s = self.get_client()
-        url = "/redirect"
-        r = s.post(url)
-        self.assertEqual(200, r.status_code)
-        post_stats = self.runner.stats.get(url, method="POST")
-        get_stats = self.runner.stats.get(url, method="GET")
-        self.assertEqual(1, post_stats.num_requests)
-        self.assertEqual(0, get_stats.num_requests)
-
-    def test_cookie(self):
-        s = self.get_client()
-        r = s.post("/set_cookie?name=testcookie&value=1337")
-        self.assertEqual(200, r.status_code)
-        r = s.get("/get_cookie?name=testcookie")
-        self.assertEqual("1337", r.content.decode())
-
-    def test_head(self):
-        s = self.get_client()
-        r = s.head("/request_method")
-        self.assertEqual(200, r.status_code)
-        self.assertEqual("", r.content.decode())
-
-    def test_delete(self):
-        s = self.get_client()
-        r = s.delete("/request_method")
-        self.assertEqual(200, r.status_code)
-        self.assertEqual("DELETE", r.content.decode())
-
-    def test_options(self):
-        s = self.get_client()
-        r = s.options("/request_method")
-        self.assertEqual(200, r.status_code)
-        self.assertEqual("", r.content.decode())
-        self.assertEqual(
-            {"OPTIONS", "DELETE", "PUT", "GET", "POST", "HEAD", "PATCH"},
-            set(r.headers["allow"].split(", ")),
-        )
-
-    def test_error_message(self):
-        s = self.get_client()
-        kwargs = {}
-
-        def on_request(**kw):
-            kwargs.update(kw)
-
-        self.environment.events.request.add_listener(on_request)
-        s.request("get", "/wrong_url", context={"foo": "bar"})
-        self.assertIn("/wrong_url", str(kwargs["exception"]))
-        self.assertDictEqual({"foo": "bar"}, kwargs["context"])
-
-    def test_context_in_success(self):
-        s = self.get_client()
-        kwargs = {}
-
-        def on_request(exception, **kw):
-            self.assertIsNone(exception)
-            kwargs.update(kw)
-
-        self.environment.events.request.add_listener(on_request)
-        s.request("get", "/request_method", context={"foo": "bar"})
-        self.assertDictEqual({"foo": "bar"}, kwargs["context"])
-
-    def test_response_parameter(self):
-        s = self.get_client()
-        kwargs = {}
-
-        def on_request(**kw):
-            kwargs.update(kw)
-
-        self.environment.events.request.add_listener(on_request)
-        s.request("get", "/request_method")
-        self.assertEqual("GET", kwargs["response"].text)
-        s.request("get", "/wrong_url")
-        self.assertEqual("Not Found", kwargs["response"].text)
-
-    def test_error_message_with_name_replacement(self):
-        s = self.get_client()
-        kwargs = {}
-
-        def on_request(**kw):
-            self.assertIsNotNone(kw["exception"])
-            kwargs.update(kw)
-
-        self.environment.events.request.add_listener(on_request)
-        before_request = time.time()
-        s.request("get", "/wrong_url/01", name="replaced_url_name", context={"foo": "bar"})
-        after_request = time.time()
-        self.assertIn("for url: replaced_url_name", str(kwargs["exception"]))
-        self.assertAlmostEqual(before_request, kwargs["start_time"], delta=0.01)
-        self.assertAlmostEqual(after_request, kwargs["start_time"] + kwargs["response_time"] / 1000, delta=0.01)
-        self.assertEqual(s.base_url + "/wrong_url/01", kwargs["url"])  # url is unaffected by name
-        self.assertDictEqual({"foo": "bar"}, kwargs["context"])
-
-    def test_get_with_params(self):
-        s = self.get_client()
-        r = s.get("/get_arg", params={"arg": "test_123"})
-        self.assertEqual(200, r.status_code)
-        self.assertEqual("test_123", r.text)
-
-    def test_catch_response_fail_successful_request(self):
-        s = self.get_client()
-        with s.get("/ultra_fast", catch_response=True) as r:
-            r.failure("nope")
-        self.assertEqual(1, self.environment.stats.get("/ultra_fast", "GET").num_requests)
-        self.assertEqual(1, self.environment.stats.get("/ultra_fast", "GET").num_failures)
-
-    def test_catch_response_fail_successful_request_with_non_string_error_message(self):
-        s = self.get_client()
-        with s.get("/ultra_fast", catch_response=True) as r:
-            r.failure({"other types are also wrapped as exceptions": True})
-        self.assertEqual(1, self.environment.stats.get("/ultra_fast", "GET").num_requests)
-        self.assertEqual(1, self.environment.stats.get("/ultra_fast", "GET").num_failures)
-
-    def test_catch_response_pass_failed_request(self):
-        s = self.get_client()
-        with s.get("/fail", catch_response=True) as r:
-            r.success()
-        self.assertEqual(1, self.environment.stats.total.num_requests)
-        self.assertEqual(0, self.environment.stats.total.num_failures)
-
-    def test_catch_response_multiple_failure_and_success(self):
-        s = self.get_client()
-        with s.get("/ultra_fast", catch_response=True) as r:
-            r.failure("nope")
-            r.success()
-            r.failure("nooo")
-            r.success()
-        self.assertEqual(1, self.environment.stats.total.num_requests)
-        self.assertEqual(0, self.environment.stats.total.num_failures)
-
-    def test_catch_response_timeout(self):
-        s = self.get_client()
-        with s.get("/slow", catch_response=True, timeout=0.1) as r:
-            self.assertAlmostEqual(r.request_meta["response_time"], 100, delta=50)
-        self.assertEqual(1, self.environment.stats.total.num_requests)
-        self.assertEqual(1, self.environment.stats.total.num_failures)
-
-    def test_catch_response_pass_failed_request_with_other_exception_within_block(self):
-        class OtherException(Exception):
-            pass
-
-        s = self.get_client()
-        try:
-            with s.get("/fail", catch_response=True) as r:
-                r.success()
-                raise OtherException("wtf")
-        except OtherException:
-            pass
-        else:
-            self.fail("OtherException should have been raised")
-
-        self.assertEqual(1, self.environment.stats.total.num_requests)
-        self.assertEqual(0, self.environment.stats.total.num_failures)
-
-    def test_catch_response_response_error(self):
-        s = self.get_client()
-        try:
-            with s.get("/fail", catch_response=True):
-                raise ResponseError("response error")
-        except ResponseError:
-            self.fail("ResponseError should not have been raised")
-
-        self.assertEqual(1, self.environment.stats.total.num_requests)
-        self.assertEqual(1, self.environment.stats.total.num_failures)
-
-    def test_catch_response_default_success(self):
-        s = self.get_client()
-        with s.get("/ultra_fast", catch_response=True):
-            pass
-        self.assertEqual(1, self.environment.stats.get("/ultra_fast", "GET").num_requests)
-        self.assertEqual(0, self.environment.stats.get("/ultra_fast", "GET").num_failures)
-
-    def test_catch_response_default_fail(self):
-        s = self.get_client()
-        with s.get("/fail", catch_response=True):
-            pass
-        self.assertEqual(1, self.environment.stats.total.num_requests)
-        self.assertEqual(1, self.environment.stats.total.num_failures)
-
-    def test_catch_response_with_name_replacement(self):
-        s = self.get_client()
-        kwargs = {}
-
-        def on_request(**kw):
-            self.assertIsNotNone(kw["exception"])
-            kwargs.update(kw)
-
-        self.environment.events.request.add_listener(on_request)
-
-        with s.get("/wrong_url/01", name="replaced_url_name"):
-            pass
-
-        self.assertIn("for url: replaced_url_name", str(kwargs["exception"]))
-        self.assertEqual(s.base_url + "/wrong_url/01", kwargs["url"])  # url is unaffected by name
-
-    def test_catch_response_missing_with_block(self):
-        s = self.get_client()
-        # incorrect usage, missing with-block
-        r = s.get("/fail", catch_response=True)
-        self.assertRaises(LocustError, r.success)
-        self.assertRaises(LocustError, r.failure, "")
-
-    def test_missing_catch_response_true(self):
-        s = self.get_client()
-        # incorrect usage, missing catch_response=True
-        with s.get("/fail") as resp:
-            self.assertRaises(LocustError, resp.success)
-
-    def test_event_measure(self):
-        kwargs = {}
-
-        def on_request(**kw):
-            kwargs.update(**kw)
-
-        self.environment.events.request.add_listener(on_request)
-
-        with self.environment.events.request.measure("GET", "/test") as request_meta:
-            time.sleep(0.001)
-
-        self.assertTrue(1 <= kwargs["response_time"] <= 1.5, kwargs["response_time"])
-        self.assertEqual(kwargs["name"], "/test")
-        self.assertIsNone(kwargs["exception"])
-
-        with self.environment.events.request.measure("GET", "/test") as request_meta:
-            request_meta["foo"] = "bar"
-            raise Exception("nooo")
-
-        self.assertEqual(kwargs["name"], "/test")
-        self.assertEqual(kwargs["foo"], "bar")
-        self.assertEqual(str(kwargs["exception"]), "nooo")
-
-    def test_user_context(self):
-        class TestUser(HttpUser):
-            host = f"http://127.0.0.1:{self.port}"
-
-            def context(self):
-                return {"user": self.username}
-
-        kwargs = {}
-
-        def on_request(**kw):
-            kwargs.update(kw)
-
-        self.environment.events.request.add_listener(on_request)
-
-        user = TestUser(self.environment)
-        user.username = "foo"
-        user.client.request("get", "/request_method")
-        self.assertDictEqual({"user": "foo"}, kwargs["context"])
-        self.assertEqual("GET", kwargs["response"].text)
-        user.client.request("get", "/request_method", context={"user": "bar"})  # override User context
-        self.assertDictEqual({"user": "bar"}, kwargs["context"])

locust/test/test_interruptable_task.py

@@ -1,48 +0,0 @@
-from locust import SequentialTaskSet, User, constant, task
-from locust.env import Environment
-from locust.exception import StopUser
-
-from collections import defaultdict
-from unittest import TestCase
-
-
-class InterruptableTaskSet(SequentialTaskSet):
-    counter: defaultdict[str, int] = defaultdict(int)
-
-    def on_start(self):
-        super().on_start()
-        self.counter["on_start"] += 1
-
-    @task
-    def t1(self):
-        self.counter["t1"] += 1
-        self.interrupt(reschedule=False)
-
-    @task
-    def t2(self):
-        self.counter["t2"] += 1
-
-    def on_stop(self):
-        super().on_stop()
-        self.counter["on_stop"] += 1
-        if self.counter["on_stop"] >= 2:
-            raise StopUser()
-
-
-class TestInterruptableTask(TestCase):
-    def setUp(self):
-        super().setUp()
-
-        class InterruptableUser(User):
-            host = "127.0.0.1"
-            tasks = [InterruptableTaskSet]
-            wait_time = constant(0)
-
-        self.locust = InterruptableUser(Environment(catch_exceptions=True))
-
-    def test_interruptable_task(self):
-        self.locust.run()
-        self.assertEqual(InterruptableTaskSet.counter.get("on_start"), 2)
-        self.assertEqual(InterruptableTaskSet.counter.get("t1"), 2)
-        self.assertEqual(InterruptableTaskSet.counter.get("t2", 0), 0)
-        self.assertEqual(InterruptableTaskSet.counter.get("on_stop"), 2)

locust/test/test_load_locustfile.py

@@ -1,228 +0,0 @@
-from locust import main
-from locust.argument_parser import parse_locustfile_option, parse_options
-from locust.main import create_environment
-from locust.user import HttpUser, TaskSet, User
-from locust.util.load_locustfile import is_user_class
-
-import filecmp
-import os
-import pathlib
-import textwrap
-
-from .mock_locustfile import MOCK_LOCUSTFILE_CONTENT, mock_locustfile
-from .testcases import LocustTestCase
-from .util import temporary_file
-
-
-class TestLoadLocustfile(LocustTestCase):
-    def test_is_user_class(self):
-        self.assertFalse(is_user_class(User))
-        self.assertFalse(is_user_class(HttpUser))
-        self.assertFalse(is_user_class({}))
-        self.assertFalse(is_user_class([]))
-
-        class MyTaskSet(TaskSet):
-            pass
-
-        class MyHttpUser(HttpUser):
-            tasks = [MyTaskSet]
-
-        class MyUser(User):
-            tasks = [MyTaskSet]
-
-        self.assertTrue(is_user_class(MyHttpUser))
-        self.assertTrue(is_user_class(MyUser))
-
-        class ThriftLocust(User):
-            abstract = True
-
-        self.assertFalse(is_user_class(ThriftLocust))
-
-    def test_load_locust_file_from_absolute_path(self):
-        with mock_locustfile() as mocked:
-            docstring, user_classes, shape_classes = main.load_locustfile(mocked.file_path)
-            self.assertIn("UserSubclass", user_classes)
-            self.assertNotIn("NotUserSubclass", user_classes)
-            self.assertNotIn("LoadTestShape", user_classes)
-            self.assertEqual(shape_classes, [])
-
-    def test_load_locust_file_from_relative_path(self):
-        with mock_locustfile() as mocked:
-            docstring, user_classes, shape_classes = main.load_locustfile(
-                os.path.join(os.path.relpath(mocked.directory, os.getcwd()), mocked.filename)
-            )
-
-    def test_load_locust_file_called_locust_dot_py(self):
-        with mock_locustfile() as mocked:
-            new_filename = mocked.file_path.replace(mocked.filename, "locust.py")
-            os.rename(mocked.file_path, new_filename)
-            try:
-                docstring, user_classes, shape_classes = main.load_locustfile(new_filename)
-            finally:
-                # move it back, so it can be deleted
-                os.rename(new_filename, mocked.file_path)
-
-    def test_load_locust_file_with_a_dot_in_filename(self):
-        with mock_locustfile(filename_prefix="mocked.locust.file") as mocked:
-            docstring, user_classes, shape_classes = main.load_locustfile(mocked.file_path)
-
-    def test_return_docstring_and_user_classes(self):
-        with mock_locustfile() as mocked:
-            docstring, user_classes, shape_classes = main.load_locustfile(mocked.file_path)
-            self.assertEqual("This is a mock locust file for unit testing", docstring)
-            self.assertIn("UserSubclass", user_classes)
-            self.assertNotIn("NotUserSubclass", user_classes)
-            self.assertNotIn("LoadTestShape", user_classes)
-
-    def test_with_shape_class(self):
-        content = (
-            MOCK_LOCUSTFILE_CONTENT
-            + """class LoadTestShape(LoadTestShape):
-                def tick(self):
-                    return None
-        """
-        )
-        with mock_locustfile(content=content) as mocked:
-            docstring, user_classes, shape_classes = main.load_locustfile(mocked.file_path)
-            self.assertEqual("This is a mock locust file for unit testing", docstring)
-            self.assertIn("UserSubclass", user_classes)
-            self.assertNotIn("NotUserSubclass", user_classes)
-            self.assertEqual(shape_classes[0].__class__.__name__, "LoadTestShape")
-
-    def test_with_multiple_shape_classes(self):
-        content = MOCK_LOCUSTFILE_CONTENT + textwrap.dedent(
-            """\
-        class LoadTestShape1(LoadTestShape):
-            def tick(self):
-                pass
-
-        class LoadTestShape2(LoadTestShape):
-            def tick(self):
-                pass
-        """
-        )
-        with mock_locustfile(content=content) as mocked:
-            docstring, user_classes, shape_classes = main.load_locustfile(mocked.file_path)
-            self.assertEqual("This is a mock locust file for unit testing", docstring)
-            self.assertIn("UserSubclass", user_classes)
-            self.assertNotIn("NotUserSubclass", user_classes)
-            self.assertEqual(shape_classes[0].__class__.__name__, "LoadTestShape1")
-            self.assertEqual(shape_classes[1].__class__.__name__, "LoadTestShape2")
-
-    def test_with_abstract_shape_class(self):
-        content = MOCK_LOCUSTFILE_CONTENT + textwrap.dedent(
-            """\
-        class UserBaseLoadTestShape(LoadTestShape):
-            abstract = True
-
-            def tick(self):
-                pass
-
-
-        class UserLoadTestShape(UserBaseLoadTestShape):
-            pass
-        """
-        )
-
-        with mock_locustfile(content=content) as mocked:
-            _, user_classes, shape_classes = main.load_locustfile(mocked.file_path)
-            self.assertNotIn("UserBaseLoadTestShape", user_classes)
-            self.assertNotIn("UserLoadTestShape", user_classes)
-            self.assertEqual(shape_classes[0].__class__.__name__, "UserLoadTestShape")
-
-    def test_with_not_imported_shape_class(self):
-        content = MOCK_LOCUSTFILE_CONTENT + textwrap.dedent(
-            """\
-        class UserLoadTestShape(LoadTestShape):
-            def tick(self):
-                pass
-        """
-        )
-
-        with mock_locustfile(content=content) as mocked:
-            _, user_classes, shape_classes = main.load_locustfile(mocked.file_path)
-            self.assertNotIn("UserLoadTestShape", user_classes)
-            self.assertEqual(shape_classes[0].__class__.__name__, "UserLoadTestShape")
-
-    def test_create_environment(self):
-        options = parse_options(
-            args=[
-                "--host",
-                "https://custom-host",
-                "--reset-stats",
-            ]
-        )
-        env = create_environment([], options)
-        self.assertEqual("https://custom-host", env.host)
-        self.assertTrue(env.reset_stats)
-
-        options = parse_options(args=[])
-        env = create_environment([], options)
-        self.assertEqual(None, env.host)
-        self.assertFalse(env.reset_stats)
-
-    def test_specify_config_file(self):
-        with temporary_file(
-            textwrap.dedent(
-                """
-            host = localhost  # With "="
-            u 100             # Short form
-            spawn-rate 5      # long form
-                              # boolean
-            headless
-            # (for some reason an inline comment makes boolean values fail in configargparse nowadays)
-        """
-            ),
-            suffix=".conf",
-        ) as conf_file_path:
-            options = parse_options(
-                args=[
-                    "--config",
-                    conf_file_path,
-                ]
-            )
-            self.assertEqual(conf_file_path, options.config)
-            self.assertEqual("localhost", options.host)
-            self.assertEqual(100, options.num_users)
-            self.assertEqual(5, options.spawn_rate)
-            self.assertTrue(options.headless)
-
-    def test_command_line_arguments_override_config_file(self):
-        with temporary_file("host=from_file", suffix=".conf") as conf_file_path:
-            options = parse_options(
-                args=[
-                    "--config",
-                    conf_file_path,
-                    "--host",
-                    "from_args",
-                ]
-            )
-            self.assertEqual("from_args", options.host)
-
-    def test_locustfile_can_be_set_in_config_file(self):
-        with temporary_file(
-            "locustfile my_locust_file.py",
-            suffix=".conf",
-        ) as conf_file_path:
-            options = parse_options(
-                args=[
-                    "--config",
-                    conf_file_path,
-                ]
-            )
-            self.assertEqual("my_locust_file.py", options.locustfile)
-
-    def test_locustfile_from_url(self):
-        locustfiles = parse_locustfile_option(
-            args=[
-                "-f",
-                "https://raw.githubusercontent.com/locustio/locust/master/examples/basic.py",
-            ]
-        )
-        self.assertEqual(len(locustfiles), 1)
-        self.assertTrue(
-            filecmp.cmp(
-                locustfiles[0],
-                f"{os.getcwd()}/examples/basic.py",
-            )
-        )