locust 2.29.2.dev34__py3-none-any.whl → 2.29.2.dev45__py3-none-any.whl

locust/test/test_tags.py

@@ -1,440 +0,0 @@
-from locust import TaskSet, User, tag, task
-from locust.env import Environment
-from locust.user.task import filter_tasks_by_tags
-
-from .testcases import LocustTestCase
-
-
-class TestTags(LocustTestCase):
-    def test_tagging(self):
-        @tag("tag1")
-        @task
-        def tagged():
-            pass
-
-        self.assertIn("locust_tag_set", dir(tagged))
-        self.assertEqual({"tag1"}, tagged.locust_tag_set)
-
-        @tag("tag2", "tag3")
-        @task
-        def tagged_multiple_args():
-            pass
-
-        self.assertIn("locust_tag_set", dir(tagged_multiple_args))
-        self.assertEqual({"tag2", "tag3"}, tagged_multiple_args.locust_tag_set)
-
-        @tag("tag4")
-        @tag("tag5")
-        @task
-        def tagged_multiple_times():
-            pass
-
-        self.assertIn("locust_tag_set", dir(tagged_multiple_times))
-        self.assertEqual({"tag4", "tag5"}, tagged_multiple_times.locust_tag_set)
-
-    def test_tagging_taskset(self):
-        @tag("taskset")
-        @task
-        class MyTaskSet(TaskSet):
-            @task
-            def tagged(self):
-                pass
-
-            @tag("task")
-            @task
-            def tagged_again(self):
-                pass
-
-            @tag("taskset2")
-            @task
-            class NestedTaskSet(TaskSet):
-                @task
-                def nested_task(self):
-                    pass
-
-        # when tagging taskset, its tasks receive the tag
-        self.assertIn("locust_tag_set", dir(MyTaskSet.tagged))
-        self.assertEqual({"taskset"}, MyTaskSet.tagged.locust_tag_set)
-
-        # tagging inner task receives both
-        self.assertIn("locust_tag_set", dir(MyTaskSet.tagged_again))
-        self.assertEqual({"taskset", "task"}, MyTaskSet.tagged_again.locust_tag_set)
-
-        # when tagging nested taskset, its tasks receives both
-        self.assertIn("locust_tag_set", dir(MyTaskSet.NestedTaskSet.nested_task))
-        self.assertEqual({"taskset", "taskset2"}, MyTaskSet.NestedTaskSet.nested_task.locust_tag_set)
-
-    def test_tagging_without_args_fails(self):
-        @task
-        def dummy_task(self):
-            pass
-
-        # task is tagged without parens
-        self.assertRaises(ValueError, lambda: tag(dummy_task))
-
-        # task is tagged with empty parens
-        self.assertRaises(ValueError, lambda: tag()(dummy_task))
-
-    def test_including_tags(self):
-        class MyTaskSet(TaskSet):
-            @tag("include this", "other tag")
-            @task
-            def included(self):
-                pass
-
-            @tag("dont include this", "other tag")
-            @task
-            def not_included(self):
-                pass
-
-            @task
-            def dont_include_this_either(self):
-                pass
-
-        self.assertListEqual(
-            MyTaskSet.tasks, [MyTaskSet.included, MyTaskSet.not_included, MyTaskSet.dont_include_this_either]
-        )
-
-        filter_tasks_by_tags(MyTaskSet, tags={"include this"})
-        self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.included])
-
-    def test_excluding_tags(self):
-        class MyTaskSet(TaskSet):
-            @tag("exclude this", "other tag")
-            @task
-            def excluded(self):
-                pass
-
-            @tag("dont exclude this", "other tag")
-            @task
-            def not_excluded(self):
-                pass
-
-            @task
-            def dont_exclude_this_either(self):
-                pass
-
-        self.assertListEqual(
-            MyTaskSet.tasks, [MyTaskSet.excluded, MyTaskSet.not_excluded, MyTaskSet.dont_exclude_this_either]
-        )
-
-        filter_tasks_by_tags(MyTaskSet, exclude_tags={"exclude this"})
-        self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.not_excluded, MyTaskSet.dont_exclude_this_either])
-
-    def test_including_and_excluding(self):
-        class MyTaskSet(TaskSet):
-            @task
-            def not_included_or_excluded(self):
-                pass
-
-            @tag("included")
-            @task
-            def included(self):
-                pass
-
-            @tag("excluded")
-            @task
-            def excluded(self):
-                pass
-
-            @tag("included", "excluded")
-            @task
-            def included_and_excluded(self):
-                pass
-
-        filter_tasks_by_tags(MyTaskSet, tags={"included"}, exclude_tags={"excluded"})
-        self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.included])
-
-    def test_including_tasksets(self):
-        class MyTaskSet(TaskSet):
-            @task
-            class MixedNestedTaskSet(TaskSet):
-                @tag("included")
-                @task
-                def included(self):
-                    pass
-
-                @task
-                def not_included(self):
-                    pass
-
-            @tag("included")
-            @task
-            class TaggedNestedTaskSet(TaskSet):
-                @task
-                def included(self):
-                    pass
-
-            @task
-            class NormalNestedTaskSet(TaskSet):
-                @task
-                def not_included(self):
-                    pass
-
-        filter_tasks_by_tags(MyTaskSet, tags={"included"})
-        self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.MixedNestedTaskSet, MyTaskSet.TaggedNestedTaskSet])
-        self.assertListEqual(MyTaskSet.MixedNestedTaskSet.tasks, [MyTaskSet.MixedNestedTaskSet.included])
-
-    def test_excluding_tasksets(self):
-        class MyTaskSet(TaskSet):
-            @task
-            class MixedNestedTaskSet(TaskSet):
-                @tag("excluded")
-                @task
-                def excluded(self):
-                    pass
-
-                @task
-                def not_excluded(self):
-                    pass
-
-            @task
-            class ExcludedNestedTaskSet(TaskSet):
-                @tag("excluded")
-                @task
-                def excluded(self):
-                    pass
-
-            @tag("excluded")
-            @task
-            class TaggedNestedTaskSet(TaskSet):
-                @task
-                def excluded(self):
-                    pass
-
-            @task
-            class NormalNestedTaskSet(TaskSet):
-                @task
-                def not_excluded(self):
-                    pass
-
-        filter_tasks_by_tags(MyTaskSet, exclude_tags={"excluded"})
-        self.assertListEqual(MyTaskSet.tasks, [MyTaskSet.MixedNestedTaskSet, MyTaskSet.NormalNestedTaskSet])
-        self.assertListEqual(MyTaskSet.MixedNestedTaskSet.tasks, [MyTaskSet.MixedNestedTaskSet.not_excluded])
-
-    def test_including_tags_with_weights(self):
-        class MyTaskSet(TaskSet):
-            @tag("included")
-            @task(2)
-            def include_twice(self):
-                pass
-
-            @tag("included")
-            @task(3)
-            def include_3_times(self):
-                pass
-
-            @tag("dont include this")
-            @task(4)
-            def dont_include_4_times(self):
-                pass
-
-            @task(5)
-            def dont_include_5_times(self):
-                pass
-
-        self.assertListEqual(
-            MyTaskSet.tasks,
-            [
-                MyTaskSet.include_twice,
-                MyTaskSet.include_twice,
-                MyTaskSet.include_3_times,
-                MyTaskSet.include_3_times,
-                MyTaskSet.include_3_times,
-                MyTaskSet.dont_include_4_times,
-                MyTaskSet.dont_include_4_times,
-                MyTaskSet.dont_include_4_times,
-                MyTaskSet.dont_include_4_times,
-                MyTaskSet.dont_include_5_times,
-                MyTaskSet.dont_include_5_times,
-                MyTaskSet.dont_include_5_times,
-                MyTaskSet.dont_include_5_times,
-                MyTaskSet.dont_include_5_times,
-            ],
-        )
-
-        filter_tasks_by_tags(MyTaskSet, tags={"included"})
-
-        self.assertListEqual(
-            MyTaskSet.tasks,
-            [
-                MyTaskSet.include_twice,
-                MyTaskSet.include_twice,
-                MyTaskSet.include_3_times,
-                MyTaskSet.include_3_times,
-                MyTaskSet.include_3_times,
-            ],
-        )
-
-    def test_excluding_tags_with_weights(self):
-        class MyTaskSet(TaskSet):
-            @tag("dont exclude this")
-            @task(2)
-            def dont_exclude_twice(self):
-                pass
-
-            @task(3)
-            def dont_exclude_3_times(self):
-                pass
-
-            @tag("excluded")
-            @task(4)
-            def exclude_4_times(self):
-                pass
-
-            @tag("excluded")
-            @task(5)
-            def exclude_5_times(self):
-                pass
-
-        self.assertListEqual(
-            MyTaskSet.tasks,
-            [
-                MyTaskSet.dont_exclude_twice,
-                MyTaskSet.dont_exclude_twice,
-                MyTaskSet.dont_exclude_3_times,
-                MyTaskSet.dont_exclude_3_times,
-                MyTaskSet.dont_exclude_3_times,
-                MyTaskSet.exclude_4_times,
-                MyTaskSet.exclude_4_times,
-                MyTaskSet.exclude_4_times,
-                MyTaskSet.exclude_4_times,
-                MyTaskSet.exclude_5_times,
-                MyTaskSet.exclude_5_times,
-                MyTaskSet.exclude_5_times,
-                MyTaskSet.exclude_5_times,
-                MyTaskSet.exclude_5_times,
-            ],
-        )
-
-        filter_tasks_by_tags(MyTaskSet, exclude_tags={"excluded"})
-
-        self.assertListEqual(
-            MyTaskSet.tasks,
-            [
-                MyTaskSet.dont_exclude_twice,
-                MyTaskSet.dont_exclude_twice,
-                MyTaskSet.dont_exclude_3_times,
-                MyTaskSet.dont_exclude_3_times,
-                MyTaskSet.dont_exclude_3_times,
-            ],
-        )
-
-    def test_tagged_tasks_shared_across_tasksets(self):
-        @tag("tagged")
-        def shared_task():
-            pass
-
-        def untagged_shared_task():
-            pass
-
-        @tag("tagged")
-        class SharedTaskSet(TaskSet):
-            @task
-            def inner_task(self):
-                pass
-
-        class IncludeTaskSet(TaskSet):
-            tasks = [shared_task, untagged_shared_task, SharedTaskSet]
-
-        class ExcludeTaskSet(TaskSet):
-            tasks = [shared_task, untagged_shared_task, SharedTaskSet]
-
-        filter_tasks_by_tags(IncludeTaskSet, tags={"tagged"})
-
-        self.assertListEqual(IncludeTaskSet.tasks, [shared_task, SharedTaskSet])
-        self.assertListEqual(IncludeTaskSet.tasks[1].tasks, [SharedTaskSet.inner_task])
-
-        filter_tasks_by_tags(ExcludeTaskSet, exclude_tags={"tagged"})
-
-        self.assertListEqual(ExcludeTaskSet.tasks, [untagged_shared_task])
-
-    def test_include_tags_under_user(self):
-        class MyUser(User):
-            @tag("include this")
-            @task
-            def included(self):
-                pass
-
-            @tag("dont include this")
-            @task
-            def not_included(self):
-                pass
-
-            @task
-            def dont_include_this_either(self):
-                pass
-
-        filter_tasks_by_tags(MyUser, tags={"include this"})
-
-        self.assertListEqual(MyUser.tasks, [MyUser.included])
-
-    def test_exclude_tags_under_user(self):
-        class MyUser(User):
-            @tag("exclude this")
-            @task
-            def excluded(self):
-                pass
-
-            @tag("dont exclude this")
-            @task
-            def not_excluded(self):
-                pass
-
-            @task
-            def dont_exclude_this_either(self):
-                pass
-
-        filter_tasks_by_tags(MyUser, exclude_tags={"exclude this"})
-
-        self.assertListEqual(MyUser.tasks, [MyUser.not_excluded, MyUser.dont_exclude_this_either])
-
-    def test_env_include_tags(self):
-        class MyTaskSet(TaskSet):
-            @tag("include this")
-            @task
-            def included(self):
-                pass
-
-            @tag("dont include this")
-            @task
-            def not_included(self):
-                pass
-
-            @task
-            def dont_include_this_either(self):
-                pass
-
-        class MyUser(User):
-            tasks = [MyTaskSet]
-
-        env = Environment(user_classes=[MyUser], tags=["include this"])
-        env._filter_tasks_by_tags()
-
-        self.assertListEqual(MyUser.tasks, [MyTaskSet])
-        self.assertListEqual(MyUser.tasks[0].tasks, [MyTaskSet.included])
-
-    def test_env_exclude_tags(self):
-        class MyTaskSet(User):
-            @tag("exclude this")
-            @task
-            def excluded(self):
-                pass
-
-            @tag("dont exclude this")
-            @task
-            def not_excluded(self):
-                pass
-
-            @task
-            def dont_exclude_this_either(self):
-                pass
-
-        class MyUser(User):
-            tasks = [MyTaskSet]
-
-        env = Environment(user_classes=[MyUser], exclude_tags=["exclude this"])
-        env._filter_tasks_by_tags()
-
-        self.assertListEqual(MyUser.tasks, [MyTaskSet])
-        self.assertListEqual(MyUser.tasks[0].tasks, [MyTaskSet.not_excluded, MyTaskSet.dont_exclude_this_either])

