* Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
*/
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <stdexcept>
#include "client/client_factory.h"
#include "client/client_call_interceptor.h"
#include "client/client.h"
#include "types.h"
namespace A2A::Client::Test {
using namespace A2A;
using namespace A2A::Client;
using ::testing::_;
using ::testing::Return;
using ::testing::NiceMock;
static AgentCard MakeTestAgentCard()
{
AgentCard card;
card.name = "Test Agent";
card.description = "Test Description";
card.version = "1.0.0";
AgentInterface jsonrpcInterface;
jsonrpcInterface.protocolBinding = JSONRPC_TRANSPORT;
jsonrpcInterface.url = "http://localhost:8080/jsonrpc";
jsonrpcInterface.protocolVersion = "2.0";
card.supportedInterfaces = {jsonrpcInterface};
return card;
}
static ClientConfig MakeTestConfig(const std::vector<std::string>& transports, bool useClientPreference)
{
ClientConfig config;
config.supportedTransports = transports;
config.useClientPreference = useClientPreference;
return config;
}
static Consumer MakeTestConsumer()
{
auto func = [](const std::variant<Message, A2AError, std::pair<Task, std::variant<std::monostate,
TaskStatusUpdateEvent, TaskArtifactUpdateEvent>>>&, const AgentCard&) {
};
return Consumer(func);
}
class MockInterceptor : public ClientCallInterceptor {
public:
MOCK_METHOD5(Intercept,
void(const std::string& methodName,
std::string& payload,
std::map<std::string, std::string>& headers,
const AgentCard* agentCard,
const ClientCallContext* context));
};
class ClientFactoryTest : public ::testing::Test {
protected:
void SetUp() override
{
card = MakeTestAgentCard();
config = MakeTestConfig({JSONRPC_TRANSPORT}, true);
}
AgentCard card;
ClientConfig config;
std::vector<Consumer> emptyConsumers;
std::vector<std::shared_ptr<ClientCallInterceptor>> emptyInterceptors;
};
TEST_F(ClientFactoryTest, CreateBasicClient)
{
auto client = ClientFactory::Create(card, config, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateHttpClient)
{
AgentCard httpCard = card;
httpCard.supportedInterfaces.clear();
AgentInterface httpInterface;
httpInterface.protocolBinding = JSONRPC_TRANSPORT;
httpInterface.url = "https://api.example.com/a2a";
httpInterface.protocolVersion = "2.0";
httpCard.supportedInterfaces.push_back(httpInterface);
ClientConfig httpConfig = MakeTestConfig({JSONRPC_TRANSPORT}, true);
auto client = ClientFactory::Create(httpCard, httpConfig, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithNullInterceptor_ReturnsNull)
{
auto mockInterceptor = std::make_shared<NiceMock<MockInterceptor>>();
std::vector<std::shared_ptr<ClientCallInterceptor>> interceptors = {mockInterceptor, nullptr};
auto client = ClientFactory::Create(card, config, emptyConsumers, interceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithEmptyInterfaces_ReturnsNull)
{
card.supportedInterfaces.clear();
auto client = ClientFactory::Create(card, config, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithInvalidInterface_MissingUrl_ReturnsNull)
{
AgentInterface invalidInterface;
invalidInterface.protocolBinding = JSONRPC_TRANSPORT;
invalidInterface.protocolVersion = "2.0";
card.supportedInterfaces = {invalidInterface};
auto client = ClientFactory::Create(card, config, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithInvalidInterface_MissingProtocolBinding_ReturnsNull)
{
AgentInterface invalidInterface;
invalidInterface.url = "http://localhost:8080/jsonrpc";
invalidInterface.protocolVersion = "2.0";
card.supportedInterfaces = {invalidInterface};
auto client = ClientFactory::Create(card, config, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithInvalidInterface_MissingProtocolVersion_ReturnsNull)
{
AgentInterface invalidInterface;
invalidInterface.protocolBinding = JSONRPC_TRANSPORT;
invalidInterface.url = "http://localhost:8080/jsonrpc";
card.supportedInterfaces = {invalidInterface};
auto client = ClientFactory::Create(card, config, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithInvalidConfig_EmptyTransport_ReturnsNull)
{
ClientConfig invalidConfig = MakeTestConfig({JSONRPC_TRANSPORT, ""}, true);
auto client = ClientFactory::Create(card, invalidConfig, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, ProtocolSelection_ClientPreference_FirstMatch)
{
ClientConfig prefConfig = MakeTestConfig({JSONRPC_TRANSPORT}, true);
auto client = ClientFactory::Create(card, prefConfig, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, ProtocolSelection_ServerPreference_FirstMatch)
{
ClientConfig serverPrefConfig = MakeTestConfig({JSONRPC_TRANSPORT}, false);
auto client = ClientFactory::Create(card, serverPrefConfig, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, ProtocolSelection_NoMatchingProtocol_ReturnsNull)
{
ClientConfig noMatchConfig = MakeTestConfig({"UNKNOWN_PROTOCOL"}, true);
auto client = ClientFactory::Create(card, noMatchConfig, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, ProtocolSelection_DefaultTransport_WhenConfigEmpty)
{
ClientConfig defaultConfig = MakeTestConfig({}, true);
auto client = ClientFactory::Create(card, defaultConfig, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, ProtocolSelection_DuplicateBindings_Succeeds)
{
AgentInterface duplicateInterface;
duplicateInterface.protocolBinding = JSONRPC_TRANSPORT;
duplicateInterface.url = "http://localhost:8080/jsonrpc2";
duplicateInterface.protocolVersion = "2.0";
card.supportedInterfaces.push_back(duplicateInterface);
auto client = ClientFactory::Create(card, config, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithConsumers_Succeeds)
{
std::vector<Consumer> consumers = {MakeTestConsumer()};
auto client = ClientFactory::Create(card, config, consumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithMultipleConsumers_Succeeds)
{
std::vector<Consumer> consumers = {
MakeTestConsumer(),
MakeTestConsumer(),
MakeTestConsumer()
};
auto client = ClientFactory::Create(card, config, consumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithInterceptors_Succeeds)
{
auto mockInterceptor = std::make_shared<NiceMock<MockInterceptor>>();
std::vector<std::shared_ptr<ClientCallInterceptor>> interceptors = {mockInterceptor};
auto client = ClientFactory::Create(card, config, emptyConsumers, interceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithMultipleInterceptors_Succeeds)
{
std::vector<std::shared_ptr<ClientCallInterceptor>> interceptors;
for (int i = 0; i < 5; i++) {
interceptors.push_back(std::make_shared<NiceMock<MockInterceptor>>());
}
auto client = ClientFactory::Create(card, config, emptyConsumers, interceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithAllComponents_Succeeds)
{
auto mockInterceptor = std::make_shared<NiceMock<MockInterceptor>>();
std::vector<std::shared_ptr<ClientCallInterceptor>> interceptors = {mockInterceptor};
std::vector<Consumer> consumers = {MakeTestConsumer()};
auto client = ClientFactory::Create(card, config, consumers, interceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, CreateWithNullTransport_ReturnsNull)
{
auto client = ClientFactory::Create(card, config, nullptr, emptyConsumers);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, ServerPreference_NoMatch_ReturnsNull)
{
ClientConfig serverPrefConfig = MakeTestConfig({"UNSUPPORTED_TRANSPORT"}, false);
card.supportedInterfaces.clear();
AgentInterface jsonrpcInterface;
jsonrpcInterface.protocolBinding = JSONRPC_TRANSPORT;
jsonrpcInterface.url = "http://localhost:8080/jsonrpc";
jsonrpcInterface.protocolVersion = "2.0";
card.supportedInterfaces.push_back(jsonrpcInterface);
auto client = ClientFactory::Create(card, serverPrefConfig, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, UnsupportedTransport_ReturnsNull)
{
AgentInterface unsupportedInterface;
unsupportedInterface.protocolBinding = "UNSUPPORTED";
unsupportedInterface.url = "http://localhost:8080/unsupported";
unsupportedInterface.protocolVersion = "1.0";
card.supportedInterfaces = {unsupportedInterface};
ClientConfig unsupportedConfig = MakeTestConfig({"UNSUPPORTED"}, true);
auto client = ClientFactory::Create(card, unsupportedConfig, emptyConsumers, emptyInterceptors);
EXPECT_EQ(client, nullptr);
}
TEST_F(ClientFactoryTest, EmptyConfig_Succeeds)
{
ClientConfig emptyConfig;
auto client = ClientFactory::Create(card, emptyConfig, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
TEST_F(ClientFactoryTest, ServerPreference_WithUnsupportedFirst_FallsBack)
{
card.supportedInterfaces.clear();
AgentInterface unsupportedInterface;
unsupportedInterface.protocolBinding = "UNSUPPORTED";
unsupportedInterface.url = "unsupported://test";
unsupportedInterface.protocolVersion = "1.0";
AgentInterface jsonrpcInterface;
jsonrpcInterface.protocolBinding = JSONRPC_TRANSPORT;
jsonrpcInterface.url = "http://localhost:8080/jsonrpc";
jsonrpcInterface.protocolVersion = "2.0";
card.supportedInterfaces = {unsupportedInterface, jsonrpcInterface};
ClientConfig serverPrefConfig = MakeTestConfig({JSONRPC_TRANSPORT}, false);
auto client = ClientFactory::Create(card, serverPrefConfig, emptyConsumers, emptyInterceptors);
EXPECT_NE(client, nullptr);
}
}