test_protocol_serializer.cpp File Reference

#include <gtest/gtest.h>
#include <cstdint>
#include <string>
#include <vector>
#include <map>
#include "database/protocol/database_protocol.h"

Include dependency graph for test_protocol_serializer.cpp:

Go to the source code of this file.

Classes
class	MessageHeaderTest
class	ConnectProtocolTest
class	QueryProtocolTest
class	TransactionProtocolTest
class	ErrorProtocolTest
class	SerializerEdgeCaseTest

Functions
	TEST_F (MessageHeaderTest, DefaultMagicAndVersion)
	TEST_F (MessageHeaderTest, InvalidMagic)
	TEST_F (MessageHeaderTest, InvalidVersion)
	TEST_F (MessageHeaderTest, SerializeDeserializeRoundTrip)
	TEST_F (MessageHeaderTest, DeserializeHeaderTooSmall)
	TEST_F (MessageHeaderTest, DeserializeInvalidMagicReturnsError)
	TEST_F (MessageHeaderTest, AllMessageTypes)
	TEST_F (MessageHeaderTest, LargeRequestIdAndPayload)
	TEST_F (ConnectProtocolTest, ConnectRequestRoundTrip)
	TEST_F (ConnectProtocolTest, ConnectRequestEmptyOptions)
	TEST_F (ConnectProtocolTest, ConnectRequestTooSmall)
	TEST_F (ConnectProtocolTest, ConnectResponseSuccessRoundTrip)
	TEST_F (ConnectProtocolTest, ConnectResponseFailureRoundTrip)
	TEST_F (ConnectProtocolTest, ConnectResponseEmptyData)
	TEST_F (QueryProtocolTest, QueryRequestSelectRoundTrip)
	TEST_F (QueryProtocolTest, QueryRequestInsertWithMultipleParams)
	TEST_F (QueryProtocolTest, QueryRequestNoParameters)
	TEST_F (QueryProtocolTest, QueryRequestAllOperationTypes)
	TEST_F (QueryProtocolTest, QueryRequestSpecialCharacters)
	TEST_F (QueryProtocolTest, QueryRequestEmptyData)
	TEST_F (QueryProtocolTest, QueryResponseSuccessWithRows)
	TEST_F (QueryProtocolTest, QueryResponseInsertResult)
	TEST_F (QueryProtocolTest, QueryResponseFailure)
	TEST_F (QueryProtocolTest, QueryResponseEmptyData)
	TEST_F (QueryProtocolTest, QueryResponseLargePayload)
	TEST_F (TransactionProtocolTest, BeginTransactionRoundTrip)
	TEST_F (TransactionProtocolTest, CommitTransactionRoundTrip)
	TEST_F (TransactionProtocolTest, RollbackTransactionRoundTrip)
	TEST_F (TransactionProtocolTest, TransactionRequestTooSmall)
	TEST_F (TransactionProtocolTest, TransactionResponseSuccessRoundTrip)
	TEST_F (TransactionProtocolTest, TransactionResponseFailureRoundTrip)
	TEST_F (TransactionProtocolTest, TransactionResponseEmptyData)
	TEST_F (ErrorProtocolTest, ErrorResponseRoundTrip)
	TEST_F (ErrorProtocolTest, ErrorResponseNegativeCode)
	TEST_F (ErrorProtocolTest, ErrorResponseTooSmall)
	TEST_F (SerializerEdgeCaseTest, EmptyStringFields)
	TEST_F (SerializerEdgeCaseTest, LongStringPreserved)
	TEST_F (SerializerEdgeCaseTest, UnicodeStringPreserved)
	TEST_F (SerializerEdgeCaseTest, ManyOptionsMapPreserved)
	TEST_F (SerializerEdgeCaseTest, QueryRequestManyParameters)
	TEST_F (SerializerEdgeCaseTest, HeaderZeroRequestId)

Function Documentation

TEST_F() [1/41]

