folderRepositoryManager.test.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import { default as assert } from 'assert';
import { createSandbox, SinonSandbox } from 'sinon';

import { FolderRepositoryManager, titleAndBodyFrom } from '../../github/folderRepositoryManager';
import { MockRepository } from '../mocks/mockRepository';
import { MockTelemetry } from '../mocks/mockTelemetry';
import { MockCommandRegistry } from '../mocks/mockCommandRegistry';
import { PullRequestModel } from '../../github/pullRequestModel';
import { GitHubRemote, Remote } from '../../common/remote';
import { Protocol } from '../../common/protocol';
import { GitHubRepository } from '../../github/githubRepository';
import { PullRequestBuilder } from '../builders/rest/pullRequestBuilder';
import { convertRESTPullRequestToRawPullRequest } from '../../github/utils';
import { GitApiImpl } from '../../api/api1';
import { CredentialStore } from '../../github/credentials';
import { MockExtensionContext } from '../mocks/mockExtensionContext';
import { Uri } from 'vscode';
import { GitHubServerType } from '../../common/authentication';
import { CreatePullRequestHelper } from '../../view/createPullRequestHelper';
import { RepositoriesManager } from '../../github/repositoriesManager';
import { MockThemeWatcher } from '../mocks/mockThemeWatcher';

describe('PullRequestManager', function () {
	let sinon: SinonSandbox;
	let manager: FolderRepositoryManager;
	let telemetry: MockTelemetry;
	let mockThemeWatcher: MockThemeWatcher;
	let mockRepository: MockRepository;

	beforeEach(function () {
		sinon = createSandbox();
		MockCommandRegistry.install(sinon);

		telemetry = new MockTelemetry();
		mockThemeWatcher = new MockThemeWatcher();
		mockRepository = new MockRepository();
		const context = new MockExtensionContext();
		const credentialStore = new CredentialStore(telemetry, context);
		const repositoriesManager = new RepositoriesManager(credentialStore, telemetry);
		manager = new FolderRepositoryManager(0, context, mockRepository, telemetry, new GitApiImpl(repositoriesManager), credentialStore, new CreatePullRequestHelper(), mockThemeWatcher);
	});

	afterEach(function () {
		sinon.restore();
	});

	describe('activePullRequest', function () {
		it('gets and sets the active pull request', function () {
			assert.strictEqual(manager.activePullRequest, undefined);

			const changeFired = sinon.spy();
			manager.onDidChangeActivePullRequest(changeFired);

			const url = 'https://github.com/aaa/bbb.git';
			const protocol = new Protocol(url);
			const remote = new GitHubRemote('origin', url, protocol, GitHubServerType.GitHubDotCom);
			const rootUri = Uri.file('C:\\users\\test\\repo');
			const repository = new GitHubRepository(1, remote, rootUri, manager.credentialStore, telemetry);
			const prItem = convertRESTPullRequestToRawPullRequest(new PullRequestBuilder().build(), repository);
			const pr = new PullRequestModel(manager.credentialStore, telemetry, repository, remote, prItem);

			manager.activePullRequest = pr;
			assert(changeFired.called);
			assert.deepStrictEqual(manager.activePullRequest, pr);
		});
	});

	describe('getOrigin', function () {
		it('falls back to configured GitHub remote when upstream is not GitHub', async function () {
			// Setup: Add a GitHub remote
			const githubUrl = 'https://github.com/test/repo.git';
			await mockRepository.addRemote('github', githubUrl);

			const githubProtocol = new Protocol(githubUrl);
			const githubRemote = new GitHubRemote('github', githubUrl, githubProtocol, GitHubServerType.GitHubDotCom);
			const rootUri = Uri.file('/test/repo');
			const githubRepository = new GitHubRepository(1, githubRemote, rootUri, manager.credentialStore, telemetry);

			// Manually set up the GitHub repository in the manager (simulating successful initialization)
			(manager as any)._githubRepositories = [githubRepository];

			// Add a non-GitHub remote (simulating the scenario from the bug)
			await mockRepository.addRemote('origin', 'https://example.com/git/repo.git');

			// Create a branch with upstream set to non-GitHub remote
			await mockRepository.createBranch('test-branch', true);
			await mockRepository.setBranchUpstream('test-branch', 'refs/remotes/origin/main');

			// Mock getAllGitHubRemotes to return only the github remote
			sinon.stub(manager, 'getAllGitHubRemotes').resolves([githubRemote]);

			// Act: getOrigin should fall back to the configured GitHub remote instead of throwing
			const result = await manager.getOrigin();

			// Assert: Should return the GitHub repository, not throw an error
			assert.strictEqual(result, githubRepository);
		});
	});
});

describe('titleAndBodyFrom', function () {
	it('separates title and body', async function () {
		const message = Promise.resolve('title\n\ndescription 1\n\ndescription 2\n');

		const result = await titleAndBodyFrom(message);
		assert.strictEqual(result?.title, 'title');
		assert.strictEqual(result?.body, 'description 1\n\ndescription 2');
	});

	it('returns only title with no body', async function () {
		const message = Promise.resolve('title');

		const result = await titleAndBodyFrom(message);
		assert.strictEqual(result?.title, 'title');
		assert.strictEqual(result?.body, '');
	});

	it('returns only title when body contains only whitespace', async function () {
		const message = Promise.resolve('title\n\n');

		const result = await titleAndBodyFrom(message);
		assert.strictEqual(result?.title, 'title');
		assert.strictEqual(result?.body, '');
	});
});