refactor: rename isBranchStale -> isBranchBehindBase

lib/modules/platform/azure/index.spec.ts

@@ -41,7 +41,7 @@ describe('modules/platform/azure/index', () => {
     logger = (await import('../../../logger')).logger as never;
     git = require('../../../util/git');
     git.branchExists.mockReturnValue(true);
-    git.isBranchStale.mockResolvedValue(false);
+    git.isBranchBehindBase.mockResolvedValue(false);
     hostRules.find.mockReturnValue({
       token: 'token',
     });

lib/modules/platform/bitbucket-server/index.spec.ts

@@ -209,7 +209,7 @@ describe('modules/platform/bitbucket-server/index', () => {
         bitbucket = await import('.');
         git = require('../../../util/git');
         git.branchExists.mockReturnValue(true);
-        git.isBranchStale.mockResolvedValue(false);
+        git.isBranchBehindBase.mockResolvedValue(false);
         git.getBranchCommit.mockReturnValue(
           '0d9c7726c3d628b7e28af234595cfd20febdbf8e'
         );

lib/modules/platform/bitbucket/index.spec.ts

@@ -34,7 +34,7 @@ describe('modules/platform/bitbucket/index', () => {
     logger = (await import('../../../logger')).logger as any;
     git = require('../../../util/git');
     git.branchExists.mockReturnValue(true);
-    git.isBranchStale.mockResolvedValue(false);
+    git.isBranchBehindBase.mockResolvedValue(false);
     // clean up hostRules
     hostRules.clear();
     hostRules.find.mockReturnValue({

lib/modules/platform/gitea/index.spec.ts

@@ -179,7 +179,7 @@ describe('modules/platform/gitea/index', () => {
     helper = mocked(await import('./gitea-helper'));
     logger = mocked((await import('../../../logger')).logger);
     gitvcs = require('../../../util/git');
-    gitvcs.isBranchStale.mockResolvedValue(false);
+    gitvcs.isBranchBehindBase.mockResolvedValue(false);
     gitvcs.getBranchCommit.mockReturnValue(mockCommitHash);
     hostRules = mocked(await import('../../../util/host-rules'));
     hostRules.clear();

lib/modules/platform/github/index.spec.ts

@@ -35,7 +35,7 @@ describe('modules/platform/github/index', () => {
     setBaseUrl(githubApiHost);
 
     git.branchExists.mockReturnValue(true);
-    git.isBranchStale.mockResolvedValue(true);
+    git.isBranchBehindBase.mockResolvedValue(true);
     git.getBranchCommit.mockReturnValue(
       '0d9c7726c3d628b7e28af234595cfd20febdbf8e'
     );

lib/modules/platform/gitlab/index.spec.ts

@@ -36,7 +36,7 @@ describe('modules/platform/gitlab/index', () => {
     jest.mock('../../../util/git');
     git = require('../../../util/git');
     git.branchExists.mockReturnValue(true);
-    git.isBranchStale.mockResolvedValue(true);
+    git.isBranchBehindBase.mockResolvedValue(true);
     git.getBranchCommit.mockReturnValue(
       '0d9c7726c3d628b7e28af234595cfd20febdbf8e'
     );

lib/util/git/index.spec.ts

@@ -237,18 +237,20 @@ describe('util/git/index', () => {
     });
   });
 
-  describe('isBranchStale()', () => {
+  describe('isBranchBehindBase()', () => {
     it('should return false if same SHA as master', async () => {
-      expect(await git.isBranchStale('renovate/future_branch')).toBeFalse();
+      expect(
+        await git.isBranchBehindBase('renovate/future_branch')
+      ).toBeFalse();
     });
 
     it('should return true if SHA different from master', async () => {
-      expect(await git.isBranchStale('renovate/past_branch')).toBeTrue();
+      expect(await git.isBranchBehindBase('renovate/past_branch')).toBeTrue();
     });
 
     it('should return result even if non-default and not under branchPrefix', async () => {
-      expect(await git.isBranchStale('develop')).toBeTrue();
-      expect(await git.isBranchStale('develop')).toBeTrue(); // cache
+      expect(await git.isBranchBehindBase('develop')).toBeTrue();
+      expect(await git.isBranchBehindBase('develop')).toBeTrue(); // cache
     });
   });
 

lib/util/git/index.ts

@@ -542,7 +542,7 @@ export function getBranchList(): string[] {
   return Object.keys(config.branchCommits);
 }
 
-export async function isBranchStale(branchName: string): Promise<boolean> {
+export async function isBranchBehindBase(branchName: string): Promise<boolean> {
   await syncGit();
   try {
     const { currentBranchSha, currentBranch } = config;
@@ -552,12 +552,12 @@ export async function isBranchStale(branchName: string): Promise<boolean> {
       '--contains',
       config.currentBranchSha,
     ]);
-    const isStale = !branches.all.map(localName).includes(branchName);
+    const isBehind = !branches.all.map(localName).includes(branchName);
     logger.debug(
-      { isStale, currentBranch, currentBranchSha },
-      `isBranchStale=${isStale}`
+      { isBehind, currentBranch, currentBranchSha },
+      `isBranchBehindBase=${isBehind}`
     );
-    return isStale;
+    return isBehind;
   } catch (err) /* istanbul ignore next */ {
     const errChecked = checkForPlatformFailure(err);
     if (errChecked) {

lib/workers/repository/config-migration/branch/rebase.spec.ts

@@ -52,7 +52,7 @@ describe('workers/repository/config-migration/branch/rebase', () => {
     });
 
     it('rebases migration branch', async () => {
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       await rebaseMigrationBranch(config, migratedConfigData);
       expect(git.commitFiles).toHaveBeenCalledTimes(1);
     });
@@ -61,14 +61,14 @@ describe('workers/repository/config-migration/branch/rebase', () => {
       GlobalConfig.set({
         dryRun: 'full',
       });
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       await rebaseMigrationBranch(config, migratedConfigData);
       expect(git.commitFiles).toHaveBeenCalledTimes(0);
     });
 
     it('rebases via platform', async () => {
       config.platformCommit = true;
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       await rebaseMigrationBranch(config, migratedConfigData);
       expect(platform.commitFiles).toHaveBeenCalledTimes(1);
     });

lib/workers/repository/config-migration/branch/rebase.ts

@@ -2,7 +2,11 @@ import { GlobalConfig } from '../../../../config/global';
 import type { RenovateConfig } from '../../../../config/types';
 import { logger } from '../../../../logger';
 import { commitAndPush } from '../../../../modules/platform/commit';
-import { getFile, isBranchModified, isBranchStale } from '../../../../util/git';
+import {
+  getFile,
+  isBranchBehindBase,
+  isBranchModified,
+} from '../../../../util/git';
 import { getMigrationBranchName } from '../common';
 import { ConfigMigrationCommitMessageFactory } from './commit-message';
 import type { MigratedData } from './migrated-data';
@@ -20,7 +24,10 @@ export async function rebaseMigrationBranch(
   const configFileName = migratedConfigData.filename;
   const contents = migratedConfigData.content;
   const existingContents = await getFile(configFileName, branchName);
-  if (contents === existingContents && !(await isBranchStale(branchName))) {
+  if (
+    contents === existingContents &&
+    !(await isBranchBehindBase(branchName))
+  ) {
     logger.debug('Migration branch is up to date');
     return null;
   }

lib/workers/repository/onboarding/branch/rebase.spec.ts

@@ -44,21 +44,21 @@ describe('workers/repository/onboarding/branch/rebase', () => {
     });
 
     it('rebases onboarding branch', async () => {
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       await rebaseOnboardingBranch(config);
       expect(git.commitFiles).toHaveBeenCalledTimes(1);
     });
 
     it('rebases via platform', async () => {
       platform.commitFiles = jest.fn();
       config.platformCommit = true;
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       await rebaseOnboardingBranch(config);
       expect(platform.commitFiles).toHaveBeenCalledTimes(1);
     });
 
     it('uses the onboardingConfigFileName if set', async () => {
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       await rebaseOnboardingBranch({
         ...config,
         onboardingConfigFileName: '.github/renovate.json',
@@ -73,7 +73,7 @@ describe('workers/repository/onboarding/branch/rebase', () => {
     });
 
     it('falls back to "renovate.json" if onboardingConfigFileName is not set', async () => {
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       await rebaseOnboardingBranch({
         ...config,
         onboardingConfigFileName: undefined,

lib/workers/repository/onboarding/branch/rebase.ts

@@ -3,7 +3,11 @@ import { GlobalConfig } from '../../../../config/global';
 import type { RenovateConfig } from '../../../../config/types';
 import { logger } from '../../../../logger';
 import { commitAndPush } from '../../../../modules/platform/commit';
-import { getFile, isBranchModified, isBranchStale } from '../../../../util/git';
+import {
+  getFile,
+  isBranchBehindBase,
+  isBranchModified,
+} from '../../../../util/git';
 import { OnboardingCommitMessageFactory } from './commit-message';
 import { getOnboardingConfigContents } from './config';
 
@@ -27,7 +31,7 @@ export async function rebaseOnboardingBranch(
   // TODO #7154
   if (
     contents === existingContents &&
-    !(await isBranchStale(config.onboardingBranch!))
+    !(await isBranchBehindBase(config.onboardingBranch!))
   ) {
     logger.debug('Onboarding branch is up to date');
     return null;

lib/workers/repository/update/branch/reuse.spec.ts

@@ -173,15 +173,15 @@ describe('workers/repository/update/branch/reuse', () => {
       config.automerge = true;
       config.automergeType = 'branch';
       git.branchExists.mockReturnValueOnce(true);
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       const res = await shouldReuseExistingBranch(config);
       expect(res.reuseExistingBranch).toBeFalse();
     });
 
     it('returns true if rebaseWhen=behind-base-branch but cannot rebase', async () => {
       config.rebaseWhen = 'behind-base-branch';
       git.branchExists.mockReturnValueOnce(true);
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       git.isBranchConflicted.mockResolvedValueOnce(true);
       platform.getBranchPr.mockResolvedValueOnce(pr);
       git.isBranchModified.mockResolvedValueOnce(true);
@@ -194,7 +194,7 @@ describe('workers/repository/update/branch/reuse', () => {
       config.automerge = true;
       config.automergeType = 'pr';
       git.branchExists.mockReturnValueOnce(true);
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       const res = await shouldReuseExistingBranch(config);
       expect(res.reuseExistingBranch).toBeFalse();
     });
@@ -203,7 +203,7 @@ describe('workers/repository/update/branch/reuse', () => {
       config.rebaseWhen = 'auto';
       platform.getRepoForceRebase.mockResolvedValueOnce(true);
       git.branchExists.mockReturnValueOnce(true);
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       const res = await shouldReuseExistingBranch(config);
       expect(res.reuseExistingBranch).toBeFalse();
     });
@@ -214,15 +214,15 @@ describe('workers/repository/update/branch/reuse', () => {
       git.branchExists.mockReturnValueOnce(true);
       const res = await shouldReuseExistingBranch(config);
       expect(res.reuseExistingBranch).toBeTrue();
-      expect(git.isBranchStale).not.toHaveBeenCalled();
+      expect(git.isBranchBehindBase).not.toHaveBeenCalled();
       expect(git.isBranchModified).not.toHaveBeenCalled();
     });
 
     it('returns true if automerge, rebaseWhen=conflicted and stale', async () => {
       config.rebaseWhen = 'conflicted';
       config.automerge = true;
       git.branchExists.mockReturnValueOnce(true);
-      git.isBranchStale.mockResolvedValueOnce(true);
+      git.isBranchBehindBase.mockResolvedValueOnce(true);
       const res = await shouldReuseExistingBranch(config);
       expect(res.reuseExistingBranch).toBeTrue();
     });

lib/workers/repository/update/branch/reuse.ts

@@ -5,9 +5,9 @@ import { platform } from '../../../../modules/platform';
 import type { RangeStrategy } from '../../../../types';
 import {
   branchExists,
+  isBranchBehindBase,
   isBranchConflicted,
   isBranchModified,
-  isBranchStale,
 } from '../../../../util/git';
 import type { BranchConfig } from '../../../types';
 
@@ -62,7 +62,7 @@ export async function shouldReuseExistingBranch(
     (config.rebaseWhen === 'auto' &&
       (config.automerge || (await platform.getRepoForceRebase())))
   ) {
-    if (await isBranchStale(branchName)) {
+    if (await isBranchBehindBase(branchName)) {
       logger.debug(`Branch is stale and needs rebasing`);
       // We can rebase the branch only if no PR or PR can be rebased
       if (await isBranchModified(branchName)) {