TEST_F	(	ConnectProtocolTest	,
		ConnectRequestEmptyOptions	)

Definition at line 146 of file test_protocol_serializer.cpp.

                                                        {
    connect_request original;
    original.database_type = "sqlite";
    original.connection_string = "file:test.db";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_connect_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.database_type, "sqlite");
    EXPECT_EQ(recovered.connection_string, "file:test.db");
    EXPECT_TRUE(recovered.options.empty());
}

References ASSERT_TRUE, database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::protocol::protocol_serializer::deserialize_connect_request(), and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [2/41]

TEST_F	(	ConnectProtocolTest	,
		ConnectRequestRoundTrip	)

Definition at line 126 of file test_protocol_serializer.cpp.

                                                     {
    connect_request original;
    original.database_type = "postgresql";
    original.connection_string = "host=localhost port=5432 dbname=testdb";
    original.options = {{"timeout", "30"}, {"ssl", "true"}};
 
    auto bytes = protocol_serializer::serialize(original);
    EXPECT_FALSE(bytes.empty());
 
    auto result = protocol_serializer::deserialize_connect_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.database_type, original.database_type);
    EXPECT_EQ(recovered.connection_string, original.connection_string);
    EXPECT_EQ(recovered.options.size(), original.options.size());
    EXPECT_EQ(recovered.options.at("timeout"), "30");
    EXPECT_EQ(recovered.options.at("ssl"), "true");
}

References ASSERT_TRUE, database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::protocol::protocol_serializer::deserialize_connect_request(), database::protocol::connect_request::options, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [3/41]

TEST_F	(	ConnectProtocolTest	,
		ConnectRequestTooSmall	)

