Method check

tests/treq_asgi.py:203–256

Parse request and verify it matches expected values.

(self, cfg, sender)

            read += chunk

    def check(self, cfg, sender):
        """Parse request and verify it matches expected values."""
        body_chunks = []

        # Handle limit_request_field_size=0 meaning "use default"
        field_size = cfg.limit_request_field_size
        if field_size <= 0:
            field_size = 8190  # Default max

        parser = PythonProtocol(
            on_body=lambda chunk: body_chunks.append(chunk),
            limit_request_line=cfg.limit_request_line,
            limit_request_fields=cfg.limit_request_fields,
            limit_request_field_size=field_size,
            permit_unconventional_http_method=cfg.permit_unconventional_http_method,
            permit_unconventional_http_version=cfg.permit_unconventional_http_version,
            proxy_protocol=getattr(cfg, 'proxy_protocol', 'off'),
        )

        for chunk in sender():
            parser.feed(chunk)
        parser.finish()  # Signal EOF

        # Verify parsed request matches expected
        exp = self.expect[0]  # For now, handle single request

        assert parser.method == exp["method"].encode('latin-1'), \
            f"Method mismatch: {parser.method} != {exp['method']}"

        # Path comparison - parser stores raw bytes
        expected_path = exp["uri"]["raw"].encode('latin-1')
        assert parser.path == expected_path, \
            f"Path mismatch: {parser.path} != {expected_path}"

        assert parser.http_version == exp["version"], \
            f"Version mismatch: {parser.http_version} != {exp['version']}"

        # Headers - convert to comparable format
        parsed_headers = [
            (n.decode('latin-1').upper(), v.decode('latin-1'))
            for n, v in parser.headers
        ]
        assert parsed_headers == exp["headers"], \
            f"Headers mismatch: {parsed_headers} != {exp['headers']}"

        # Body - ensure expected_body is bytes for comparison
        body = b"".join(body_chunks)
        expected_body = exp["body"]
        if isinstance(expected_body, str):
            expected_body = expected_body.encode('latin-1')
        assert body == expected_body, \
            f"Body mismatch: {body!r} != {expected_body!r}"

        assert parser.is_complete, "Parser did not complete"


class badrequest: