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

locust/test/test_zmqrpc.py

@@ -1,58 +0,0 @@
-from locust.exception import RPCError, RPCReceiveError, RPCSendError
-from locust.rpc import Message, zmqrpc
-from locust.test.testcases import LocustTestCase
-
-from time import sleep
-
-import zmq
-
-
-class ZMQRPC_tests(LocustTestCase):
-    def setUp(self):
-        super().setUp()
-        self.server = zmqrpc.Server("*", 0)
-        self.client = zmqrpc.Client("localhost", self.server.port, "identity")
-
-    def tearDown(self):
-        self.server.close()
-        self.client.close()
-        super().tearDown()
-
-    def test_constructor(self):
-        self.assertEqual(self.server.socket.getsockopt(zmq.TCP_KEEPALIVE), 1)
-        self.assertEqual(self.server.socket.getsockopt(zmq.TCP_KEEPALIVE_IDLE), 30)
-        self.assertEqual(self.server.socket.getsockopt(zmq.IPV6), 1)
-        self.assertEqual(self.client.socket.getsockopt(zmq.TCP_KEEPALIVE), 1)
-        self.assertEqual(self.client.socket.getsockopt(zmq.TCP_KEEPALIVE_IDLE), 30)
-        self.assertEqual(self.client.socket.getsockopt(zmq.IPV6), 1)
-
-    def test_client_send(self):
-        self.client.send(Message("test", "message", "identity"))
-        addr, msg = self.server.recv_from_client()
-        self.assertEqual(addr, "identity")
-        self.assertEqual(msg.type, "test")
-        self.assertEqual(msg.data, "message")
-
-    def test_client_recv(self):
-        sleep(0.1)
-        # We have to wait for the client to finish connecting
-        # before sending a msg to it.
-        self.server.send_to_client(Message("test", "message", "identity"))
-        msg = self.client.recv()
-        self.assertEqual(msg.type, "test")
-        self.assertEqual(msg.data, "message")
-        self.assertEqual(msg.node_id, "identity")
-
-    def test_client_retry(self):
-        server = zmqrpc.Server("*", 0)
-        server.socket.close()
-        with self.assertRaises(RPCError):
-            server.recv_from_client()
-
-    def test_rpc_error(self):
-        server = zmqrpc.Server("*", 0)
-        with self.assertRaises(RPCError):
-            server = zmqrpc.Server("*", server.port)
-        server.close()
-        with self.assertRaises(RPCSendError):
-            server.send_to_client(Message("test", "message", "identity"))

locust/test/testcases.py