locust/test/test_taskratio.py

@@ -1,94 +0,0 @@
-from locust.user import TaskSet, User, task
-from locust.user.inspectuser import _get_task_ratio, get_ratio
-
-import unittest
-
-
-class TestTaskRatio(unittest.TestCase):
-    def test_task_ratio_command(self):
-        class Tasks(TaskSet):
-            @task
-            def root_task1(self):
-                pass
-
-            @task
-            class SubTasks(TaskSet):
-                @task
-                def task1(self):
-                    pass
-
-                @task
-                def task2(self):
-                    pass
-
-        class MyUser(User):
-            tasks = [Tasks]
-
-        ratio_dict = _get_task_ratio(Tasks.tasks, True, 1.0)
-
-        self.assertEqual(
-            {
-                "SubTasks": {"tasks": {"task1": {"ratio": 0.25}, "task2": {"ratio": 0.25}}, "ratio": 0.5},
-                "root_task1": {"ratio": 0.5},
-            },
-            ratio_dict,
-        )
-
-    def test_task_ratio_command_with_locust_weight(self):
-        class Tasks(TaskSet):
-            @task(1)
-            def task1(self):
-                pass
-
-            @task(3)
-            def task3(self):
-                pass
-
-        class UnlikelyUser(User):
-            weight = 1
-            tasks = [Tasks]
-
-        class MoreLikelyUser(User):
-            weight = 3
-            tasks = [Tasks]
-
-        ratio_dict = get_ratio([UnlikelyUser, MoreLikelyUser], {"UnlikelyUser": 1, "MoreLikelyUser": 3}, True)
-
-        self.assertDictEqual(
-            {
-                "UnlikelyUser": {
-                    "ratio": 0.25,
-                    "tasks": {
-                        "Tasks": {
-                            "tasks": {
-                                "task1": {"ratio": 0.25 * 0.25},
-                                "task3": {"ratio": 0.25 * 0.75},
-                            },
-                            "ratio": 0.25,
-                        }
-                    },
-                },
-                "MoreLikelyUser": {
-                    "ratio": 0.75,
-                    "tasks": {
-                        "Tasks": {
-                            "tasks": {
-                                "task1": {"ratio": 0.75 * 0.25},
-                                "task3": {"ratio": 0.75 * 0.75},
-                            },
-                            "ratio": 0.75,
-                        },
-                    },
-                },
-            },
-            ratio_dict,
-        )
-        unlikely = ratio_dict["UnlikelyUser"]["tasks"]["Tasks"]["tasks"]
-        likely = ratio_dict["MoreLikelyUser"]["tasks"]["Tasks"]["tasks"]
-        assert (
-            unlikely["task1"]["ratio"]
-            + unlikely["task3"]["ratio"]
-            + likely["task1"]["ratio"]
-            + likely["task3"]["ratio"]
-            == 1
-        )

