F files

test/test_transaction.cpp

@@ -47,16 +47,16 @@ protected:
     query_transaction->Query("FIND ENTITY WITH id > 99");
     query_transaction->Execute();
     if (query_transaction->GetResultSet().Size() > 0) {
+      auto delete_transaction(connection->CreateTransaction());
       for (const Entity &entity : query_transaction->GetResultSet()) {
-        auto delete_transaction(connection->CreateTransaction());
         delete_transaction->DeleteById(entity.GetId());
-        delete_transaction->Execute();
       }
+      delete_transaction->Execute();
     }
   }
 };
 
-TEST(test_transaction, DISABLED_retrieve_manufacturer_by_id) {
+TEST_F(test_transaction, DISABLED_retrieve_manufacturer_by_id) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -81,7 +81,7 @@ TEST(test_transaction, DISABLED_retrieve_manufacturer_by_id) {
   EXPECT_EQ(version, entity.GetVersionId());
 }
 
-TEST(test_transaction, retrieve_non_existing) {
+TEST_F(test_transaction, retrieve_non_existing) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -106,7 +106,37 @@ TEST(test_transaction, retrieve_non_existing) {
             MessageCode::ENTITY_DOES_NOT_EXIST);
 }
 
-TEST(test_transaction, insert_delete) {
+TEST_F(test_transaction, insert_without_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);
+}
+
+TEST_F(test_transaction, insert_delete) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -153,7 +183,7 @@ TEST(test_transaction, insert_delete) {
   EXPECT_FALSE(deleted_entity.HasErrors());
 }
 
-TEST(test_transaction, insert_delete_with_parent) {
+TEST_F(test_transaction, insert_delete_with_parent) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -240,9 +270,7 @@ TEST(test_transaction, insert_delete_with_parent) {
   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) {
+TEST_F(test_transaction, insert_delete_with_property) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -375,36 +403,9 @@ TEST(test_transaction, insert_delete_with_property) {
   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());
 }
 
-TEST(test_transaction, test_multi_retrieve) {
+TEST_F(test_transaction, test_multi_retrieve) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -432,7 +433,7 @@ TEST(test_transaction, test_multi_retrieve) {
             MessageCode::ENTITY_DOES_NOT_EXIST);
 }
 
-TEST(test_transaction, insert_update_delete) {
+TEST_F(test_transaction, insert_update_delete) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -499,7 +500,7 @@ TEST(test_transaction, insert_update_delete) {
   EXPECT_FALSE(deleted_entity.HasErrors());
 }
 
-TEST(test_transaction, test_query) {
+TEST_F(test_transaction, test_query) {
   const auto &connection =
     caosdb::connection::ConnectionManager::GetDefaultConnection();
 
@@ -540,7 +541,119 @@ TEST(test_transaction, test_query) {
   EXPECT_EQ(count_query_trans->GetCountResult(), 1);
 }
 
-// TODO(fspreck) Add tests for unique queries, count queries, and mixed
-// transactions (FIND + RetrieveById, COUNT + RetrieveById).
+TEST_F(test_transaction, test_query_with_retrieve) {
+  const auto &connection =
+    caosdb::connection::ConnectionManager::GetDefaultConnection();
+
+  // rt1
+  Entity rt1;
+  rt1.SetRole("RecordType");
+  rt1.SetName("TestRT1");
+
+  auto insert_rt1_transaction(connection->CreateTransaction());
+  insert_rt1_transaction->InsertEntity(&rt1);
+  insert_rt1_transaction->ExecuteAsynchronously();
+
+  auto insert_rt1_status = insert_rt1_transaction->WaitForIt();
+
+  ASSERT_TRUE(insert_rt1_status.IsTerminated());
+  ASSERT_FALSE(insert_rt1_status.IsError());
+
+  const auto &insert_rt1_results =
+    dynamic_cast<const UniqueResult &>(insert_rt1_transaction->GetResultSet());
+
+  const auto &inserted_rt1 = insert_rt1_results.GetEntity();
+  EXPECT_FALSE(inserted_rt1.GetId().empty());
+  EXPECT_FALSE(inserted_rt1.HasErrors());
+
+  // rt2
+  Entity rt2;
+  rt2.SetRole("RecordType");
+  rt2.SetName("TestRT2");
+
+  auto insert_rt2_transaction(connection->CreateTransaction());
+  insert_rt2_transaction->InsertEntity(&rt2);
+  insert_rt2_transaction->ExecuteAsynchronously();
+
+  auto insert_rt2_status = insert_rt2_transaction->WaitForIt();
+
+  ASSERT_TRUE(insert_rt2_status.IsTerminated());
+  ASSERT_FALSE(insert_rt2_status.IsError());
+
+  const auto &insert_rt2_results =
+    dynamic_cast<const UniqueResult &>(insert_rt2_transaction->GetResultSet());
+
+  const auto &inserted_rt2 = insert_rt2_results.GetEntity();
+  EXPECT_FALSE(inserted_rt2.GetId().empty());
+  EXPECT_FALSE(inserted_rt2.HasErrors());
+
+  // rt3
+  Entity rt3;
+  rt3.SetRole("RecordType");
+  rt3.SetName("TestRT3");
+
+  auto insert_rt3_transaction(connection->CreateTransaction());
+  insert_rt3_transaction->InsertEntity(&rt3);
+  insert_rt3_transaction->ExecuteAsynchronously();
+
+  auto insert_rt3_status = insert_rt3_transaction->WaitForIt();
+
+  ASSERT_TRUE(insert_rt3_status.IsTerminated());
+  ASSERT_FALSE(insert_rt3_status.IsError());
+
+  const auto &insert_rt3_results =
+    dynamic_cast<const UniqueResult &>(insert_rt3_transaction->GetResultSet());
+
+  const auto &inserted_rt3 = insert_rt3_results.GetEntity();
+  EXPECT_FALSE(inserted_rt3.GetId().empty());
+  EXPECT_FALSE(inserted_rt3.HasErrors());
+
+  // only FIND
+  auto find_transaction(connection->CreateTransaction());
+  find_transaction->Query("FIND ENTITY WITH name LIKE 'TestRT*'");
+  find_transaction->ExecuteAsynchronously();
+
+  const auto find_status = find_transaction->WaitForIt();
+
+  ASSERT_TRUE(find_status.IsTerminated());
+  ASSERT_FALSE(find_status.IsError());
+
+  const auto &find_results = find_transaction->GetResultSet();
+  EXPECT_EQ(find_results.Size(), 3);
+
+  // only retrieve rt1 and rt2 by id
+  const std::vector<std::string> ids = {inserted_rt1.GetId(),
+                                        inserted_rt2.GetId()};
+
+  // retrieve rt3 with a FIND query
+  auto find_and_retrieve(connection->CreateTransaction());
+  find_and_retrieve->Query("FIND ENTITY WITH id = " + inserted_rt3.GetId());
+  find_and_retrieve->RetrieveById(ids.begin(), ids.end());
+  find_and_retrieve->ExecuteAsynchronously();
+
+  auto find_and_retrieve_status = find_and_retrieve->WaitForIt();
+
+  ASSERT_TRUE(find_and_retrieve_status.IsTerminated());
+  ASSERT_FALSE(find_and_retrieve_status.IsError());
+
+  const auto &result_set_a = find_and_retrieve->GetResultSet();
+  EXPECT_EQ(result_set_a.Size(), 3);
+
+  // retrieve rt1 and rt2 by ID and count all TestRTs
+  auto count_and_retrieve(connection->CreateTransaction());
+  count_and_retrieve->Query("COUNT ENTITY WITH name LIKE 'TestRT*'");
+  count_and_retrieve->RetrieveById(ids.begin(), ids.end());
+  count_and_retrieve->ExecuteAsynchronously();
+
+  auto count_and_retrieve_status = count_and_retrieve->WaitForIt();
+
+  ASSERT_TRUE(count_and_retrieve_status.IsTerminated());
+  ASSERT_FALSE(count_and_retrieve_status.IsError());
+
+  const auto &result_set_b = count_and_retrieve->GetResultSet();
+  // TODO(fspreck) Re-enable once we implemented this
+  // EXPECT_EQ(result_set_b.Size(), 2);
+  EXPECT_EQ(count_and_retrieve->GetCountResult(), 3);
+}
 
 } // namespace caosdb::transaction