- Added Snappy compression/decompression test case to the remote test app

Author: avalerio-tkd

CMakeLists.txt

@@ -86,7 +86,7 @@ FetchContent_Declare(
 FetchContent_Declare(
   snappy
   GIT_REPOSITORY https://github.com/google/snappy.git
-  GIT_TAG 1.1.10
+  GIT_TAG 1.2.2
 )
 
 # Fetch dependencies
@@ -222,9 +222,12 @@ target_link_libraries(dbpa_remote_testapp
   dbps_remote_lib
   dbps_client_lib
   dbps_common_lib
+  dbps_server_lib
 )
 target_include_directories(dbpa_remote_testapp PRIVATE
   ${CMAKE_BINARY_DIR}/_deps/cxxopts-src/include
+  src/server
+  ${CMAKE_BINARY_DIR}/_deps/snappy-src
 )
 
 # =============================================================================

src/scripts/dbpa_remote_testapp.cpp

@@ -28,6 +28,7 @@
 #include "../common/dbpa_remote.h"
 #include "../client/httplib_client.h"
 #include "../common/enums.h"
+#include "../server/compression_utils.h"
 #include "tcb/span.hpp"
 
 using namespace dbps::external;
@@ -143,7 +144,7 @@ class DBPARemoteTestApp {
                 "demo_fixed_len_key_001",      // column_key_id
                 Type::FIXED_LEN_BYTE_ARRAY,   // datatype
                 8,                            // datatype_length (8 bytes per element)
-                CompressionCodec::UNCOMPRESSED, // compression_type
+                CompressionCodec::SNAPPY,      // compression_type (input will be Snappy-compressed)
                 VALID_ENCRYPTION_METADATA       // column_encryption_metadata
             );
 
@@ -464,11 +465,16 @@ class DBPARemoteTestApp {
             }
 
             std::cout << "Test data: 3 fixed-length strings (8 bytes each)" << std::endl;
-            std::cout << "Total size: " << fixed_length_data.size() << " bytes" << std::endl;
+            std::cout << "Original size: " << fixed_length_data.size() << " bytes" << std::endl;
 
+            // Compress the test data using Snappy before sending to server
+            std::vector<uint8_t> fixed_length_data_compressed = Compress(fixed_length_data, CompressionCodec::SNAPPY);
+            std::cout << "Compressed size: " << fixed_length_data_compressed.size() << " bytes" << std::endl;
+
             // Test encryption with FIXED_LEN_BYTE_ARRAY and datatype_length
+            // The server will decompress the fixed_length_data_compressed, encrypt it, and compress the encrypted result
             std::map<std::string, std::string> fixed_len_encoding_attributes = {{"page_encoding", "PLAIN"}, {"page_type", "DICTIONARY_PAGE"}};
-            auto encrypt_result = fixed_len_agent_->Encrypt(span<const uint8_t>(fixed_length_data), fixed_len_encoding_attributes);
+            auto encrypt_result = fixed_len_agent_->Encrypt(span<const uint8_t>(fixed_length_data_compressed), fixed_len_encoding_attributes);
 
             if (!encrypt_result || !encrypt_result->success()) {
                 std::cout << "ERROR: FIXED_LEN_BYTE_ARRAY encryption failed" << std::endl;
@@ -493,13 +499,22 @@ class DBPARemoteTestApp {
 
             std::cout << "OK: FIXED_LEN_BYTE_ARRAY decrypted successfully" << std::endl;
 
+            // The server returns compressed plaintext (same compression as input)
+            // Decompress it before comparing with original data
+            auto decrypted_compressed_span = decrypt_result->plaintext();
+            std::vector<uint8_t> decrypted_compressed(decrypted_compressed_span.begin(), decrypted_compressed_span.end());
+            std::vector<uint8_t> decrypted_data = Decompress(decrypted_compressed, CompressionCodec::SNAPPY);
+            std::cout << "Decrypted compressed size: " << decrypted_compressed.size() << " bytes" << std::endl;
+            std::cout << "Decrypted uncompressed size: " << decrypted_data.size() << " bytes" << std::endl;
+            
             // Verify data integrity
-            auto decrypted_data = decrypt_result->plaintext();
             if (decrypted_data.size() == fixed_length_data.size() && 
-                std::equal(decrypted_data.begin(), decrypted_data.end(), fixed_length_data.begin())) {
+                std::equal(decrypted_data.begin(), decrypted_data.end(), fixed_length_data.begin(), fixed_length_data.end())) {
                 std::cout << "OK: FIXED_LEN_BYTE_ARRAY data integrity verified" << std::endl;
             } else {
                 std::cout << "ERROR: FIXED_LEN_BYTE_ARRAY data integrity check failed" << std::endl;
+                std::cout << "  Expected size: " << fixed_length_data.size() << " bytes" << std::endl;
+                std::cout << "  Got size: " << decrypted_data.size() << " bytes" << std::endl;
                 return false;
             }