ClangPchManager: Expose more internals from BuildDependenciesProvider

We will need it later.

Change-Id: Ic2c85780bf965be8e4c8603fed365d806576fdc6
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

src/tools/clangpchmanagerbackend/source/builddependenciesprovider.cpp

@@ -54,22 +54,25 @@ OutputContainer setUnion(InputContainer1 &&input1,
 }
 
 BuildDependency BuildDependenciesProvider::create(const ProjectPartContainer &projectPart)
+{
+    return create(projectPart,
+                  createSourceEntriesFromStorage(projectPart.sourcePathIds, projectPart.projectPartId));
+}
+
+BuildDependency BuildDependenciesProvider::create(const ProjectPartContainer &projectPart,
+                                                  SourceEntries &&sourceEntries)
 {
     m_ensureAliveMessageIsSentCallback();
 
-    auto sourcesAndProjectPart = createSourceEntriesFromStorage(projectPart.sourcePathIds,
+    if (!m_modifiedTimeChecker.isUpToDate(sourceEntries)) {
-                                                                projectPart.projectPartId);
-
-    if (!m_modifiedTimeChecker.isUpToDate(sourcesAndProjectPart.first)) {
         BuildDependency buildDependency = m_generator.create(projectPart);
 
-        storeBuildDependency(buildDependency, sourcesAndProjectPart.second);
+        storeBuildDependency(buildDependency, projectPart.projectPartId);
 
         return buildDependency;
     }
 
-    return createBuildDependencyFromStorage(
+    return createBuildDependencyFromStorage(std::move(sourceEntries));
-        std::move(sourcesAndProjectPart.first));
 }
 
 BuildDependency BuildDependenciesProvider::createBuildDependencyFromStorage(
@@ -103,7 +106,7 @@ UsedMacros BuildDependenciesProvider::createUsedMacrosFromStorage(const SourceEn
     return usedMacros;
 }
 
-std::pair<SourceEntries, ProjectPartId> BuildDependenciesProvider::createSourceEntriesFromStorage(
+SourceEntries BuildDependenciesProvider::createSourceEntriesFromStorage(
     const FilePathIds &sourcePathIds, ProjectPartId projectPartId) const
 {
     SourceEntries includes;
@@ -119,7 +122,7 @@ std::pair<SourceEntries, ProjectPartId> BuildDependenciesProvider::createSourceE
 
     transaction.commit();
 
-    return {includes, projectPartId};
+    return includes;
 }
 
 void BuildDependenciesProvider::storeBuildDependency(const BuildDependency &buildDependency,

src/tools/clangpchmanagerbackend/source/builddependenciesprovider.h

@@ -52,17 +52,20 @@ public:
     {}
 
     BuildDependency create(const ProjectPartContainer &projectPart) override;
+    BuildDependency create(const ProjectPartContainer &projectPart,
+                           SourceEntries &&sourceEntries) override;
 
     void setEnsureAliveMessageIsSentCallback(std::function<void()> &&callback)
     {
         m_ensureAliveMessageIsSentCallback = std::move(callback);
     }
 
+    SourceEntries createSourceEntriesFromStorage(const FilePathIds &sourcePathIds,
+                                                 ProjectPartId projectPartId) const override;
+
 private:
     BuildDependency createBuildDependencyFromStorage(SourceEntries &&includes) const;
     UsedMacros createUsedMacrosFromStorage(const SourceEntries &includes) const;
-    std::pair<SourceEntries, ProjectPartId> createSourceEntriesFromStorage(
-        const FilePathIds &sourcePathIds, ProjectPartId projectPartId) const;
     void storeBuildDependency(const BuildDependency &buildDependency, ProjectPartId projectPartId);
 
 private:

src/tools/clangpchmanagerbackend/source/builddependenciesproviderinterface.h

@@ -35,6 +35,9 @@ class BuildDependenciesProviderInterface
 {
 public:
     virtual BuildDependency create(const ProjectPartContainer &projectPart) = 0;
+    virtual BuildDependency create(const ProjectPartContainer &projectPart, SourceEntries &&sourceEntries) = 0;
+    virtual SourceEntries createSourceEntriesFromStorage(const FilePathIds &sourcePathIds,
+                                                         ProjectPartId projectPartId) const = 0;
 
 protected:
     ~BuildDependenciesProviderInterface() = default;

tests/unit/unittest/builddependenciesprovider-test.cpp

@@ -176,13 +176,30 @@ TEST_F(BuildDependenciesProvider, CreateCallsFetchDependSourcesFromGeneratorIfTi
     provider.create(projectPart1);
 }
 
+TEST_F(BuildDependenciesProvider,
+       CreateCallsFetchDependSourcesFromGeneratorIfProvidedTimeStampsAreNotUpToDate)
+{
+    InSequence s;
+
+    EXPECT_CALL(mockModifiedTimeChecker, isUpToDate(firstSources)).WillRepeatedly(Return(false));
+    EXPECT_CALL(mockBuildDependenciesGenerator, create(projectPart1)).WillOnce(Return(buildDependency));
+    EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin());
+    EXPECT_CALL(mockBuildDependenciesStorage, insertOrUpdateSources(Eq(secondSources), {1}));
+    EXPECT_CALL(mockBuildDependenciesStorage, insertOrUpdateFileStatuses(Eq(fileStatuses)));
+    EXPECT_CALL(mockBuildDependenciesStorage,
+                insertOrUpdateSourceDependencies(Eq(sourceDependencies)));
+    EXPECT_CALL(mockBuildDependenciesStorage, insertOrUpdateUsedMacros(Eq(secondUsedMacros)));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+
+    provider.create(projectPart1, std::move(firstSources));
+}
+
 TEST_F(BuildDependenciesProvider, FetchDependSourcesFromGenerator)
 {
-    ON_CALL(mockBuildDependenciesStorage, fetchDependSources({2}, {1})).WillByDefault(Return(firstSources));
     ON_CALL(mockModifiedTimeChecker, isUpToDate(_)).WillByDefault(Return(false));
     ON_CALL(mockBuildDependenciesGenerator, create(projectPart1)).WillByDefault(Return(buildDependency));
 
-    auto buildDependency = provider.create(projectPart1);
+    auto buildDependency = provider.create(projectPart1, std::move(firstSources));
 
     ASSERT_THAT(buildDependency.sources, ElementsAre(HasSourceId(1), HasSourceId(3), HasSourceId(8)));
 }
@@ -191,10 +208,6 @@ TEST_F(BuildDependenciesProvider, CreateCallsFetchUsedMacrosFromStorageIfTimeSta
 {
     InSequence s;
 
-    EXPECT_CALL(mockSqliteTransactionBackend, deferredBegin());
-    EXPECT_CALL(mockBuildDependenciesStorage, fetchDependSources({2}, {1}))
-        .WillRepeatedly(Return(firstSources));
-    EXPECT_CALL(mockSqliteTransactionBackend, commit());
     EXPECT_CALL(mockModifiedTimeChecker, isUpToDate(firstSources)).WillRepeatedly(Return(true));
     EXPECT_CALL(mockSqliteTransactionBackend, deferredBegin());
     EXPECT_CALL(mockBuildDependenciesStorage, fetchUsedMacros({1}));
@@ -202,26 +215,60 @@ TEST_F(BuildDependenciesProvider, CreateCallsFetchUsedMacrosFromStorageIfTimeSta
     EXPECT_CALL(mockBuildDependenciesStorage, fetchUsedMacros({10}));
     EXPECT_CALL(mockSqliteTransactionBackend, commit());
 
-    provider.create(projectPart1);
+    provider.create(projectPart1, std::move(firstSources));
 }
 
 TEST_F(BuildDependenciesProvider, FetchUsedMacrosFromStorageIfDependSourcesAreUpToDate)
 {
-    ON_CALL(mockBuildDependenciesStorage, fetchDependSources({2}, {1})).WillByDefault(Return(firstSources));
     ON_CALL(mockModifiedTimeChecker, isUpToDate(firstSources)).WillByDefault(Return(true));
     ON_CALL(mockBuildDependenciesStorage, fetchUsedMacros({1})).WillByDefault(Return(firstUsedMacros));
     ON_CALL(mockBuildDependenciesStorage, fetchUsedMacros({2})).WillByDefault(Return(secondUsedMacros));
     ON_CALL(mockBuildDependenciesStorage, fetchUsedMacros({10})).WillByDefault(Return(thirdUsedMacros));
 
-    auto buildDependency = provider.create(projectPart1);
+    auto buildDependency = provider.create(projectPart1, std::move(firstSources));
 
-    ASSERT_THAT(buildDependency.usedMacros, ElementsAre(UsedMacro{"YI", 1}, UsedMacro{"ER", 2}, UsedMacro{"LIANG", 2}, UsedMacro{"SAN", 10}));
+    ASSERT_THAT(buildDependency.usedMacros,
+                ElementsAre(UsedMacro{"YI", 1},
+                            UsedMacro{"ER", 2},
+                            UsedMacro{"LIANG", 2},
+                            UsedMacro{"SAN", 10}));
 }
 
 TEST_F(BuildDependenciesProvider, CallEnsureAliveMessageIsSentCallback)
 {
     EXPECT_CALL(mockEnsureAliveMessageIsSentCallback, Call());
 
-    provider.create(projectPart1);
+    provider.create(projectPart1, std::move(firstSources));
 }
+
+TEST_F(BuildDependenciesProvider, CreateSourceEntriesFromStorage)
+{
+    ON_CALL(mockBuildDependenciesStorage, fetchDependSources({2}, {2})).WillByDefault(Return(firstSources));
+    ON_CALL(mockBuildDependenciesStorage, fetchDependSources({3}, {2}))
+        .WillByDefault(Return(secondSources));
+    ON_CALL(mockBuildDependenciesStorage, fetchDependSources({4}, {2})).WillByDefault(Return(thirdSources));
+    ON_CALL(mockModifiedTimeChecker, isUpToDate(_)).WillByDefault(Return(true));
+
+    auto sources = provider.createSourceEntriesFromStorage(projectPart2.sourcePathIds,
+                                                           projectPart2.projectPartId);
+
+    ASSERT_THAT(sources,
+                ElementsAre(HasSourceId(1),
+                            HasSourceId(2),
+                            HasSourceId(3),
+                            HasSourceId(4),
+                            HasSourceId(8),
+                            HasSourceId(10)));
 }
+
+TEST_F(BuildDependenciesProvider, CreateSourceEntriesFromStorageCalls)
+{
+    EXPECT_CALL(mockSqliteTransactionBackend, deferredBegin());
+    EXPECT_CALL(mockBuildDependenciesStorage, fetchDependSources({2}, {1}))
+        .WillRepeatedly(Return(firstSources));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
+
+    auto sources = provider.createSourceEntriesFromStorage(projectPart1.sourcePathIds,
+                                                           projectPart1.projectPartId);
+}
+} // namespace

tests/unit/unittest/mockbuilddependenciesprovider.h

@@ -35,4 +35,15 @@ public:
     MOCK_METHOD1(
         create,
         ClangBackEnd::BuildDependency(const ClangBackEnd::ProjectPartContainer &projectPart));
+    MOCK_METHOD2(create,
+                 ClangBackEnd::BuildDependency(const ClangBackEnd::ProjectPartContainer &projectPart,
+                                               const ClangBackEnd::SourceEntries &sourceEntries));
+    MOCK_CONST_METHOD2(createSourceEntriesFromStorage,
+                       ClangBackEnd::SourceEntries(const ClangBackEnd::FilePathIds &sourcePathIds,
+                                                   ClangBackEnd::ProjectPartId projectPartId));
+    ClangBackEnd::BuildDependency create(const ClangBackEnd::ProjectPartContainer &projectPart,
+                                         ClangBackEnd::SourceEntries &&sourceEntries) override
+    {
+        return create(projectPart, sourceEntries);
+    }
 };