FakeProducer

async def publish(
    self,
    message: AioPikaSendableMessage = "",
    queue: Union[RabbitQueue, str] = "",
    exchange: Union[RabbitExchange, str, None] = None,
    *,
    routing_key: str = "",
    mandatory: bool = True,
    immediate: bool = False,
    timeout: TimeoutType = None,
    rpc: bool = False,
    rpc_timeout: Optional[float] = 30.0,
    raise_timeout: bool = False,
    persist: bool = False,
    reply_to: Optional[str] = None,
    **message_kwargs: Any,
) -> Optional[SendableMessage]:
    """
    Publish a message to a RabbitMQ queue or exchange.

    Args:
        message (AioPikaSendableMessage, optional): The message to be published.
        queue (Union[RabbitQueue, str], optional): The target queue for the message.
        exchange (Union[RabbitExchange, str, None], optional): The target exchange for the message.
        routing_key (str, optional): The routing key for the message.
        mandatory (bool, optional): Whether the message is mandatory.
        immediate (bool, optional): Whether the message should be sent immediately.
        timeout (TimeoutType, optional): The timeout for the message.
        rpc (bool, optional): Whether the message is for RPC.
        rpc_timeout (float, optional): The RPC timeout.
        raise_timeout (bool, optional): Whether to raise a timeout exception.
        persist (bool, optional): Whether to persist the message.
        reply_to (str, optional): The reply-to address for RPC messages.
        **message_kwargs (Any): Additional message properties and content.

    Returns:
        Optional[SendableMessage]: The published message if successful, or None if not.
    """
    exch = RabbitExchange.validate(exchange)

    incoming = build_message(
        message=message,
        queue=queue,
        exchange=exch,
        routing_key=routing_key,
        reply_to=reply_to,
        **message_kwargs,
    )

    for handler in self.broker.handlers.values():  # pragma: no branch
        if handler.exchange == exch:
            call: bool = False

            if (
                handler.exchange is None
                or handler.exchange.type == ExchangeType.DIRECT
            ):
                call = handler.queue.name == incoming.routing_key

            elif handler.exchange.type == ExchangeType.FANOUT:
                call = True

            elif handler.exchange.type == ExchangeType.TOPIC:
                call = bool(
                    re.match(
                        handler.queue.routing_key.replace(".", r"\.").replace(
                            "*", ".*"
                        ),
                        incoming.routing_key or "",
                    )
                )

            elif handler.exchange.type == ExchangeType.HEADERS:  # pramga: no branch
                queue_headers = (handler.queue.bind_arguments or {}).copy()
                msg_headers = incoming.headers

                if not queue_headers:
                    call = True

                else:
                    matcher = queue_headers.pop("x-match", "all")

                    full = True
                    none = True
                    for k, v in queue_headers.items():
                        if msg_headers.get(k) != v:
                            full = False
                        else:
                            none = False

                    if not none:
                        call = (matcher == "any") or full

            else:  # pragma: no cover
                raise AssertionError("unreachable")

            if call:
                r = await call_handler(
                    handler=handler,
                    message=incoming,
                    rpc=rpc,
                    rpc_timeout=rpc_timeout,
                    raise_timeout=raise_timeout,
                )

                if rpc:  # pragma: no branch
                    return r

    return None