release-it 0.0.0-pl.0

package/test/git.init.js

@@ -0,0 +1,250 @@
+import test from 'ava';
+import sh from 'shelljs';
+import Shell from '../lib/shell.js';
+import Git from '../lib/plugin/git/Git.js';
+import { readJSON } from '../lib/util.js';
+import { factory } from './util/index.js';
+import { mkTmpDir, gitAdd } from './util/helpers.js';
+
+const { git } = readJSON(new URL('../config/release-it.json', import.meta.url));
+
+test.serial.beforeEach(t => {
+  const bare = mkTmpDir();
+  const target = mkTmpDir();
+  sh.pushd('-q', bare);
+  sh.exec(`git init --bare .`);
+  sh.exec(`git clone ${bare} ${target}`);
+  sh.pushd('-q', target);
+  gitAdd('line', 'file', 'Add file');
+  t.context = { bare, target };
+});
+
+test.serial('should throw if on wrong branch', async t => {
+  const options = { git: { requireBranch: 'dev' } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git remote remove origin');
+  await t.throwsAsync(gitClient.init(), { message: /^Must be on branch dev/ });
+});
+
+test.serial('should throw if on negated branch', async t => {
+  const options = { git: { requireBranch: '!main' } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git checkout -b main');
+  await t.throwsAsync(gitClient.init(), { message: /^Must be on branch !main/ });
+});
+
+test.serial('should not throw if required branch matches', async t => {
+  const options = { git: { requireBranch: 'ma?*' } };
+  const gitClient = factory(Git, { options });
+  await t.notThrowsAsync(gitClient.init());
+});
+
+test.serial('should not throw if one of required branch matches', async t => {
+  const options = { git: { requireBranch: ['release/*', 'hotfix/*'] } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git checkout -b release/v1');
+  await t.notThrowsAsync(gitClient.init());
+});
+
+test.serial('should throw if there is no remote Git url', async t => {
+  const gitClient = factory(Git, { options: { git } });
+  sh.exec('git remote remove origin');
+  await t.throwsAsync(gitClient.init(), { message: /^Could not get remote Git url/ });
+});
+
+test.serial('should throw if working dir is not clean', async t => {
+  const gitClient = factory(Git, { options: { git } });
+  sh.exec('rm file');
+  await t.throwsAsync(gitClient.init(), { message: /^Working dir must be clean/ });
+});
+
+test.serial('should throw if no upstream is configured', async t => {
+  const gitClient = factory(Git, { options: { git } });
+  sh.exec('git checkout -b foo');
+  await t.throwsAsync(gitClient.init(), { message: /^No upstream configured for current branch/ });
+});
+
+test.serial('should throw if there are no commits', async t => {
+  const options = { git: { requireCommits: true } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git tag 1.0.0');
+  await t.throwsAsync(gitClient.init(), { message: /^There are no commits since the latest tag/ });
+});
+
+test.serial('should not throw if there are commits', async t => {
+  const options = { git: { requireCommits: true } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git tag 1.0.0');
+  gitAdd('line', 'file', 'Add file');
+  await t.notThrowsAsync(gitClient.init());
+});
+
+test.serial('should fail (exit code 1) if there are no commits', async t => {
+  const options = { git: { requireCommits: true } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git tag 1.0.0');
+  await t.throwsAsync(gitClient.init(), { code: 1 });
+});
+
+test.serial('should not fail (exit code 0) if there are no commits', async t => {
+  const options = { git: { requireCommits: true, requireCommitsFail: false } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git tag 1.0.0');
+  await t.throwsAsync(gitClient.init(), { code: 0 });
+});
+
+test.serial('should throw if there are no commits in specified path', async t => {
+  const options = { git: { requireCommits: true, commitsPath: 'dir' } };
+  const gitClient = factory(Git, { options });
+  sh.mkdir('dir');
+  sh.exec('git tag 1.0.0');
+  await t.throwsAsync(gitClient.init(), { message: /^There are no commits since the latest tag/ });
+});
+
+test.serial('should not throw if there are commits in specified path', async t => {
+  const options = { git: { requireCommits: true, commitsPath: 'dir' } };
+  const gitClient = factory(Git, { options });
+  sh.exec('git tag 1.0.0');
+  gitAdd('line', 'dir/file', 'Add file');
+  await t.notThrowsAsync(gitClient.init());
+});
+
+test.serial('should not throw if there are no tags', async t => {
+  const options = { git: { requireCommits: true } };
+  const gitClient = factory(Git, { options });
+  gitAdd('line', 'file', 'Add file');
+  await t.notThrowsAsync(gitClient.init());
+});
+
+test.serial('should not throw if origin remote is renamed', async t => {
+  sh.exec('git remote rename origin upstream');
+  const gitClient = factory(Git);
+  await t.notThrowsAsync(gitClient.init());
+});
+
+test.serial('should detect and include version prefix ("v")', async t => {
+  const gitClient = factory(Git, { options: { git } });
+  sh.exec('git tag v1.0.0');
+  await gitClient.init();
+  await gitClient.bump('1.0.1');
+  t.is(gitClient.config.getContext('tagName'), 'v1.0.1');
+});
+
+test.serial('should detect and exclude version prefix', async t => {
+  const gitClient = factory(Git, { options: { git } });
+  sh.exec('git tag 1.0.0');
+  await gitClient.init();
+  await gitClient.bump('1.0.1');
+  t.is(gitClient.config.getContext('tagName'), '1.0.1');
+});
+
+test.serial('should detect and exclude version prefix (configured)', async t => {
+  const gitClient = factory(Git, { options: { git: { tagName: 'v${version}' } } });
+  sh.exec('git tag 1.0.0');
+  await gitClient.init();
+  await gitClient.bump('1.0.1');
+  t.is(gitClient.config.getContext('tagName'), 'v1.0.1');
+});
+
+test.serial('should honor custom tagName configuration', async t => {
+  const gitClient = factory(Git, { options: { git: { tagName: 'TAGNAME-${repo.project}-v${version}' } } });
+  sh.exec('git tag 1.0.0');
+  await gitClient.init();
+  await gitClient.bump('1.0.1');
+  const { project } = gitClient.getContext('repo');
+  t.is(gitClient.config.getContext('tagName'), `TAGNAME-${project}-v1.0.1`);
+});
+
+test.serial('should get the latest tag after fetch', async t => {
+  const shell = factory(Shell);
+  const gitClient = factory(Git, { container: { shell } });
+  const { bare, target } = t.context;
+  const other = mkTmpDir();
+  sh.exec('git push');
+  sh.exec(`git clone ${bare} ${other}`);
+  sh.pushd('-q', other);
+  sh.exec('git tag 1.0.0');
+  sh.exec('git push --tags');
+  sh.pushd('-q', target);
+  await gitClient.init();
+  t.is(gitClient.config.getContext('latestTag'), '1.0.0');
+});
+
+test.serial('should get the latest custom tag after fetch when tagName is configured', async t => {
+  const shell = factory(Shell);
+  const gitClient = factory(Git, {
+    options: { git: { tagName: 'TAGNAME-v${version}' } },
+    container: { shell }
+  });
+  const { bare, target } = t.context;
+  const other = mkTmpDir();
+  sh.exec('git push');
+  sh.exec(`git clone ${bare} ${other}`);
+  sh.pushd('-q', other);
+  sh.exec('git tag TAGNAME-OTHER-v2.0.0');
+  sh.exec('git tag TAGNAME-v1.0.0');
+  sh.exec('git tag TAGNAME-OTHER-v2.0.2');
+  sh.exec('git push --tags');
+  sh.pushd('-q', target);
+  await gitClient.init();
+  t.is(gitClient.config.getContext('latestTag'), 'TAGNAME-v1.0.0');
+});
+
+test.serial('should get the latest tag based on tagMatch', async t => {
+  const shell = factory(Shell);
+  const gitClient = factory(Git, {
+    options: { git: { tagMatch: '[0-9][0-9]\\.[0-1][0-9]\\.[0-9]*' } },
+    container: { shell }
+  });
+  sh.exec('git tag 1.0.0');
+  sh.exec('git tag 21.04.3');
+  sh.exec('git tag 1.0.1');
+  sh.exec('git push --tags');
+  await gitClient.init();
+  t.is(gitClient.config.getContext('latestTag'), '21.04.3');
+});
+
+test.serial('should get the latest tag based on tagExclude', async t => {
+  const shell = factory(Shell);
+  const gitClient = factory(Git, {
+    options: { git: { tagExclude: '*[-]*' } },
+    container: { shell }
+  });
+  sh.exec('git tag 1.0.0');
+  sh.exec('git commit --allow-empty -m "commit 1"');
+  sh.exec('git tag 1.0.1-rc.0');
+  sh.exec('git tag 1.0.1');
+  sh.exec('git commit --allow-empty -m "commit 2"');
+  sh.exec('git tag 1.1.0-rc.0');
+  sh.exec('git push --tags');
+  await gitClient.init();
+  t.is(gitClient.config.getContext('latestTag'), '1.0.1');
+});
+
+test.serial('should generate correct changelog', async t => {
+  const gitClient = factory(Git, { options: { git } });
+  sh.exec('git tag 1.0.0');
+  gitAdd('line', 'file', 'Add file');
+  gitAdd('line', 'file', 'Add file');
+  await gitClient.init();
+  const changelog = await gitClient.getChangelog();
+  t.regex(changelog, /\* Add file \(\w{7}\)\n\* Add file \(\w{7}\)/);
+});
+
+test.serial('should get the full changelog since latest major tag', async t => {
+  const shell = factory(Shell);
+  const gitClient = factory(Git, {
+    options: { git: { tagMatch: '[0-9]\\.[0-9]\\.[0-9]', changelog: git.changelog } },
+    container: { shell }
+  });
+  sh.exec('git tag 1.0.0');
+  gitAdd('line', 'file', 'Add file');
+  sh.exec('git tag 2.0.0-rc.0');
+  gitAdd('line', 'file', 'Add file');
+  sh.exec('git tag 2.0.0-rc.1');
+  gitAdd('line', 'file', 'Add file');
+  await gitClient.init();
+  t.is(gitClient.config.getContext('latestTag'), '1.0.0');
+  const changelog = await gitClient.getChangelog();
+  t.regex(changelog, /\* Add file \(\w{7}\)\n\* Add file \(\w{7}\)\n\* Add file \(\w{7}\)/);
+});

package/test/git.js

@@ -0,0 +1,358 @@
+import { EOL } from 'node:os';
+import test from 'ava';
+import sinon from 'sinon';
+import sh from 'shelljs';
+import Git from '../lib/plugin/git/Git.js';
+import { factory } from './util/index.js';
+import { mkTmpDir, readFile, gitAdd } from './util/helpers.js';
+
+test.beforeEach(() => {
+  const tmp = mkTmpDir();
+  sh.pushd('-q', tmp);
+});
+
+test.serial('should return whether repo has upstream branch', async t => {
+  const gitClient = factory(Git);
+  sh.exec('git init');
+  gitAdd('line', 'file', 'Add file');
+  t.false(await gitClient.hasUpstreamBranch());
+});
+
+test.serial('should return branch name', async t => {
+  const gitClient = factory(Git);
+  sh.exec('git init');
+  t.is(await gitClient.getBranchName(), null);
+  sh.exec('git checkout -b feat');
+  gitAdd('line', 'file', 'Add file');
+  t.is(await gitClient.getBranchName(), 'feat');
+});
+
+test.serial('should return whether tag exists and if working dir is clean', async t => {
+  const gitClient = factory(Git);
+  sh.exec('git init');
+  t.false(await gitClient.tagExists('1.0.0'));
+  sh.touch('file');
+  t.false(await gitClient.isWorkingDirClean());
+  gitAdd('line', 'file', 'Add file');
+  sh.exec('git tag 1.0.0');
+  t.true(await gitClient.tagExists('1.0.0'));
+  t.true(await gitClient.isWorkingDirClean());
+});
+
+test.serial('should throw if tag exists', async t => {
+  const gitClient = factory(Git);
+  sh.exec('git init');
+  sh.touch('file');
+  gitAdd('line', 'file', 'Add file');
+  sh.exec('git tag 0.0.2');
+  gitClient.config.setContext({ latestTag: '0.0.1', tagName: '0.0.2' });
+  const expected = { instanceOf: Error, message: /fatal: tag '0\.0\.2' already exists/ };
+  await t.throwsAsync(gitClient.tag({ name: '0.0.2' }), expected);
+});
+
+test.serial('should only warn if tag exists intentionally', async t => {
+  const gitClient = factory(Git);
+  const { warn } = gitClient.log;
+  sh.exec('git init');
+  sh.touch('file');
+  gitAdd('line', 'file', 'Add file');
+  sh.exec('git tag 1.0.0');
+  gitClient.config.setContext({ latestTag: '1.0.0', tagName: '1.0.0' });
+  await t.notThrowsAsync(gitClient.tag());
+  t.is(warn.callCount, 1);
+  t.is(warn.firstCall.args[0], 'Tag "1.0.0" already exists');
+});
+
+test.serial('should return the remote url', async t => {
+  sh.exec(`git init`);
+  {
+    const options = { git: { pushRepo: 'origin' } };
+    const gitClient = factory(Git, { options });
+    t.is(await gitClient.getRemoteUrl(), null);
+    sh.exec(`git remote add origin foo`);
+    t.is(await gitClient.getRemoteUrl(), 'foo');
+  }
+  {
+    const options = { git: { pushRepo: 'another' } };
+    const gitClient = factory(Git, { options });
+    t.is(await gitClient.getRemoteUrl(), null);
+    sh.exec(`git remote add another bar`);
+    t.is(await gitClient.getRemoteUrl(), 'bar');
+  }
+  {
+    const options = { git: { pushRepo: 'git://github.com/webpro/release-it.git' } };
+    const gitClient = factory(Git, { options });
+    t.is(await gitClient.getRemoteUrl(), 'git://github.com/webpro/release-it.git');
+  }
+});
+
+test.serial('should return the non-origin remote', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  gitAdd('line', 'file', 'Add file');
+  sh.exec('git remote rename origin upstream');
+  const gitClient = factory(Git);
+  t.is(await gitClient.getRemoteUrl(), bare);
+});
+
+test.serial('should stage, commit, tag and push', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  const version = '1.2.3';
+  gitAdd(`{"version":"${version}"}`, 'package.json', 'Add package.json');
+  {
+    const gitClient = factory(Git);
+    sh.exec(`git tag ${version}`);
+    t.is(await gitClient.getLatestTagName(), version);
+  }
+  {
+    const gitClient = factory(Git);
+    gitAdd('line', 'file', 'Add file');
+    sh.exec('npm --no-git-tag-version version patch');
+    await gitClient.stage('package.json');
+    await gitClient.commit({ message: `Release v1.2.4` });
+    await gitClient.tag({ name: 'v1.2.4', annotation: 'Release v1.2.4' });
+    t.is(await gitClient.getLatestTagName(), 'v1.2.4');
+    await gitClient.push();
+    const status = sh.exec('git status -uno');
+    t.true(status.includes('nothing to commit'));
+  }
+});
+
+test.serial('should commit, tag and push with extra args', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  gitAdd('line', 'file', 'Add file');
+  const options = { git: { commitArgs: '-S', tagArgs: ['-T', 'foo'], pushArgs: ['-U', 'bar', '-V'] } };
+  const gitClient = factory(Git, { options });
+  const stub = sinon.stub(gitClient.shell, 'exec').resolves();
+  await gitClient.stage('package.json');
+  await gitClient.commit({ message: `Release v1.2.4` });
+  await gitClient.tag({ name: 'v1.2.4', annotation: 'Release v1.2.4' });
+  await gitClient.push();
+  t.true(stub.secondCall.args[0].includes('-S'));
+  t.is(stub.thirdCall.args[0][5], '-T');
+  t.is(stub.thirdCall.args[0][6], 'foo');
+  t.true(stub.lastCall.args[0].join(' ').includes('-U bar -V'));
+  stub.restore();
+});
+
+test.serial('should amend commit without message if not provided', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  gitAdd('line', 'file', 'Add file');
+  const options = { git: { commitArgs: ['--amend', '--no-edit', '--no-verify'] } };
+  const gitClient = factory(Git, { options });
+  const stub = sinon.stub(gitClient.shell, 'exec').resolves();
+  await gitClient.stage('package.json');
+  await gitClient.commit();
+  t.deepEqual(stub.secondCall.args[0], ['git', 'commit', '--amend', '--no-edit', '--no-verify']);
+  stub.restore();
+});
+
+test.serial('should commit and tag with quoted characters', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  const gitClient = factory(Git, {
+    options: { git: { commitMessage: 'Release ${version}', tagAnnotation: 'Release ${version}\n\n${changelog}' } }
+  });
+  sh.touch('file');
+  const changelog = `- Foo's${EOL}- "$bar"${EOL}- '$baz'${EOL}- foo`;
+  gitClient.config.setContext({ version: '1.0.0', changelog });
+
+  await gitClient.stage('file');
+  await gitClient.commit();
+  await gitClient.tag({ name: '1.0.0' });
+  await gitClient.push();
+  {
+    const { stdout } = sh.exec('git log -1 --format=%s');
+    t.is(stdout.trim(), 'Release 1.0.0');
+  }
+  {
+    const { stdout } = sh.exec('git tag -n99');
+    t.is(stdout.trim(), `1.0.0           Release 1.0.0\n    \n    - Foo's\n    - "$bar"\n    - '$baz'\n    - foo`);
+  }
+});
+
+test.serial('should push to origin', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  gitAdd('line', 'file', 'Add file');
+  const gitClient = factory(Git);
+  const spy = sinon.spy(gitClient.shell, 'exec');
+  await gitClient.push();
+  t.deepEqual(spy.lastCall.args[0], ['git', 'push']);
+  const actual = sh.exec('git ls-tree -r HEAD --name-only', { cwd: bare });
+  t.is(actual.trim(), 'file');
+  spy.restore();
+});
+
+test.serial('should push to tracked upstream branch', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  sh.exec(`git remote rename origin upstream`);
+  gitAdd('line', 'file', 'Add file');
+  const gitClient = factory(Git);
+  const spy = sinon.spy(gitClient.shell, 'exec');
+  await gitClient.push();
+  t.deepEqual(spy.lastCall.args[0], ['git', 'push']);
+  const actual = sh.exec('git ls-tree -r HEAD --name-only', { cwd: bare });
+  t.is(actual.trim(), 'file');
+  spy.restore();
+});
+
+test.serial('should push to repo url', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  gitAdd('line', 'file', 'Add file');
+  const options = { git: { pushRepo: 'https://host/repo.git' } };
+  const gitClient = factory(Git, { options });
+  const spy = sinon.spy(gitClient.shell, 'exec');
+  try {
+    await gitClient.push();
+  } catch (err) {
+    t.deepEqual(spy.lastCall.args[0], ['git', 'push', 'https://host/repo.git']);
+  }
+  spy.restore();
+});
+
+test.serial('should push to remote name (not "origin")', async t => {
+  const bare = mkTmpDir();
+  sh.exec(`git init --bare ${bare}`);
+  sh.exec(`git clone ${bare} .`);
+  gitAdd('line', 'file', 'Add file');
+  sh.exec(`git remote add upstream ${sh.exec('git config --get remote.origin.url')}`);
+  const options = { git: { pushRepo: 'upstream' } };
+  const gitClient = factory(Git, { options });
+  const spy = sinon.spy(gitClient.shell, 'exec');
+  await gitClient.push();
+  t.deepEqual(spy.lastCall.args[0], ['git', 'push', 'upstream']);
+  const actual = sh.exec('git ls-tree -r HEAD --name-only', { cwd: bare });
+  t.is(actual.trim(), 'file');
+  {
+    sh.exec(`git checkout -b foo`);
+    gitAdd('line', 'file', 'Add file');
+    await gitClient.push();
+    t.deepEqual(spy.lastCall.args[0], ['git', 'push', '--set-upstream', 'upstream', 'foo']);
+    t.regex(
+      await spy.lastCall.returnValue,
+      /branch .?foo.? set up to track (remote branch .?foo.? from .?upstream.?|.?upstream\/foo.?)/i
+    );
+  }
+  spy.restore();
+});
+
+test.serial('should return repo status', async t => {
+  const gitClient = factory(Git);
+  sh.exec('git init');
+  gitAdd('line', 'file1', 'Add file');
+  sh.ShellString('line').toEnd('file1');
+  sh.ShellString('line').toEnd('file2');
+  sh.exec('git add file2');
+  t.is(await gitClient.status(), ' M file1\nA  file2');
+});
+
+test.serial('should reset files', async t => {
+  const gitClient = factory(Git);
+  sh.exec('git init');
+  gitAdd('line', 'file', 'Add file');
+  sh.ShellString('line').toEnd('file');
+  t.regex(await readFile('file'), /^line\s*line\s*$/);
+  await gitClient.reset('file');
+  t.regex(await readFile('file'), /^line\s*$/);
+  await gitClient.reset(['file2, file3']);
+  t.regex(gitClient.log.warn.firstCall.args[0], /Could not reset file2, file3/);
+});
+
+test.serial('should roll back when cancelled', async t => {
+  sh.exec('git init');
+  sh.exec(`git remote add origin file://foo`);
+  const version = '1.2.3';
+  gitAdd(`{"version":"${version}"}`, 'package.json', 'Add package.json');
+  const options = { git: { requireCleanWorkingDir: true, commit: true, tag: true, tagName: 'v${version}' } };
+  const gitClient = factory(Git, { options });
+  const exec = sinon.spy(gitClient.shell, 'execFormattedCommand');
+  sh.exec(`git tag ${version}`);
+  gitAdd('line', 'file', 'Add file');
+
+  await gitClient.init();
+
+  sh.exec('npm --no-git-tag-version version patch');
+
+  gitClient.bump('1.2.4');
+  await gitClient.beforeRelease();
+  await gitClient.stage('package.json');
+  await gitClient.commit({ message: 'Add this' });
+  await gitClient.tag();
+  await gitClient.rollbackOnce();
+
+  t.is(exec.args[11][0], 'git tag --delete v1.2.4');
+  t.is(exec.args[12][0], 'git reset --hard HEAD~1');
+});
+
+test.serial('should not touch existing history when rolling back', async t => {
+  sh.exec('git init');
+  const version = '1.2.3';
+  gitAdd(`{"version":"${version}"}`, 'package.json', 'Add package.json');
+  const options = { git: { requireCleanWorkingDir: true, commit: true, tag: true } };
+  const gitClient = factory(Git, { options });
+  sh.exec(`git tag ${version}`);
+
+  const exec = sinon.spy(gitClient.shell, 'execFormattedCommand');
+  gitClient.config.setContext({ version: '1.2.4' });
+  await gitClient.beforeRelease();
+  await gitClient.commit();
+  await gitClient.rollbackOnce();
+
+  t.is(exec.args[3][0], 'git reset --hard HEAD');
+});
+
+test.serial('should not roll back with risky config', async t => {
+  sh.exec('git init');
+  const options = { git: { requireCleanWorkingDir: false, commit: true, tag: true } };
+  const gitClient = factory(Git, { options });
+  await gitClient.beforeRelease();
+  t.is('rollbackOnce' in gitClient, false);
+});
+
+test.serial('should return latest tag from default branch (not parent commit)', async t => {
+  sh.exec('git init');
+
+  {
+    const options = { git: { getLatestTagFromAllRefs: true } };
+    const gitClient = factory(Git, { options });
+    gitAdd('main', 'file', 'Add file in main');
+    const defaultBranchName = await gitClient.getBranchName();
+    const developBranchName = 'develop';
+    const featureBranchPrefix = 'feature';
+    await gitClient.tag({ name: '1.0.0' });
+    sh.exec(`git branch ${developBranchName} ${defaultBranchName}`);
+    sh.exec(`git checkout -b ${featureBranchPrefix}/first ${developBranchName}`);
+    gitAdd('feature/1', 'file', 'Update file in feature branch (1)');
+    sh.exec(`git checkout ${developBranchName}`);
+    sh.exec(`git merge --no-ff ${featureBranchPrefix}/first`);
+    await gitClient.tag({ name: '1.1.0-rc.1' });
+    sh.exec(`git checkout ${defaultBranchName}`);
+    sh.exec(`git merge --no-ff ${developBranchName}`);
+    await gitClient.tag({ name: '1.1.0' });
+    sh.exec(`git checkout -b ${featureBranchPrefix}/second ${developBranchName}`);
+    gitAdd('feature/2', 'file', 'Update file again, in feature branch (2)');
+    sh.exec(`git checkout ${developBranchName}`);
+    sh.exec(`git merge --no-ff ${featureBranchPrefix}/second`);
+    t.is(await gitClient.getLatestTagName(), '1.1.0');
+  }
+
+  {
+    const options = { git: { getLatestTagFromAllRefs: false } };
+    const gitClient = factory(Git, { options });
+    t.is(await gitClient.getLatestTagName(), '1.1.0-rc.1');
+  }
+});