diff --git a/lib/workers/repository/update/branch/index.spec.ts b/lib/workers/repository/update/branch/index.spec.ts
index 99be0cfac0beb2cb82b07a1cc464127fff67c96d..ba8aba7d85a76f7153fe14a8bffb88b36cab779e 100644
--- a/lib/workers/repository/update/branch/index.spec.ts
+++ b/lib/workers/repository/update/branch/index.spec.ts
@@ -109,6 +109,10 @@ describe('workers/repository/update/branch/index', () => {
beforeEach(() => {
scm.branchExists.mockResolvedValue(false);
+ reuse.shouldReuseExistingBranch.mockImplementation(
+ // eslint-disable-next-line require-await, @typescript-eslint/require-await
+ async (config) => config,
+ );
prWorker.ensurePr = jest.fn();
prWorker.getPlatformPrOptions = jest.fn();
prAutomerge.checkAutoMerge = jest.fn();
diff --git a/lib/workers/repository/update/branch/index.ts b/lib/workers/repository/update/branch/index.ts
index e88b3e5b321229d48cdce98e6fbc1fdad6f4f1cf..4f35e4ad3667e91848db0c7c36a78c404b731067 100644
--- a/lib/workers/repository/update/branch/index.ts
+++ b/lib/workers/repository/update/branch/index.ts
@@ -467,7 +467,7 @@ export async function processBranch(
);
config.reuseExistingBranch = false;
} else {
- config = { ...config, ...(await shouldReuseExistingBranch(config)) };
+ config = await shouldReuseExistingBranch(config);
}
// TODO: types (#22198)
logger.debug(`Using reuseExistingBranch: ${config.reuseExistingBranch!}`);
diff --git a/lib/workers/repository/update/branch/reuse.spec.ts b/lib/workers/repository/update/branch/reuse.spec.ts
index 6ebe09a6888f662684ad49fc1525aea26383c6ea..8f47e9782763eddda2caa21a67cb4983a760d625 100644
--- a/lib/workers/repository/update/branch/reuse.spec.ts
+++ b/lib/workers/repository/update/branch/reuse.spec.ts
@@ -222,5 +222,45 @@ describe('workers/repository/update/branch/reuse', () => {
const res = await shouldReuseExistingBranch(config);
expect(res.reuseExistingBranch).toBeTrue();
});
+
+ it('converts rebaseWhen=auto to behind-base-branch if automerge', async () => {
+ config.rebaseWhen = 'auto';
+ config.automerge = true;
+ scm.branchExists.mockResolvedValueOnce(true);
+ scm.isBranchBehindBase.mockResolvedValueOnce(false);
+ const result = await shouldReuseExistingBranch(config);
+ expect(config.rebaseWhen).toBe('auto');
+ expect(result.rebaseWhen).toBe('behind-base-branch');
+ });
+
+ it('converts rebaseWhen=auto to behind-base-branch if getBranchForceRebase', async () => {
+ config.rebaseWhen = 'auto';
+ platform.getBranchForceRebase.mockResolvedValueOnce(true);
+ scm.branchExists.mockResolvedValueOnce(true);
+ scm.isBranchBehindBase.mockResolvedValueOnce(false);
+ const result = await shouldReuseExistingBranch(config);
+ expect(config.rebaseWhen).toBe('auto');
+ expect(result.rebaseWhen).toBe('behind-base-branch');
+ });
+
+ it('converts rebaseWhen=auto to behind-base-branch if keepUpdatedLabel', async () => {
+ config.rebaseWhen = 'auto';
+ config.keepUpdatedLabel = 'keep-updated';
+ platform.getBranchPr.mockResolvedValue(pr);
+ scm.branchExists.mockResolvedValueOnce(true);
+ scm.isBranchBehindBase.mockResolvedValueOnce(false);
+ const result = await shouldReuseExistingBranch(config);
+ expect(config.rebaseWhen).toBe('auto');
+ expect(result.rebaseWhen).toBe('behind-base-branch');
+ });
+
+ it('converts rebaseWhen=auto to conflicted', async () => {
+ config.rebaseWhen = 'auto';
+ scm.branchExists.mockResolvedValueOnce(true);
+ scm.isBranchBehindBase.mockResolvedValueOnce(false);
+ const result = await shouldReuseExistingBranch(config);
+ expect(config.rebaseWhen).toBe('auto');
+ expect(result.rebaseWhen).toBe('conflicted');
+ });
});
});
diff --git a/lib/workers/repository/update/branch/reuse.ts b/lib/workers/repository/update/branch/reuse.ts
index 4fc52c4830ece59ef4516bd9506e03e799f23169..a9450e8f60a3d2ddcf952921f511c38ab0a16fee 100644
--- a/lib/workers/repository/update/branch/reuse.ts
+++ b/lib/workers/repository/update/branch/reuse.ts
@@ -4,12 +4,6 @@ import { scm } from '../../../../modules/platform/scm';
import type { RangeStrategy } from '../../../../types';
import type { BranchConfig } from '../../../types';
-type ParentBranch = {
- reuseExistingBranch: boolean;
- isModified?: boolean;
- isConflicted?: boolean;
-};
-
async function shouldKeepUpdated(
config: BranchConfig,
baseBranch: string,
@@ -34,21 +28,42 @@ async function shouldKeepUpdated(
export async function shouldReuseExistingBranch(
config: BranchConfig,
-): Promise<ParentBranch> {
+): Promise<BranchConfig> {
const { baseBranch, branchName } = config;
- const result: ParentBranch = { reuseExistingBranch: false };
+ const result: BranchConfig = { ...config, reuseExistingBranch: false };
// Check if branch exists
if (!(await scm.branchExists(branchName))) {
logger.debug(`Branch needs creating`);
return result;
}
logger.debug(`Branch already exists`);
+ if (result.rebaseWhen === 'auto') {
+ if (result.automerge === true) {
+ logger.debug(
+ 'Converting rebaseWhen=auto to rebaseWhen=behind-base-branch because automerge=true',
+ );
+ result.rebaseWhen = 'behind-base-branch';
+ } else if (await platform.getBranchForceRebase?.(result.baseBranch)) {
+ logger.debug(
+ 'Converting rebaseWhen=auto to rebaseWhen=behind-base-branch because platform is configured to require up-to-date branches',
+ );
+ result.rebaseWhen = 'behind-base-branch';
+ } else if (await shouldKeepUpdated(result, baseBranch, branchName)) {
+ logger.debug(
+ 'Converting rebaseWhen=auto to rebaseWhen=behind-base-branch because keep-updated label is set',
+ );
+ result.rebaseWhen = 'behind-base-branch';
+ }
+ }
+ if (result.rebaseWhen === 'auto') {
+ logger.debug(
+ 'Converting rebaseWhen=auto to rebaseWhen=conflicted because no rule for converting to rebaseWhen=behind-base-branch applies',
+ );
+ result.rebaseWhen = 'conflicted';
+ }
if (
- config.rebaseWhen === 'behind-base-branch' ||
- (await shouldKeepUpdated(config, baseBranch, branchName)) ||
- (config.rebaseWhen === 'auto' &&
- (config.automerge === true ||
- (await platform.getBranchForceRebase?.(config.baseBranch))))
+ result.rebaseWhen === 'behind-base-branch' ||
+ (await shouldKeepUpdated(result, baseBranch, branchName))
) {
if (await scm.isBranchBehindBase(branchName, baseBranch)) {
logger.debug(`Branch is behind base branch and needs rebasing`);
@@ -65,7 +80,7 @@ export async function shouldReuseExistingBranch(
logger.debug('Branch is up-to-date');
} else {
logger.debug(
- `Skipping behind base branch check due to rebaseWhen=${config.rebaseWhen!}`,
+ `Skipping behind base branch check due to rebaseWhen=${result.rebaseWhen!}`,
);
}
@@ -77,8 +92,8 @@ export async function shouldReuseExistingBranch(
if ((await scm.isBranchModified(branchName, baseBranch)) === false) {
logger.debug(`Branch is not mergeable and needs rebasing`);
if (
- config.rebaseWhen === 'never' &&
- !(await shouldKeepUpdated(config, baseBranch, branchName))
+ result.rebaseWhen === 'never' &&
+ !(await shouldKeepUpdated(result, baseBranch, branchName))
) {
logger.debug('Rebasing disabled by config');
result.reuseExistingBranch = true;
@@ -99,7 +114,7 @@ export async function shouldReuseExistingBranch(
// along with the changes to the package.json. Thus ending up with an incomplete branch update
// This is why we are skipping branch reuse in this case (#10050)
const groupedByPackageFile: Record<string, Set<RangeStrategy>> = {};
- for (const upgrade of config.upgrades) {
+ for (const upgrade of result.upgrades) {
const packageFile = upgrade.packageFile!;
groupedByPackageFile[packageFile] ??= new Set();
groupedByPackageFile[packageFile].add(upgrade.rangeStrategy!);