Database System 0.1.0
Advanced C++20 Database System with Multi-Backend Support
Loading...
Searching...
No Matches
Classes | Functions
test_entity_metadata.cpp File Reference
#include <gtest/gtest.h>
#include <string>
#include "database/orm/entity.h"
Include dependency graph for test_entity_metadata.cpp:

Go to the source code of this file.

Classes

class  FieldMetadataTest
 
class  EntityMetadataTest
 

Functions

 TEST_F (FieldMetadataTest, ConstructsWithNameAndType)
 
 TEST_F (FieldMetadataTest, DefaultConstraintIsNone)
 
 TEST_F (FieldMetadataTest, PrimaryKeyConstraint)
 
 TEST_F (FieldMetadataTest, CombinedConstraints)
 
 TEST_F (FieldMetadataTest, NotNullAndUniqueConstraints)
 
 TEST_F (FieldMetadataTest, IndexConstraintWithName)
 
 TEST_F (FieldMetadataTest, ForeignKeyConstraint)
 
 TEST_F (FieldMetadataTest, DefaultNowConstraint)
 
 TEST_F (FieldMetadataTest, SqlDefinitionInt32)
 
 TEST_F (FieldMetadataTest, SqlDefinitionInt64)
 
 TEST_F (FieldMetadataTest, SqlDefinitionDouble)
 
 TEST_F (FieldMetadataTest, SqlDefinitionString)
 
 TEST_F (FieldMetadataTest, SqlDefinitionBool)
 
 TEST_F (FieldMetadataTest, SqlDefinitionTimestamp)
 
 TEST_F (FieldMetadataTest, SqlDefinitionUnknownTypeFallsBackToText)
 
 TEST_F (FieldMetadataTest, SqlDefinitionPrimaryKey)
 
 TEST_F (FieldMetadataTest, SqlDefinitionAutoIncrement)
 
 TEST_F (FieldMetadataTest, SqlDefinitionNotNull)
 
 TEST_F (FieldMetadataTest, SqlDefinitionUniqueNonPK)
 
 TEST_F (FieldMetadataTest, SqlDefinitionPrimaryKeyOmitsNotNull)
 
 TEST_F (FieldMetadataTest, SqlDefinitionPrimaryKeyOmitsUnique)
 
 TEST_F (FieldMetadataTest, SqlDefinitionDefaultNow)
 
 TEST_F (FieldMetadataTest, HasConstraintFunction)
 
 TEST_F (EntityMetadataTest, TableName)
 
 TEST_F (EntityMetadataTest, FieldCount)
 
 TEST_F (EntityMetadataTest, AddFieldStoresInOrder)
 
 TEST_F (EntityMetadataTest, GetPrimaryKeyFindsId)
 
 TEST_F (EntityMetadataTest, GetPrimaryKeyReturnsNullWhenMissing)
 
 TEST_F (EntityMetadataTest, GetIndexesFindsIndexedFields)
 
 TEST_F (EntityMetadataTest, GetForeignKeysFindsFK)
 
 TEST_F (EntityMetadataTest, CreateTableSqlContainsTableName)
 
 TEST_F (EntityMetadataTest, CreateTableSqlContainsAllColumns)
 
 TEST_F (EntityMetadataTest, CreateTableSqlContainsForeignKeyConstraint)
 
 TEST_F (EntityMetadataTest, CreateIndexesSqlWithNamedIndex)
 
 TEST_F (EntityMetadataTest, CreateIndexesSqlAutoGeneratesNameWhenMissing)
 
 TEST_F (EntityMetadataTest, CreateIndexesSqlEmptyWhenNoIndexes)
 
 TEST_F (EntityMetadataTest, EmptyTableProducesMinimalDDL)
 
 TEST_F (EntityMetadataTest, ConstraintHelperFunctions)
 

Function Documentation

◆ TEST_F() [1/38]

TEST_F ( EntityMetadataTest ,
AddFieldStoresInOrder  )

Definition at line 220 of file test_entity_metadata.cpp.

220 {
221 EXPECT_EQ(meta_->fields()[0].name(), "id");
222 EXPECT_EQ(meta_->fields()[1].name(), "name");
223 EXPECT_EQ(meta_->fields()[2].name(), "email");
224 EXPECT_EQ(meta_->fields()[3].name(), "department_id");
225 EXPECT_EQ(meta_->fields()[4].name(), "created_at");
226}

◆ TEST_F() [2/38]

TEST_F ( EntityMetadataTest ,
ConstraintHelperFunctions  )

Definition at line 306 of file test_entity_metadata.cpp.

306 {
307 EXPECT_EQ(static_cast<int>(primary_key()), static_cast<int>(field_constraint::primary_key));
308 EXPECT_EQ(static_cast<int>(not_null()), static_cast<int>(field_constraint::not_null));
309 EXPECT_EQ(static_cast<int>(unique()), static_cast<int>(field_constraint::unique));
310 EXPECT_EQ(static_cast<int>(auto_increment()), static_cast<int>(field_constraint::auto_increment));
311 EXPECT_EQ(static_cast<int>(default_now()), static_cast<int>(field_constraint::default_now));
312}
database::orm::auto_increment
field_constraint auto_increment()
Definition entity.h:303
database::orm::unique
field_constraint unique()
Definition entity.h:302
database::orm::not_null
field_constraint not_null()
Definition entity.h:301
database::orm::primary_key
field_constraint primary_key()
Definition entity.h:300
database::orm::default_now
field_constraint default_now()
Definition entity.h:304

References database::orm::auto_increment(), database::orm::default_now(), database::orm::not_null(), database::orm::primary_key(), and database::orm::unique().

Here is the call graph for this function:

◆ TEST_F() [3/38]

TEST_F ( EntityMetadataTest ,
CreateIndexesSqlAutoGeneratesNameWhenMissing  )

Definition at line 281 of file test_entity_metadata.cpp.

281 {
282 entity_metadata meta("products");
283 meta.add_field(field_metadata("category", "std::string", field_constraint::index));
284
285 std::string sql = meta.create_indexes_sql();
286 EXPECT_NE(sql.find("CREATE INDEX IF NOT EXISTS idx_products_category ON products(category)"),
287 std::string::npos);
288}
database::orm::entity_metadata
Metadata for entire entities including table mapping and relationships.
Definition entity.h:118
database::orm::field_metadata
Metadata for entity fields including constraints and relationships.
Definition entity.h:78

References database::orm::entity_metadata::add_field(), and database::orm::entity_metadata::create_indexes_sql().

Here is the call graph for this function:

◆ TEST_F() [4/38]

TEST_F ( EntityMetadataTest ,
CreateIndexesSqlEmptyWhenNoIndexes  )

Definition at line 290 of file test_entity_metadata.cpp.

290 {
291 entity_metadata meta("simple");
292 meta.add_field(field_metadata("name", "std::string"));
293
294 std::string sql = meta.create_indexes_sql();
295 EXPECT_TRUE(sql.empty());
296}

References database::orm::entity_metadata::add_field(), and database::orm::entity_metadata::create_indexes_sql().

Here is the call graph for this function:

◆ TEST_F() [5/38]

TEST_F ( EntityMetadataTest ,
CreateIndexesSqlWithNamedIndex  )

Definition at line 275 of file test_entity_metadata.cpp.

275 {
276 std::string sql = meta_->create_indexes_sql();
277 EXPECT_NE(sql.find("CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)"),
278 std::string::npos);
279}

◆ TEST_F() [6/38]

TEST_F ( EntityMetadataTest ,
CreateTableSqlContainsAllColumns  )

Definition at line 260 of file test_entity_metadata.cpp.

260 {
261 std::string sql = meta_->create_table_sql();
262 EXPECT_NE(sql.find("id BIGINT PRIMARY KEY AUTO_INCREMENT"), std::string::npos);
263 EXPECT_NE(sql.find("name VARCHAR(255) NOT NULL"), std::string::npos);
264 EXPECT_NE(sql.find("email VARCHAR(255) NOT NULL UNIQUE"), std::string::npos);
265 EXPECT_NE(sql.find("department_id BIGINT"), std::string::npos);
266 EXPECT_NE(sql.find("created_at TIMESTAMP"), std::string::npos);
267}

◆ TEST_F() [7/38]

TEST_F ( EntityMetadataTest ,
CreateTableSqlContainsForeignKeyConstraint  )

Definition at line 269 of file test_entity_metadata.cpp.

269 {
270 std::string sql = meta_->create_table_sql();
271 EXPECT_NE(sql.find("FOREIGN KEY (department_id) REFERENCES departments(id)"),
272 std::string::npos);
273}

◆ TEST_F() [8/38]

TEST_F ( EntityMetadataTest ,
CreateTableSqlContainsTableName  )

Definition at line 255 of file test_entity_metadata.cpp.

255 {
256 std::string sql = meta_->create_table_sql();
257 EXPECT_NE(sql.find("CREATE TABLE IF NOT EXISTS users"), std::string::npos);
258}

