diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h index d662ba57899..a8c96b51552 100644 --- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h +++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h @@ -117,11 +117,27 @@ public: .template valueWithTransaction(&typeId, name); } - TypeId fetchTypeIdByQualifiedNameAndVersion(Utils::SmallStringView name, - Storage::Version version = Storage::Version{}) + TypeId fetchTypeIdByExportedName(Utils::SmallStringView name) const { - return selectTypeIdByQualifiedNameStatement.template valueWithTransaction( - name, version.major.version, version.minor.version); + return selectTypeIdByExportedNameStatement.template valueWithTransaction(name); + } + + TypeId fetchTypeIdByImportIdsAndExportedName(const ImportIds &importsIds, + Utils::SmallStringView name) const + { + std::vector ids; + ids.resize(importsIds.size()); + + std::memcpy(ids.data(), importsIds.data(), ids.size() * sizeof(ImportId::DatabaseType)); + + return selectTypeIdByImportIdsAndExportedNameStatement + .template valueWithTransaction(Utils::span{ids}, name); + } + + TypeId fetchTypeIdByName(ImportId importId, Utils::SmallStringView name) + { + return selectTypeIdByImportIdAndNameStatement.template valueWithTransaction(&importId, + name); } Storage::Type fetchTypeByTypeId(TypeId typeId) @@ -443,12 +459,9 @@ private: selectTypeIdsForImportIdStatement.readCallback(callback, &importId); } - void upsertExportedType(Utils::SmallStringView qualifiedName, Storage::Version version, TypeId typeId) + void upsertExportedType(ImportId importId, Utils::SmallStringView name, TypeId typeId) { - upsertExportedTypesStatement.write(qualifiedName, - version.major.version, - version.minor.version, - &typeId); + upsertExportedTypesStatement.write(&importId, name, &typeId); } void synchronizePropertyDeclarations(TypeId typeId, @@ -469,7 +482,7 @@ private: }; auto insert = [&](const Storage::PropertyDeclaration &value) { - auto propertyTypeId = fetchTypeIdByName(value.typeName); + auto propertyTypeId = fetchTypeIdByNameUngarded(value.typeName); insertPropertyDeclarationStatement.write(&typeId, value.name, @@ -479,7 +492,7 @@ private: auto update = [&](const Storage::PropertyDeclarationView &view, const Storage::PropertyDeclaration &value) { - auto propertyTypeId = fetchTypeIdByName(value.typeName); + auto propertyTypeId = fetchTypeIdByNameUngarded(value.typeName); if (view.traits == value.traits && propertyTypeId == view.typeId) return; @@ -680,12 +693,12 @@ private: { auto typeId = type.typeId; - auto prototypeId = fetchTypeIdByName(type.prototype); + auto prototypeId = fetchTypeIdByNameUngarded(type.prototype); updatePrototypeStatement.write(&typeId, &prototypeId); for (const auto &exportedType : type.exportedTypes) - upsertExportedType(exportedType.qualifiedTypeName, exportedType.version, typeId); + upsertExportedType(type.importId, exportedType.qualifiedTypeName, typeId); synchronizePropertyDeclarations(typeId, type.propertyDeclarations); synchronizeFunctionDeclarations(typeId, type.functionDeclarations); @@ -693,7 +706,7 @@ private: synchronizeEnumerationDeclarations(typeId, type.enumerationDeclarations); } - TypeId fetchTypeIdByName(Utils::SmallStringView name) + TypeId fetchTypeIdByNameUngarded(Utils::SmallStringView name) { if (name.isEmpty()) return TypeId{}; @@ -901,12 +914,11 @@ private: table.setUseIfNotExists(true); table.setUseWithoutRowId(true); table.setName("exportedTypes"); - auto &qualifiedNameColumn = table.addColumn("qualifiedName"); + auto &importIdColumn = table.addColumn("importId"); + auto &nameColumn = table.addColumn("name"); table.addColumn("typeId"); - auto &majorVersionColumn = table.addColumn("majorVersion"); - auto &minorVersionColumn = table.addColumn("minorVersion"); - table.addPrimaryKeyContraint({qualifiedNameColumn, majorVersionColumn, minorVersionColumn}); + table.addPrimaryKeyContraint({importIdColumn, nameColumn}); table.initialize(database); } @@ -1002,10 +1014,8 @@ public: database}; WriteStatement updatePrototypeStatement{ "UPDATE types SET prototypeId=nullif(?2, -1) WHERE typeId=?1", database}; - mutable ReadStatement<1> selectTypeIdByQualifiedNameStatement{ - "SELECT typeId FROM exportedTypes WHERE qualifiedName=?1 AND majorVersion=?2 AND " - "minorVersion<=?3 ORDER BY minorVersion DESC LIMIT 1", - database}; + mutable ReadStatement<1> selectTypeIdByExportedNameStatement{ + "SELECT typeId FROM exportedTypes WHERE name=?1", database}; mutable ReadStatement<1> selectPrototypeIdStatement{ "WITH RECURSIVE " " typeSelection(typeId) AS (" @@ -1029,12 +1039,9 @@ public: "SELECT propertyDeclarationId FROM propertyDeclarations JOIN typeSelection USING(typeId) " " WHERE name=?2 LIMIT 1", database}; - WriteStatement upsertExportedTypesStatement{ - "INSERT INTO exportedTypes(qualifiedName, majorVersion, minorVersion, typeId) VALUES(?1, " - "?2, ?3, ?4) ON CONFLICT DO NOTHING", - database}; - mutable ReadStatement<1> selectAccessSemanticsStatement{ - "SELECT typeId FROM exportedTypes WHERE qualifiedName=?", database}; + WriteStatement upsertExportedTypesStatement{"INSERT INTO exportedTypes(importId, name, typeId) " + "VALUES(?1, ?2, ?3) ON CONFLICT DO NOTHING", + database}; mutable ReadStatement<1> selectPrototypeIdsStatement{ "WITH RECURSIVE " " typeSelection(typeId) AS (" @@ -1067,9 +1074,8 @@ public: "SELECT importId, name, (SELECT name FROM types WHERE typeId=outerTypes.prototypeId), " "accessSemantics, ifnull(sourceId, -1) FROM types AS outerTypes WHERE typeId=?", database}; - mutable ReadStatement<3> selectExportedTypesByTypeIdStatement{ - "SELECT qualifiedName, majorVersion, minorVersion FROM exportedTypes WHERE typeId=?", - database}; + mutable ReadStatement<1> selectExportedTypesByTypeIdStatement{ + "SELECT name FROM exportedTypes WHERE typeId=?", database}; mutable ReadStatement<6> selectTypesStatement{ "SELECT importId, name, typeId, (SELECT name FROM types WHERE " "typeId=outerTypes.prototypeId), accessSemantics, ifnull(sourceId, -1) FROM types AS " @@ -1195,6 +1201,10 @@ public: database}; mutable ReadStatement<1> selectTypeIdsForImportIdStatement{ "SELECT typeId FROM types WHERE importId=?", database}; + mutable ReadStatement<1> selectTypeIdByImportIdAndNameStatement{ + "SELECT typeId FROM types WHERE importId=?1 and name=?2", database}; + mutable ReadStatement<1> selectTypeIdByImportIdsAndExportedNameStatement{ + "SELECT typeId FROM exportedTypes WHERE importId IN carray(?1) AND name=?2", database}; }; } // namespace QmlDesigner diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h index d60966bdc8a..81e1309e5a6 100644 --- a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h +++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h @@ -105,19 +105,12 @@ class ExportedType { public: explicit ExportedType() = default; - explicit ExportedType(Utils::SmallStringView qualifiedTypeName, Version version = Version{}) + explicit ExportedType(Utils::SmallStringView qualifiedTypeName) : qualifiedTypeName{qualifiedTypeName} - , version{version} - {} - - explicit ExportedType(Utils::SmallStringView qualifiedTypeName, int majorVersion, int minorVersion) - : qualifiedTypeName{qualifiedTypeName} - , version{majorVersion, minorVersion} {} public: Utils::SmallString qualifiedTypeName; - Version version; }; using ExportedTypes = std::vector; diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp index 7f31d417b95..77bfdcf8a9d 100644 --- a/tests/unit/unittest/gtest-creator-printing.cpp +++ b/tests/unit/unittest/gtest-creator-printing.cpp @@ -1661,7 +1661,7 @@ std::ostream &operator<<(std::ostream &out, Version version) std::ostream &operator<<(std::ostream &out, const ExportedType &exportedType) { - return out << "(\"" << exportedType.qualifiedTypeName << "\", " << exportedType.version << ")"; + return out << "(\"" << exportedType.qualifiedTypeName << "\")"; } std::ostream &operator<<(std::ostream &out, const Type &type) diff --git a/tests/unit/unittest/projectstorage-test.cpp b/tests/unit/unittest/projectstorage-test.cpp index 3cfbac731cc..aee13112e0c 100644 --- a/tests/unit/unittest/projectstorage-test.cpp +++ b/tests/unit/unittest/projectstorage-test.cpp @@ -98,15 +98,14 @@ MATCHER_P4(IsStorageTypeWithInvalidSourceId, && type.accessSemantics == accessSemantics && !type.sourceId.isValid(); } -MATCHER_P2(IsExportedType, - qualifiedTypeName, - version, - std::string(negation ? "isn't " : "is ") - + PrintToString(Storage::ExportedType{qualifiedTypeName, version})) +MATCHER_P(IsExportedType, + qualifiedTypeName, + std::string(negation ? "isn't " : "is ") + + PrintToString(Storage::ExportedType{qualifiedTypeName})) { const Storage::ExportedType &type = arg; - return type.qualifiedTypeName == qualifiedTypeName && type.version == version; + return type.qualifiedTypeName == qualifiedTypeName; } MATCHER_P3(IsPropertyDeclaration, @@ -193,7 +192,7 @@ protected: NiceMock databaseMock; ProjectStorageMock storage{databaseMock, true}; ReadWriteStatement<1> &upsertTypeStatement = storage.upsertTypeStatement; - ReadStatement<1> &selectTypeIdByQualifiedNameStatement = storage.selectTypeIdByQualifiedNameStatement; + ReadStatement<1> &selectTypeIdByExportedNameStatement = storage.selectTypeIdByExportedNameStatement; ReadWriteStatement<1> &upsertPropertyDeclarationStatement = storage.upsertPropertyDeclarationStatement; ReadStatement<1> &selectPropertyDeclarationByTypeIdAndNameStatement = storage.selectPropertyDeclarationByTypeIdAndNameStatement; WriteStatement &upsertExportedTypesStatement = storage.upsertExportedTypesStatement; @@ -212,7 +211,7 @@ protected: ReadStatement<1> &selectSourceContextIdFromSourcesBySourceIdStatement = storage.selectSourceContextIdFromSourcesBySourceIdStatement; ReadStatement<1> &selectTypeIdByNameStatement = storage.selectTypeIdByNameStatement; ReadStatement<5> &selectTypeByTypeIdStatement = storage.selectTypeByTypeIdStatement; - ReadStatement<3> &selectExportedTypesByTypeIdStatement = storage.selectExportedTypesByTypeIdStatement; + ReadStatement<1> &selectExportedTypesByTypeIdStatement = storage.selectExportedTypesByTypeIdStatement; ReadStatement<6> &selectTypesStatement = storage.selectTypesStatement; }; @@ -477,8 +476,7 @@ protected: "QObject", TypeAccessSemantics::Reference, sourceId1, - {Storage::ExportedType{"Item", Storage::Version{5, 15}}, - Storage::ExportedType{"Item", Storage::Version{5, 1}}}, + {Storage::ExportedType{"Item"}}, {Storage::PropertyDeclaration{"data", "QObject", Storage::DeclarationTraits::IsList}, Storage::PropertyDeclaration{"children", "QQuickItem", @@ -508,8 +506,7 @@ protected: {}, TypeAccessSemantics::Reference, sourceId2, - {Storage::ExportedType{"Object", Storage::Version{5, 14}}, - Storage::ExportedType{"Object", Storage::Version{5, 1}}}}}; + {Storage::ExportedType{"Object"}, Storage::ExportedType{"Obj"}}}}; } auto createImports() @@ -773,12 +770,9 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsNewTypes) UnorderedElementsAre( AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))), + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))), AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), - IsExportedType("Item", Storage::Version{5, 15})))))); + Field(&Storage::Type::exportedTypes, UnorderedElementsAre(IsExportedType("Item")))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsNewTypesReverseOrder) @@ -793,12 +787,9 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsNewTypesReverseOrder) UnorderedElementsAre( AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))), + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))), AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), - IsExportedType("Item", Storage::Version{5, 15})))))); + Field(&Storage::Type::exportedTypes, UnorderedElementsAre(IsExportedType("Item")))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesTypeAccessSemantics) @@ -815,12 +806,9 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesTypeAccessSemantics) UnorderedElementsAre( AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Value, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))), + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))), AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Value, sourceId1), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), - IsExportedType("Item", Storage::Version{5, 15})))))); + Field(&Storage::Type::exportedTypes, UnorderedElementsAre(IsExportedType("Item")))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesSources) @@ -837,38 +825,9 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesSources) UnorderedElementsAre( AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId4), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))), + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))), AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId3), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), - IsExportedType("Item", Storage::Version{5, 15})))))); -} - -TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesTypes) -{ - Storage::Types types{createTypes()}; - storage.synchronizeTypes(types, {sourceId1, sourceId2}); - types[0].exportedTypes.push_back(Storage::ExportedType{"Item", Storage::Version{5, 19}}); - types[0].exportedTypes.push_back(Storage::ExportedType{"Item", Storage::Version{6, 1}}); - types[1].exportedTypes.push_back(Storage::ExportedType{"Object", Storage::Version{6, 1}}); - - storage.synchronizeTypes(types, {sourceId3, sourceId4}); - - ASSERT_THAT( - storage.fetchTypes(), - UnorderedElementsAre( - AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14}), - IsExportedType("Object", Storage::Version{6, 1})))), - AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), - IsExportedType("Item", Storage::Version{5, 15}), - IsExportedType("Item", Storage::Version{5, 19}), - IsExportedType("Item", Storage::Version{6, 1})))))); + Field(&Storage::Type::exportedTypes, UnorderedElementsAre(IsExportedType("Item")))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesInsertTypeIntoPrototypeChain) @@ -881,7 +840,7 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesInsertTypeIntoPrototypeChain) "QObject", TypeAccessSemantics::Reference, sourceId1, - {Storage::ExportedType{"Object", Storage::Version{5, 15}}}}); + {Storage::ExportedType{"Object"}}}); storage.synchronizeTypes(types, {sourceId1, sourceId2}); @@ -890,15 +849,11 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesInsertTypeIntoPrototypeChain) UnorderedElementsAre( AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))), + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))), AllOf(IsStorageType(importId2, "QQuickObject", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 15})))), + Field(&Storage::Type::exportedTypes, UnorderedElementsAre(IsExportedType("Object")))), AllOf(IsStorageType(importId2, "QQuickItem", "QQuickObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), - IsExportedType("Item", Storage::Version{5, 15})))))); + Field(&Storage::Type::exportedTypes, UnorderedElementsAre(IsExportedType("Item")))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesDontThrowsForMissingPrototype) @@ -909,7 +864,7 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesDontThrowsForMissingPrototype) "QObject", TypeAccessSemantics::Reference, sourceId1, - {Storage::ExportedType{"Item", Storage::Version{5, 15}}}}}; + {Storage::ExportedType{"Item"}}}}; ASSERT_NO_THROW(storage.synchronizeTypes(types, {sourceId1})); } @@ -921,7 +876,7 @@ TEST_F(ProjectStorageSlowTest, TypeWithInvalidSourceIdThrows) "", TypeAccessSemantics::Reference, SourceId{}, - {Storage::ExportedType{"Item", Storage::Version{5, 15}}}}}; + {Storage::ExportedType{"Item"}}}}; ASSERT_THROW(storage.synchronizeTypes(types, {}), QmlDesigner::TypeHasInvalidSourceId); } @@ -934,13 +889,11 @@ TEST_F(ProjectStorageSlowTest, DeleteTypeIfSourceIdIsSynchronized) storage.synchronizeTypes(types, {sourceId1, sourceId2}); - ASSERT_THAT( - storage.fetchTypes(), - UnorderedElementsAre( - AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))))); + ASSERT_THAT(storage.fetchTypes(), + UnorderedElementsAre(AllOf( + IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), + Field(&Storage::Type::exportedTypes, + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))))); } TEST_F(ProjectStorageSlowTest, DontDeleteTypeIfSourceIdIsNotSynchronized) @@ -956,12 +909,9 @@ TEST_F(ProjectStorageSlowTest, DontDeleteTypeIfSourceIdIsNotSynchronized) UnorderedElementsAre( AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))), + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))), AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), - IsExportedType("Item", Storage::Version{5, 15})))))); + Field(&Storage::Type::exportedTypes, UnorderedElementsAre(IsExportedType("Item")))))); } TEST_F(ProjectStorageSlowTest, BreakingPrototypeChainByDeletingBaseComponentThrows) @@ -1973,13 +1923,71 @@ TEST_F(ProjectStorageSlowTest, RemovingImportRemovesDependentTypesToo) imports.pop_back(); storage.synchronizeImports(imports); - ASSERT_THAT( - storage.fetchTypes(), - UnorderedElementsAre( - AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), - Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), - IsExportedType("Object", Storage::Version{5, 14})))))); + ASSERT_THAT(storage.fetchTypes(), + UnorderedElementsAre(AllOf( + IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), + Field(&Storage::Type::exportedTypes, + UnorderedElementsAre(IsExportedType("Object"), IsExportedType("Obj")))))); +} + +TEST_F(ProjectStorageSlowTest, FetchTypeIdByImportIdAndName) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + + auto typeId = storage.fetchTypeIdByName(importId1, "QObject"); + + ASSERT_THAT(storage.fetchTypeIdByExportedName("Object"), Eq(typeId)); +} + +TEST_F(ProjectStorageSlowTest, FetchTypeIdByExportedName) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + + auto typeId = storage.fetchTypeIdByExportedName("Object"); + + ASSERT_THAT(storage.fetchTypeIdByName(importId1, "QObject"), Eq(typeId)); +} + +TEST_F(ProjectStorageSlowTest, FetchTypeIdByImporIdsAndExportedName) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + + auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({importId1, importId2}, "Object"); + + ASSERT_THAT(storage.fetchTypeIdByName(importId1, "QObject"), Eq(typeId)); +} + +TEST_F(ProjectStorageSlowTest, FetchInvalidTypeIdByImporIdsAndExportedNameIfImportIdsAreEmpty) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + + auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({}, "Object"); + + ASSERT_FALSE(typeId.isValid()); +} + +TEST_F(ProjectStorageSlowTest, FetchInvalidTypeIdByImporIdsAndExportedNameIfImportIdsAreInvalid) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + + auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({ImportId{}}, "Object"); + + ASSERT_FALSE(typeId.isValid()); +} + +TEST_F(ProjectStorageSlowTest, FetchInvalidTypeIdByImporIdsAndExportedNameIfNotInImport) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + + auto typeId = storage.fetchTypeIdByImportIdsAndExportedName({importId2, importId3}, "Object"); + + ASSERT_FALSE(typeId.isValid()); } } // namespace