How to use the h11.Data function in h11

async def test_post_request(serving_app: Quart, event_loop: asyncio.AbstractEventLoop) -> None:
    connection = MockConnection(serving_app, event_loop)
    await connection.send(
        h11.Request(
            method='POST', target='/echo',
            headers=BASIC_HEADERS + [('content-length', str(len(BASIC_DATA.encode())))],
        ),
    )
    await connection.send(h11.Data(data=BASIC_DATA.encode()))
    await connection.send(h11.EndOfMessage())
    await connection.transport.closed.wait()
    response, *data, end = connection.get_events()
    assert isinstance(response, h11.Response)
    assert response.status_code == 200
    assert all(isinstance(datum, h11.Data) for datum in data)
    assert b''.join(datum.data for datum in data).decode() == BASIC_DATA
    assert isinstance(end, h11.EndOfMessage)

def test_handshake_rejection_with_body() -> None:
    events = _make_handshake_rejection(400, body=b"Hello")
    assert events == [
        h11.Response(headers=[(b"content-length", b"5")], status_code=400),
        h11.Data(data=b"Hello"),
        h11.EndOfMessage(),
    ]

async def __anext__(self):
        event = await self.event_source()

        if type(event) is h11.Data:
            return event.data
        elif type(event) is h11.EndOfMessage:
            raise StopAsyncIteration
        else:
            raise ValueError('Unknown h11 event: %r', event)

async def read_body(self) -> None:
        while True:
            try:
                event = self.connection.next_event()
            except h11.RemoteProtocolError:
                await self.send_error()
                await self.asgi_put({"type": "http.disconnect"})
                raise MustCloseError()
            else:
                if event is h11.NEED_DATA:
                    await self.read_data()
                elif isinstance(event, h11.EndOfMessage):
                    await self.asgi_put({"type": "http.request", "body": b"", "more_body": False})
                    return
                elif isinstance(event, h11.Data):
                    await self.asgi_put(
                        {"type": "http.request", "body": event.data, "more_body": True}
                    )
                elif isinstance(event, h11.ConnectionClosed) or event is h11.PAUSED:
                    break

def handle_no_connect(self, event):
        headers = [
            (b"content-type", b"text/plain; charset=utf-8"),
            (b"connection", b"close"),
        ]
        msg = h11.Response(status_code=400, headers=headers, reason="Bad Request")
        output = self.conn.send(msg)
        msg = h11.Data(data=event.reason.encode("utf-8"))
        output += self.conn.send(msg)
        msg = h11.EndOfMessage()
        output += self.conn.send(msg)
        self.transport.write(output)
        self.transport.close()

def _request_bytes_iterable(request, state_machine):
    """
    An iterable that serialises a set of bytes for the body.
    """
    h11_request = h11.Request(
        method=request.method,
        target=request.target,
        headers=_stringify_headers(request.headers.items()),
    )
    yield state_machine.send(h11_request)

    for chunk in _make_body_iterable(request.body):
        yield state_machine.send(h11.Data(data=chunk))

    yield state_machine.send(h11.EndOfMessage())

async def send_simple_response(wrapper, status_code, content_type, body):
    wrapper.info("Sending", status_code,
                 "response with", len(body), "bytes")
    headers = wrapper.basic_headers()
    headers.append(("Content-Type", content_type))
    headers.append(("Content-Length", str(len(body))))
    res = h11.Response(status_code=status_code, headers=headers)
    await wrapper.send(res)
    await wrapper.send(h11.Data(data=body))
    await wrapper.send(h11.EndOfMessage())

def write(self, content: bytes) -> None:
        """
        Handle a write from the producer.
        """
        sender = self._sender
        self._sender = Deferred()
        sender.callback(h11.Data(data=content))

break
            else:
                if isinstance(event, h11.Request):
                    headers = CIMultiDict()
                    if event.http_version < b'1.1':
                        headers.setdefault('host', self.app.config['SERVER_NAME'] or '')
                    for name, value in event.headers:
                        headers.add(name.decode().title(), value.decode())
                    if 'Upgrade' in headers:
                        self._handle_upgrade_request(headers, event)
                    self.handle_request(
                        0, event.method.decode().upper(), event.target.decode(), headers,
                    )
                elif isinstance(event, h11.EndOfMessage):
                    self.streams[0].complete()
                elif isinstance(event, h11.Data):
                    self.streams[0].append(event.data)
                elif event is h11.NEED_DATA or event is h11.PAUSED:
                    break
                elif isinstance(event, h11.ConnectionClosed):
                    break
        if self.connection.our_state is h11.MUST_CLOSE:
            self.close()

async def send_response(self, stream_id: int, response: Response) -> None:
        headers = chain(
            ((key, value) for key, value in response.headers.items()), self.response_headers(),
        )
        self._send(h11.Response(status_code=response.status_code, headers=headers))
        for data in response.response:
            self._send(h11.Data(data=data))
        self._send(h11.EndOfMessage())