locust/test/test_users.py

@@ -1,69 +0,0 @@
-from locust import HttpUser, User
-from locust.test.testcases import WebserverTestCase
-
-import unittest
-
-from urllib3 import PoolManager
-
-
-class TestUserClass(unittest.TestCase):
-    class MyClassScopedUser(User):
-        pass
-
-    def test_fullname_module_scoped(self):
-        self.assertEqual(MyModuleScopedUser.fullname(), "locust.test.test_users.MyModuleScopedUser")
-
-    def test_fullname_class_scoped(self):
-        self.assertEqual(self.MyClassScopedUser.fullname(), "locust.test.test_users.TestUserClass.MyClassScopedUser")
-
-    def test_fullname_function_scoped(self):
-        class MyFunctionScopedUser(User):
-            pass
-
-        self.assertEqual(
-            MyFunctionScopedUser.fullname(),
-            "locust.test.test_users.TestUserClass.test_fullname_function_scoped.MyFunctionScopedUser",
-        )
-
-
-class MyModuleScopedUser(User):
-    pass
-
-
-class TestHttpUserWithWebserver(WebserverTestCase):
-    def test_shared_pool_manager(self):
-        shared_pool_manager = PoolManager(maxsize=1, block=True)
-
-        class MyUserA(HttpUser):
-            host = "http://127.0.0.1:%i" % self.port
-            pool_manager = shared_pool_manager
-
-        class MyUserB(HttpUser):
-            host = "http://127.0.0.1:%i" % self.port
-            pool_manager = shared_pool_manager
-
-        user_a = MyUserA(self.environment)
-        user_b = MyUserB(self.environment)
-
-        user_a.client.get("/ultra_fast")
-        user_b.client.get("/ultra_fast")
-        user_b.client.get("/ultra_fast")
-        user_a.client.get("/ultra_fast")
-
-        self.assertEqual(1, self.connections_count)
-        self.assertEqual(4, self.requests_count)
-
-    def test_pool_manager_per_user_instance(self):
-        class MyUser(HttpUser):
-            host = "http://127.0.0.1:%i" % self.port
-
-        user_a = MyUser(self.environment)
-        user_b = MyUser(self.environment)
-
-        user_a.client.get("/ultra_fast")
-        user_b.client.get("/ultra_fast")
-        user_b.client.get("/ultra_fast")
-        user_a.client.get("/ultra_fast")
-
-        self.assertEqual(2, self.connections_count)
-        self.assertEqual(4, self.requests_count)