@@ -1,248 +0,0 @@
-import locust
-from locust import log
-from locust.env import Environment
-from locust.event import Events
-from locust.test.mock_logging import MockedLoggingHandler
-from locust.test.util import clear_all_functools_lru_cache
-
-import base64
-import logging
-import random
-import sys
-import unittest
-import warnings
-from io import BytesIO
-
-import gevent
-import gevent.pywsgi
-from flask import Flask, Response, make_response, redirect, request, send_file, stream_with_context
-
-app = Flask(__name__)
-app.jinja_env.add_extension("jinja2.ext.do")
-
-
-@app.route("/ultra_fast")
-def ultra_fast():
-    return "This is an ultra fast response"
-
-
-@app.route("/fast")
-def fast():
-    gevent.sleep(random.choice([0.1, 0.2, 0.3]))
-    return "This is a fast response"
-
-
-@app.route("/slow")
-def slow():
-    if delay := request.args.get("delay"):
-        gevent.sleep(float(delay))
-    else:
-        gevent.sleep(random.choice([0.5, 1, 1.5]))
-    return "This is a slow response"
-
-
-@app.route("/consistent")
-def consistent():
-    gevent.sleep(0.2)
-    return "This is a consistent response"
-
-
-@app.route("/request_method", methods=["POST", "GET", "HEAD", "PUT", "DELETE", "PATCH"])
-def request_method():
-    return request.method
-
-
-@app.route("/request_header_test")
-def request_header_test():
-    x_header_test = request.headers["X-Header-Test"]
-    response = Response(x_header_test)
-    response.headers["X-Header-Test"] = x_header_test
-
-    return response
-
-
-@app.route("/post", methods=["POST"])
-@app.route("/put", methods=["PUT"])
-def manipulate():
-    return str(request.form.get("arg", ""))
-
-
-@app.route("/get_arg", methods=["GET"])
-def get_arg():
-    return request.args.get("arg")
-
-
-@app.route("/fail")
-def failed_request():
-    return "This response failed", 500
-
-
-@app.route("/status/204")
-def status_204():
-    return "", 204
-
-
-@app.route("/redirect", methods=["GET", "POST"])
-def do_redirect():
-    if delay := request.args.get("delay"):
-        gevent.sleep(float(delay))
-    url = request.args.get("url", "/ultra_fast")
-    return redirect(url)
-
-
-@app.route("/basic_auth")
-def basic_auth():
-    auth = base64.b64decode(request.headers.get("Authorization", "").replace("Basic ", "")).decode("utf-8")
-    if auth == "locust:menace":
-        return "Authorized"
-    resp = make_response("401 Authorization Required", 401)
-    resp.headers["WWW-Authenticate"] = 'Basic realm="Locust"'
-    return resp
-
-
-@app.route("/no_content_length")
-def no_content_length():
-    r = send_file(
-        BytesIO(b"This response does not have content-length in the header"),
-        etag=False,
-        mimetype="text/plain",
-    )
-    r.headers.remove("Content-Length")
-    return r
-
-
-@app.errorhandler(404)
-def not_found(error):
-    return "Not Found", 404
-
-
-@app.route("/streaming/<int:iterations>")
-def streaming_response(iterations):
-    import time
-
-    def generate():
-        yield "<html><body><h1>streaming response</h1>"
-        for i in range(iterations):
-            yield f"<span>{i}</span>\n"
-            time.sleep(0.01)
-        yield "</body></html>"
-
-    return Response(stream_with_context(generate()), mimetype="text/html")
-
-
-@app.route("/set_cookie", methods=["POST"])
-def set_cookie():
-    response = make_response("ok")
-    response.set_cookie(request.args.get("name"), request.args.get("value"))
-    return response
-
-
-@app.route("/get_cookie")
-def get_cookie():
-    return make_response(request.cookies.get(request.args.get("name"), ""))
-
-
-@app.route("/rest", methods=["POST"])
-def rest():
-    return request.json
-
-
-@app.route("/content_type_missing_charset")
-def content_type_missing_charset():
-    resp = make_response("stuff")
-    resp.headers["Content-Type"] = "Content-Type: application/json;"
-    return resp
-
-
-@app.route("/content_type_regular")
-def content_type_regular():
-    resp = make_response("stuff")
-    resp.headers["Content-Type"] = "Content-Type: application/json; charset=utf-8;"
-    return resp
-
-
-@app.route("/content_type_with_extra_stuff")
-def content_type_with_extra_stuff():
-    resp = make_response("stuff")
-    resp.headers["Content-Type"] = "Content-Type: application/json; charset=utf-8; api-version=3.0"
-    return resp
-
-
-class LocustTestCase(unittest.TestCase):
-    """
-    Test case class that restores locust.events.EventHook listeners on tearDown, so that it is
-    safe to register any custom event handlers within the test.
-    """
-
-    def setUp(self):
-        # Prevent args passed to test runner from being passed to Locust
-        del sys.argv[1:]
-
-        locust.events = Events()
-        self.environment = Environment(events=locust.events, catch_exceptions=False)
-        self.runner = self.environment.create_local_runner()
-
-        # When running the tests in Python 3 we get warnings about unclosed sockets.
-        # This causes tests that depends on calls to sys.stderr to fail, so we'll
-        # suppress those warnings. For more info see:
-        # https://github.com/requests/requests/issues/1882
-        warnings.filterwarnings(action="ignore", message="unclosed <socket object", category=ResourceWarning)
-        warnings.filterwarnings(
-            action="ignore", message="unclosed context <zmq.green.Context", category=ResourceWarning
-        )
-
-        # set up mocked logging handler
-        self._logger_class = MockedLoggingHandler()
-        self._logger_class.setLevel(logging.INFO)
-        self._root_log_handlers = [h for h in logging.root.handlers]
-        [logging.root.removeHandler(h) for h in logging.root.handlers]
-        logging.root.addHandler(self._logger_class)
-        logging.root.setLevel(logging.INFO)
-        self.mocked_log = MockedLoggingHandler
-
-        # set unhandled exception flag to False
-        log.unhandled_greenlet_exception = False
-
-    def tearDown(self):
-        # restore logging class
-        logging.root.removeHandler(self._logger_class)
-        [logging.root.addHandler(h) for h in self._root_log_handlers]
-        self.mocked_log.reset()
-
-        clear_all_functools_lru_cache()
-
-
-class WebserverTestCase(LocustTestCase):
-    """
-    Test case class that sets up an HTTP server which can be used within the tests
-    """
-
-    def setUp(self):
-        super().setUp()
-
-        self.connections_count = 0
-        self.requests_count = 0
-
-        class CountingWSGIHandler(gevent.pywsgi.WSGIHandler):
-            def handle(this):
-                self.connections_count += 1
-                super().handle()
-
-            def log_request(this):
-                self.requests_count += 1
-                super().log_request()
-
-        self._web_server = gevent.pywsgi.WSGIServer(
-            ("127.0.0.1", 0),
-            app,
-            log=None,
-            handler_class=CountingWSGIHandler,
-        )
-        gevent.spawn(lambda: self._web_server.serve_forever())
-        gevent.sleep(0.01)
-        self.port = self._web_server.server_port
-
-    def tearDown(self):
-        super().tearDown()
-        self._web_server.stop_accepting()
-        self._web_server.stop()

