* Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
*/
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <variant>
#include <vector>
#include <nlohmann/json.hpp>
#define private public
#define protected public
#include "server/server_impl.h"
#undef private
#undef protected
#include "error.h"
#include "jsonrpc.h"
#include "server/request_handler.h"
#include "transport/server_transport.h"
#include "transport/transport_emitter.h"
#include "types.h"
using ::testing::_;
using ::testing::DoAll;
using ::testing::Invoke;
using ::testing::IsNull;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::SaveArg;
using ::testing::Throw;
using nlohmann::json;
using namespace A2A;
using namespace A2A::Server;
namespace {
class MockTransportEmitter : public Transport::TransportEmitter {
public:
MOCK_METHOD(void, WriteStreamingData, (const std::string& data), (override));
MOCK_METHOD(void, WriteNonStreamingData, (const std::string& data), (override));
MOCK_METHOD(void, WriteDone, (), (override));
};
std::shared_ptr<Transport::TransportEmitter> WrapEmitter(MockTransportEmitter& emitter)
{
return std::shared_ptr<Transport::TransportEmitter>(&emitter, [](auto*) {});
}
class MockServerTransport : public Transport::ServerTransport {
public:
MOCK_METHOD(int, Start, (), (override));
MOCK_METHOD(void, Stop, (), (override));
MOCK_METHOD(int, SendData, (const std::string& url, const std::string& data), (const, override));
MOCK_METHOD(void, SetRpcHandler, (Transport::ServerTransportRpcHandler handler), (override));
MOCK_METHOD(void, SetCardHandler, (Transport::ServerTransportCardHandler handler), (override));
Transport::ServerTransportRpcHandler rpcHandler;
Transport::ServerTransportCardHandler cardHandler;
};
class MockRequestHandler : public RequestHandler {
public:
MOCK_METHOD(void, OnSendMessage,
(const MessageSendParams&, const std::shared_ptr<ServerCallContext>, StreamEmitter, const std::string&),
(override));
MOCK_METHOD(Task, OnGetTask,
(const TaskQueryParams&, std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD(Task, OnCancelTask,
(const TaskIdParams&, std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD(void, OnSetTaskPushNotificationConfig,
(const TaskPushNotificationConfig&, std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD(TaskPushNotificationConfig, OnGetTaskPushNotificationConfig,
(const GetTaskPushNotificationConfigParams&, std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD((std::vector<TaskPushNotificationConfig>), OnListTaskPushNotificationConfigs,
(const ListTaskPushNotificationConfigParams&, std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD(void, OnDeleteTaskPushNotificationConfig,
(const DeleteTaskPushNotificationConfigParams&, std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD(AgentCard, OnGetCard,
(std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD(void, OnSendMessageStreaming,
(const MessageSendParams&, StreamEmitter, std::shared_ptr<ServerCallContext>), (override));
MOCK_METHOD(void, OnResubscribeToTask,
(const TaskIdParams&, StreamEmitter, std::shared_ptr<ServerCallContext>), (override));
};
class ServerImplTest : public ::testing::Test {
protected:
std::shared_ptr<NiceMock<MockServerTransport>> mockTransport =
std::make_shared<NiceMock<MockServerTransport>>();
std::shared_ptr<NiceMock<MockRequestHandler>> mockHandler =
std::make_shared<NiceMock<MockRequestHandler>>();
std::shared_ptr<AgentCard> agentCard = std::make_shared<AgentCard>();
std::shared_ptr<AgentCard> extendedAgentCard = std::make_shared<AgentCard>();
HttpConfig config {"127.0.0.1", 0, 1, "/jsonrpc"};
std::unique_ptr<ServerImpl> server;
static Task MakeTask(const std::string& id = "task-1")
{
Task task;
task.id = id;
task.contextId = "ctx-1";
TaskStatus status;
status.state = TaskState::WORKING;
status.timestamp = "2026-03-17T00:00:00Z";
task.status = status;
return task;
}
static Message MakeMessage(const std::string& messageId = "msg-1")
{
Message msg;
msg.messageId = messageId;
msg.role = Role::USER;
return msg;
}
static AgentCard MakeAgentCard()
{
AgentCard card;
card.name = "ut-agent";
card.capabilities.streaming = true;
return card;
}
static json MakeBaseReq(const std::string& method, const json& id = "req-1")
{
return json{
{"jsonrpc", "2.0"},
{"id", id},
{"method", method}
};
}
void SetUp() override
{
agentCard->capabilities.streaming = true;
server = std::make_unique<ServerImpl>(
agentCard,
extendedAgentCard,
nullptr,
config,
mockTransport,
nullptr);
server->handler_ = mockHandler;
server->jsonRpcHandler_ = std::make_unique<JSONRPCHandler>(mockHandler);
}
};
TEST_F(ServerImplTest, Start_WhenTransportIsNull_ReturnsOne)
{
server->transport_.reset();
EXPECT_EQ(server->Start(), 1);
}
TEST_F(ServerImplTest, Start_Success_RegistersHandlersAndStartsTransport)
{
EXPECT_CALL(*mockTransport, SetRpcHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportRpcHandler handler) {
mockTransport->rpcHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, SetCardHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportCardHandler handler) {
mockTransport->cardHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, Start())
.WillOnce(Return(0));
EXPECT_EQ(server->Start(), 0);
EXPECT_TRUE(server->started_.load());
EXPECT_TRUE(static_cast<bool>(mockTransport->rpcHandler));
EXPECT_TRUE(static_cast<bool>(mockTransport->cardHandler));
}
TEST_F(ServerImplTest, Start_WhenAlreadyStarted_DoesNotCallTransportStartAgain)
{
EXPECT_CALL(*mockTransport, SetRpcHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportRpcHandler handler) {
mockTransport->rpcHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, SetCardHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportCardHandler handler) {
mockTransport->cardHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, Start())
.WillOnce(Return(0));
EXPECT_EQ(server->Start(), 0);
EXPECT_EQ(server->Start(), 0);
}
TEST_F(ServerImplTest, Stop_StopsTransportAndResetsIt)
{
server->Stop();
EXPECT_FALSE(server->started_.load());
}
TEST_F(ServerImplTest, OnGetCard_ReturnsAgentCard)
{
agentCard->name = "ut-agent";
AgentCard card = server->OnGetCard(nullptr);
EXPECT_EQ(card.name, "ut-agent");
}
TEST_F(ServerImplTest, OnGetCard_WhenAgentCardNull_Throws)
{
server->agentCard_.reset();
EXPECT_THROW(server->OnGetCard(nullptr), std::runtime_error);
}
TEST_F(ServerImplTest, OnGetAuthenticatedExtendedCard_ReturnsAgentCard)
{
agentCard->name = "ut-agent";
AgentCard card = server->OnGetAuthenticatedExtendedCard(nullptr);
EXPECT_EQ(card.name, "ut-agent");
}
TEST_F(ServerImplTest, HandleNonStreamingRequest_ForCardPath_ReturnsAgentCard)
{
AgentCard card = MakeAgentCard();
EXPECT_CALL(*mockHandler, OnGetCard(IsNull()))
.WillOnce(Return(card));
std::string resp;
json req = json::object();
NiceMock<MockTransportEmitter> emitter;
server->HandleNonStreamingRequest(req, "{}", resp, "", WrapEmitter(emitter));
json out = json::parse(resp);
EXPECT_EQ(out["result"]["name"], "ut-agent");
}
TEST_F(ServerImplTest, ProcessStandardJsonRpc_OnGetTask_RoutesCorrectly)
{
Task task = MakeTask("task-9");
json req = MakeBaseReq(METHOD_TASK_GET);
req["params"] = {
{"id", "task-9"},
{"historyLength", 3}
};
EXPECT_CALL(*mockHandler, OnGetTask(_, IsNull()))
.WillOnce(Return(task));
std::string resp;
NiceMock<MockTransportEmitter> emitter;
server->ProcessStandardJsonRpc(req, resp, METHOD_TASK_GET, WrapEmitter(emitter));
json out = json::parse(resp);
EXPECT_EQ(out["jsonrpc"], "2.0");
EXPECT_EQ(out["id"], "req-1");
EXPECT_EQ(out["result"]["id"], "task-9");
}
TEST_F(ServerImplTest, ProcessStandardJsonRpc_OnCancelTask_RoutesCorrectly)
{
Task task = MakeTask("task-cancel");
json req = MakeBaseReq(METHOD_TASK_CANCEL);
req["params"] = {
{"id", "task-cancel"}
};
EXPECT_CALL(*mockHandler, OnCancelTask(_, IsNull()))
.WillOnce(Return(task));
std::string resp;
NiceMock<MockTransportEmitter> emitter;
server->ProcessStandardJsonRpc(req, resp, METHOD_TASK_CANCEL, WrapEmitter(emitter));
json out = json::parse(resp);
EXPECT_EQ(out["result"]["id"], "task-cancel");
}
TEST_F(ServerImplTest, ProcessStandardJsonRpc_UnknownMethod_ReturnsMethodNotFound)
{
json req = MakeBaseReq("unknown.method");
std::string resp;
NiceMock<MockTransportEmitter> emitter;
server->ProcessStandardJsonRpc(req, resp, "unknown.method", WrapEmitter(emitter));
json out = json::parse(resp);
EXPECT_TRUE(out.contains("error"));
EXPECT_EQ(out["error"]["code"], static_cast<int>(A2AErrorCode::JSONRPC_METHOD_NOT_FOUND));
}
TEST_F(ServerImplTest, CreateStreamEmitter_WritesSuccessResponse)
{
NiceMock<MockTransportEmitter> emitter;
std::function<void(const StreamEvent&)> streamEmit;
json req = MakeBaseReq(METHOD_MESSAGE_STREAM, "stream-1");
EXPECT_CALL(emitter, WriteStreamingData(_))
.WillOnce(Invoke([&](const std::string& s) {
json out = json::parse(s);
EXPECT_EQ(out["id"], "stream-1");
EXPECT_TRUE(out.contains("result"));
}));
server->CreateStreamEmitter(req, streamEmit, WrapEmitter(emitter), true);
Task task = MakeTask("task-stream");
streamEmit(task);
}
TEST_F(ServerImplTest, HandleStreamingRequest_MessageStream_WhenMessageInvalid_WritesInternalError)
{
NiceMock<MockTransportEmitter> emitter;
json req = MakeBaseReq(METHOD_MESSAGE_STREAM, "stream-2");
req["params"] = {
{"message", {
{"messageId", "msg-stream"},
{"role", "USER"}
}}
};
EXPECT_CALL(*mockHandler, OnSendMessageStreaming(_, IsNull(), _)).Times(0);
EXPECT_CALL(emitter, WriteStreamingData(_))
.WillOnce(Invoke([&](const std::string& s) {
json out = json::parse(s);
EXPECT_TRUE(out.contains("error"));
EXPECT_EQ(out["error"]["code"], static_cast<int>(A2AErrorCode::JSONRPC_INTERNAL_ERROR));
}));
EXPECT_CALL(emitter, WriteDone()).Times(1);
server->HandleStreamingRequest(req, METHOD_MESSAGE_STREAM, WrapEmitter(emitter));
}
TEST_F(ServerImplTest, HandleStreamingRequest_TaskResubscribe_RoutesCorrectly)
{
NiceMock<MockTransportEmitter> emitter;
json req = MakeBaseReq(METHOD_TASK_RESUBSCRIBE, "stream-3");
req["params"] = {
{"id", "task-sub"}
};
EXPECT_CALL(*mockHandler, OnResubscribeToTask(_, _, IsNull()))
.WillOnce(Invoke([&](const TaskIdParams&,
StreamEmitter&& cb,
std::shared_ptr<ServerCallContext>) {
cb(MakeMessage("msg-sub"));
}));
EXPECT_CALL(emitter, WriteStreamingData(_)).Times(1);
server->HandleStreamingRequest(req, METHOD_TASK_RESUBSCRIBE, WrapEmitter(emitter));
}
TEST_F(ServerImplTest, HandleStreamingRequest_UnsupportedMethod_WritesMethodNotFound)
{
NiceMock<MockTransportEmitter> emitter;
json req = MakeBaseReq("stream.unknown", "stream-4");
EXPECT_CALL(emitter, WriteStreamingData(_))
.WillOnce(Invoke([&](const std::string& s) {
json out = json::parse(s);
EXPECT_TRUE(out.contains("error"));
EXPECT_EQ(out["error"]["code"], static_cast<int>(A2AErrorCode::JSONRPC_METHOD_NOT_FOUND));
}));
EXPECT_CALL(emitter, WriteDone()).Times(1);
server->HandleStreamingRequest(req, "stream.unknown", WrapEmitter(emitter));
}
TEST_F(ServerImplTest, HandleStreamingRequest_WhenHandlerThrowsServerError_WritesError)
{
NiceMock<MockTransportEmitter> emitter;
json req = MakeBaseReq(METHOD_TASK_RESUBSCRIBE, "stream-5");
req["params"] = {
{"id", "task-sub"}
};
EXPECT_CALL(*mockHandler, OnResubscribeToTask(_, _, IsNull()))
.WillOnce(Throw(A2AServerError("stream failed",
static_cast<int>(A2AErrorCode::JSONRPC_METHOD_NOT_FOUND))));
EXPECT_CALL(emitter, WriteStreamingData(_))
.WillOnce(Invoke([&](const std::string& s) {
json out = json::parse(s);
EXPECT_TRUE(out.contains("error"));
EXPECT_EQ(out["error"]["code"], static_cast<int>(A2AErrorCode::JSONRPC_METHOD_NOT_FOUND));
EXPECT_EQ(out["error"]["message"], "stream failed");
}));
EXPECT_CALL(emitter, WriteDone()).Times(1);
server->HandleStreamingRequest(req, METHOD_TASK_RESUBSCRIBE, WrapEmitter(emitter));
}
TEST_F(ServerImplTest, HandleStreamingRequest_WhenHandlerThrowsStdException_WritesInternalError)
{
NiceMock<MockTransportEmitter> emitter;
json req = MakeBaseReq(METHOD_TASK_RESUBSCRIBE, "stream-6");
req["params"] = {
{"id", "task-sub"}
};
EXPECT_CALL(*mockHandler, OnResubscribeToTask(_, _, IsNull()))
.WillOnce(Throw(std::runtime_error("boom")));
EXPECT_CALL(emitter, WriteStreamingData(_))
.WillOnce(Invoke([&](const std::string& s) {
json out = json::parse(s);
EXPECT_TRUE(out.contains("error"));
EXPECT_EQ(out["error"]["code"], static_cast<int>(A2AErrorCode::JSONRPC_INTERNAL_ERROR));
}));
EXPECT_CALL(emitter, WriteDone()).Times(1);
server->HandleStreamingRequest(req, METHOD_TASK_RESUBSCRIBE, WrapEmitter(emitter));
}
TEST_F(ServerImplTest, Start_RegisteredRpcHandler_HandlesInvalidJson)
{
EXPECT_CALL(*mockTransport, SetRpcHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportRpcHandler handler) {
mockTransport->rpcHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, SetCardHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportCardHandler handler) {
mockTransport->cardHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, Start())
.WillOnce(Return(0));
ASSERT_EQ(server->Start(), 0);
std::shared_ptr<Transport::TransportEmitter> emitter;
std::string resp;
mockTransport->rpcHandler("{invalid json", resp, emitter);
json out = json::parse(resp);
EXPECT_TRUE(out.contains("error"));
EXPECT_EQ(out["error"]["code"], static_cast<int>(A2AErrorCode::JSONRPC_INTERNAL_ERROR));
}
TEST_F(ServerImplTest, Start_RegisteredCardHandler_ReturnsCardResponse)
{
agentCard->name = "ut-agent";
EXPECT_CALL(*mockTransport, SetRpcHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportRpcHandler handler) {
mockTransport->rpcHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, SetCardHandler(_))
.WillOnce(Invoke([&](Transport::ServerTransportCardHandler handler) {
mockTransport->cardHandler = std::move(handler);
}));
EXPECT_CALL(*mockTransport, Start())
.WillOnce(Return(0));
ASSERT_EQ(server->Start(), 0);
ASSERT_TRUE(static_cast<bool>(mockTransport->cardHandler));
std::string resp;
mockTransport->cardHandler("{}", resp);
json out = json::parse(resp);
EXPECT_EQ(out["name"], "ut-agent");
}
}