locust/test/test_util.py

@@ -1,33 +0,0 @@
-from locust.util.rounding import proper_round
-from locust.util.timespan import parse_timespan
-
-import unittest
-
-
-class TestParseTimespan(unittest.TestCase):
-    def test_parse_timespan_invalid_values(self):
-        self.assertRaises(ValueError, parse_timespan, None)
-        self.assertRaises(ValueError, parse_timespan, "")
-        self.assertRaises(ValueError, parse_timespan, "q")
-
-    def test_parse_timespan(self):
-        self.assertEqual(7, parse_timespan("7"))
-        self.assertEqual(7, parse_timespan("7s"))
-        self.assertEqual(60, parse_timespan("1m"))
-        self.assertEqual(7200, parse_timespan("2h"))
-        self.assertEqual(3787, parse_timespan("1h3m7s"))
-
-
-class TestRounding(unittest.TestCase):
-    def test_rounding_down(self):
-        self.assertEqual(1, proper_round(1.499999999))
-        self.assertEqual(5, proper_round(5.499999999))
-        self.assertEqual(2, proper_round(2.05))
-        self.assertEqual(3, proper_round(3.05))
-
-    def test_rounding_up(self):
-        self.assertEqual(2, proper_round(1.5))
-        self.assertEqual(3, proper_round(2.5))
-        self.assertEqual(4, proper_round(3.5))
-        self.assertEqual(5, proper_round(4.5))
-        self.assertEqual(6, proper_round(5.5))