| // Copyright (C) 2019 Google LLC | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include "icing/schema/schema-store.h" | |
| #include <memory> | |
| #include <string> | |
| #include <vector> | |
| #include "icing/text_classifier/lib3/utils/base/status.h" | |
| #include "gmock/gmock.h" | |
| #include "gtest/gtest.h" | |
| #include "icing/absl_ports/str_cat.h" | |
| #include "icing/document-builder.h" | |
| #include "icing/file/filesystem.h" | |
| #include "icing/file/mock-filesystem.h" | |
| #include "icing/file/version-util.h" | |
| #include "icing/portable/equals-proto.h" | |
| #include "icing/proto/debug.pb.h" | |
| #include "icing/proto/document.pb.h" | |
| #include "icing/proto/logging.pb.h" | |
| #include "icing/proto/schema.pb.h" | |
| #include "icing/proto/storage.pb.h" | |
| #include "icing/proto/term.pb.h" | |
| #include "icing/schema-builder.h" | |
| #include "icing/schema/schema-util.h" | |
| #include "icing/schema/section-manager.h" | |
| #include "icing/schema/section.h" | |
| #include "icing/store/document-filter-data.h" | |
| #include "icing/testing/common-matchers.h" | |
| #include "icing/testing/fake-clock.h" | |
| #include "icing/testing/tmp-directory.h" | |
| #include "icing/util/crc32.h" | |
| namespace icing { | |
| namespace lib { | |
| namespace { | |
| using ::icing::lib::portable_equals_proto::EqualsProto; | |
| using ::testing::ElementsAre; | |
| using ::testing::Eq; | |
| using ::testing::Ge; | |
| using ::testing::Gt; | |
| using ::testing::HasSubstr; | |
| using ::testing::Not; | |
| using ::testing::Pointee; | |
| using ::testing::Return; | |
| using ::testing::SizeIs; | |
| using ::testing::UnorderedElementsAre; | |
| constexpr int64_t kDefaultTimestamp = 12345678; | |
| class SchemaStoreTest : public ::testing::Test { | |
| protected: | |
| void SetUp() override { | |
| test_dir_ = GetTestTempDir() + "/icing"; | |
| schema_store_dir_ = test_dir_ + "/schema_store"; | |
| filesystem_.CreateDirectoryRecursively(schema_store_dir_.c_str()); | |
| schema_ = SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder() | |
| .SetType("email") | |
| .AddProperty( | |
| // Add an indexed property so we generate | |
| // section metadata on it | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_EXACT, | |
| TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| } | |
| void TearDown() override { | |
| // Check that the schema store directory is the *only* directory in the | |
| // schema_store_dir_. IOW, ensure that all temporary directories have been | |
| // properly cleaned up. | |
| std::vector<std::string> sub_dirs; | |
| ASSERT_TRUE(filesystem_.ListDirectory(test_dir_.c_str(), &sub_dirs)); | |
| ASSERT_THAT(sub_dirs, ElementsAre("schema_store")); | |
| // Finally, clean everything up. | |
| ASSERT_TRUE(filesystem_.DeleteDirectoryRecursively(test_dir_.c_str())); | |
| } | |
| Filesystem filesystem_; | |
| std::string test_dir_; | |
| std::string schema_store_dir_; | |
| SchemaProto schema_; | |
| FakeClock fake_clock_; | |
| }; | |
| TEST_F(SchemaStoreTest, CreationWithNullPointerShouldFail) { | |
| EXPECT_THAT(SchemaStore::Create(/*filesystem=*/nullptr, schema_store_dir_, | |
| &fake_clock_), | |
| StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION)); | |
| } | |
| TEST_F(SchemaStoreTest, SchemaStoreMoveConstructible) { | |
| // Create an instance of SchemaStore. | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("type_a").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("prop1") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| ICING_ASSERT_OK_AND_ASSIGN(Crc32 expected_checksum, | |
| schema_store->ComputeChecksum()); | |
| // Move construct an instance of SchemaStore | |
| SchemaStore move_constructed_schema_store(std::move(*schema_store)); | |
| EXPECT_THAT(move_constructed_schema_store.GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| EXPECT_THAT(move_constructed_schema_store.ComputeChecksum(), | |
| IsOkAndHolds(Eq(expected_checksum))); | |
| SectionMetadata expected_metadata(/*id_in=*/0, TYPE_STRING, TOKENIZER_PLAIN, | |
| TERM_MATCH_EXACT, NUMERIC_MATCH_UNKNOWN, | |
| "prop1"); | |
| EXPECT_THAT(move_constructed_schema_store.GetSectionMetadata("type_a"), | |
| IsOkAndHolds(Pointee(ElementsAre(expected_metadata)))); | |
| } | |
| TEST_F(SchemaStoreTest, SchemaStoreMoveAssignment) { | |
| // Create an instance of SchemaStore. | |
| SchemaProto schema1 = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("type_a").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("prop1") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema1, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| ICING_ASSERT_OK_AND_ASSIGN(Crc32 expected_checksum, | |
| schema_store->ComputeChecksum()); | |
| // Construct another instance of SchemaStore | |
| SchemaProto schema2 = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("type_b").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("prop2") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> move_assigned_schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema2, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // Move assign the first instance into the second one. | |
| *move_assigned_schema_store = std::move(*schema_store); | |
| EXPECT_THAT(move_assigned_schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema1)))); | |
| EXPECT_THAT(move_assigned_schema_store->ComputeChecksum(), | |
| IsOkAndHolds(Eq(expected_checksum))); | |
| SectionMetadata expected_metadata(/*id_in=*/0, TYPE_STRING, TOKENIZER_PLAIN, | |
| TERM_MATCH_EXACT, NUMERIC_MATCH_UNKNOWN, | |
| "prop1"); | |
| EXPECT_THAT(move_assigned_schema_store->GetSectionMetadata("type_a"), | |
| IsOkAndHolds(Pointee(ElementsAre(expected_metadata)))); | |
| } | |
| TEST_F(SchemaStoreTest, CorruptSchemaError) { | |
| { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| } | |
| // "Corrupt" the ground truth schema by adding new data to it. This will mess | |
| // up the checksum of the schema store | |
| SchemaProto corrupt_schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("corrupted")) | |
| .Build(); | |
| const std::string schema_file = | |
| absl_ports::StrCat(schema_store_dir_, "/schema.pb"); | |
| const std::string serialized_schema = corrupt_schema.SerializeAsString(); | |
| filesystem_.Write(schema_file.c_str(), serialized_schema.data(), | |
| serialized_schema.size()); | |
| // If ground truth was corrupted, we won't know what to do | |
| EXPECT_THAT( | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_), | |
| StatusIs(libtextclassifier3::StatusCode::INTERNAL)); | |
| } | |
| TEST_F(SchemaStoreTest, RecoverCorruptDerivedFileOk) { | |
| { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| } | |
| // "Corrupt" the derived SchemaTypeIds by deleting the entire directory. This | |
| // will mess up the initialization of schema store, causing everything to be | |
| // regenerated from ground truth | |
| const std::string schema_type_mapper_dir = | |
| absl_ports::StrCat(schema_store_dir_, "/schema_type_mapper"); | |
| filesystem_.DeleteDirectoryRecursively(schema_type_mapper_dir.c_str()); | |
| InitializeStatsProto initialize_stats; | |
| fake_clock_.SetTimerElapsedMilliseconds(123); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_, | |
| &initialize_stats)); | |
| EXPECT_THAT(initialize_stats.schema_store_recovery_cause(), | |
| Eq(InitializeStatsProto::IO_ERROR)); | |
| EXPECT_THAT(initialize_stats.schema_store_recovery_latency_ms(), Eq(123)); | |
| // Everything looks fine, ground truth and derived data | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| } | |
| TEST_F(SchemaStoreTest, RecoverDiscardDerivedFilesOk) { | |
| { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| } | |
| ICING_ASSERT_OK( | |
| SchemaStore::DiscardDerivedFiles(&filesystem_, schema_store_dir_)); | |
| InitializeStatsProto initialize_stats; | |
| fake_clock_.SetTimerElapsedMilliseconds(123); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_, | |
| &initialize_stats)); | |
| EXPECT_THAT(initialize_stats.schema_store_recovery_cause(), | |
| Eq(InitializeStatsProto::IO_ERROR)); | |
| EXPECT_THAT(initialize_stats.schema_store_recovery_latency_ms(), Eq(123)); | |
| // Everything looks fine, ground truth and derived data | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| } | |
| TEST_F(SchemaStoreTest, RecoverBadChecksumOk) { | |
| { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| } | |
| // Change the SchemaStore's header combined checksum so that it won't match | |
| // the recalculated checksum on initialization. This will force a regeneration | |
| // of derived files from ground truth. | |
| const std::string header_file = | |
| absl_ports::StrCat(schema_store_dir_, "/schema_store_header"); | |
| SchemaStore::LegacyHeader header; | |
| header.magic = SchemaStore::Header::kMagic; | |
| header.checksum = 10; // Arbitrary garbage checksum | |
| filesystem_.DeleteFile(header_file.c_str()); | |
| filesystem_.Write(header_file.c_str(), &header, sizeof(header)); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Everything looks fine, ground truth and derived data | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| } | |
| TEST_F(SchemaStoreTest, CreateNoPreviousSchemaOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // The apis to retrieve information about the schema should fail gracefully. | |
| EXPECT_THAT(store->GetSchema(), | |
| StatusIs(libtextclassifier3::StatusCode::NOT_FOUND)); | |
| EXPECT_THAT(store->GetSchemaTypeConfig("foo"), | |
| StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION)); | |
| EXPECT_THAT(store->GetSchemaTypeId("foo"), | |
| StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION)); | |
| EXPECT_THAT(store->GetSectionMetadata(/*schema_type_id=*/0, /*section_id=*/0), | |
| StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION)); | |
| EXPECT_THAT(store->GetJoinablePropertyMetadata(/*schema_type_id=*/0, | |
| /*property_path=*/"A"), | |
| StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION)); | |
| // The apis to extract content from a document should fail gracefully. | |
| DocumentProto doc; | |
| PropertyProto* prop = doc.add_properties(); | |
| prop->set_name("name"); | |
| prop->add_string_values("foo bar baz"); | |
| EXPECT_THAT(store->ExtractSections(doc), | |
| StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION)); | |
| EXPECT_THAT(store->ExtractJoinableProperties(doc), | |
| StatusIs(libtextclassifier3::StatusCode::FAILED_PRECONDITION)); | |
| // The apis to persist and checksum data should succeed. | |
| EXPECT_THAT(store->ComputeChecksum(), IsOkAndHolds(Crc32())); | |
| EXPECT_THAT(store->PersistToDisk(), IsOk()); | |
| } | |
| TEST_F(SchemaStoreTest, CreateWithPreviousSchemaOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| schema_store.reset(); | |
| EXPECT_THAT( | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_), | |
| IsOk()); | |
| } | |
| TEST_F(SchemaStoreTest, MultipleCreateOk) { | |
| DocumentProto document; | |
| document.set_schema("email"); | |
| auto subject_property = document.add_properties(); | |
| subject_property->set_name("subject"); | |
| subject_property->add_string_values("subject_content"); | |
| auto timestamp_property = document.add_properties(); | |
| timestamp_property->set_name("timestamp"); | |
| timestamp_property->add_int64_values(kDefaultTimestamp); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| // Verify that our in-memory structures are ok | |
| EXPECT_THAT(schema_store->GetSchemaTypeConfig("email"), | |
| IsOkAndHolds(Pointee(EqualsProto(schema_.types(0))))); | |
| ICING_ASSERT_OK_AND_ASSIGN(SectionGroup section_group, | |
| schema_store->ExtractSections(document)); | |
| EXPECT_THAT(section_group.string_sections[0].content, | |
| ElementsAre("subject_content")); | |
| EXPECT_THAT(section_group.integer_sections[0].content, | |
| ElementsAre(kDefaultTimestamp)); | |
| // Verify that our persisted data is ok | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| schema_store.reset(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Verify that our in-memory structures are ok | |
| EXPECT_THAT(schema_store->GetSchemaTypeConfig("email"), | |
| IsOkAndHolds(Pointee(EqualsProto(schema_.types(0))))); | |
| ICING_ASSERT_OK_AND_ASSIGN(section_group, | |
| schema_store->ExtractSections(document)); | |
| EXPECT_THAT(section_group.string_sections[0].content, | |
| ElementsAre("subject_content")); | |
| EXPECT_THAT(section_group.integer_sections[0].content, | |
| ElementsAre(kDefaultTimestamp)); | |
| // Verify that our persisted data is ok | |
| EXPECT_THAT(schema_store->GetSchemaTypeId("email"), IsOkAndHolds(0)); | |
| } | |
| TEST_F(SchemaStoreTest, SetNewSchemaOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSameSchemaOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| // And one more for fun | |
| result = SchemaStore::SetSchemaResult(); | |
| result.success = true; | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| } | |
| TEST_F(SchemaStoreTest, SetIncompatibleSchemaOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema_)); | |
| // Make the schema incompatible by removing a type. | |
| schema_.clear_types(); | |
| // Set the incompatible schema | |
| result = SchemaStore::SetSchemaResult(); | |
| result.success = false; | |
| result.schema_types_deleted_by_name.emplace("email"); | |
| result.schema_types_deleted_by_id.emplace(0); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithAddedTypeOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email")) | |
| .Build(); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("email"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| // Add a type, shouldn't affect the index or cached SchemaTypeIds | |
| schema = SchemaBuilder(schema) | |
| .AddType(SchemaTypeConfigBuilder().SetType("new_type")) | |
| .Build(); | |
| // Set the compatible schema | |
| result = SchemaStore::SetSchemaResult(); | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("new_type"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithDeletedTypeOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email")) | |
| .AddType(SchemaTypeConfigBuilder().SetType("message")) | |
| .Build(); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("email"); | |
| result.schema_types_new_by_name.insert("message"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId old_email_schema_type_id, | |
| schema_store->GetSchemaTypeId("email")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId old_message_schema_type_id, | |
| schema_store->GetSchemaTypeId("message")); | |
| // Remove "email" type, this also changes previous SchemaTypeIds | |
| schema = SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("message")) | |
| .Build(); | |
| SchemaStore::SetSchemaResult incompatible_result; | |
| incompatible_result.success = false; | |
| incompatible_result.old_schema_type_ids_changed.emplace( | |
| old_message_schema_type_id); | |
| incompatible_result.schema_types_deleted_by_name.emplace("email"); | |
| incompatible_result.schema_types_deleted_by_id.emplace( | |
| old_email_schema_type_id); | |
| // Can't set the incompatible schema | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(incompatible_result))); | |
| SchemaStore::SetSchemaResult force_result; | |
| force_result.success = true; | |
| force_result.old_schema_type_ids_changed.emplace(old_message_schema_type_id); | |
| force_result.schema_types_deleted_by_name.emplace("email"); | |
| force_result.schema_types_deleted_by_id.emplace(old_email_schema_type_id); | |
| // Force set the incompatible schema | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/true, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(force_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithReorderedTypesOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email")) | |
| .AddType(SchemaTypeConfigBuilder().SetType("message")) | |
| .Build(); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("email"); | |
| result.schema_types_new_by_name.insert("message"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| // Reorder the types | |
| schema = SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("message")) | |
| .AddType(SchemaTypeConfigBuilder().SetType("email")) | |
| .Build(); | |
| // Since we assign SchemaTypeIds based on order in the SchemaProto, this will | |
| // cause SchemaTypeIds to change | |
| result = SchemaStore::SetSchemaResult(); | |
| result.success = true; | |
| result.old_schema_type_ids_changed.emplace(0); // Old SchemaTypeId of "email" | |
| result.old_schema_type_ids_changed.emplace( | |
| 1); // Old SchemaTypeId of "message" | |
| // Set the compatible schema | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| } | |
| TEST_F(SchemaStoreTest, IndexedPropertyChangeRequiresReindexingOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email").AddProperty( | |
| // Add an unindexed property | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataType(TYPE_STRING) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("email"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| // Make a previously unindexed property indexed | |
| schema = SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| // Set the compatible schema | |
| result = SchemaStore::SetSchemaResult(); | |
| result.success = true; | |
| result.schema_types_index_incompatible_by_name.insert("email"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| } | |
| TEST_F(SchemaStoreTest, IndexNestedDocumentsChangeRequiresReindexingOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Make two schemas. One that sets index_nested_properties to false and one | |
| // that sets it to true. | |
| SchemaTypeConfigProto email_type_config = | |
| SchemaTypeConfigBuilder() | |
| .SetType("email") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto no_nested_index_schema = | |
| SchemaBuilder() | |
| .AddType(email_type_config) | |
| .AddType(SchemaTypeConfigBuilder().SetType("person").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("emails") | |
| .SetDataTypeDocument("email", | |
| /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_REPEATED))) | |
| .Build(); | |
| SchemaProto nested_index_schema = | |
| SchemaBuilder() | |
| .AddType(email_type_config) | |
| .AddType(SchemaTypeConfigBuilder().SetType("person").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("emails") | |
| .SetDataTypeDocument("email", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_REPEATED))) | |
| .Build(); | |
| // Set schema with index_nested_properties=false to start. | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("email"); | |
| result.schema_types_new_by_name.insert("person"); | |
| EXPECT_THAT( | |
| schema_store->SetSchema(no_nested_index_schema, | |
| /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(no_nested_index_schema)); | |
| // Set schema with index_nested_properties=true and confirm that the change to | |
| // 'person' is index incompatible. | |
| result = SchemaStore::SetSchemaResult(); | |
| result.success = true; | |
| result.schema_types_index_incompatible_by_name.insert("person"); | |
| EXPECT_THAT( | |
| schema_store->SetSchema(nested_index_schema, | |
| /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(nested_index_schema)); | |
| // Set schema with index_nested_properties=false and confirm that the change | |
| // to 'person' is index incompatible. | |
| result = SchemaStore::SetSchemaResult(); | |
| result.success = true; | |
| result.schema_types_index_incompatible_by_name.insert("person"); | |
| EXPECT_THAT( | |
| schema_store->SetSchema(no_nested_index_schema, | |
| /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(no_nested_index_schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithIncompatibleTypesOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email").AddProperty( | |
| // Add a STRING property | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataType(TYPE_STRING) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("email"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId old_email_schema_type_id, | |
| schema_store->GetSchemaTypeId("email")); | |
| // Make a previously STRING property into DOUBLE | |
| schema = SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email").AddProperty( | |
| // Add a STRING property | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataType(TYPE_DOUBLE) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| SchemaStore::SetSchemaResult incompatible_result; | |
| incompatible_result.success = false; | |
| incompatible_result.schema_types_incompatible_by_name.emplace("email"); | |
| incompatible_result.schema_types_incompatible_by_id.emplace( | |
| old_email_schema_type_id); | |
| // Can't set the incompatible schema | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(incompatible_result))); | |
| SchemaStore::SetSchemaResult force_result; | |
| force_result.success = true; | |
| force_result.schema_types_incompatible_by_name.emplace("email"); | |
| force_result.schema_types_incompatible_by_id.emplace( | |
| old_email_schema_type_id); | |
| // Force set the incompatible schema | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/true, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(force_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithIncompatibleNestedTypesOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // 1. Create a ContactPoint type with a repeated property and set that schema | |
| SchemaTypeConfigBuilder contact_point_repeated_label = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaProto old_schema = | |
| SchemaBuilder().AddType(contact_point_repeated_label).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| old_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId old_contact_point_type_id, | |
| schema_store->GetSchemaTypeId("ContactPoint")); | |
| // 2. Create a type that references the ContactPoint type and make a backwards | |
| // incompatible change to ContactPoint | |
| SchemaTypeConfigBuilder contact_point_optional_label = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL)); | |
| SchemaTypeConfigBuilder person = | |
| SchemaTypeConfigBuilder().SetType("Person").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("contactPoints") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaProto new_schema = SchemaBuilder() | |
| .AddType(contact_point_optional_label) | |
| .AddType(person) | |
| .Build(); | |
| // 3. SetSchema should fail with ignore_errors_and_delete_documents=false and | |
| // the old schema should remain | |
| SchemaStore::SetSchemaResult expected_result; | |
| expected_result.success = false; | |
| expected_result.schema_types_incompatible_by_name.insert("ContactPoint"); | |
| expected_result.schema_types_incompatible_by_id.insert( | |
| old_contact_point_type_id); | |
| expected_result.schema_types_new_by_name.insert("Person"); | |
| EXPECT_THAT( | |
| schema_store->SetSchema(new_schema, | |
| /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(expected_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(old_schema)); | |
| // 4. SetSchema should succeed with ignore_errors_and_delete_documents=true | |
| // and the new schema should be set | |
| expected_result.success = true; | |
| EXPECT_THAT( | |
| schema_store->SetSchema(new_schema, | |
| /*ignore_errors_and_delete_documents=*/true, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(expected_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(new_schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithIndexIncompatibleNestedTypesOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // 1. Create a ContactPoint type with label that matches prefix and set that | |
| // schema | |
| SchemaTypeConfigBuilder contact_point_prefix_label = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaProto old_schema = | |
| SchemaBuilder().AddType(contact_point_prefix_label).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| old_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // 2. Create a type that references the ContactPoint type and make a index | |
| // backwards incompatible change to ContactPoint | |
| SchemaTypeConfigBuilder contact_point_exact_label = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaTypeConfigBuilder person = | |
| SchemaTypeConfigBuilder().SetType("Person").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("contactPoints") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaProto new_schema = SchemaBuilder() | |
| .AddType(contact_point_exact_label) | |
| .AddType(person) | |
| .Build(); | |
| // SetSchema should succeed, and only ContactPoint should be in | |
| // schema_types_index_incompatible_by_name. | |
| SchemaStore::SetSchemaResult expected_result; | |
| expected_result.success = true; | |
| expected_result.schema_types_index_incompatible_by_name.insert( | |
| "ContactPoint"); | |
| expected_result.schema_types_new_by_name.insert("Person"); | |
| EXPECT_THAT( | |
| schema_store->SetSchema(new_schema, | |
| /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(expected_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(new_schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithCompatibleNestedTypesOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // 1. Create a ContactPoint type with a optional property and set that schema | |
| SchemaTypeConfigBuilder contact_point_optional_label = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL)); | |
| SchemaProto old_schema = | |
| SchemaBuilder().AddType(contact_point_optional_label).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| old_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // 2. Create a type that references the ContactPoint type and make a backwards | |
| // compatible change to ContactPoint | |
| SchemaTypeConfigBuilder contact_point_repeated_label = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaTypeConfigBuilder person = | |
| SchemaTypeConfigBuilder().SetType("Person").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("contactPoints") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaProto new_schema = SchemaBuilder() | |
| .AddType(contact_point_repeated_label) | |
| .AddType(person) | |
| .Build(); | |
| // 3. SetSchema should succeed, and only ContactPoint should be in | |
| // schema_types_changed_fully_compatible_by_name. | |
| SchemaStore::SetSchemaResult expected_result; | |
| expected_result.success = true; | |
| expected_result.schema_types_changed_fully_compatible_by_name.insert( | |
| "ContactPoint"); | |
| expected_result.schema_types_new_by_name.insert("Person"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| new_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(expected_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(new_schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithAddedIndexableNestedTypeOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // 1. Create a ContactPoint type with a optional property, and a type that | |
| // references the ContactPoint type. | |
| SchemaTypeConfigBuilder contact_point = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaTypeConfigBuilder person = | |
| SchemaTypeConfigBuilder().SetType("Person").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("contactPoints") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaProto old_schema = | |
| SchemaBuilder().AddType(contact_point).AddType(person).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| old_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // 2. Add another nested document property to "Person" that has type | |
| // "ContactPoint" | |
| SchemaTypeConfigBuilder new_person = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Person") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("contactPoints") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_REPEATED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("anotherContactPoint") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_REPEATED)); | |
| SchemaProto new_schema = | |
| SchemaBuilder().AddType(contact_point).AddType(new_person).Build(); | |
| // 3. Set to new schema. "Person" should be index-incompatible since we need | |
| // to index an additional property: 'anotherContactPoint.label'. | |
| // - "Person" is also considered join-incompatible since the added nested | |
| // document property could also contain a joinable property. | |
| SchemaStore::SetSchemaResult expected_result; | |
| expected_result.success = true; | |
| expected_result.schema_types_index_incompatible_by_name.insert("Person"); | |
| expected_result.schema_types_join_incompatible_by_name.insert("Person"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| new_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(expected_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(new_schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaWithAddedJoinableNestedTypeOk) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // 1. Create a ContactPoint type with a optional property, and a type that | |
| // references the ContactPoint type. | |
| SchemaTypeConfigBuilder contact_point = | |
| SchemaTypeConfigBuilder() | |
| .SetType("ContactPoint") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("label") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/false) | |
| .SetCardinality(CARDINALITY_REQUIRED)); | |
| SchemaTypeConfigBuilder person = | |
| SchemaTypeConfigBuilder().SetType("Person").AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("contactPoints") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)); | |
| SchemaProto old_schema = | |
| SchemaBuilder().AddType(contact_point).AddType(person).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| old_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // 2. Add another nested document property to "Person" that has type | |
| // "ContactPoint", but make it non-indexable | |
| SchemaTypeConfigBuilder new_person = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Person") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("contactPoints") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("anotherContactPoint") | |
| .SetDataTypeDocument("ContactPoint", | |
| /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)); | |
| SchemaProto new_schema = | |
| SchemaBuilder().AddType(contact_point).AddType(new_person).Build(); | |
| // 3. Set to new schema. "Person" should be join-incompatible but | |
| // index-compatible. | |
| SchemaStore::SetSchemaResult expected_result; | |
| expected_result.success = true; | |
| expected_result.schema_types_join_incompatible_by_name.insert("Person"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| new_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(expected_result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(new_schema)); | |
| } | |
| TEST_F(SchemaStoreTest, GetSchemaTypeId) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| schema_.clear_types(); | |
| // Add a few schema types | |
| const std::string first_type = "first"; | |
| auto type = schema_.add_types(); | |
| type->set_schema_type(first_type); | |
| const std::string second_type = "second"; | |
| type = schema_.add_types(); | |
| type->set_schema_type(second_type); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(first_type); | |
| result.schema_types_new_by_name.insert(second_type); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema_, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId(first_type), IsOkAndHolds(0)); | |
| EXPECT_THAT(schema_store->GetSchemaTypeId(second_type), IsOkAndHolds(1)); | |
| } | |
| TEST_F(SchemaStoreTest, ComputeChecksumDefaultOnEmptySchemaStore) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| Crc32 default_checksum; | |
| EXPECT_THAT(schema_store->ComputeChecksum(), IsOkAndHolds(default_checksum)); | |
| } | |
| TEST_F(SchemaStoreTest, ComputeChecksumSameBetweenCalls) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto foo_schema = | |
| SchemaBuilder().AddType(SchemaTypeConfigBuilder().SetType("foo")).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| foo_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| ICING_ASSERT_OK_AND_ASSIGN(Crc32 checksum, schema_store->ComputeChecksum()); | |
| // Calling it again doesn't change the checksum | |
| EXPECT_THAT(schema_store->ComputeChecksum(), IsOkAndHolds(checksum)); | |
| } | |
| TEST_F(SchemaStoreTest, ComputeChecksumSameAcrossInstances) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto foo_schema = | |
| SchemaBuilder().AddType(SchemaTypeConfigBuilder().SetType("foo")).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| foo_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| ICING_ASSERT_OK_AND_ASSIGN(Crc32 checksum, schema_store->ComputeChecksum()); | |
| // Destroy the previous instance and recreate SchemaStore | |
| schema_store.reset(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->ComputeChecksum(), IsOkAndHolds(checksum)); | |
| } | |
| TEST_F(SchemaStoreTest, ComputeChecksumChangesOnModification) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto foo_schema = | |
| SchemaBuilder().AddType(SchemaTypeConfigBuilder().SetType("foo")).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| foo_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| ICING_ASSERT_OK_AND_ASSIGN(Crc32 checksum, schema_store->ComputeChecksum()); | |
| // Modifying the SchemaStore changes the checksum | |
| SchemaProto foo_bar_schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("foo")) | |
| .AddType(SchemaTypeConfigBuilder().SetType("bar")) | |
| .Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| foo_bar_schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->ComputeChecksum(), IsOkAndHolds(Not(Eq(checksum)))); | |
| } | |
| TEST_F(SchemaStoreTest, PersistToDiskFineForEmptySchemaStore) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Persisting is fine and shouldn't affect anything | |
| ICING_EXPECT_OK(schema_store->PersistToDisk()); | |
| } | |
| TEST_F(SchemaStoreTest, PersistToDiskPreservesAcrossInstances) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = | |
| SchemaBuilder().AddType(SchemaTypeConfigBuilder().SetType("foo")).Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // Persisting shouldn't change anything | |
| ICING_EXPECT_OK(schema_store->PersistToDisk()); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* actual_schema, | |
| schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| // Modify the schema so that something different is persisted next time | |
| schema = SchemaBuilder(schema) | |
| .AddType(SchemaTypeConfigBuilder().SetType("bar")) | |
| .Build(); | |
| ICING_EXPECT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // Should also persist on destruction | |
| schema_store.reset(); | |
| // And we get the same schema back on reinitialization | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK_AND_ASSIGN(actual_schema, schema_store->GetSchema()); | |
| EXPECT_THAT(*actual_schema, EqualsProto(schema)); | |
| } | |
| TEST_F(SchemaStoreTest, SchemaStoreStorageInfoProto) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Create a schema with two types: one simple type and one type that uses all | |
| // 64 sections. | |
| PropertyConfigProto prop = | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .Build(); | |
| SchemaTypeConfigBuilder full_sections_type_builder = | |
| SchemaTypeConfigBuilder().SetType("fullSectionsType"); | |
| for (int i = 0; i < 64; ++i) { | |
| full_sections_type_builder.AddProperty( | |
| PropertyConfigBuilder(prop).SetName("prop" + std::to_string(i))); | |
| } | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("email").AddProperty( | |
| PropertyConfigBuilder(prop))) | |
| .AddType(full_sections_type_builder) | |
| .Build(); | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert("email"); | |
| result.schema_types_new_by_name.insert("fullSectionsType"); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| SchemaStoreStorageInfoProto storage_info = schema_store->GetStorageInfo(); | |
| EXPECT_THAT(storage_info.schema_store_size(), Ge(0)); | |
| EXPECT_THAT(storage_info.num_schema_types(), Eq(2)); | |
| EXPECT_THAT(storage_info.num_total_sections(), Eq(65)); | |
| EXPECT_THAT(storage_info.num_schema_types_sections_exhausted(), Eq(1)); | |
| } | |
| TEST_F(SchemaStoreTest, GetDebugInfo) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set schema | |
| ASSERT_THAT( | |
| schema_store->SetSchema(schema_, | |
| /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(SchemaStore::SetSchemaResult{ | |
| .success = true, | |
| .schema_types_new_by_name = {schema_.types(0).schema_type()}}))); | |
| // Check debug info | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaDebugInfoProto out, | |
| schema_store->GetDebugInfo()); | |
| EXPECT_THAT(out.schema(), EqualsProto(schema_)); | |
| EXPECT_THAT(out.crc(), Gt(0)); | |
| } | |
| TEST_F(SchemaStoreTest, GetDebugInfoForEmptySchemaStore) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Check debug info before setting a schema | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaDebugInfoProto out, | |
| schema_store->GetDebugInfo()); | |
| SchemaDebugInfoProto expected_out; | |
| expected_out.set_crc(0); | |
| EXPECT_THAT(out, EqualsProto(expected_out)); | |
| } | |
| TEST_F(SchemaStoreTest, InitializeRegenerateDerivedFilesFailure) { | |
| // This test covers the first point that RegenerateDerivedFiles could fail. | |
| // This should simply result in SetSchema::Create returning an INTERNAL error. | |
| { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = SchemaBuilder() | |
| .AddType(SchemaTypeConfigBuilder().SetType("Type")) | |
| .Build(); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| std::move(schema), /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| } | |
| auto mock_filesystem = std::make_unique<MockFilesystem>(); | |
| ON_CALL(*mock_filesystem, | |
| CreateDirectoryRecursively(HasSubstr("key_mapper_dir"))) | |
| .WillByDefault(Return(false)); | |
| { | |
| EXPECT_THAT(SchemaStore::Create(mock_filesystem.get(), schema_store_dir_, | |
| &fake_clock_), | |
| StatusIs(libtextclassifier3::StatusCode::INTERNAL)); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, SetSchemaRegenerateDerivedFilesFailure) { | |
| // This test covers the second point that RegenerateDerivedFiles could fail. | |
| // If handled correctly, the schema store and section manager should still be | |
| // in the original, valid state. | |
| SchemaTypeConfigProto type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Type") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("intProp1") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("stringProp1") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaProto schema = SchemaBuilder().AddType(type).Build(); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| std::move(schema), /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| } | |
| { | |
| auto mock_filesystem = std::make_unique<MockFilesystem>(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(mock_filesystem.get(), schema_store_dir_, | |
| &fake_clock_)); | |
| ON_CALL(*mock_filesystem, | |
| CreateDirectoryRecursively(HasSubstr("key_mapper_dir"))) | |
| .WillByDefault(Return(false)); | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType(type) | |
| .AddType(SchemaTypeConfigBuilder().SetType("Type2")) | |
| .Build(); | |
| EXPECT_THAT( | |
| schema_store->SetSchema(std::move(schema), | |
| /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| StatusIs(libtextclassifier3::StatusCode::INTERNAL)); | |
| DocumentProto document = | |
| DocumentBuilder() | |
| .SetSchema("Type") | |
| .AddInt64Property("intProp1", 1, 2, 3) | |
| .AddStringProperty("stringProp1", "foo bar baz") | |
| .Build(); | |
| SectionMetadata expected_int_prop1_metadata( | |
| /*id_in=*/0, TYPE_INT64, TOKENIZER_NONE, TERM_MATCH_UNKNOWN, | |
| NUMERIC_MATCH_RANGE, "intProp1"); | |
| SectionMetadata expected_string_prop1_metadata( | |
| /*id_in=*/1, TYPE_STRING, TOKENIZER_PLAIN, TERM_MATCH_EXACT, | |
| NUMERIC_MATCH_UNKNOWN, "stringProp1"); | |
| ICING_ASSERT_OK_AND_ASSIGN(SectionGroup section_group, | |
| schema_store->ExtractSections(document)); | |
| ASSERT_THAT(section_group.string_sections, SizeIs(1)); | |
| EXPECT_THAT(section_group.string_sections.at(0).metadata, | |
| Eq(expected_string_prop1_metadata)); | |
| EXPECT_THAT(section_group.string_sections.at(0).content, | |
| ElementsAre("foo bar baz")); | |
| ASSERT_THAT(section_group.integer_sections, SizeIs(1)); | |
| EXPECT_THAT(section_group.integer_sections.at(0).metadata, | |
| Eq(expected_int_prop1_metadata)); | |
| EXPECT_THAT(section_group.integer_sections.at(0).content, | |
| ElementsAre(1, 2, 3)); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, CanCheckForPropertiesDefinedInSchema) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Set it for the first time | |
| SchemaStore::SetSchemaResult result; | |
| result.success = true; | |
| result.schema_types_new_by_name.insert(schema_.types(0).schema_type()); | |
| // Don't use schema_ defined in the test suite, as we want to make sure that | |
| // the test is written correctly without referring to what the suite has | |
| // defined. | |
| SchemaProto schema = | |
| SchemaBuilder() | |
| .AddType( | |
| SchemaTypeConfigBuilder() | |
| .SetType("email") | |
| .AddProperty( | |
| // Add an indexed property so we generate | |
| // section metadata on it | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_OPTIONAL))) | |
| .Build(); | |
| EXPECT_THAT(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false), | |
| IsOkAndHolds(EqualsSetSchemaResult(result))); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId schema_id, | |
| schema_store->GetSchemaTypeId("email")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(schema_id, "subject")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(schema_id, "timestamp")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema(schema_id, "foobar")); | |
| } | |
| TEST_F(SchemaStoreTest, GetSchemaTypeIdsWithChildren) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Create a schema with the following inheritance relation: | |
| // A | |
| // / \ | |
| // B E | |
| // / \ | |
| // C D | |
| // | | |
| // F | |
| SchemaTypeConfigProto type_a = SchemaTypeConfigBuilder().SetType("A").Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder().SetType("B").AddParentType("A").Build(); | |
| SchemaTypeConfigProto type_c = | |
| SchemaTypeConfigBuilder().SetType("C").AddParentType("B").Build(); | |
| SchemaTypeConfigProto type_d = | |
| SchemaTypeConfigBuilder().SetType("D").AddParentType("B").Build(); | |
| SchemaTypeConfigProto type_e = | |
| SchemaTypeConfigBuilder().SetType("E").AddParentType("A").Build(); | |
| SchemaTypeConfigProto type_f = | |
| SchemaTypeConfigBuilder().SetType("F").AddParentType("D").Build(); | |
| SchemaProto schema = SchemaBuilder() | |
| .AddType(type_a) | |
| .AddType(type_b) | |
| .AddType(type_c) | |
| .AddType(type_d) | |
| .AddType(type_e) | |
| .AddType(type_f) | |
| .Build(); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // Get schema type id for each type. | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_a_id, | |
| schema_store->GetSchemaTypeId("A")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_b_id, | |
| schema_store->GetSchemaTypeId("B")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_c_id, | |
| schema_store->GetSchemaTypeId("C")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_d_id, | |
| schema_store->GetSchemaTypeId("D")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_e_id, | |
| schema_store->GetSchemaTypeId("E")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_f_id, | |
| schema_store->GetSchemaTypeId("F")); | |
| // Check the results from GetSchemaTypeIdsWithChildren | |
| EXPECT_THAT( | |
| schema_store->GetSchemaTypeIdsWithChildren("A"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre( | |
| type_a_id, type_b_id, type_c_id, type_d_id, type_e_id, type_f_id)))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeIdsWithChildren("B"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre( | |
| type_b_id, type_c_id, type_d_id, type_f_id)))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeIdsWithChildren("C"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre(type_c_id)))); | |
| EXPECT_THAT( | |
| schema_store->GetSchemaTypeIdsWithChildren("D"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre(type_d_id, type_f_id)))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeIdsWithChildren("E"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre(type_e_id)))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeIdsWithChildren("F"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre(type_f_id)))); | |
| } | |
| TEST_F(SchemaStoreTest, DiamondGetSchemaTypeIdsWithChildren) { | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| // Create a schema with the following inheritance relation: | |
| // A | |
| // / \ | |
| // B E | |
| // / \ / | |
| // C D | |
| // \ / | |
| // F | |
| SchemaTypeConfigProto type_a = SchemaTypeConfigBuilder().SetType("A").Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder().SetType("B").AddParentType("A").Build(); | |
| SchemaTypeConfigProto type_c = | |
| SchemaTypeConfigBuilder().SetType("C").AddParentType("B").Build(); | |
| SchemaTypeConfigProto type_d = SchemaTypeConfigBuilder() | |
| .SetType("D") | |
| .AddParentType("B") | |
| .AddParentType("E") | |
| .Build(); | |
| SchemaTypeConfigProto type_e = | |
| SchemaTypeConfigBuilder().SetType("E").AddParentType("A").Build(); | |
| SchemaTypeConfigProto type_f = SchemaTypeConfigBuilder() | |
| .SetType("F") | |
| .AddParentType("C") | |
| .AddParentType("D") | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder() | |
| .AddType(type_a) | |
| .AddType(type_b) | |
| .AddType(type_c) | |
| .AddType(type_d) | |
| .AddType(type_e) | |
| .AddType(type_f) | |
| .Build(); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| // Get schema type id for each type. | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_a_id, | |
| schema_store->GetSchemaTypeId("A")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_b_id, | |
| schema_store->GetSchemaTypeId("B")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_c_id, | |
| schema_store->GetSchemaTypeId("C")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_d_id, | |
| schema_store->GetSchemaTypeId("D")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_e_id, | |
| schema_store->GetSchemaTypeId("E")); | |
| ICING_ASSERT_OK_AND_ASSIGN(SchemaTypeId type_f_id, | |
| schema_store->GetSchemaTypeId("F")); | |
| // Check the results from GetSchemaTypeIdsWithChildren | |
| EXPECT_THAT( | |
| schema_store->GetSchemaTypeIdsWithChildren("A"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre( | |
| type_a_id, type_b_id, type_c_id, type_d_id, type_e_id, type_f_id)))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeIdsWithChildren("B"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre( | |
| type_b_id, type_c_id, type_d_id, type_f_id)))); | |
| EXPECT_THAT( | |
| schema_store->GetSchemaTypeIdsWithChildren("C"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre(type_c_id, type_f_id)))); | |
| EXPECT_THAT( | |
| schema_store->GetSchemaTypeIdsWithChildren("D"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre(type_d_id, type_f_id)))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeIdsWithChildren("E"), | |
| IsOkAndHolds(Pointee( | |
| UnorderedElementsAre(type_e_id, type_d_id, type_f_id)))); | |
| EXPECT_THAT(schema_store->GetSchemaTypeIdsWithChildren("F"), | |
| IsOkAndHolds(Pointee(UnorderedElementsAre(type_f_id)))); | |
| } | |
| TEST_F(SchemaStoreTest, IndexableFieldsAreDefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("senderQualifiedId") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("recipients") | |
| .SetDataTypeString(TERM_MATCH_EXACT, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REPEATED)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("recipientIds") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REPEATED)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(email_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeEmailSchemaId = 0; | |
| // Indexables. | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, "subject")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "senderQualifiedId")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "recipients")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "recipientIds")); | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, "timestamp")); | |
| } | |
| TEST_F(SchemaStoreTest, JoinableFieldsAreDefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("tagQualifiedId") | |
| .SetDataType(TYPE_STRING) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("senderQualifiedId") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(email_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeEmailSchemaId = 0; | |
| // Joinables. | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "tagQualifiedId")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "senderQualifiedId")); | |
| } | |
| TEST_F(SchemaStoreTest, NonIndexableFieldsAreDefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("text") | |
| .SetDataTypeString(TERM_MATCH_UNKNOWN, TOKENIZER_NONE) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("attachment") | |
| .SetDataType(TYPE_BYTES) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("nonindexableInteger") | |
| .SetDataType(TYPE_INT64) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(email_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeEmailSchemaId = 0; | |
| // Non-indexables. | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "attachment")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "nonindexableInteger")); | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, "text")); | |
| } | |
| TEST_F(SchemaStoreTest, NonExistentFieldsAreUndefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("senderQualifiedId") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("nonindexableInteger") | |
| .SetDataType(TYPE_INT64) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(email_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeEmailSchemaId = 0; | |
| // Non-existents. | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, "foobar")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, | |
| "timestamp.foo")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeEmailSchemaId, "time")); | |
| } | |
| TEST_F(SchemaStoreTest, NestedIndexableFieldsAreDefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("tagQualifiedId") | |
| .SetDataType(TYPE_STRING) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("text") | |
| .SetDataTypeString(TERM_MATCH_UNKNOWN, TOKENIZER_NONE) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaTypeConfigProto conversation_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Conversation") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("emails") | |
| .SetDataTypeDocument( | |
| "Email", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("nestedNonIndexable") | |
| .SetDataTypeDocument("Email", | |
| /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = | |
| SchemaBuilder().AddType(email_type).AddType(conversation_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeConversationSchemaId = 1; | |
| // Indexables. | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeConversationSchemaId, | |
| "emails.subject")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeConversationSchemaId, | |
| "emails.timestamp")); | |
| } | |
| TEST_F(SchemaStoreTest, NestedJoinableFieldsAreDefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("tagQualifiedId") | |
| .SetDataType(TYPE_STRING) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("text") | |
| .SetDataTypeString(TERM_MATCH_UNKNOWN, TOKENIZER_NONE) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaTypeConfigProto conversation_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Conversation") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("emails") | |
| .SetDataTypeDocument( | |
| "Email", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("nestedNonIndexable") | |
| .SetDataTypeDocument("Email", | |
| /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = | |
| SchemaBuilder().AddType(email_type).AddType(conversation_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeConversationSchemaId = 1; | |
| // Joinables. | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeConversationSchemaId, | |
| "emails.tagQualifiedId")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "nestedNonIndexable.tagQualifiedId")); | |
| } | |
| TEST_F(SchemaStoreTest, NestedNonIndexableFieldsAreDefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("tagQualifiedId") | |
| .SetDataType(TYPE_STRING) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("text") | |
| .SetDataTypeString(TERM_MATCH_UNKNOWN, TOKENIZER_NONE) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaTypeConfigProto conversation_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Conversation") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("emails") | |
| .SetDataTypeDocument( | |
| "Email", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("nestedNonIndexable") | |
| .SetDataTypeDocument("Email", | |
| /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = | |
| SchemaBuilder().AddType(email_type).AddType(conversation_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeConversationSchemaId = 1; | |
| // Non-indexables. | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeConversationSchemaId, | |
| "emails.text")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "nestedNonIndexable.subject")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "nestedNonIndexable.text")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "nestedNonIndexable.timestamp")); | |
| } | |
| TEST_F(SchemaStoreTest, NestedNonExistentFieldsAreUndefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("tagQualifiedId") | |
| .SetDataType(TYPE_STRING) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("text") | |
| .SetDataTypeString(TERM_MATCH_UNKNOWN, TOKENIZER_NONE) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaTypeConfigProto conversation_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Conversation") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("emails") | |
| .SetDataTypeDocument( | |
| "Email", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("nestedNonIndexable") | |
| .SetDataTypeDocument("Email", | |
| /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = | |
| SchemaBuilder().AddType(email_type).AddType(conversation_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeConversationSchemaId = 1; | |
| // Non-existents. | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "emails.foobar")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "nestedNonIndexable.foobar")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "emails.timestamp.foo")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema( | |
| kTypeConversationSchemaId, "emails.time")); | |
| } | |
| TEST_F(SchemaStoreTest, IntermediateDocumentPropertiesAreDefined) { | |
| SchemaTypeConfigProto email_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Email") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("tagQualifiedId") | |
| .SetDataType(TYPE_STRING) | |
| .SetJoinable(JOINABLE_VALUE_TYPE_QUALIFIED_ID, | |
| /*propagate_delete=*/true) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("text") | |
| .SetDataTypeString(TERM_MATCH_UNKNOWN, TOKENIZER_NONE) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("timestamp") | |
| .SetDataTypeInt64(NUMERIC_MATCH_RANGE) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .Build(); | |
| SchemaTypeConfigProto conversation_type = | |
| SchemaTypeConfigBuilder() | |
| .SetType("Conversation") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("emails") | |
| .SetDataTypeDocument( | |
| "Email", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("nestedNonIndexable") | |
| .SetDataTypeDocument("Email", | |
| /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = | |
| SchemaBuilder().AddType(email_type).AddType(conversation_type).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeConversationSchemaId = 1; | |
| // Intermediate documents props. | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeConversationSchemaId, | |
| "emails")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeConversationSchemaId, | |
| "nestedNonIndexable")); | |
| } | |
| TEST_F(SchemaStoreTest, CyclePathsAreDefined) { | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("A") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("b") | |
| .SetDataTypeDocument("B", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("B") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("body") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("a") | |
| .SetDataTypeDocument("A", /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeASchemaId = 0; | |
| constexpr SchemaTypeId kTypeBSchemaId = 1; | |
| // A's top-level properties | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "subject")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b")); | |
| // A's nested properties in B | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.body")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.a")); | |
| // A's nested properties in B's nested property in A | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.a.subject")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.a.b")); | |
| // B's top-level properties | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "body")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a")); | |
| // B's nested properties in A | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.subject")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.b")); | |
| // B's nested properties in A's nested property in B | |
| EXPECT_TRUE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.b.body")); | |
| EXPECT_TRUE(schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.b.a")); | |
| } | |
| TEST_F(SchemaStoreTest, WrongTypeCyclePathsAreUndefined) { | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("A") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("b") | |
| .SetDataTypeDocument("B", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("B") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("body") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("a") | |
| .SetDataTypeDocument("A", /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeASchemaId = 0; | |
| constexpr SchemaTypeId kTypeBSchemaId = 1; | |
| // The same paths as above, but we check the wrong types instead. | |
| // A's top-level properties | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "subject")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "b")); | |
| // A's nested properties in B | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "b.body")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "b.a")); | |
| // A's nested properties in B's nested property in A | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "b.a.subject")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "b.a.b")); | |
| // B's top-level properties | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "body")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "a")); | |
| // B's nested properties in A | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "a.subject")); | |
| EXPECT_FALSE(schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "a.b")); | |
| // B's nested properties in A's nested property in B | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "a.b.body")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "a.b.a")); | |
| } | |
| TEST_F(SchemaStoreTest, CyclePathsNonexistentPropertiesAreUndefined) { | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("A") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("subject") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("b") | |
| .SetDataTypeDocument("B", /*index_nested_properties=*/true) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("B") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("body") | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN) | |
| .SetCardinality(CARDINALITY_REQUIRED)) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("a") | |
| .SetDataTypeDocument("A", /*index_nested_properties=*/false) | |
| .SetCardinality(CARDINALITY_OPTIONAL)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/true)); | |
| constexpr SchemaTypeId kTypeASchemaId = 0; | |
| constexpr SchemaTypeId kTypeBSchemaId = 1; | |
| // Undefined paths in A | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.subject")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.a.body")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.a.a")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeASchemaId, "b.a.subject.b")); | |
| // Undefined paths in B | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.body")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.b.subject")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.b.b")); | |
| EXPECT_FALSE( | |
| schema_store->IsPropertyDefinedInSchema(kTypeBSchemaId, "a.b.body.a")); | |
| } | |
| TEST_F(SchemaStoreTest, LoadsOverlaySchemaOnInit) { | |
| // Create a schema that is rollback incompatible and will trigger us to create | |
| // an overlay schema. | |
| PropertyConfigBuilder indexed_string_property_builder = | |
| PropertyConfigBuilder() | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN); | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_b") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| // The overlay should exist | |
| std::string overlay_schema_path = schema_store_dir_ + "/overlay_schema.pb"; | |
| ASSERT_TRUE(filesystem_.FileExists(overlay_schema_path.c_str())); | |
| // The base schema should hold a compatible schema | |
| SchemaTypeConfigProto modified_type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataType(TYPE_STRING)) | |
| .Build(); | |
| SchemaProto expected_base_schema = | |
| SchemaBuilder().AddType(modified_type_a).AddType(type_b).Build(); | |
| std::string base_schema_path = schema_store_dir_ + "/schema.pb"; | |
| auto base_schema_file_ = std::make_unique<FileBackedProto<SchemaProto>>( | |
| filesystem_, base_schema_path); | |
| ICING_ASSERT_OK_AND_ASSIGN(const SchemaProto* base_schema, | |
| base_schema_file_->Read()); | |
| EXPECT_THAT(*base_schema, EqualsProto(expected_base_schema)); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, LoadsBaseSchemaWithNoOverlayOnInit) { | |
| // Create a normal schema that won't require an overlay. | |
| PropertyConfigBuilder indexed_string_property_builder = | |
| PropertyConfigBuilder() | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN); | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_b") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| { | |
| // Create a new instance of the schema store and check that the same schema | |
| // is present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| // Additionally, the overlay should not exist | |
| std::string overlay_schema_path = schema_store_dir_ + "/overlay_schema.pb"; | |
| ASSERT_FALSE(filesystem_.FileExists(overlay_schema_path.c_str())); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, LoadSchemaBackupSchemaMissing) { | |
| // Create a schema that is rollback incompatible and will trigger us to create | |
| // a backup schema. | |
| PropertyConfigBuilder indexed_string_property_builder = | |
| PropertyConfigBuilder() | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN); | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_b") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Delete the backup schema. | |
| std::string backup_schema_path = schema_store_dir_ + "/schema.pb"; | |
| ASSERT_TRUE(filesystem_.DeleteFile(backup_schema_path.c_str())); | |
| { | |
| // Create a new instance of the schema store and check that it fails because | |
| // the backup schema is not available. | |
| EXPECT_THAT( | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_), | |
| StatusIs(libtextclassifier3::StatusCode::INTERNAL)); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, LoadSchemaOverlaySchemaMissing) { | |
| // Create a schema that is rollback incompatible and will trigger us to create | |
| // a backup schema. | |
| PropertyConfigBuilder indexed_string_property_builder = | |
| PropertyConfigBuilder() | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN); | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_b") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Delete the overlay schema. | |
| std::string overlay_schema_path = schema_store_dir_ + "/overlay_schema.pb"; | |
| ASSERT_TRUE(filesystem_.DeleteFile(overlay_schema_path.c_str())); | |
| { | |
| // Create a new instance of the schema store and check that it fails because | |
| // the overlay schema is not available when we expected it to be. | |
| EXPECT_THAT( | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_), | |
| StatusIs(libtextclassifier3::StatusCode::INTERNAL)); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, LoadSchemaHeaderMissing) { | |
| // Create a schema that is rollback incompatible and will trigger us to create | |
| // a backup schema. | |
| PropertyConfigBuilder indexed_string_property_builder = | |
| PropertyConfigBuilder() | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN); | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_b") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Delete the overlay schema. | |
| std::string schema_header_path = schema_store_dir_ + "/schema_store_header"; | |
| ASSERT_TRUE(filesystem_.DeleteFile(schema_header_path.c_str())); | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| EXPECT_THAT( | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_), | |
| StatusIs(libtextclassifier3::StatusCode::INTERNAL)); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, LoadSchemaNoOverlayHeaderMissing) { | |
| // Create a normal schema that won't require a backup. | |
| PropertyConfigBuilder indexed_string_property_builder = | |
| PropertyConfigBuilder() | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN); | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN)) | |
| .Build(); | |
| SchemaTypeConfigProto type_b = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_b") | |
| .AddProperty(indexed_string_property_builder.SetName("prop0")) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).AddType(type_b).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Delete the schema header. | |
| std::string schema_header_path = schema_store_dir_ + "/schema_store_header"; | |
| ASSERT_TRUE(filesystem_.DeleteFile(schema_header_path.c_str())); | |
| { | |
| // Create a new instance of the schema store and check that it fails because | |
| // the schema header (which is now a part of the ground truth) is not | |
| // available. | |
| EXPECT_THAT( | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_), | |
| StatusIs(libtextclassifier3::StatusCode::INTERNAL)); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, MigrateSchemaCompatibleNoChange) { | |
| // Create a schema that is rollback incompatible and will trigger us to create | |
| // a backup schema. | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kCompatible, | |
| version_util::kVersion)); | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, MigrateSchemaUpgradeNoChange) { | |
| // Create a schema that is rollback incompatible and will trigger us to create | |
| // a backup schema. | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kUpgrade, | |
| version_util::kVersion + 1)); | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, MigrateSchemaVersionZeroUpgradeNoChange) { | |
| // Because we are upgrading from version zero, the schema must be compatible | |
| // with version zero. | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_PLAIN)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| ICING_EXPECT_OK( | |
| SchemaStore::MigrateSchema(&filesystem_, schema_store_dir_, | |
| version_util::StateChange::kVersionZeroUpgrade, | |
| version_util::kVersion + 1)); | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, | |
| MigrateSchemaRollbackDiscardsIncompatibleOverlaySchema) { | |
| // Because we are upgrading from version zero, the schema must be compatible | |
| // with version zero. | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Rollback to a version before kVersionOne. The schema header will declare | |
| // that the overlay is compatible with any version starting with kVersionOne. | |
| // So kVersionOne - 1 is incompatible and will throw out the schema. | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kRollBack, | |
| version_util::kVersionOne - 1)); | |
| { | |
| // Create a new of the schema store and check that we fell back to the | |
| // base schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| SchemaTypeConfigProto other_type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataType(TYPE_STRING)) | |
| .Build(); | |
| SchemaProto base_schema = SchemaBuilder().AddType(other_type_a).Build(); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(base_schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, MigrateSchemaRollbackKeepsCompatibleOverlaySchema) { | |
| // Because we are upgrading from version zero, the schema must be compatible | |
| // with version zero. | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Rollback to kVersion. The schema header will declare that the overlay is | |
| // compatible with any version starting with kVersion. So we will be | |
| // compatible and retain the overlay schema. | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kRollBack, | |
| version_util::kVersion)); | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, MigrateSchemaRollforwardRetainsBaseSchema) { | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Rollback to a version before kVersionOne. The schema header will declare | |
| // that the overlay is compatible with any version starting with kVersionOne. | |
| // So kVersionOne - 1 is incompatible and will throw out the schema. | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kRollBack, | |
| version_util::kVersionOne - 1)); | |
| SchemaTypeConfigProto other_type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataType(TYPE_STRING)) | |
| .Build(); | |
| SchemaProto base_schema = SchemaBuilder().AddType(other_type_a).Build(); | |
| { | |
| // Create a new of the schema store and check that we fell back to the | |
| // base schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(base_schema)))); | |
| } | |
| // Now rollforward to a new version. This should accept whatever schema is | |
| // present (currently base schema) | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kRollForward, | |
| version_util::kVersion)); | |
| { | |
| // Create a new of the schema store and check that we fell back to the | |
| // base schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(base_schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, MigrateSchemaRollforwardRetainsOverlaySchema) { | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Rollback to kVersion. The schema header will declare that the overlay is | |
| // compatible with any version starting with kVersion. So we will be | |
| // compatible and retain the overlay schema. | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kRollBack, | |
| version_util::kVersion)); | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // Now rollforward to a new version. This should accept whatever schema is | |
| // present (currently overlay schema) | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kRollForward, | |
| version_util::kVersion)); | |
| { | |
| // Create a new of the schema store and check that the same schema is | |
| // present. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, | |
| MigrateSchemaVersionZeroRollforwardDiscardsOverlaySchema) { | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // A VersionZeroRollforward will always discard the overlay schema because it | |
| // could be stale. | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, | |
| version_util::StateChange::kVersionZeroRollForward, | |
| version_util::kVersion)); | |
| SchemaTypeConfigProto other_type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataType(TYPE_STRING)) | |
| .Build(); | |
| SchemaProto base_schema = SchemaBuilder().AddType(other_type_a).Build(); | |
| { | |
| // Create a new of the schema store and check that we fell back to the | |
| // base schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(base_schema)))); | |
| } | |
| } | |
| TEST_F(SchemaStoreTest, MigrateSchemaVersionUndeterminedDiscardsOverlaySchema) { | |
| SchemaTypeConfigProto type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty( | |
| PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataTypeString(TERM_MATCH_PREFIX, TOKENIZER_RFC822)) | |
| .Build(); | |
| SchemaProto schema = SchemaBuilder().AddType(type_a).Build(); | |
| { | |
| // Create an instance of the schema store and set the schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| ICING_ASSERT_OK(schema_store->SetSchema( | |
| schema, /*ignore_errors_and_delete_documents=*/false, | |
| /*allow_circular_schema_definitions=*/false)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(schema)))); | |
| } | |
| // An Undetermined will always discard the overlay schema because it doesn't | |
| // know which state we're in and so it fallback to the base schema because | |
| // it should always be valid. | |
| ICING_EXPECT_OK(SchemaStore::MigrateSchema( | |
| &filesystem_, schema_store_dir_, version_util::StateChange::kUndetermined, | |
| version_util::kVersion)); | |
| SchemaTypeConfigProto other_type_a = | |
| SchemaTypeConfigBuilder() | |
| .SetType("type_a") | |
| .AddProperty(PropertyConfigBuilder() | |
| .SetName("propRfc") | |
| .SetCardinality(CARDINALITY_OPTIONAL) | |
| .SetDataType(TYPE_STRING)) | |
| .Build(); | |
| SchemaProto base_schema = SchemaBuilder().AddType(other_type_a).Build(); | |
| { | |
| // Create a new of the schema store and check that we fell back to the | |
| // base schema. | |
| ICING_ASSERT_OK_AND_ASSIGN( | |
| std::unique_ptr<SchemaStore> schema_store, | |
| SchemaStore::Create(&filesystem_, schema_store_dir_, &fake_clock_)); | |
| EXPECT_THAT(schema_store->GetSchema(), | |
| IsOkAndHolds(Pointee(EqualsProto(base_schema)))); | |
| } | |
| } | |
| } // namespace | |
| } // namespace lib | |
| } // namespace icing |