locust/test/util.py

@@ -1,88 +0,0 @@
-import datetime
-import functools
-import gc
-import os
-import socket
-import warnings
-from contextlib import contextmanager
-from tempfile import NamedTemporaryFile
-
-from cryptography import x509
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes, serialization
-from cryptography.hazmat.primitives.asymmetric import rsa
-from cryptography.x509.oid import NameOID
-
-
-@contextmanager
-def temporary_file(content, suffix="_locustfile.py", dir=None):
-    f = NamedTemporaryFile(suffix=suffix, delete=False, dir=dir)
-    f.write(content.encode("utf-8"))
-    f.close()
-    try:
-        yield f.name
-    finally:
-        if os.path.exists(f.name):
-            os.remove(f.name)
-
-
-@contextmanager
-def patch_env(name: str, value: str):
-    prev_value = os.getenv(name)
-    os.environ[name] = value
-    try:
-        yield
-    finally:
-        if prev_value is None:
-            del os.environ[name]
-        else:
-            os.environ[name] = prev_value
-
-
-def get_free_tcp_port():
-    """
-    Find an unused TCP port
-    """
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.bind(("127.0.0.1", 0))
-    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    port = s.getsockname()[1]
-    s.close()
-    return port
-
-
-def create_tls_cert(hostname):
-    """Generate a TLS cert and private key to serve over https"""
-    key = rsa.generate_private_key(public_exponent=2**16 + 1, key_size=2048, backend=default_backend())
-    name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, hostname)])
-    now = datetime.datetime.now(tz=datetime.timezone.utc)
-    cert = (
-        x509.CertificateBuilder()
-        .subject_name(name)
-        .issuer_name(name)
-        .public_key(key.public_key())
-        .serial_number(1000)
-        .not_valid_before(now)
-        .not_valid_after(now + datetime.timedelta(days=10 * 365))
-        .sign(key, hashes.SHA256(), default_backend())
-    )
-    cert_pem = cert.public_bytes(encoding=serialization.Encoding.PEM)
-    key_pem = key.private_bytes(
-        encoding=serialization.Encoding.PEM,
-        format=serialization.PrivateFormat.TraditionalOpenSSL,
-        encryption_algorithm=serialization.NoEncryption(),
-    )
-
-    return cert_pem, key_pem
-
-
-def clear_all_functools_lru_cache() -> None:
-    # Clear all `functools.lru_cache` to ensure that no state are persisted from one test to another.
-    # Taken from https://stackoverflow.com/a/50699209.
-    with warnings.catch_warnings():
-        warnings.simplefilter(action="ignore", category=ResourceWarning)
-        gc.collect()
-    wrappers = [a for a in gc.get_objects() if isinstance(a, functools._lru_cache_wrapper)]
-    assert len(wrappers) > 0
-    for wrapper in wrappers:
-        wrapper.cache_clear()

locust-2.29.2.dev34.dist-info/WHEEL

@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: setuptools (70.2.0)
-Root-Is-Purelib: true
-Tag: py3-none-any
-

locust-2.29.2.dev34.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-locust = locust.main:main

locust-2.29.2.dev34.dist-info/top_level.txt

@@ -1 +0,0 @@
-locust