* Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
*/
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <memory>
#include <future>
#include <chrono>
#include <thread>
#include <iostream>
#include "client/http_card_resolver.h"
#include "client/jsonrpc_transport.h"
#include "types.h"
namespace A2A::Client::Test {
using namespace A2A::Client;
using ::testing::_;
using ::testing::Return;
using ::testing::Invoke;
using ::testing::SaveArg;
using ::testing::DoAll;
using ::testing::NiceMock;
class MockJsonRpcTransport : public JsonRpcTransport {
public:
MockJsonRpcTransport() : JsonRpcTransport("", AgentCard{}, ClientConfig{}, {})
{}
MOCK_METHOD(void, SetTransportCallback, (TransportEventCallback), (override));
MOCK_METHOD(void, GetCard, (const std::string&, const ClientCallContext*, int), (override));
MOCK_METHOD(void, Close, (), (override));
MOCK_METHOD(void, SendMessage, (const std::string&, const MessageSendParams&, const ClientCallContext*, int),
(override));
MOCK_METHOD(void, SendMessageStreaming, (const std::string&, const MessageSendParams&,
const ClientCallContext*, int), (override));
MOCK_METHOD(void, GetTask, (const std::string&, const TaskQueryParams&,
const ClientCallContext*, int), (override));
MOCK_METHOD(void, CancelTask, (const std::string&, const TaskIdParams&, const ClientCallContext*, int),
(override));
MOCK_METHOD(void, SetTaskPushNotificationConfig, (const std::string&, const TaskPushNotificationConfig&,
const ClientCallContext*, int), (override));
MOCK_METHOD(void, GetTaskPushNotificationConfig, (const std::string&, const GetTaskPushNotificationConfigParams&,
const ClientCallContext*, int), (override));
MOCK_METHOD(void, ListTaskPushNotificationConfigs, (const std::string&, const ListTaskPushNotificationConfigParams&,
const ClientCallContext*, int), (override));
MOCK_METHOD(void, DeleteTaskPushNotificationConfig, (const std::string&,
const DeleteTaskPushNotificationConfigParams&, const ClientCallContext*, int), (override));
MOCK_METHOD(void, Resubscribe, (const std::string&, const TaskIdParams&, const ClientCallContext*, int),
(override));
};
class TestableHttpCardResolver : public HttpCardResolver {
public:
TestableHttpCardResolver(std::string baseUrl,
const std::optional<std::string>& relativeCardPath,
std::map<std::string, std::string> httpKwargs)
: HttpCardResolver(std::move(baseUrl), relativeCardPath, std::move(httpKwargs))
{
}
~TestableHttpCardResolver()
{
invalid_ = true;
}
void SetMockTransport(std::shared_ptr<JsonRpcTransport> transport)
{
transport_ = transport;
TestableHttpCardResolver* rawThis = this;
std::atomic<bool>* invalid = &invalid_;
transport_->SetTransportCallback([rawThis, invalid](const std::string& id, const TransportEvent& ev) {
if (!invalid->load() && rawThis) {
rawThis->OnTransportEvent(id, ev);
}
});
}
void TriggerOnTransportEvent(const std::string& requestId, const TransportEvent& event)
{
OnTransportEvent(requestId, event);
}
size_t GetPendingPromiseCount()
{
std::lock_guard<std::mutex> lock(callbackMutex_);
return pendingPromises_.size();
}
std::string GetLastRequestId()
{
std::lock_guard<std::mutex> lock(callbackMutex_);
if (pendingPromises_.empty()) {
return "";
}
return pendingPromises_.begin()->first;
}
bool HasPromiseForRequest(const std::string& requestId)
{
std::lock_guard<std::mutex> lock(callbackMutex_);
return pendingPromises_.find(requestId) != pendingPromises_.end();
}
private:
std::atomic<bool> invalid_{false};
};
class HttpCardResolverMockTest : public ::testing::Test {
protected:
void SetUp() override
{
baseUrl = "https://api.example.com";
relativePath = "agent/card";
httpKwargs = {{"timeout", "30"}};
testCard.name = "Test Agent";
testCard.description = "Test Description";
testCard.version = "1.0.0";
AgentCapabilities caps;
caps.streaming = true;
caps.pushNotifications = false;
caps.extendedAgentCard = true;
testCard.capabilities = caps;
testCard.defaultInputModes = {"text/plain"};
testCard.defaultOutputModes = {"text/plain"};
mockTransport = std::make_shared<NiceMock<MockJsonRpcTransport>>();
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
}
std::string baseUrl;
std::string relativePath;
std::map<std::string, std::string> httpKwargs;
AgentCard testCard;
std::shared_ptr<NiceMock<MockJsonRpcTransport>> mockTransport;
std::shared_ptr<TestableHttpCardResolver> resolver;
TransportEventCallback capturedCallback;
};
TEST_F(HttpCardResolverMockTest, SetsTransportCallback)
{
EXPECT_CALL(*mockTransport, SetTransportCallback(_))
.WillOnce(SaveArg<0>(&capturedCallback));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
ASSERT_NE(capturedCallback, nullptr);
}
TEST_F(HttpCardResolverMockTest, GetAgentCardCallsGetCard)
{
std::string capturedRequestId;
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.WillOnce(Invoke([&capturedRequestId](const std::string& requestId,
const ClientCallContext*,
int) {
capturedRequestId = requestId;
}));
auto future = resolver->GetAgentCard(std::nullopt);
EXPECT_FALSE(capturedRequestId.empty());
EXPECT_TRUE(resolver->HasPromiseForRequest(capturedRequestId));
EXPECT_EQ(resolver->GetPendingPromiseCount(), 1);
}
TEST_F(HttpCardResolverMockTest, HandlesSuccessResponse)
{
std::string capturedRequestId;
TransportEventCallback capturedCallback;
EXPECT_CALL(*mockTransport, SetTransportCallback(_))
.WillOnce(SaveArg<0>(&capturedCallback));
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.WillOnce(Invoke([&capturedRequestId](const std::string& requestId,
const ClientCallContext*,
int) {
capturedRequestId = requestId;
}));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
auto future = resolver->GetAgentCard(std::nullopt);
ASSERT_NE(capturedCallback, nullptr);
ASSERT_FALSE(capturedRequestId.empty());
TransportEvent event = testCard;
capturedCallback(capturedRequestId, event);
EXPECT_EQ(resolver->GetPendingPromiseCount(), 0);
EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready);
AgentCard result = future.get();
EXPECT_EQ(result.name, testCard.name);
EXPECT_EQ(result.version, testCard.version);
}
TEST_F(HttpCardResolverMockTest, HandlesErrorResponse)
{
std::string capturedRequestId;
TransportEventCallback capturedCallback;
EXPECT_CALL(*mockTransport, SetTransportCallback(_))
.WillOnce(SaveArg<0>(&capturedCallback));
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.WillOnce(Invoke([&capturedRequestId](const std::string& requestId,
const ClientCallContext*,
int) {
capturedRequestId = requestId;
}));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
auto future = resolver->GetAgentCard(std::nullopt);
TransportError error;
error.errorCode = 404;
error.errInfo = "Not found";
capturedCallback(capturedRequestId, error);
EXPECT_EQ(resolver->GetPendingPromiseCount(), 0);
EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready);
EXPECT_THROW(future.get(), std::runtime_error);
}
TEST_F(HttpCardResolverMockTest, HandlesUnexpectedResponseType)
{
std::string capturedRequestId;
TransportEventCallback capturedCallback;
EXPECT_CALL(*mockTransport, SetTransportCallback(_))
.WillOnce(SaveArg<0>(&capturedCallback));
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.WillOnce(Invoke([&capturedRequestId](const std::string& requestId,
const ClientCallContext*,
int) {
capturedRequestId = requestId;
}));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
auto future = resolver->GetAgentCard(std::nullopt);
A2A::Message message;
message.messageId = "test-msg";
capturedCallback(capturedRequestId, message);
EXPECT_EQ(resolver->GetPendingPromiseCount(), 0);
EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready);
EXPECT_THROW(future.get(), std::runtime_error);
}
TEST_F(HttpCardResolverMockTest, HandlesNoResponse)
{
std::string capturedRequestId;
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.WillOnce(Invoke([&capturedRequestId](const std::string& requestId,
const ClientCallContext*,
int) {
capturedRequestId = requestId;
}));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
auto future = resolver->GetAgentCard(std::nullopt);
EXPECT_EQ(resolver->GetPendingPromiseCount(), 1);
EXPECT_TRUE(resolver->HasPromiseForRequest(capturedRequestId));
EXPECT_TRUE(future.valid());
}
TEST_F(HttpCardResolverMockTest, HandlesConcurrentRequests)
{
std::vector<std::string> capturedRequestIds;
TransportEventCallback capturedCallback;
EXPECT_CALL(*mockTransport, SetTransportCallback(_))
.WillOnce(SaveArg<0>(&capturedCallback));
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.Times(3)
.WillRepeatedly(Invoke([&capturedRequestIds](const std::string& requestId,
const ClientCallContext*,
int) {
capturedRequestIds.push_back(requestId);
}));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
std::vector<std::future<AgentCard>> futures;
for (int i = 0; i < 3; i++) {
futures.push_back(resolver->GetAgentCard(std::nullopt));
}
EXPECT_EQ(capturedRequestIds.size(), 3);
EXPECT_EQ(resolver->GetPendingPromiseCount(), 3);
for (size_t i = 0; i < capturedRequestIds.size(); i++) {
capturedCallback(capturedRequestIds[i], testCard);
EXPECT_EQ(resolver->GetPendingPromiseCount(), 2 - i);
}
for (auto& future : futures) {
EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready);
EXPECT_NO_THROW(future.get());
}
}
TEST_F(HttpCardResolverMockTest, GetAllAgentCardsWorks)
{
std::string capturedRequestId;
TransportEventCallback capturedCallback;
EXPECT_CALL(*mockTransport, SetTransportCallback(_))
.WillOnce(SaveArg<0>(&capturedCallback));
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.WillOnce(Invoke([&capturedRequestId](const std::string& requestId,
const ClientCallContext*,
int) {
capturedRequestId = requestId;
}));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
auto future = resolver->GetAllAgentCards();
EXPECT_FALSE(capturedRequestId.empty());
capturedCallback(capturedRequestId, testCard);
EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready);
std::vector<AgentCard> cards = future.get();
ASSERT_EQ(cards.size(), 1);
EXPECT_EQ(cards[0].name, testCard.name);
}
TEST_F(HttpCardResolverMockTest, HandlesTransportException)
{
EXPECT_CALL(*mockTransport, GetCard(_, _, _))
.WillOnce(Invoke([](const std::string&, const ClientCallContext*, int) {
throw std::runtime_error("Transport error");
}));
resolver = std::make_shared<TestableHttpCardResolver>(baseUrl, relativePath, httpKwargs);
resolver->SetMockTransport(mockTransport);
auto future = resolver->GetAgentCard(std::nullopt);
EXPECT_EQ(resolver->GetPendingPromiseCount(), 0);
EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready);
EXPECT_THROW(future.get(), std::runtime_error);
}
}