◆ TEST_F() [9/38]

TEST_F ( EntityMetadataTest ,
EmptyTableProducesMinimalDDL  )

Definition at line 298 of file test_entity_metadata.cpp.

298 {
299 entity_metadata meta("empty_table");
300 std::string sql = meta.create_table_sql();
301 EXPECT_NE(sql.find("CREATE TABLE IF NOT EXISTS empty_table"), std::string::npos);
302}

References database::orm::entity_metadata::create_table_sql().

Here is the call graph for this function:

◆ TEST_F() [10/38]

TEST_F ( EntityMetadataTest ,
FieldCount  )

Definition at line 216 of file test_entity_metadata.cpp.

216 {
217 EXPECT_EQ(meta_->fields().size(), 5u);
218}

◆ TEST_F() [11/38]

TEST_F ( EntityMetadataTest ,
GetForeignKeysFindsFK  )

Definition at line 247 of file test_entity_metadata.cpp.

247 {
248 auto fks = meta_->get_foreign_keys();
249 ASSERT_EQ(fks.size(), 1u);
250 EXPECT_EQ(fks[0]->name(), "department_id");
251 EXPECT_EQ(fks[0]->foreign_table(), "departments");
252 EXPECT_EQ(fks[0]->foreign_field(), "id");
253}
ASSERT_EQ
#define ASSERT_EQ(expected, actual, message)
Definition test_connection_string_builder.cpp:38

References ASSERT_EQ.

◆ TEST_F() [12/38]

TEST_F ( EntityMetadataTest ,
GetIndexesFindsIndexedFields  )

Definition at line 241 of file test_entity_metadata.cpp.

241 {
242 auto indexes = meta_->get_indexes();
243 ASSERT_EQ(indexes.size(), 1u);
244 EXPECT_EQ(indexes[0]->name(), "email");
245}

References ASSERT_EQ.

◆ TEST_F() [13/38]

TEST_F ( EntityMetadataTest ,
GetPrimaryKeyFindsId  )

Definition at line 228 of file test_entity_metadata.cpp.

228 {
229 const auto* pk = meta_->get_primary_key();
230 ASSERT_NE(pk, nullptr);
231 EXPECT_EQ(pk->name(), "id");
232 EXPECT_TRUE(pk->is_primary_key());
233}

◆ TEST_F() [14/38]

TEST_F ( EntityMetadataTest ,
GetPrimaryKeyReturnsNullWhenMissing  )

Definition at line 235 of file test_entity_metadata.cpp.

235 {
236 entity_metadata meta("no_pk_table");
237 meta.add_field(field_metadata("name", "std::string"));
238 EXPECT_EQ(meta.get_primary_key(), nullptr);
239}

References database::orm::entity_metadata::add_field(), and database::orm::entity_metadata::get_primary_key().

Here is the call graph for this function:

◆ TEST_F() [15/38]

TEST_F ( EntityMetadataTest ,
TableName  )

Definition at line 212 of file test_entity_metadata.cpp.

212 {
213 EXPECT_EQ(meta_->table_name(), "users");
214}

◆ TEST_F() [16/38]

TEST_F ( FieldMetadataTest ,
CombinedConstraints  )

Definition at line 48 of file test_entity_metadata.cpp.

48 {
49 field_metadata field("id", "int64_t",
50 field_constraint::primary_key | field_constraint::auto_increment);
51 EXPECT_TRUE(field.is_primary_key());
52 EXPECT_TRUE(field.is_auto_increment());
53 EXPECT_FALSE(field.is_not_null());
54}

References database::orm::field_metadata::is_auto_increment(), database::orm::field_metadata::is_not_null(), and database::orm::field_metadata::is_primary_key().

Here is the call graph for this function:

◆ TEST_F() [17/38]

TEST_F ( FieldMetadataTest ,
ConstructsWithNameAndType  )

Definition at line 25 of file test_entity_metadata.cpp.

25 {
26 field_metadata field("id", "int64_t");
27 EXPECT_EQ(field.name(), "id");
28 EXPECT_EQ(field.type_name(), "int64_t");
29}

References database::orm::field_metadata::name(), and database::orm::field_metadata::type_name().

Here is the call graph for this function:

◆ TEST_F() [18/38]

TEST_F ( FieldMetadataTest ,
DefaultConstraintIsNone  )

Definition at line 31 of file test_entity_metadata.cpp.