Definition at line 161 of file test_protocol_serializer.cpp.

                                                    {
    std::vector<uint8_t> data = {0x01, 0x02};
    auto result = protocol_serializer::deserialize_connect_request(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_connect_request().

Here is the call graph for this function:

TEST_F() [4/41]

TEST_F	(	ConnectProtocolTest	,
		ConnectResponseEmptyData	)

Definition at line 199 of file test_protocol_serializer.cpp.

                                                      {
    std::vector<uint8_t> data;
    auto result = protocol_serializer::deserialize_connect_response(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_connect_response().

Here is the call graph for this function:

TEST_F() [5/41]

TEST_F	(	ConnectProtocolTest	,
		ConnectResponseFailureRoundTrip	)

Definition at line 183 of file test_protocol_serializer.cpp.

                                                             {
    connect_response original;
    original.success = false;
    original.session_id = "";
    original.error_message = "Authentication failed: invalid credentials";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_connect_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_FALSE(recovered.success);
    EXPECT_TRUE(recovered.session_id.empty());
    EXPECT_EQ(recovered.error_message, "Authentication failed: invalid credentials");
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_connect_response(), database::protocol::connect_response::error_message, database::protocol::protocol_serializer::serialize(), database::protocol::connect_response::session_id, and database::protocol::connect_response::success.

Here is the call graph for this function:

TEST_F() [6/41]

TEST_F	(	ConnectProtocolTest	,
		ConnectResponseSuccessRoundTrip	)

Definition at line 167 of file test_protocol_serializer.cpp.

                                                             {
    connect_response original;
    original.success = true;
    original.session_id = "sess-abc-123-def-456";
    original.error_message = "";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_connect_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_TRUE(recovered.success);
    EXPECT_EQ(recovered.session_id, "sess-abc-123-def-456");
    EXPECT_TRUE(recovered.error_message.empty());
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_connect_response(), database::protocol::connect_response::error_message, database::protocol::protocol_serializer::serialize(), database::protocol::connect_response::session_id, and database::protocol::connect_response::success.

Here is the call graph for this function:

TEST_F() [7/41]

TEST_F	(	ErrorProtocolTest	,
		ErrorResponseNegativeCode	)

Definition at line 493 of file test_protocol_serializer.cpp.

                                                     {
    error_response original;
    original.error_code = -1;
    original.error_message = "Internal server error";
    original.error_context = "";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_error_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.error_code, -1);
    EXPECT_EQ(recovered.error_message, "Internal server error");
    EXPECT_TRUE(recovered.error_context.empty());
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_error_response(), database::protocol::error_response::error_code, database::protocol::error_response::error_context, database::protocol::error_response::error_message, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [8/41]

TEST_F	(	ErrorProtocolTest	,
		ErrorResponseRoundTrip	)

Definition at line 477 of file test_protocol_serializer.cpp.

                                                  {
    error_response original;
    original.error_code = 1001;
    original.error_message = "Table not found";
    original.error_context = "SELECT * FROM nonexistent_table";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_error_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.error_code, 1001);
    EXPECT_EQ(recovered.error_message, "Table not found");
    EXPECT_EQ(recovered.error_context, "SELECT * FROM nonexistent_table");
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_error_response(), database::protocol::error_response::error_code, database::protocol::error_response::error_context, database::protocol::error_response::error_message, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [9/41]

TEST_F	(	ErrorProtocolTest	,
		ErrorResponseTooSmall	)

Definition at line 509 of file test_protocol_serializer.cpp.

                                                 {
    std::vector<uint8_t> data = {0x01, 0x02};
    auto result = protocol_serializer::deserialize_error_response(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_error_response().

Here is the call graph for this function:

TEST_F() [10/41]

TEST_F	(	MessageHeaderTest	,
		AllMessageTypes	)

Definition at line 83 of file test_protocol_serializer.cpp.

                                           {
    const message_type types[] = {
        message_type::CONNECT_REQUEST, message_type::CONNECT_RESPONSE,
        message_type::DISCONNECT, message_type::PING, message_type::PONG,
        message_type::QUERY_REQUEST, message_type::QUERY_RESPONSE,
        message_type::BEGIN_TRANSACTION, message_type::COMMIT_TRANSACTION,
        message_type::ROLLBACK_TRANSACTION, message_type::TRANSACTION_RESPONSE,
        message_type::PREPARE_STATEMENT, message_type::EXECUTE_PREPARED,
        message_type::CLOSE_PREPARED, message_type::ERROR_RESPONSE
    };
 
    for (auto type : types) {
        message_header header;
        header.type = type;
        header.request_id = 42;
        header.payload_size = 0;
 
        auto bytes = protocol_serializer::serialize_header(header);
        auto result = protocol_serializer::deserialize_header(bytes);
        ASSERT_TRUE(result.is_ok()) << "Failed for message_type " << static_cast<uint16_t>(type);
        EXPECT_EQ(result.value().type, type);
    }
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_header(), database::protocol::message_header::payload_size, database::protocol::message_header::request_id, database::protocol::protocol_serializer::serialize_header(), and database::protocol::message_header::type.

Here is the call graph for this function:

TEST_F() [11/41]

TEST_F	(	MessageHeaderTest	,
		DefaultMagicAndVersion	)

Definition at line 26 of file test_protocol_serializer.cpp.

                                                  {
    message_header header;
    EXPECT_EQ(header.magic, message_header::MAGIC);
    EXPECT_EQ(header.version, message_header::PROTOCOL_VERSION);
    EXPECT_TRUE(header.is_valid());
}

References database::protocol::message_header::is_valid(), database::protocol::message_header::MAGIC, database::protocol::message_header::magic, database::protocol::message_header::PROTOCOL_VERSION, and database::protocol::message_header::version.

Here is the call graph for this function:

TEST_F() [12/41]

TEST_F	(	MessageHeaderTest	,
		DeserializeHeaderTooSmall	)

Definition at line 65 of file test_protocol_serializer.cpp.

                                                     {
    std::vector<uint8_t> data = {0x01, 0x02, 0x03};
    auto result = protocol_serializer::deserialize_header(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_header().

Here is the call graph for this function:

TEST_F() [13/41]

TEST_F	(	MessageHeaderTest	,
		DeserializeInvalidMagicReturnsError	)

Definition at line 71 of file test_protocol_serializer.cpp.

                                                               {
    // Build a 20-byte buffer with wrong magic
    std::vector<uint8_t> data(20, 0);
    // Write garbage magic (little-endian)
    data[0] = 0xEF; data[1] = 0xBE; data[2] = 0xAD; data[3] = 0xDE;
    // Write valid version (1, little-endian)
    data[4] = 0x01; data[5] = 0x00;
 
    auto result = protocol_serializer::deserialize_header(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_header().

Here is the call graph for this function:

TEST_F() [14/41]

TEST_F	(	MessageHeaderTest	,
		InvalidMagic	)

Definition at line 33 of file test_protocol_serializer.cpp.

                                        {
    message_header header;
    header.magic = 0xDEADBEEF;
    EXPECT_FALSE(header.is_valid());
}

References database::protocol::message_header::is_valid(), and database::protocol::message_header::magic.

Here is the call graph for this function:

TEST_F() [15/41]

TEST_F	(	MessageHeaderTest	,
		InvalidVersion	)

Definition at line 39 of file test_protocol_serializer.cpp.

                                          {
    message_header header;
    header.version = 99;
    EXPECT_FALSE(header.is_valid());
}

References database::protocol::message_header::is_valid(), and database::protocol::message_header::version.

Here is the call graph for this function:

TEST_F() [16/41]

TEST_F	(	MessageHeaderTest	,
		LargeRequestIdAndPayload	)

Definition at line 107 of file test_protocol_serializer.cpp.

                                                    {
    message_header header;
    header.type = message_type::QUERY_REQUEST;
    header.request_id = UINT64_MAX;
    header.payload_size = UINT32_MAX;
 
    auto bytes = protocol_serializer::serialize_header(header);
    auto result = protocol_serializer::deserialize_header(bytes);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().request_id, UINT64_MAX);
    EXPECT_EQ(result.value().payload_size, UINT32_MAX);
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_header(), database::protocol::message_header::payload_size, database::protocol::message_header::request_id, database::protocol::protocol_serializer::serialize_header(), and database::protocol::message_header::type.

Here is the call graph for this function:

TEST_F() [17/41]

TEST_F	(	MessageHeaderTest	,
		SerializeDeserializeRoundTrip	)

Definition at line 45 of file test_protocol_serializer.cpp.

                                                         {
    message_header original;
    original.type = message_type::QUERY_REQUEST;
    original.request_id = 12345;
    original.payload_size = 100;
 
    auto bytes = protocol_serializer::serialize_header(original);
    EXPECT_EQ(bytes.size(), 20u);
 
    auto result = protocol_serializer::deserialize_header(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.magic, original.magic);
    EXPECT_EQ(recovered.version, original.version);
    EXPECT_EQ(recovered.type, original.type);
    EXPECT_EQ(recovered.request_id, original.request_id);
    EXPECT_EQ(recovered.payload_size, original.payload_size);
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_header(), database::protocol::message_header::magic, database::protocol::message_header::payload_size, database::protocol::message_header::request_id, database::protocol::protocol_serializer::serialize_header(), database::protocol::message_header::type, and database::protocol::message_header::version.

Here is the call graph for this function:

TEST_F() [18/41]

TEST_F	(	QueryProtocolTest	,
		QueryRequestAllOperationTypes	)

Definition at line 260 of file test_protocol_serializer.cpp.

                                                         {
    const query_operation ops[] = {
        query_operation::SELECT, query_operation::INSERT,
        query_operation::UPDATE, query_operation::DELETE,
        query_operation::CREATE, query_operation::ALTER,
        query_operation::DROP, query_operation::OTHER
    };
 
    for (auto op : ops) {
        query_request original;
        original.operation = op;
        original.query_string = "test query";
 
        auto bytes = protocol_serializer::serialize(original);
        auto result = protocol_serializer::deserialize_query_request(bytes);
        ASSERT_TRUE(result.is_ok()) << "Failed for operation " << static_cast<int>(op);
        EXPECT_EQ(result.value().operation, op);
    }
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_request(), database::protocol::query_request::operation, database::protocol::query_request::query_string, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [19/41]

TEST_F	(	QueryProtocolTest	,
		QueryRequestEmptyData	)

Definition at line 298 of file test_protocol_serializer.cpp.

                                                 {
    std::vector<uint8_t> data;
    auto result = protocol_serializer::deserialize_query_request(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_query_request().

Here is the call graph for this function:

TEST_F() [20/41]

TEST_F	(	QueryProtocolTest	,
		QueryRequestInsertWithMultipleParams	)

Definition at line 228 of file test_protocol_serializer.cpp.

                                                                {
    query_request original;
    original.operation = query_operation::INSERT;
    original.query_string = "INSERT INTO users (name, email, age) VALUES (?, ?, ?)";
    original.parameters = {"Alice", "alice@example.com", "30"};
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.operation, query_operation::INSERT);
    ASSERT_EQ(recovered.parameters.size(), 3u);
    EXPECT_EQ(recovered.parameters[0], "Alice");
    EXPECT_EQ(recovered.parameters[1], "alice@example.com");
    EXPECT_EQ(recovered.parameters[2], "30");
}

References ASSERT_EQ, ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_request(), database::protocol::query_request::operation, database::protocol::query_request::parameters, database::protocol::query_request::query_string, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [21/41]

TEST_F	(	QueryProtocolTest	,
		QueryRequestNoParameters	)

Definition at line 246 of file test_protocol_serializer.cpp.

                                                    {
    query_request original;
    original.operation = query_operation::CREATE;
    original.query_string = "CREATE TABLE test (id INTEGER PRIMARY KEY)";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.operation, query_operation::CREATE);
    EXPECT_TRUE(recovered.parameters.empty());
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_request(), database::protocol::query_request::operation, database::protocol::query_request::query_string, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [22/41]

TEST_F	(	QueryProtocolTest	,
		QueryRequestSelectRoundTrip	)

Definition at line 211 of file test_protocol_serializer.cpp.

                                                       {
    query_request original;
    original.operation = query_operation::SELECT;
    original.query_string = "SELECT * FROM users WHERE id = ?";
    original.parameters = {"42"};
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.operation, query_operation::SELECT);
    EXPECT_EQ(recovered.query_string, original.query_string);
    ASSERT_EQ(recovered.parameters.size(), 1u);
    EXPECT_EQ(recovered.parameters[0], "42");
}

References ASSERT_EQ, ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_request(), database::protocol::query_request::operation, database::protocol::query_request::parameters, database::protocol::query_request::query_string, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [23/41]

TEST_F	(	QueryProtocolTest	,
		QueryRequestSpecialCharacters	)

Definition at line 280 of file test_protocol_serializer.cpp.

                                                         {
    query_request original;
    original.operation = query_operation::SELECT;
    original.query_string = "SELECT * FROM users WHERE name LIKE ?";
    original.parameters = {"O'Brien", "50%", "tab\tchar", "newline\nchar"};
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    ASSERT_EQ(recovered.parameters.size(), 4u);
    EXPECT_EQ(recovered.parameters[0], "O'Brien");
    EXPECT_EQ(recovered.parameters[1], "50%");
    EXPECT_EQ(recovered.parameters[2], "tab\tchar");
    EXPECT_EQ(recovered.parameters[3], "newline\nchar");
}

References ASSERT_EQ, ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_request(), database::protocol::query_request::operation, database::protocol::query_request::parameters, database::protocol::query_request::query_string, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [24/41]

TEST_F	(	QueryProtocolTest	,
		QueryResponseEmptyData	)

Definition at line 367 of file test_protocol_serializer.cpp.

                                                  {
    std::vector<uint8_t> data;
    auto result = protocol_serializer::deserialize_query_response(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_query_response().

Here is the call graph for this function:

TEST_F() [25/41]

TEST_F	(	QueryProtocolTest	,
		QueryResponseFailure	)

Definition at line 351 of file test_protocol_serializer.cpp.

                                                {
    query_response original;
    original.success = false;
    original.error_code = 1045;
    original.error_message = "Access denied for user 'root'@'localhost'";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_FALSE(recovered.success);
    EXPECT_EQ(recovered.error_code, 1045);
    EXPECT_EQ(recovered.error_message, "Access denied for user 'root'@'localhost'");
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_response(), database::protocol::query_response::error_code, database::protocol::query_response::error_message, database::protocol::protocol_serializer::serialize(), and database::protocol::query_response::success.

Here is the call graph for this function:

TEST_F() [26/41]

TEST_F	(	QueryProtocolTest	,
		QueryResponseInsertResult	)

Definition at line 332 of file test_protocol_serializer.cpp.

                                                     {
    query_response original;
    original.success = true;
    original.affected_rows = 1;
    original.last_insert_id = 42;
    original.error_code = 0;
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_TRUE(recovered.success);
    EXPECT_EQ(recovered.affected_rows, 1u);
    EXPECT_EQ(recovered.last_insert_id, 42u);
    EXPECT_TRUE(recovered.column_names.empty());
    EXPECT_TRUE(recovered.rows.empty());
}

References database::protocol::query_response::affected_rows, ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_response(), database::protocol::query_response::error_code, database::protocol::query_response::last_insert_id, database::protocol::protocol_serializer::serialize(), and database::protocol::query_response::success.

Here is the call graph for this function:

TEST_F() [27/41]

TEST_F	(	QueryProtocolTest	,
		QueryResponseLargePayload	)

Definition at line 373 of file test_protocol_serializer.cpp.

                                                     {
    query_response original;
    original.success = true;
    original.column_names = {"id", "data"};
 
    for (int i = 0; i < 100; ++i) {
        original.rows.push_back({
            {"id", std::to_string(i)},
            {"data", std::string(256, 'x')}
        });
    }
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    ASSERT_EQ(recovered.rows.size(), 100u);
    EXPECT_EQ(recovered.rows[50].at("id"), "50");
    EXPECT_EQ(recovered.rows[50].at("data").size(), 256u);
}

References ASSERT_EQ, ASSERT_TRUE, database::protocol::query_response::column_names, database::protocol::protocol_serializer::deserialize_query_response(), database::protocol::query_response::rows, database::protocol::protocol_serializer::serialize(), and database::protocol::query_response::success.

Here is the call graph for this function:

TEST_F() [28/41]

TEST_F	(	QueryProtocolTest	,
		QueryResponseSuccessWithRows	)

Definition at line 304 of file test_protocol_serializer.cpp.

                                                        {
    query_response original;
    original.success = true;
    original.affected_rows = 0;
    original.last_insert_id = 0;
    original.error_code = 0;
    original.column_names = {"id", "name", "email"};
    original.rows = {
        {{"id", "1"}, {"name", "Alice"}, {"email", "alice@test.com"}},
        {{"id", "2"}, {"name", "Bob"}, {"email", "bob@test.com"}}
    };
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_TRUE(recovered.success);
    EXPECT_EQ(recovered.affected_rows, 0u);
    ASSERT_EQ(recovered.column_names.size(), 3u);
    EXPECT_EQ(recovered.column_names[0], "id");
    EXPECT_EQ(recovered.column_names[1], "name");
    EXPECT_EQ(recovered.column_names[2], "email");
    ASSERT_EQ(recovered.rows.size(), 2u);
    EXPECT_EQ(recovered.rows[0].at("name"), "Alice");
    EXPECT_EQ(recovered.rows[1].at("email"), "bob@test.com");
}

References database::protocol::query_response::affected_rows, ASSERT_EQ, ASSERT_TRUE, database::protocol::query_response::column_names, database::protocol::protocol_serializer::deserialize_query_response(), database::protocol::query_response::error_code, database::protocol::query_response::last_insert_id, database::protocol::query_response::rows, database::protocol::protocol_serializer::serialize(), and database::protocol::query_response::success.

Here is the call graph for this function:

TEST_F() [29/41]

TEST_F	(	SerializerEdgeCaseTest	,
		EmptyStringFields	)

Definition at line 521 of file test_protocol_serializer.cpp.

                                                  {
    connect_request original;
    original.database_type = "";
    original.connection_string = "";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_connect_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_TRUE(recovered.database_type.empty());
    EXPECT_TRUE(recovered.connection_string.empty());
}

References ASSERT_TRUE, database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::protocol::protocol_serializer::deserialize_connect_request(), and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [30/41]

TEST_F	(	SerializerEdgeCaseTest	,
		HeaderZeroRequestId	)

Definition at line 594 of file test_protocol_serializer.cpp.

                                                    {
    message_header header;
    header.type = message_type::PING;
    header.request_id = 0;
    header.payload_size = 0;
 
    auto bytes = protocol_serializer::serialize_header(header);
    auto result = protocol_serializer::deserialize_header(bytes);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().request_id, 0u);
    EXPECT_EQ(result.value().payload_size, 0u);
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_header(), database::protocol::message_header::payload_size, database::protocol::message_header::request_id, database::protocol::protocol_serializer::serialize_header(), and database::protocol::message_header::type.

Here is the call graph for this function:

TEST_F() [31/41]

TEST_F	(	SerializerEdgeCaseTest	,
		LongStringPreserved	)

Definition at line 535 of file test_protocol_serializer.cpp.

                                                    {
    connect_request original;
    original.database_type = "postgresql";
    original.connection_string = std::string(4096, 'A');
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_connect_request(bytes);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().connection_string.size(), 4096u);
}

References ASSERT_TRUE, database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::protocol::protocol_serializer::deserialize_connect_request(), and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [32/41]

TEST_F	(	SerializerEdgeCaseTest	,
		ManyOptionsMapPreserved	)

Definition at line 557 of file test_protocol_serializer.cpp.

                                                        {
    connect_request original;
    original.database_type = "postgresql";
    original.connection_string = "localhost";
 
    for (int i = 0; i < 50; ++i) {
        original.options["key_" + std::to_string(i)] = "val_" + std::to_string(i);
    }
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_connect_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_EQ(recovered.options.size(), 50u);
    EXPECT_EQ(recovered.options.at("key_25"), "val_25");
}

References ASSERT_TRUE, database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::protocol::protocol_serializer::deserialize_connect_request(), database::protocol::connect_request::options, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [33/41]

TEST_F	(	SerializerEdgeCaseTest	,
		QueryRequestManyParameters	)

Definition at line 575 of file test_protocol_serializer.cpp.

                                                           {
    query_request original;
    original.operation = query_operation::SELECT;
    original.query_string = "BULK QUERY";
 
    for (int i = 0; i < 100; ++i) {
        original.parameters.push_back("param_" + std::to_string(i));
    }
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_query_request(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    ASSERT_EQ(recovered.parameters.size(), 100u);
    EXPECT_EQ(recovered.parameters[0], "param_0");
    EXPECT_EQ(recovered.parameters[99], "param_99");
}

References ASSERT_EQ, ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_query_request(), database::protocol::query_request::operation, database::protocol::query_request::parameters, database::protocol::query_request::query_string, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [34/41]

TEST_F	(	SerializerEdgeCaseTest	,
		UnicodeStringPreserved	)

Definition at line 546 of file test_protocol_serializer.cpp.

                                                       {
    connect_request original;
    original.database_type = "postgresql";
    original.connection_string = "dbname=\xE4\xB8\xAD\xE6\x96\x87\xE6\xB5\x8B\xE8\xAF\x95";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_connect_request(bytes);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().connection_string, original.connection_string);
}

References ASSERT_TRUE, database::protocol::connect_request::connection_string, database::protocol::connect_request::database_type, database::protocol::protocol_serializer::deserialize_connect_request(), and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [35/41]

TEST_F	(	TransactionProtocolTest	,
		BeginTransactionRoundTrip	)

Definition at line 401 of file test_protocol_serializer.cpp.

                                                           {
    transaction_request original;
    original.operation = message_type::BEGIN_TRANSACTION;
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_transaction_request(bytes);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().operation, message_type::BEGIN_TRANSACTION);
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_transaction_request(), database::protocol::transaction_request::operation, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [36/41]

TEST_F	(	TransactionProtocolTest	,
		CommitTransactionRoundTrip	)

Definition at line 411 of file test_protocol_serializer.cpp.

                                                            {
    transaction_request original;
    original.operation = message_type::COMMIT_TRANSACTION;
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_transaction_request(bytes);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().operation, message_type::COMMIT_TRANSACTION);
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_transaction_request(), database::protocol::transaction_request::operation, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [37/41]

TEST_F	(	TransactionProtocolTest	,
		RollbackTransactionRoundTrip	)

Definition at line 421 of file test_protocol_serializer.cpp.

                                                              {
    transaction_request original;
    original.operation = message_type::ROLLBACK_TRANSACTION;
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_transaction_request(bytes);
    ASSERT_TRUE(result.is_ok());
    EXPECT_EQ(result.value().operation, message_type::ROLLBACK_TRANSACTION);
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_transaction_request(), database::protocol::transaction_request::operation, and database::protocol::protocol_serializer::serialize().

Here is the call graph for this function:

TEST_F() [38/41]

TEST_F	(	TransactionProtocolTest	,
		TransactionRequestTooSmall	)

Definition at line 431 of file test_protocol_serializer.cpp.

                                                            {
    std::vector<uint8_t> data = {0x01};
    auto result = protocol_serializer::deserialize_transaction_request(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_transaction_request().

Here is the call graph for this function:

TEST_F() [39/41]

TEST_F	(	TransactionProtocolTest	,
		TransactionResponseEmptyData	)

Definition at line 465 of file test_protocol_serializer.cpp.

                                                              {
    std::vector<uint8_t> data;
    auto result = protocol_serializer::deserialize_transaction_response(data);
    EXPECT_TRUE(result.is_err());
}

References database::protocol::protocol_serializer::deserialize_transaction_response().

Here is the call graph for this function:

TEST_F() [40/41]

TEST_F	(	TransactionProtocolTest	,
		TransactionResponseFailureRoundTrip	)

Definition at line 451 of file test_protocol_serializer.cpp.

                                                                     {
    transaction_response original;
    original.success = false;
    original.error_message = "Deadlock detected";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_transaction_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_FALSE(recovered.success);
    EXPECT_EQ(recovered.error_message, "Deadlock detected");
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_transaction_response(), database::protocol::transaction_response::error_message, database::protocol::protocol_serializer::serialize(), and database::protocol::transaction_response::success.

Here is the call graph for this function:

TEST_F() [41/41]

TEST_F	(	TransactionProtocolTest	,
		TransactionResponseSuccessRoundTrip	)

Definition at line 437 of file test_protocol_serializer.cpp.

                                                                     {
    transaction_response original;
    original.success = true;
    original.error_message = "";
 
    auto bytes = protocol_serializer::serialize(original);
    auto result = protocol_serializer::deserialize_transaction_response(bytes);
    ASSERT_TRUE(result.is_ok());
 
    auto recovered = result.value();
    EXPECT_TRUE(recovered.success);
    EXPECT_TRUE(recovered.error_message.empty());
}

References ASSERT_TRUE, database::protocol::protocol_serializer::deserialize_transaction_response(), database::protocol::transaction_response::error_message, database::protocol::protocol_serializer::serialize(), and database::protocol::transaction_response::success.

Here is the call graph for this function: