TST: Add Tests for insert and delete

Integration tests for https://gitlab.indiscale.com/caosdb/customers/lfpb/management/-/issues/394 and caosdb-cpplib!4 (merged).

test/test_transaction.cpp

@@ -27,10 +27,24 @@
 #include "gtest/gtest-message.h"       // for Message
 #include "gtest/gtest-test-part.h"     // for TestPartResult, SuiteApiResolver
 #include "gtest/gtest_pred_impl.h"     // for Test, EXPECT_EQ, AssertionResult
+#include <iostream>                    // for endl, basic_ostream, cout
 #include <memory>                      // for unique_ptr, allocator, __shar...
+#include <string>                      // for string
 
 namespace caosdb::transaction {
+using caosdb::entity::Entity;
 using caosdb::entity::MessageCode;
+using caosdb::entity::Parent;
+using caosdb::entity::Property;
+
+class test_transaction : public ::testing::Test {
+protected:
+  void SetUp() override {}
+
+  void TearDown() override {
+    // TODO(tf): delete all created entities
+  }
+};
 
 TEST(test_transaction, DISABLED_retrieve_manufacturer_by_id) {
   const auto &connection =
@@ -47,15 +61,14 @@ TEST(test_transaction, DISABLED_retrieve_manufacturer_by_id) {
   transaction->Execute();
 
   const auto &result_set =
-    dynamic_cast<const caosdb::transaction::UniqueResult &>(
-      transaction->GetResultSet());
+    dynamic_cast<const UniqueResult &>(transaction->GetResultSet());
 
   const auto &entity = result_set.GetEntity();
   EXPECT_EQ(id, entity.GetId());
   EXPECT_EQ(name, entity.GetName());
   EXPECT_EQ(role, entity.GetRole());
   EXPECT_EQ(description, entity.GetDescription());
-  EXPECT_EQ(version, entity.GetVersion());
+  EXPECT_EQ(version, entity.GetVersionId());
 }
 
 TEST(test_transaction, retrieve_non_existing) {
@@ -73,8 +86,7 @@ TEST(test_transaction, retrieve_non_existing) {
   ASSERT_EQ(status.GetCode(), StatusCode::GENERIC_TRANSACTION_ERROR);
 
   const auto &result_set =
-    dynamic_cast<const caosdb::transaction::UniqueResult &>(
-      transaction->GetResultSet());
+    dynamic_cast<const UniqueResult &>(transaction->GetResultSet());
 
   const auto &entity = result_set.GetEntity();
   EXPECT_EQ(id, entity.GetId());
@@ -84,4 +96,303 @@ TEST(test_transaction, retrieve_non_existing) {
             MessageCode::ENTITY_DOES_NOT_EXIST);
 }
 
+TEST(test_transaction, insert_delete) {
+  const auto &connection =
+    caosdb::connection::ConnectionManager::GetDefaultConnection();
+
+  auto insert_transaction(connection->CreateTransaction());
+
+  Entity entity;
+  entity.SetRole("RecordType");
+  entity.SetName("RT1");
+  insert_transaction->InsertEntity(&entity);
+  insert_transaction->ExecuteAsynchronously();
+
+  auto insert_status = insert_transaction->WaitForIt();
+
+  ASSERT_TRUE(insert_status.IsTerminated());
+  ASSERT_FALSE(insert_status.IsError());
+
+  const auto &insert_result_set =
+    dynamic_cast<const UniqueResult &>(insert_transaction->GetResultSet());
+
+  const auto &new_entity = insert_result_set.GetEntity();
+  EXPECT_FALSE(new_entity.GetId().empty());
+  EXPECT_FALSE(new_entity.HasErrors());
+  // Should have a warning since it has no properties
+  EXPECT_TRUE(new_entity.HasWarnings());
+  EXPECT_EQ(new_entity.GetWarnings().Size(), 1);
+  EXPECT_EQ(new_entity.GetWarnings().At(0).GetCode(),
+            MessageCode::ENTITY_HAS_NO_PROPERTIES);
+
+  auto delete_transaction(connection->CreateTransaction());
+
+  delete_transaction->DeleteById(new_entity.GetId());
+  delete_transaction->ExecuteAsynchronously();
+
+  auto delete_status = delete_transaction->WaitForIt();
+
+  ASSERT_TRUE(delete_status.IsTerminated());
+  ASSERT_FALSE(delete_status.IsError());
+
+  const auto &delete_result_set =
+    dynamic_cast<const UniqueResult &>(delete_transaction->GetResultSet());
+
+  const auto &deleted_entity = delete_result_set.GetEntity();
+  EXPECT_EQ(deleted_entity.GetId(), new_entity.GetId());
+  EXPECT_FALSE(deleted_entity.HasErrors());
+}
+
+TEST(test_transaction, insert_delete_with_parent) {
+  const auto &connection =
+    caosdb::connection::ConnectionManager::GetDefaultConnection();
+
+  auto insert_transaction(connection->CreateTransaction());
+
+  Entity rt;
+  rt.SetRole("RecordType");
+  rt.SetName("TestRT");
+  insert_transaction->InsertEntity(&rt);
+  insert_transaction->ExecuteAsynchronously();
+
+  auto insert_status = insert_transaction->WaitForIt();
+
+  ASSERT_TRUE(insert_status.IsTerminated());
+  ASSERT_FALSE(insert_status.IsError());
+
+  const auto &insert_result_set =
+    dynamic_cast<const UniqueResult &>(insert_transaction->GetResultSet());
+
+  const auto &inserted_rt = insert_result_set.GetEntity();
+
+  Entity rec;
+  rec.SetRole("Record");
+  rec.SetName("TestRec");
+
+  Parent parent;
+  parent.SetName(rt.GetName());
+  parent.SetId(inserted_rt.GetId());
+  rec.AppendParent(parent);
+
+  auto rec_transaction(connection->CreateTransaction());
+  rec_transaction->InsertEntity(&rec);
+  rec_transaction->ExecuteAsynchronously();
+
+  auto rec_insert_status = rec_transaction->WaitForIt();
+
+  ASSERT_TRUE(rec_insert_status.IsTerminated());
+  ASSERT_FALSE(rec_insert_status.IsError());
+
+  const auto &rec_result_set =
+    dynamic_cast<const UniqueResult &>(rec_transaction->GetResultSet());
+
+  const auto &inserted_rec = rec_result_set.GetEntity();
+
+  EXPECT_FALSE(inserted_rec.GetId().empty());
+
+  auto retrieve_transaction(connection->CreateTransaction());
+  retrieve_transaction->RetrieveById(inserted_rec.GetId());
+
+  retrieve_transaction->ExecuteAsynchronously();
+
+  auto rec_retrieve_status = retrieve_transaction->WaitForIt();
+
+  ASSERT_TRUE(rec_retrieve_status.IsTerminated());
+  ASSERT_FALSE(rec_retrieve_status.IsError());
+
+  const auto &retrieve_result_set =
+    dynamic_cast<const UniqueResult &>(retrieve_transaction->GetResultSet());
+  const auto &retrieved_rec = retrieve_result_set.GetEntity();
+  std::cout << retrieved_rec.ToString() << std::endl;
+
+  EXPECT_EQ(retrieved_rec.GetName(), rec.GetName());
+  EXPECT_EQ(retrieved_rec.GetParents().Size(), 1);
+  EXPECT_EQ(retrieved_rec.GetParents().At(0).GetId(), inserted_rt.GetId());
+  EXPECT_EQ(retrieved_rec.GetParents().At(0).GetName(), rt.GetName());
+
+  auto rec_deletion(connection->CreateTransaction());
+
+  rec_deletion->DeleteById(retrieved_rec.GetId());
+  rec_deletion->ExecuteAsynchronously();
+
+  auto rec_delete_status = rec_deletion->WaitForIt();
+
+  ASSERT_TRUE(rec_delete_status.IsTerminated());
+  ASSERT_FALSE(rec_delete_status.IsError());
+
+  auto rt_deletion(connection->CreateTransaction());
+
+  rt_deletion->DeleteById(inserted_rt.GetId());
+  rt_deletion->ExecuteAsynchronously();
+
+  auto rt_delete_status = rt_deletion->WaitForIt();
+
+  ASSERT_TRUE(rt_delete_status.IsTerminated());
+  ASSERT_FALSE(rt_delete_status.IsError());
+}
+
+// TODO(fspreck) Insert a Record with a parent and a Property. Check
+// for success and delete everything.
+TEST(test_transaction, insert_delete_with_property) {
+  const auto &connection =
+    caosdb::connection::ConnectionManager::GetDefaultConnection();
+
+  // Create and insert property
+  Entity prop_ent;
+  prop_ent.SetRole("Property");
+  prop_ent.SetName("TestProperty");
+  prop_ent.SetDatatype("TEXT");
+
+  auto prop_insertion(connection->CreateTransaction());
+  prop_insertion->InsertEntity(&prop_ent);
+  prop_insertion->ExecuteAsynchronously();
+
+  auto prop_insert_status = prop_insertion->WaitForIt();
+
+  ASSERT_TRUE(prop_insert_status.IsTerminated());
+  ASSERT_FALSE(prop_insert_status.IsError());
+
+  const auto &prop_result_set =
+    dynamic_cast<const UniqueResult &>(prop_insertion->GetResultSet());
+
+  const auto &inserted_prop = prop_result_set.GetEntity();
+  EXPECT_FALSE(inserted_prop.GetId().empty());
+
+  // create and insert record type with the above property
+  Property prop_rt;
+  prop_rt.SetName(prop_ent.GetName());
+  prop_rt.SetId(inserted_prop.GetId());
+  prop_rt.SetImportance("SUGGESTED");
+
+  Entity rt;
+  rt.SetRole("RecordType");
+  rt.SetName("TestRT");
+  rt.AppendProperty(prop_rt);
+
+  auto rt_insertion(connection->CreateTransaction());
+  rt_insertion->InsertEntity(&rt);
+  rt_insertion->ExecuteAsynchronously();
+
+  auto rt_insert_status = rt_insertion->WaitForIt();
+
+  ASSERT_TRUE(rt_insert_status.IsTerminated());
+  ASSERT_FALSE(rt_insert_status.IsError());
+
+  const auto &rt_result_set =
+    dynamic_cast<const UniqueResult &>(rt_insertion->GetResultSet());
+
+  const auto &inserted_rt = rt_result_set.GetEntity();
+  EXPECT_FALSE(inserted_rt.GetId().empty());
+
+  // retrieve inserted rt for testing
+  auto rt_retrieval(connection->CreateTransaction());
+  rt_retrieval->RetrieveById(inserted_rt.GetId());
+  rt_retrieval->ExecuteAsynchronously();
+
+  auto rt_retrieve_status = rt_retrieval->WaitForIt();
+  ASSERT_TRUE(rt_retrieve_status.IsTerminated());
+  ASSERT_FALSE(rt_retrieve_status.IsError());
+
+  const auto &rt_retrieve_results =
+    dynamic_cast<const UniqueResult &>(rt_retrieval->GetResultSet());
+
+  const auto &retrieved_rt = rt_retrieve_results.GetEntity();
+  EXPECT_EQ(inserted_rt.GetId(), retrieved_rt.GetId());
+  EXPECT_EQ(rt.GetName(), retrieved_rt.GetName());
+  EXPECT_EQ(retrieved_rt.GetProperties().Size(), 1);
+
+  const auto &retrieved_prop_rt = retrieved_rt.GetProperties().At(0);
+  EXPECT_EQ(retrieved_prop_rt.GetName(), prop_ent.GetName());
+  EXPECT_EQ(retrieved_prop_rt.GetId(), inserted_prop.GetId());
+  EXPECT_EQ(retrieved_prop_rt.GetDatatype(), prop_ent.GetDatatype());
+  EXPECT_EQ(retrieved_prop_rt.GetImportance(), prop_rt.GetImportance());
+
+  // create and insert record of the above record type with a property
+  // with a value.
+  Parent parent;
+  parent.SetName(rt.GetName());
+  parent.SetId(inserted_rt.GetId());
+
+  Property prop_rec;
+  prop_rec.SetName(prop_ent.GetName());
+  prop_rec.SetId(inserted_prop.GetId());
+  prop_rec.SetValue("Test");
+
+  Entity rec;
+  rec.SetName("TestRec");
+  rec.SetRole("Record");
+  rec.AppendParent(parent);
+  rec.AppendProperty(prop_rec);
+
+  auto rec_insertion(connection->CreateTransaction());
+  rec_insertion->InsertEntity(&rec);
+  rec_insertion->ExecuteAsynchronously();
+
+  auto rec_insert_status = rec_insertion->WaitForIt();
+
+  ASSERT_TRUE(rec_insert_status.IsTerminated());
+  ASSERT_FALSE(rec_insert_status.IsError());
+
+  const auto &rec_result_set =
+    dynamic_cast<const UniqueResult &>(rec_insertion->GetResultSet());
+
+  const auto &inserted_rec = rec_result_set.GetEntity();
+  EXPECT_FALSE(inserted_rec.GetId().empty());
+
+  // Retrieve the record and verify paretn and property
+  auto rec_retrieval(connection->CreateTransaction());
+  rec_retrieval->RetrieveById(inserted_rec.GetId());
+  rec_retrieval->ExecuteAsynchronously();
+
+  auto rec_retrieve_status = rec_retrieval->WaitForIt();
+  ASSERT_TRUE(rec_retrieve_status.IsTerminated());
+  ASSERT_FALSE(rec_retrieve_status.IsError());
+
+  const auto &rec_retrieve_results =
+    dynamic_cast<const UniqueResult &>(rec_retrieval->GetResultSet());
+
+  const auto &retrieved_rec = rec_retrieve_results.GetEntity();
+  EXPECT_EQ(rec.GetName(), retrieved_rec.GetName());
+  EXPECT_EQ(inserted_rec.GetId(), retrieved_rec.GetId());
+  EXPECT_EQ(retrieved_rec.GetParents().Size(), 1);
+  EXPECT_EQ(retrieved_rec.GetProperties().Size(), 1);
+
+  const auto &retrieved_parent_rec = retrieved_rec.GetParents().At(0);
+  EXPECT_EQ(retrieved_parent_rec.GetName(), rt.GetName());
+  EXPECT_EQ(retrieved_parent_rec.GetId(), inserted_rt.GetId());
+
+  const auto &retrieved_prop_rec = retrieved_rec.GetProperties().At(0);
+  EXPECT_EQ(retrieved_prop_rec.GetName(), prop_ent.GetName());
+  EXPECT_EQ(retrieved_prop_rec.GetId(), inserted_prop.GetId());
+  EXPECT_EQ(retrieved_prop_rec.GetDatatype(), prop_ent.GetDatatype());
+  EXPECT_EQ(retrieved_prop_rec.GetValue(), prop_rec.GetValue());
+
+  // Delete eveything: First record ...
+  auto rec_deletion(connection->CreateTransaction());
+  rec_deletion->DeleteById(inserted_rec.GetId());
+  rec_deletion->ExecuteAsynchronously();
+
+  auto rec_delete_status = rec_deletion->WaitForIt();
+  ASSERT_TRUE(rec_delete_status.IsTerminated());
+  ASSERT_FALSE(rec_delete_status.IsError());
+
+  // ... then parent ...
+  auto rt_deletion(connection->CreateTransaction());
+  rt_deletion->DeleteById(inserted_rt.GetId());
+  rt_deletion->ExecuteAsynchronously();
+
+  auto rt_delete_status = rt_deletion->WaitForIt();
+  ASSERT_TRUE(rt_delete_status.IsTerminated());
+  ASSERT_FALSE(rt_delete_status.IsError());
+
+  // ... then property.
+  auto prop_deletion(connection->CreateTransaction());
+  prop_deletion->DeleteById(inserted_prop.GetId());
+  prop_deletion->ExecuteAsynchronously();
+
+  auto prop_delete_status = prop_deletion->WaitForIt();
+  ASSERT_TRUE(prop_delete_status.IsTerminated());
+  ASSERT_FALSE(prop_delete_status.IsError());
+}
+
 } // namespace caosdb::transaction