31 {
32 field_metadata field("name", "std::string");
33 EXPECT_FALSE(field.is_primary_key());
34 EXPECT_FALSE(field.is_not_null());
35 EXPECT_FALSE(field.is_unique());
36 EXPECT_FALSE(field.is_auto_increment());
37 EXPECT_FALSE(field.has_index());
38 EXPECT_FALSE(field.is_foreign_key());
39 EXPECT_FALSE(field.has_default_now());
40}

References database::orm::field_metadata::has_default_now(), database::orm::field_metadata::has_index(), database::orm::field_metadata::is_auto_increment(), database::orm::field_metadata::is_foreign_key(), database::orm::field_metadata::is_not_null(), database::orm::field_metadata::is_primary_key(), and database::orm::field_metadata::is_unique().

Here is the call graph for this function:

◆ TEST_F() [19/38]

TEST_F ( FieldMetadataTest ,
DefaultNowConstraint  )

Definition at line 79 of file test_entity_metadata.cpp.

79 {
80 field_metadata field("created_at", "std::chrono::system_clock::time_point",
81 field_constraint::default_now);
82 EXPECT_TRUE(field.has_default_now());
83}

References database::orm::field_metadata::has_default_now().

Here is the call graph for this function:

◆ TEST_F() [20/38]

TEST_F ( FieldMetadataTest ,
ForeignKeyConstraint  )

Definition at line 71 of file test_entity_metadata.cpp.

71 {
72 field_metadata field("user_id", "int64_t",
73 field_constraint::foreign_key, "", "users", "id");
74 EXPECT_TRUE(field.is_foreign_key());
75 EXPECT_EQ(field.foreign_table(), "users");
76 EXPECT_EQ(field.foreign_field(), "id");
77}

References database::orm::field_metadata::foreign_field(), database::orm::field_metadata::foreign_table(), and database::orm::field_metadata::is_foreign_key().

Here is the call graph for this function:

◆ TEST_F() [21/38]

TEST_F ( FieldMetadataTest ,
HasConstraintFunction  )

Definition at line 175 of file test_entity_metadata.cpp.

175 {
176 EXPECT_TRUE(has_constraint(
177 field_constraint::primary_key | field_constraint::not_null,
178 field_constraint::primary_key));
179 EXPECT_TRUE(has_constraint(
180 field_constraint::primary_key | field_constraint::not_null,
181 field_constraint::not_null));
182 EXPECT_FALSE(has_constraint(
183 field_constraint::primary_key | field_constraint::not_null,
184 field_constraint::unique));
185}
database::orm::has_constraint
bool has_constraint(field_constraint constraints, field_constraint check)
Definition entity.h:69

References database::orm::has_constraint().

Here is the call graph for this function:

◆ TEST_F() [22/38]

TEST_F ( FieldMetadataTest ,
IndexConstraintWithName  )

Definition at line 64 of file test_entity_metadata.cpp.

64 {
65 field_metadata field("name", "std::string",
66 field_constraint::index, "idx_users_name");
67 EXPECT_TRUE(field.has_index());
68 EXPECT_EQ(field.index_name(), "idx_users_name");
69}

References database::orm::field_metadata::has_index(), and database::orm::field_metadata::index_name().

Here is the call graph for this function:

◆ TEST_F() [23/38]

TEST_F ( FieldMetadataTest ,
NotNullAndUniqueConstraints  )

Definition at line 56 of file test_entity_metadata.cpp.

56 {
57 field_metadata field("email", "std::string",
58 field_constraint::not_null | field_constraint::unique);
59 EXPECT_TRUE(field.is_not_null());
60 EXPECT_TRUE(field.is_unique());
61 EXPECT_FALSE(field.is_primary_key());
62}

References database::orm::field_metadata::is_not_null(), database::orm::field_metadata::is_primary_key(), and database::orm::field_metadata::is_unique().

Here is the call graph for this function:

◆ TEST_F() [24/38]

TEST_F ( FieldMetadataTest ,
PrimaryKeyConstraint  )

Definition at line 42 of file test_entity_metadata.cpp.

42 {
43 field_metadata field("id", "int64_t", field_constraint::primary_key);
44 EXPECT_TRUE(field.is_primary_key());
45 EXPECT_FALSE(field.is_not_null());
46}

References database::orm::field_metadata::is_not_null(), and database::orm::field_metadata::is_primary_key().

Here is the call graph for this function:

◆ TEST_F() [25/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionAutoIncrement  )

Definition at line 128 of file test_entity_metadata.cpp.

