fix: add repoCache-check before cloning

lib/util/git/index.spec.ts

@@ -9,13 +9,16 @@ import {
 } from '../../constants/error-messages';
 import { newlineRegex, regEx } from '../regex';
 import * as _conflictsCache from './conflicts-cache';
+import * as _modifiedCache from './modified-cache';
 import type { FileChange } from './types';
 import * as git from '.';
 import { setNoVerify } from '.';
 
 jest.mock('./conflicts-cache');
+jest.mock('./modified-cache');
 jest.mock('delay');
 const conflictsCache = mocked(_conflictsCache);
+const modifiedCache = mocked(_modifiedCache);
 
 // Class is no longer exported
 const SimpleGit = Git().constructor as { prototype: ReturnType<typeof Git> };
@@ -250,6 +253,10 @@ describe('util/git/index', () => {
   });
 
   describe('isBranchModified()', () => {
+    beforeEach(() => {
+      modifiedCache.getCachedModifiedResult.mockReturnValue(null);
+    });
+
     it('should return false when branch is not found', async () => {
       expect(await git.isBranchModified('renovate/not_found')).toBeFalse();
     });
@@ -269,6 +276,11 @@ describe('util/git/index', () => {
     it('should return true when custom author is unknown', async () => {
       expect(await git.isBranchModified('renovate/custom_author')).toBeTrue();
     });
+
+    it('should return value stored in modifiedCacheResult', async () => {
+      modifiedCache.getCachedModifiedResult.mockReturnValue(true);
+      expect(await git.isBranchModified('renovate/future_branch')).toBeTrue();
+    });
   });
 
   describe('getBranchCommit(branchName)', () => {

lib/util/git/index.ts

@@ -34,6 +34,10 @@ import {
   setCachedConflictResult,
 } from './conflicts-cache';
 import { checkForPlatformFailure, handleCommitError } from './error';
+import {
+  getCachedModifiedResult,
+  setCachedModifiedResult,
+} from './modified-cache';
 import { configSigningKey, writePrivateKey } from './private-key';
 import type {
   CommitFilesConfig,
@@ -564,18 +568,27 @@ export async function isBranchStale(branchName: string): Promise<boolean> {
 }
 
 export async function isBranchModified(branchName: string): Promise<boolean> {
-  await syncGit();
-  // First check cache
-  if (config.branchIsModified[branchName] !== undefined) {
-    return config.branchIsModified[branchName];
-  }
   if (!branchExists(branchName)) {
     logger.debug(
       { branchName },
       'Branch does not exist - cannot check isModified'
     );
     return false;
   }
+  // First check local config
+  if (config.branchIsModified[branchName] !== undefined) {
+    return config.branchIsModified[branchName];
+  }
+  // Second check repoCache
+  const isModified = getCachedModifiedResult(
+    branchName,
+    config.branchCommits[branchName]
+  );
+  if (isModified !== null) {
+    return (config.branchIsModified[branchName] = isModified);
+  }
+
+  await syncGit();
   // Retrieve the author of the most recent commit
   let lastAuthor: string | undefined;
   try {
@@ -606,13 +619,19 @@ export async function isBranchModified(branchName: string): Promise<boolean> {
     // author matches - branch has not been modified
     logger.debug({ branchName }, 'Branch has not been modified');
     config.branchIsModified[branchName] = false;
+    setCachedModifiedResult(
+      branchName,
+      config.branchCommits[branchName],
+      false
+    );
     return false;
   }
   logger.debug(
     { branchName, lastAuthor, gitAuthorEmail },
     'Last commit author does not match git author email - branch has been modified'
   );
   config.branchIsModified[branchName] = true;
+  setCachedModifiedResult(branchName, config.branchCommits[branchName], true);
   return true;
 }
 

lib/util/git/modified-cache.spec.ts

@@ -0,0 +1,87 @@
+import { mocked } from '../../../test/util';
+import * as _repositoryCache from '../cache/repository';
+import type { BranchCache, RepoCacheData } from '../cache/repository/types';
+import {
+  getCachedModifiedResult,
+  setCachedModifiedResult,
+} from './modified-cache';
+
+jest.mock('../cache/repository');
+const repositoryCache = mocked(_repositoryCache);
+
+describe('util/git/modified-cache', () => {
+  let repoCache: RepoCacheData = {};
+
+  beforeEach(() => {
+    repoCache = {};
+    repositoryCache.getCache.mockReturnValue(repoCache);
+  });
+
+  describe('getCachedModifiedResult', () => {
+    it('returns null if cache is not populated', () => {
+      expect(getCachedModifiedResult('foo', '111')).toBeNull();
+    });
+
+    it('returns null if target key not found', () => {
+      expect(getCachedModifiedResult('foo', '111')).toBeNull();
+    });
+
+    it('returns null if target SHA has changed', () => {
+      repoCache.branches = [{ branchName: 'foo', sha: 'aaa' } as BranchCache];
+      expect(getCachedModifiedResult('foo', '111')).toBeNull();
+    });
+
+    it('returns true', () => {
+      repoCache.branches = [
+        { branchName: 'foo', sha: '111', isModified: true } as BranchCache,
+      ];
+      expect(getCachedModifiedResult('foo', '111')).toBeTrue();
+    });
+
+    it('returns false', () => {
+      repoCache.branches = [
+        { branchName: 'foo', sha: '111', isModified: false } as BranchCache,
+      ];
+      expect(getCachedModifiedResult('foo', '111')).toBeFalse();
+    });
+  });
+
+  describe('setCachedModifiedResult', () => {
+    it('sets value for unpopulated cache', () => {
+      setCachedModifiedResult('foo', '111', false);
+      expect(repoCache).toEqual({
+        branches: [{ branchName: 'foo', sha: '111', isModified: false }],
+      });
+    });
+
+    it('replaces value when SHA has changed', () => {
+      setCachedModifiedResult('foo', '111', false);
+      setCachedModifiedResult('foo', '121', false);
+      setCachedModifiedResult('foo', '131', false);
+      expect(repoCache).toEqual({
+        branches: [{ branchName: 'foo', sha: '131', isModified: false }],
+      });
+    });
+
+    it('replaces value when both value and SHA have changed', () => {
+      setCachedModifiedResult('foo', '111', false);
+      setCachedModifiedResult('foo', 'aaa', true);
+      expect(repoCache).toEqual({
+        branches: [{ branchName: 'foo', sha: 'aaa', isModified: true }],
+      });
+    });
+
+    it('handles multiple branches', () => {
+      setCachedModifiedResult('foo-1', '111', false);
+      setCachedModifiedResult('foo-2', 'aaa', true);
+      setCachedModifiedResult('foo-3', '222', false);
+      expect(repoCache).toEqual({
+        branches: [
+          { branchName: 'foo-1', sha: '111', isModified: false },
+          { branchName: 'foo-2', sha: 'aaa', isModified: true },
+          { branchName: 'foo-3', sha: '222', isModified: false },
+        ],
+      });
+    });
+  });
+});

lib/util/git/modified-cache.ts

@@ -0,0 +1,41 @@
+import is from '@sindresorhus/is';
+import { getCache } from '../cache/repository';
+import type { BranchCache } from '../cache/repository/types';
+
+export function getCachedModifiedResult(
+  branchName: string,
+  branchSha: string
+): boolean | null {
+  const { branches } = getCache();
+  const branch = branches?.find((branch) => branch.branchName === branchName);
+
+  if (branch?.sha !== branchSha) {
+    return null;
+  }
+
+  return branch.isModified;
+}
+
+export function setCachedModifiedResult(
+  branchName: string,
+  branchSha: string,
+  isModified: boolean
+): void {
+  const cache = getCache();
+  cache.branches ??= [];
+  const { branches } = cache;
+  const branch =
+    branches?.find((branch) => branch.branchName === branchName) ??
+    ({ branchName: branchName } as BranchCache);
+
+  // if branch not present add it to cache
+  if (is.undefined(branch.sha)) {
+    branches.push(branch);
+  }
+
+  if (branch.sha !== branchSha) {
+    branch.sha = branchSha;
+  }
+
+  branch.isModified = isModified;
+}