Merge branch 'f-full-c' into 'dev'

ENH: Test insert/update/delete and files in Extern C

See merge request !11

test/test_ccaosdb.cpp

@@ -18,15 +18,82 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-#include "caosdb/message_code.h"   // for MessageCode
-#include "caosdb/status_code.h"    // for StatusCode
-#include "ccaosdb.h"               // for caosdb_info_version_info, caosdb_...
-#include "gtest/gtest-message.h"   // for Message
-#include "gtest/gtest-test-part.h" // for TestPartResult
-#include "gtest/gtest_pred_impl.h" // for Test, EXPECT_EQ, SuiteApiResolver
-#include <memory>                  // for allocator, unique_ptr
-
-TEST(test_ccaosdb, connection_ssl_authentication_success) {
+#include "caosdb/file_transmission/file_reader.h" // for FileReader
+#include "caosdb/file_transmission/file_writer.h" // for FileWriter
+#include "caosdb/message_code.h"                  // for MessageCode
+#include "caosdb/status_code.h"                   // for StatusCode
+#include "ccaosdb.h"                 // for caosdb_info_version_info, caosdb_...
+#include <boost/filesystem/path.hpp> // for path
+#include <boost/filesystem/path_traits.hpp> // for filesystem
+#include <cstring>                          // for strcmp
+#include <gtest/gtest-message.h>            // for Message
+#include <gtest/gtest-test-part.h>          // for TestPartResult
+#include <gtest/gtest_pred_impl.h> // for Test, EXPECT_EQ, SuiteApiResolver
+#include <iostream>
+#include <memory> // for allocator, unique_ptr
+
+namespace fs = boost::filesystem;
+class test_ccaosdb : public ::testing::Test {
+protected:
+  fs::path test_upload_file_1;
+  fs::path test_download_file_1;
+
+  void SetUp() override {
+    test_upload_file_1 = fs::path("test_upload_file_1_delete_me.dat");
+    test_download_file_1 = fs::path("test_download_file_1_delete_me.dat");
+
+    // fill the file that shall be uploaded
+    caosdb::transaction::FileWriter writer(test_upload_file_1);
+    std::string buffer(1024, 'c');
+    for (int i = 0; i < 8; i++) {
+      writer.write(buffer);
+    }
+  }
+
+  /**
+   * Delete everything with id>99, C style
+   */
+  void TearDown() override {
+    // delete files
+    fs::remove(test_upload_file_1);
+    fs::remove(test_download_file_1);
+
+    caosdb_connection_connection connection;
+    caosdb_connection_connection_manager_get_default_connection(&connection);
+
+    caosdb_transaction_transaction query_transaction;
+    caosdb_connection_connection_create_transaction(&connection,
+                                                    &query_transaction);
+    caosdb_transaction_transaction_query(&query_transaction,
+                                         "FIND ENTITY WITH id > 99");
+    caosdb_transaction_transaction_execute(&query_transaction);
+
+    caosdb_transaction_result_set result_set;
+    caosdb_transaction_transaction_get_result_set(&query_transaction,
+                                                  &result_set);
+    int count[] = {-1}; // NOLINT
+    caosdb_transaction_result_set_size(&result_set, count);
+    if (*count > 0) {
+      caosdb_transaction_transaction delete_transaction;
+      caosdb_connection_connection_create_transaction(&connection,
+                                                      &delete_transaction);
+      caosdb_entity_entity entity;
+      char *id = nullptr; // NOLINT
+      for (int i = 0; i < *count; i++) {
+        caosdb_transaction_result_set_at(&result_set, &entity, i);
+        caosdb_entity_entity_get_id(&entity, &id);
+        caosdb_transaction_transaction_delete_by_id(&delete_transaction, id);
+      }
+
+      caosdb_transaction_transaction_execute(&delete_transaction);
+      caosdb_transaction_delete_transaction(&delete_transaction);
+    }
+
+    caosdb_transaction_delete_transaction(&query_transaction);
+  }
+};
+
+TEST_F(test_ccaosdb, connection_ssl_authentication_success) {
 
   caosdb_connection_connection connection;
   caosdb_connection_connection_manager_get_default_connection(&connection);
@@ -44,7 +111,7 @@ TEST(test_ccaosdb, connection_ssl_authentication_success) {
   EXPECT_STREQ(pre_release, version_info.pre_release);
 }
 
-TEST(test_ccaosdb, test_count_query) {
+TEST_F(test_ccaosdb, test_count_query) {
 
   caosdb_connection_connection connection;
   int return_code(
@@ -75,7 +142,7 @@ TEST(test_ccaosdb, test_count_query) {
   EXPECT_EQ(return_code, 0);
 }
 
-TEST(test_ccaosdb, test_query) {
+TEST_F(test_ccaosdb, test_query) {
   caosdb_connection_connection connection;
   int return_code(
     caosdb_connection_connection_manager_get_default_connection(&connection));
@@ -108,7 +175,7 @@ TEST(test_ccaosdb, test_query) {
   EXPECT_EQ(return_code, 0);
 }
 
-TEST(test_ccaosdb, test_single_id_retrieve) {
+TEST_F(test_ccaosdb, test_single_id_retrieve) {
   caosdb_connection_connection connection;
   int return_code(
     caosdb_connection_connection_manager_get_default_connection(&connection));
@@ -154,7 +221,7 @@ TEST(test_ccaosdb, test_single_id_retrieve) {
   EXPECT_EQ(return_code, 0);
 }
 
-TEST(test_ccaosdb, test_multi_id_retrieve) {
+TEST_F(test_ccaosdb, test_multi_id_retrieve) {
   caosdb_connection_connection connection;
   int return_code(
     caosdb_connection_connection_manager_get_default_connection(&connection));
@@ -216,3 +283,375 @@ TEST(test_ccaosdb, test_multi_id_retrieve) {
   return_code = caosdb_transaction_delete_transaction(&transaction);
   EXPECT_EQ(return_code, 0);
 }
+
+TEST_F(test_ccaosdb, test_insert_update_delete) {
+
+  caosdb_connection_connection connection;
+  caosdb_connection_connection_manager_get_default_connection(&connection);
+
+  caosdb_entity_entity original_entity;
+  caosdb_entity_create_entity(&original_entity);
+  caosdb_entity_entity_set_name(&original_entity, "TestName");
+  caosdb_entity_entity_set_role(&original_entity, "PROPERTY");
+  caosdb_entity_entity_set_datatype(&original_entity, "TEXT", false, false);
+
+  caosdb_transaction_transaction insert_transaction;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &insert_transaction);
+  caosdb_transaction_transaction_insert_entity(&insert_transaction,
+                                               &original_entity);
+  int return_code(caosdb_transaction_transaction_execute(&insert_transaction));
+  EXPECT_EQ(return_code, 0);
+
+  // Insert the entity and check results
+  caosdb_transaction_result_set insert_result_set;
+  caosdb_transaction_transaction_get_result_set(&insert_transaction,
+                                                &insert_result_set);
+  int count[] = {-1}; // NOLINT
+  caosdb_transaction_result_set_size(&insert_result_set, count);
+  EXPECT_EQ(*count, 1);
+  caosdb_entity_entity inserted_entity;
+  caosdb_transaction_result_set_at(&insert_result_set, &inserted_entity, 0);
+  char *in = nullptr; // NOLINT
+  caosdb_entity_entity_get_id(&inserted_entity, &in);
+
+  // Retrieve it again for checks and update
+  caosdb_transaction_transaction retrieve_transaction_1;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &retrieve_transaction_1);
+  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction_1, in);
+  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_1);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set retrieve_results_1;
+  caosdb_transaction_transaction_get_result_set(&retrieve_transaction_1,
+                                                &retrieve_results_1);
+  caosdb_transaction_result_set_size(&retrieve_results_1, count);
+  EXPECT_EQ(*count, 1);
+  caosdb_entity_entity retrieved_entity_1;
+  caosdb_transaction_result_set_at(&retrieve_results_1, &retrieved_entity_1, 0);
+  char *out = nullptr; // NOLINT
+  caosdb_entity_entity_get_id(&retrieved_entity_1, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  caosdb_entity_entity_get_name(&original_entity, &in);
+  caosdb_entity_entity_get_name(&retrieved_entity_1, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  caosdb_entity_entity_get_role(&original_entity, &in);
+  caosdb_entity_entity_get_role(&retrieved_entity_1, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  bool is_list_in[] = {false}; // NOLINT
+  bool is_ref_in[] = {false};  // NOLINT
+  caosdb_entity_entity_get_datatype(&original_entity, &in, is_ref_in,
+                                    is_list_in);
+  bool is_list_out[] = {false}; // NOLINT
+  bool is_ref_out[] = {false};  // NOLINT
+  caosdb_entity_entity_get_datatype(&retrieved_entity_1, &out, is_ref_out,
+                                    is_list_out);
+  EXPECT_EQ(strcmp(in, out), 0);
+  EXPECT_EQ(*is_list_in, *is_list_out);
+  EXPECT_EQ(*is_ref_in, *is_ref_out);
+
+  // Change name and update
+  return_code =
+    caosdb_entity_entity_set_name(&retrieved_entity_1, "TestNameNew");
+  EXPECT_EQ(return_code, 0);
+  caosdb_transaction_transaction update_transaction;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &update_transaction);
+  caosdb_transaction_transaction_update_entity(&update_transaction,
+                                               &retrieved_entity_1);
+  return_code = caosdb_transaction_transaction_execute(&update_transaction);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set update_results;
+  caosdb_transaction_transaction_get_result_set(&update_transaction,
+                                                &update_results);
+  caosdb_transaction_result_set_size(&update_results, count);
+  EXPECT_EQ(*count, 1);
+  caosdb_entity_entity updated_entity;
+  caosdb_transaction_result_set_at(&update_results, &updated_entity, 0);
+  caosdb_entity_entity_get_id(&inserted_entity, &in);
+  caosdb_entity_entity_get_id(&updated_entity, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  // Retrieve again
+  caosdb_transaction_transaction retrieve_transaction_2;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &retrieve_transaction_2);
+  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction_2, out);
+  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_2);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set retrieve_results_2;
+  caosdb_transaction_transaction_get_result_set(&retrieve_transaction_2,
+                                                &retrieve_results_2);
+  caosdb_transaction_result_set_size(&retrieve_results_2, count);
+  EXPECT_EQ(*count, 1);
+  caosdb_entity_entity retrieved_entity_2;
+  caosdb_transaction_result_set_at(&retrieve_results_2, &retrieved_entity_2, 0);
+
+  caosdb_entity_entity_get_id(&retrieved_entity_2, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  caosdb_entity_entity_get_name(&retrieved_entity_1, &in);
+  caosdb_entity_entity_get_name(&retrieved_entity_2, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  // Doesn't have the old name anymore
+  caosdb_entity_entity_get_name(&original_entity, &in);
+  EXPECT_FALSE((strcmp(in, out) == 0));
+
+  // Everything else hasn't changed
+  caosdb_entity_entity_get_role(&original_entity, &in);
+  caosdb_entity_entity_get_role(&retrieved_entity_2, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  caosdb_entity_entity_get_datatype(&original_entity, &in, is_ref_in,
+                                    is_list_in);
+  caosdb_entity_entity_get_datatype(&retrieved_entity_2, &out, is_ref_out,
+                                    is_list_out);
+  EXPECT_EQ(strcmp(in, out), 0);
+  EXPECT_EQ(*is_ref_in, *is_ref_out);
+  EXPECT_EQ(*is_list_in, *is_list_out);
+
+  // Now delete
+  caosdb_transaction_transaction delete_transaction;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &delete_transaction);
+  caosdb_entity_entity_get_id(&retrieved_entity_2, &in);
+  caosdb_transaction_transaction_delete_by_id(&delete_transaction, in);
+  return_code = caosdb_transaction_transaction_execute(&delete_transaction);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set delete_results;
+  caosdb_transaction_transaction_get_result_set(&delete_transaction,
+                                                &delete_results);
+  caosdb_transaction_result_set_size(&delete_results, count);
+  EXPECT_EQ(*count, 1);
+
+  caosdb_entity_entity deleted_entity;
+  caosdb_transaction_result_set_at(&delete_results, &deleted_entity, 0);
+  caosdb_entity_entity_get_id(&deleted_entity, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  // Try to retrieve again
+  caosdb_transaction_transaction retrieve_transaction_3;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &retrieve_transaction_3);
+  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction_3, out);
+  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_3);
+  EXPECT_TRUE((return_code > 0));
+
+  caosdb_transaction_result_set retrieve_results_3;
+  caosdb_transaction_transaction_get_result_set(&retrieve_transaction_3,
+                                                &retrieve_results_3);
+  caosdb_transaction_result_set_size(&retrieve_results_3, count);
+  EXPECT_EQ(*count, 1);
+  caosdb_entity_entity retrieved_entity_3;
+  caosdb_transaction_result_set_at(&retrieve_results_3, &retrieved_entity_3, 0);
+  caosdb_entity_entity_get_errors_size(&retrieved_entity_3, count);
+  EXPECT_EQ(*count, 1);
+  caosdb_entity_message err_msg;
+  caosdb_entity_entity_get_error(&retrieved_entity_3, &err_msg, 0);
+  caosdb_entity_message_get_code(&err_msg, count);
+  EXPECT_EQ(*count, caosdb::entity::MessageCode::ENTITY_DOES_NOT_EXIST);
+
+  // Delete everything
+  caosdb_transaction_delete_transaction(&retrieve_transaction_3);
+  caosdb_transaction_delete_transaction(&delete_transaction);
+  caosdb_transaction_delete_transaction(&retrieve_transaction_2);
+  caosdb_transaction_delete_transaction(&update_transaction);
+  caosdb_transaction_delete_transaction(&retrieve_transaction_1);
+  caosdb_transaction_delete_transaction(&insert_transaction);
+  caosdb_entity_delete_entity(&original_entity);
+}
+
+TEST_F(test_ccaosdb, test_insert_with_prop_and_parent) {
+
+  caosdb_connection_connection connection;
+  caosdb_connection_connection_manager_get_default_connection(&connection);
+
+  // Create and insert a property, ...
+  std::cout << "Creating a property..." << std::endl;
+  caosdb_entity_entity original_prop;
+  caosdb_entity_create_entity(&original_prop);
+
+  caosdb_entity_entity_set_name(&original_prop, "TestProp");
+  caosdb_entity_entity_set_role(&original_prop, "PROPERTY");
+  caosdb_entity_entity_set_datatype(&original_prop, "TEXT", false, false);
+
+  std::cout << "Inserting a property..." << std::endl;
+  caosdb_transaction_transaction prop_insertion;
+  caosdb_connection_connection_create_transaction(&connection, &prop_insertion);
+  caosdb_transaction_transaction_insert_entity(&prop_insertion, &original_prop);
+  int return_code(caosdb_transaction_transaction_execute(&prop_insertion));
+  EXPECT_EQ(return_code, 0);
+
+  std::cout << "Checking result..." << std::endl;
+  caosdb_transaction_result_set prop_results;
+  caosdb_transaction_transaction_get_result_set(&prop_insertion, &prop_results);
+  caosdb_entity_entity inserted_prop;
+  caosdb_transaction_result_set_at(&prop_results, &inserted_prop, 0);
+  char *prop_id = nullptr; // NOLINT
+  caosdb_entity_entity_get_id(&inserted_prop, &prop_id);
+
+  // ... a record type with this property, ...
+  caosdb_entity_entity original_rt;
+  caosdb_entity_create_entity(&original_rt);
+
+  caosdb_entity_entity_set_name(&original_rt, "TestType");
+  caosdb_entity_entity_set_role(&original_rt, "RECORD_TYPE");
+
+  caosdb_entity_property rt_prop;
+  caosdb_entity_create_property(&rt_prop);
+  caosdb_entity_property_set_id(&rt_prop, prop_id);
+  caosdb_entity_entity_append_property(&original_rt, &rt_prop);
+
+  caosdb_transaction_transaction rt_insertion;
+  caosdb_connection_connection_create_transaction(&connection, &rt_insertion);
+  caosdb_transaction_transaction_insert_entity(&rt_insertion, &original_rt);
+  return_code = caosdb_transaction_transaction_execute(&rt_insertion);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set rt_results;
+  caosdb_transaction_transaction_get_result_set(&rt_insertion, &rt_results);
+  caosdb_entity_entity inserted_rt;
+  caosdb_transaction_result_set_at(&rt_results, &inserted_rt, 0);
+  char *rt_id = nullptr; // NOLINT
+  caosdb_entity_entity_get_id(&inserted_rt, &rt_id);
+
+  // ... and a record with this record type as a parent.
+  caosdb_entity_entity original_rec;
+  caosdb_entity_create_entity(&original_rec);
+  caosdb_entity_entity_set_name(&original_rec, "TestRec");
+  caosdb_entity_entity_set_role(&original_rec, "RECORD");
+  caosdb_entity_parent rec_parent;
+  caosdb_entity_create_parent(&rec_parent);
+  caosdb_entity_parent_set_id(&rec_parent, rt_id);
+  caosdb_entity_entity_append_parent(&original_rec, &rec_parent);
+  caosdb_entity_property rec_prop;
+  caosdb_entity_create_property(&rec_prop);
+  caosdb_entity_property_set_id(&rec_prop, prop_id);
+  caosdb_entity_property_set_string_value(&rec_prop, "Bla");
+  caosdb_entity_entity_append_property(&original_rec, &rec_prop);
+
+  caosdb_transaction_transaction rec_insertion;
+  caosdb_connection_connection_create_transaction(&connection, &rec_insertion);
+  caosdb_transaction_transaction_insert_entity(&rec_insertion, &original_rec);
+  return_code = caosdb_transaction_transaction_execute(&rec_insertion);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set rec_results;
+  caosdb_transaction_transaction_get_result_set(&rec_insertion, &rec_results);
+  caosdb_entity_entity inserted_rec;
+  caosdb_transaction_result_set_at(&rec_results, &inserted_rec, 0);
+  char *rec_id = nullptr; // NOLINT
+  caosdb_entity_entity_get_id(&inserted_rec, &rec_id);
+
+  // Retrieve the record again for comparison
+  caosdb_transaction_transaction retrieve_transaction;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &retrieve_transaction);
+  caosdb_transaction_transaction_retrieve_by_id(&retrieve_transaction, rec_id);
+  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set retrieve_result;
+  caosdb_transaction_transaction_get_result_set(&retrieve_transaction,
+                                                &retrieve_result);
+  caosdb_entity_entity retrieved_rec;
+  caosdb_transaction_result_set_at(&retrieve_result, &retrieved_rec, 0);
+  char *in = nullptr;  // NOLINT
+  char *out = nullptr; // NOLINT
+  caosdb_entity_entity_get_name(&original_rec, &in);
+  caosdb_entity_entity_get_name(&retrieved_rec, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+  int count[] = {0}; // NOLINT
+  caosdb_entity_entity_get_properties_size(&retrieved_rec, count);
+  EXPECT_EQ(*count, 1);
+  caosdb_entity_entity_get_parents_size(&retrieved_rec, count);
+  EXPECT_EQ(*count, 1);
+
+  caosdb_entity_parent retrieved_parent;
+  caosdb_entity_entity_get_parent(&retrieved_rec, &retrieved_parent, 0);
+  caosdb_entity_entity_get_name(&original_rt, &in);
+  caosdb_entity_parent_get_name(&retrieved_parent, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+  caosdb_entity_parent_get_id(&retrieved_parent, &out);
+  EXPECT_EQ(strcmp(rt_id, out), 0);
+
+  caosdb_entity_property retrieved_property;
+  caosdb_entity_entity_get_property(&retrieved_rec, &retrieved_property, 0);
+  caosdb_entity_entity_get_name(&original_prop, &in);
+  caosdb_entity_property_get_name(&retrieved_property, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+  caosdb_entity_property_get_string_value(&rec_prop, &in);
+  caosdb_entity_property_get_string_value(&retrieved_property, &out);
+  EXPECT_EQ(strcmp(in, out), 0);
+
+  caosdb_transaction_delete_transaction(&retrieve_transaction);
+  caosdb_transaction_delete_transaction(&rec_insertion);
+  caosdb_entity_delete_property(&rec_prop);
+  caosdb_entity_delete_parent(&rec_parent);
+  caosdb_entity_delete_entity(&original_rec);
+  caosdb_transaction_delete_transaction(&rt_insertion);
+  caosdb_entity_delete_property(&rt_prop);
+  caosdb_entity_delete_entity(&original_rt);
+  caosdb_transaction_delete_transaction(&prop_insertion);
+  caosdb_entity_delete_entity(&original_prop);
+}
+
+TEST_F(test_ccaosdb, test_up_n_download_file) {
+
+  caosdb_connection_connection connection;
+  caosdb_connection_connection_manager_get_default_connection(&connection);
+
+  caosdb_entity_entity original_entity;
+  caosdb_entity_create_entity(&original_entity);
+  caosdb_entity_entity_set_role(&original_entity, "FILE");
+  caosdb_entity_entity_set_local_path(&original_entity,
+                                      test_upload_file_1.c_str());
+  caosdb_entity_entity_set_file_path(&original_entity, "/some/file");
+
+  caosdb_transaction_transaction insert_transaction;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &insert_transaction);
+  caosdb_transaction_transaction_insert_entity(&insert_transaction,
+                                               &original_entity);
+  int return_code(caosdb_transaction_transaction_execute(&insert_transaction));
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set rec_results;
+  caosdb_transaction_transaction_get_result_set(&insert_transaction,
+                                                &rec_results);
+  caosdb_entity_entity inserted_rec;
+  caosdb_transaction_result_set_at(&rec_results, &inserted_rec, 0);
+  char *rec_id = nullptr; // NOLINT
+  caosdb_entity_entity_get_id(&inserted_rec, &rec_id);
+
+  caosdb_entity_entity download_entity;
+  caosdb_entity_create_entity(&download_entity);
+  caosdb_entity_entity_set_role(&download_entity, "FILE");
+  caosdb_entity_entity_set_local_path(&download_entity, "lol");
+  caosdb_entity_entity_set_file_path(&download_entity, "/some/file");
+
+  caosdb_transaction_transaction retrieve_transaction_1;
+  caosdb_connection_connection_create_transaction(&connection,
+                                                  &retrieve_transaction_1);
+  EXPECT_EQ(return_code, 0);
+  // return_code = caosdb_transaction_transaction_retrieve_by_id(
+  //   &retrieve_transaction_1, rec_id);
+  return_code = caosdb_transaction_transaction_retrieve_and_download_file_by_id(
+      &retrieve_transaction_1, rec_id, test_download_file_1.c_str());
+  EXPECT_EQ(return_code, caosdb::StatusCode::GO_ON);
+  return_code = caosdb_transaction_transaction_execute(&retrieve_transaction_1);
+  EXPECT_EQ(return_code, 0);
+
+  caosdb_transaction_result_set result_set;
+  return_code = caosdb_transaction_transaction_get_result_set(
+      &retrieve_transaction_1, &result_set);
+  EXPECT_EQ(return_code, 0);
+}

test/test_transaction.cpp

@@ -753,7 +753,7 @@ TEST_F(test_transaction, test_file_up_n_download) {
   ASSERT_FALSE(inserted_file.HasErrors());
 
   auto download_transaction(connection->CreateTransaction());
-  download_transaction->RetrieveAndDownloadFilesById(
+  download_transaction->RetrieveAndDownloadFileById(
     inserted_file.GetId(), test_download_file_1.string());
   download_transaction->ExecuteAsynchronously();
   ASSERT_EQ(download_transaction->WaitForIt().GetCode(), StatusCode::SUCCESS);