128 {
129 field_metadata field("id", "int64_t",
130 field_constraint::primary_key | field_constraint::auto_increment);
131 std::string sql = field.to_sql_definition();
132 EXPECT_NE(sql.find("PRIMARY KEY"), std::string::npos);
133 EXPECT_NE(sql.find("AUTO_INCREMENT"), std::string::npos);
134}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [26/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionBool  )

Definition at line 107 of file test_entity_metadata.cpp.

107 {
108 field_metadata field("active", "bool");
109 EXPECT_EQ(field.to_sql_definition(), "active BOOLEAN");
110}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [27/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionDefaultNow  )

Definition at line 166 of file test_entity_metadata.cpp.

166 {
167 field_metadata field("created_at", "std::chrono::system_clock::time_point",
168 field_constraint::default_now);
169 std::string sql = field.to_sql_definition();
170 EXPECT_NE(sql.find("DEFAULT CURRENT_TIMESTAMP"), std::string::npos);
171}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [28/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionDouble  )

Definition at line 97 of file test_entity_metadata.cpp.

97 {
98 field_metadata field("price", "double");
99 EXPECT_EQ(field.to_sql_definition(), "price DOUBLE PRECISION");
100}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [29/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionInt32  )

Definition at line 87 of file test_entity_metadata.cpp.

87 {
88 field_metadata field("count", "int32_t");
89 EXPECT_EQ(field.to_sql_definition(), "count INTEGER");
90}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [30/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionInt64  )

Definition at line 92 of file test_entity_metadata.cpp.

92 {
93 field_metadata field("id", "int64_t");
94 EXPECT_EQ(field.to_sql_definition(), "id BIGINT");
95}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [31/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionNotNull  )

Definition at line 136 of file test_entity_metadata.cpp.

136 {
137 field_metadata field("name", "std::string", field_constraint::not_null);
138 std::string sql = field.to_sql_definition();
139 EXPECT_NE(sql.find("NOT NULL"), std::string::npos);
140}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [32/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionPrimaryKey  )

Definition at line 122 of file test_entity_metadata.cpp.

122 {
123 field_metadata field("id", "int64_t", field_constraint::primary_key);
124 std::string sql = field.to_sql_definition();
125 EXPECT_NE(sql.find("PRIMARY KEY"), std::string::npos);
126}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [33/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionPrimaryKeyOmitsNotNull  )

Definition at line 148 of file test_entity_metadata.cpp.

148 {
149 // Primary keys are implicitly NOT NULL, so NOT NULL should not appear
150 field_metadata field("id", "int64_t",
151 field_constraint::primary_key | field_constraint::not_null);
152 std::string sql = field.to_sql_definition();
153 EXPECT_NE(sql.find("PRIMARY KEY"), std::string::npos);
154 EXPECT_EQ(sql.find("NOT NULL"), std::string::npos);
155}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [34/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionPrimaryKeyOmitsUnique  )

Definition at line 157 of file test_entity_metadata.cpp.

157 {
158 // Primary keys are implicitly UNIQUE, so UNIQUE should not appear
159 field_metadata field("id", "int64_t",
160 field_constraint::primary_key | field_constraint::unique);
161 std::string sql = field.to_sql_definition();
162 EXPECT_NE(sql.find("PRIMARY KEY"), std::string::npos);
163 EXPECT_EQ(sql.find("UNIQUE"), std::string::npos);
164}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [35/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionString  )

Definition at line 102 of file test_entity_metadata.cpp.

102 {
103 field_metadata field("name", "std::string");
104 EXPECT_EQ(field.to_sql_definition(), "name VARCHAR(255)");
105}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [36/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionTimestamp  )

Definition at line 112 of file test_entity_metadata.cpp.

112 {
113 field_metadata field("created_at", "std::chrono::system_clock::time_point");
114 EXPECT_EQ(field.to_sql_definition(), "created_at TIMESTAMP");
115}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [37/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionUniqueNonPK  )

Definition at line 142 of file test_entity_metadata.cpp.

142 {
143 field_metadata field("email", "std::string", field_constraint::unique);
144 std::string sql = field.to_sql_definition();
145 EXPECT_NE(sql.find("UNIQUE"), std::string::npos);
146}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function:

◆ TEST_F() [38/38]

TEST_F ( FieldMetadataTest ,
SqlDefinitionUnknownTypeFallsBackToText  )

Definition at line 117 of file test_entity_metadata.cpp.

117 {
118 field_metadata field("data", "custom_type");
119 EXPECT_EQ(field.to_sql_definition(), "data TEXT");
120}

References database::orm::field_metadata::to_sql_definition().

Here is the call graph for this function: