refactor: improve branch cache logic

lib/modules/manager/sbt/extract.ts

@@ -271,11 +271,12 @@ export function extractPackageFile(
   let parsedResult: Ctx | null = null;
 
   try {
-    parsedResult = scala.query(content, query, {
-      vars: {},
-      deps: [],
-      registryUrls: [MAVEN_REPO],
-    });
+    parsedResult =
+      scala.query(content, query, {
+        vars: {},
+        deps: [],
+        registryUrls: [MAVEN_REPO],
+      }) ?? null;
   } catch (err) /* istanbul ignore next */ {
     logger.warn({ err }, 'Sbt parsing error');
   }

lib/util/cache/repository/types.ts

@@ -28,13 +28,17 @@ export interface BranchUpgradeCache {
 
 export interface BranchCache {
   automerge: boolean;
+  baseBranchName: string;
+  baseBranchSha: string | null;
   branchName: string;
-  isModified: boolean;
+  branchFingerprint?: string;
+  isBehindBaseBranch?: boolean;
+  isConflicted?: boolean;
+  isModified?: boolean;
+  parentSha?: string | null;
   prNo: number | null;
   sha: string | null;
-  parentSha: string | null;
   upgrades: BranchUpgradeCache[];
-  branchFingerprint?: string;
 }
 
 export interface RepoCacheData {

lib/util/git/behind-base-branch-cache.spec.ts

@@ -1,10 +1,16 @@
 import { mocked, partial } from '../../../test/util';
 import * as _repositoryCache from '../cache/repository';
 import type { BranchCache, RepoCacheData } from '../cache/repository/types';
-import { getCachedBehindBaseResult } from './behind-base-branch-cache';
+import {
+  getCachedBehindBaseResult,
+  setCachedBehindBaseResult,
+} from './behind-base-branch-cache';
+import * as _git from '.';
 
 jest.mock('../cache/repository');
+jest.mock('.');
 const repositoryCache = mocked(_repositoryCache);
+const git = mocked(_git);
 
 describe('util/git/behind-base-branch-cache', () => {
   let repoCache: RepoCacheData = {};
@@ -16,36 +22,92 @@ describe('util/git/behind-base-branch-cache', () => {
 
   describe('getCachedBehindBaseResult', () => {
     it('returns null if cache is not populated', () => {
-      expect(getCachedBehindBaseResult('foo', '111')).toBeNull();
+      expect(
+        getCachedBehindBaseResult('foo', 'SHA', 'base_foo', 'base_SHA')
+      ).toBeNull();
     });
 
     it('returns null if branch not found', () => {
-      expect(getCachedBehindBaseResult('foo', '111')).toBeNull();
+      const branchCache = partial<BranchCache>({
+        branchName: 'not_foo',
+        isModified: false,
+      });
+      repoCache = { branches: [branchCache] };
+      expect(
+        getCachedBehindBaseResult('foo', 'SHA', 'base_foo', 'base_SHA')
+      ).toBeNull();
     });
 
-    it('returns null if cache is partially defined', () => {
-      const branchName = 'branchName';
+    it('returns null if isBehindBaseBranch is undefined', () => {
       const branchCache = partial<BranchCache>({
-        branchName,
+        branchName: 'foo',
+        sha: 'SHA',
+        baseBranchName: 'base_foo',
         isModified: false,
       });
-      const repoCache: RepoCacheData = { branches: [branchCache] };
+      repoCache = { branches: [branchCache] };
       repositoryCache.getCache.mockReturnValue(repoCache);
-      expect(getCachedBehindBaseResult(branchName, '111')).toBeNull();
+      expect(
+        getCachedBehindBaseResult('foo', 'SHA', 'base_foo', 'base_SHA')
+      ).toBeNull();
     });
 
-    it('returns true if target SHA has changed', () => {
-      repoCache.branches = [
-        { branchName: 'foo', sha: 'aaa', parentSha: '222' } as BranchCache,
-      ];
-      expect(getCachedBehindBaseResult('foo', '111')).toBeTrue();
+    it('returns value', () => {
+      const branchCache = partial<BranchCache>({
+        branchName: 'foo',
+        sha: 'SHA',
+        baseBranchSha: 'base_SHA',
+        baseBranchName: 'base_foo',
+        isBehindBaseBranch: false,
+      });
+      repoCache = { branches: [branchCache] };
+      repositoryCache.getCache.mockReturnValue(repoCache);
+      expect(
+        getCachedBehindBaseResult('foo', 'SHA', 'base_foo', 'base_SHA')
+      ).toBeFalse();
+    });
+  });
+
+  describe('setCachedBehindBaseResult', () => {
+    it('returns if branch not found', () => {
+      git.getBranchCommit.mockReturnValueOnce('SHA');
+      setCachedBehindBaseResult('foo', false);
+      expect(repoCache).toMatchObject({});
     });
 
-    it('returns false if target SHA has not changed', () => {
-      repoCache.branches = [
-        { branchName: 'foo', sha: 'aaa', parentSha: '111' } as BranchCache,
-      ];
-      expect(getCachedBehindBaseResult('foo', '111')).toBeFalse();
+    it('handles multiple branches', () => {
+      repoCache = {
+        branches: [
+          partial<BranchCache>({
+            branchName: 'foo',
+            isBehindBaseBranch: true,
+            baseBranchName: 'base_foo',
+            sha: 'SHA',
+            baseBranchSha: 'base_SHA',
+          }),
+          partial<BranchCache>({
+            branchName: 'bar',
+            isBehindBaseBranch: false,
+          }),
+        ],
+      };
+      repositoryCache.getCache.mockReturnValue(repoCache);
+      setCachedBehindBaseResult('foo', false);
+      expect(repoCache).toMatchObject({
+        branches: [
+          {
+            branchName: 'foo',
+            isBehindBaseBranch: false,
+            baseBranchName: 'base_foo',
+            sha: 'SHA',
+            baseBranchSha: 'base_SHA',
+          },
+          {
+            branchName: 'bar',
+            isBehindBaseBranch: false,
+          },
+        ],
+      });
     });
   });
 });

lib/util/git/behind-base-branch-cache.ts

@@ -1,20 +1,40 @@
 import { getCache } from '../cache/repository';
 
-// Compare cached parent Sha of a branch to the fetched base-branch sha to determine whether the branch is behind the base
-// Since cache is updated after each run, this will be sufficient to determine whether a branch is behind its parent.
 export function getCachedBehindBaseResult(
   branchName: string,
-  currentBaseBranchSha: string
+  branchSha: string,
+  baseBranchName: string,
+  baseBranchSha: string
 ): boolean | null {
   const cache = getCache();
-  const { branches = [] } = cache;
-  const cachedBranch = branches?.find(
+  const branch = cache.branches?.find(
     (branch) => branch.branchName === branchName
   );
 
-  if (!cachedBranch?.parentSha) {
-    return null;
+  if (
+    branch &&
+    branch.baseBranchName === baseBranchName &&
+    branch.baseBranchSha === baseBranchSha &&
+    branch.sha === branchSha &&
+    branch.isBehindBaseBranch !== undefined
+  ) {
+    return branch.isBehindBaseBranch;
+  }
+  return null;
+}
+
+export function setCachedBehindBaseResult(
+  branchName: string,
+  isBehind: boolean
+): void {
+  const cache = getCache();
+  const branch = cache.branches?.find(
+    (branch) => branch.branchName === branchName
+  );
+
+  if (!branch) {
+    return;
   }
 
-  return currentBaseBranchSha !== cachedBranch.parentSha;
+  branch.isBehindBaseBranch = isBehind;
 }