fix: use the same git binary as VS Code

src/extension.js

@@ -17,7 +17,7 @@ const { GitContentProvider } = require('./review/git_content_provider');
 const { REVIEW_URI_SCHEME } = require('./constants');
 const { USER_COMMANDS, PROGRAMMATIC_COMMANDS } = require('./command_names');
 const { CiCompletionProvider } = require('./completion/ci_completion_provider');
-const { GitExtensionWrapper } = require('./git/git_extension_wrapper');
+const { gitExtensionWrapper } = require('./git/git_extension_wrapper');
 const {
   toggleResolved,
   deleteComment,
@@ -112,7 +112,7 @@ const activate = context => {
   tokenService.init(context);
   tokenServiceWrapper.init(context);
   registerCiCompletion(context);
-  context.subscriptions.push(GitExtensionWrapper.registerToGitExtension());
+  gitExtensionWrapper.init();
 };
 
 exports.activate = activate;

src/git/git_extension_wrapper.test.ts

-import { GitExtension } from '../api/git';
+import * as vscode from 'vscode';
 import { GitExtensionWrapper } from './git_extension_wrapper';
 import { GitLabRemoteSourceProviderRepository } from '../gitlab/clone/gitlab_remote_source_provider_repository';
 import { gitlabCredentialsProvider } from '../gitlab/clone/gitlab_credentials_provider';
@@ -12,20 +12,17 @@ describe('GitExtensionWrapper', () => {
 
   beforeEach(async () => {
     fakeExtension = new FakeGitExtension();
+    (vscode.extensions.getExtension as jest.Mock).mockReturnValue({ exports: fakeExtension });
   });
 
   it('creates a new GitLabRemoteSourceProviderRepository', async () => {
-    // TODO: maybe introduce something like an initialize method instead of doing the work in constructor
-    // eslint-disable-next-line no-new
-    new GitExtensionWrapper((fakeExtension as unknown) as GitExtension);
+    new GitExtensionWrapper().init();
 
     expect(GitLabRemoteSourceProviderRepository).toHaveBeenCalledWith(fakeExtension.gitApi);
   });
 
   it('adds credentials provider to the Git Extension', async () => {
-    // TODO: maybe introduce something like an initialize method instead of doing the work in constructor
-    // eslint-disable-next-line no-new
-    new GitExtensionWrapper((fakeExtension as unknown) as GitExtension);
+    new GitExtensionWrapper().init();
 
     expect(fakeExtension.gitApi.credentialsProviders).toEqual([gitlabCredentialsProvider]);
   });

src/git/git_extension_wrapper.ts

@@ -3,56 +3,66 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { extensions, Disposable } from 'vscode';
-import { GitExtension } from '../api/git';
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import { API, GitExtension } from '../api/git';
 import { gitlabCredentialsProvider } from '../gitlab/clone/gitlab_credentials_provider';
 import { GitLabRemoteSourceProviderRepository } from '../gitlab/clone/gitlab_remote_source_provider_repository';
 import { handleError, log } from '../log';
 
-export class GitExtensionWrapper implements Disposable {
-  disposables = new Set<Disposable>();
+export class GitExtensionWrapper implements vscode.Disposable {
+  disposables = new Set<vscode.Disposable>();
 
-  constructor(private gitExtension: GitExtension) {
-    this.disposables.add(
-      gitExtension.onDidChangeEnablement(this.onDidChangeGitExtensionEnablement, this),
-    );
-    this.onDidChangeGitExtensionEnablement(gitExtension.enabled);
-  }
+  private gitApi?: API;
+
+  private gitExtension?: GitExtension;
 
   private onDidChangeGitExtensionEnablement(enabled: boolean) {
     if (enabled) {
-      this.initialize();
+      this.register();
     } else {
       this.dispose();
     }
   }
 
-  private initialize() {
+  get gitBinaryPath(): string {
+    const path = this.gitApi?.git.path;
+    assert(path, 'Could not get git binary path from the Git extension.');
+    return path;
+  }
+
+  private register() {
+    assert(this.gitExtension);
     try {
-      const gitAPI = this.gitExtension.getAPI(1);
+      this.gitApi = this.gitExtension.getAPI(1);
 
-      this.disposables.add(new GitLabRemoteSourceProviderRepository(gitAPI));
-      this.disposables.add(gitAPI.registerCredentialsProvider(gitlabCredentialsProvider));
+      this.disposables.add(new GitLabRemoteSourceProviderRepository(this.gitApi));
+      this.disposables.add(this.gitApi.registerCredentialsProvider(gitlabCredentialsProvider));
     } catch (err) {
       handleError(err);
     }
   }
 
   dispose(): void {
+    this.gitApi = undefined;
     this.disposables.forEach(d => d?.dispose());
     this.disposables.clear();
   }
 
-  static registerToGitExtension(): Disposable {
+  init(): void {
     try {
-      const gitExtension = extensions.getExtension<GitExtension>('vscode.git')?.exports;
-      if (gitExtension !== undefined) {
-        return new GitExtensionWrapper(gitExtension);
+      this.gitExtension = vscode.extensions.getExtension<GitExtension>('vscode.git')?.exports;
+      if (this.gitExtension !== undefined) {
+        this.disposables.add(
+          this.gitExtension.onDidChangeEnablement(this.onDidChangeGitExtensionEnablement, this),
+        );
+        this.onDidChangeGitExtensionEnablement(this.gitExtension.enabled);
       }
       log('Could not get Git Extension');
     } catch (error) {
       handleError(error);
     }
-    return { dispose: () => undefined };
   }
 }
+
+export const gitExtensionWrapper = new GitExtensionWrapper();

src/git_service.test.ts

@@ -4,6 +4,7 @@ import { promises as fs } from 'fs';
 import * as path from 'path';
 import simpleGit, { SimpleGit } from 'simple-git';
 import { GitService, GitServiceOptions } from './git_service';
+import { gitExtensionWrapper } from './git/git_extension_wrapper';
 
 describe('git_service', () => {
   const ORIGIN = 'origin';
@@ -38,6 +39,7 @@ describe('git_service', () => {
     (vscode.workspace.getConfiguration as jest.Mock).mockReturnValue({
       instanceUrl: 'https://gitlab.com',
     });
+    jest.spyOn(gitExtensionWrapper, 'gitBinaryPath', 'get').mockReturnValue('git');
   });
 
   afterEach(() => {

src/git_service.ts

 import * as execa from 'execa';
 import { UserFriendlyError } from './errors/user_friendly_error';
+import { gitExtensionWrapper } from './git/git_extension_wrapper';
 import { parseGitRemote, GitRemote } from './git/git_remote_parser';
 import { log } from './log';
 import { getInstanceUrl } from './utils/get_instance_url';
@@ -20,8 +21,8 @@ export class GitService {
   }
 
   private async fetch(cmd: string): Promise<string> {
-    const [git, ...args] = cmd.trim().split(' ');
-    const { stdout } = await execa(git, args, {
+    const [, ...args] = cmd.trim().split(' ');
+    const { stdout } = await execa(gitExtensionWrapper.gitBinaryPath, args, {
       cwd: this.workspaceFolder,
       preferLocal: false,
     });

src/utils/get_instance_url.test.ts

@@ -4,6 +4,7 @@ import simpleGit, { SimpleGit } from 'simple-git';
 import { getInstanceUrl } from './get_instance_url';
 import { tokenService } from '../services/token_service';
 import { GITLAB_COM_URL } from '../constants';
+import { gitExtensionWrapper } from '../git/git_extension_wrapper';
 
 describe('get_instance_url', () => {
   const ORIGIN = 'origin';
@@ -22,6 +23,10 @@ describe('get_instance_url', () => {
       });
     });
 
+  beforeEach(() => {
+    jest.spyOn(gitExtensionWrapper, 'gitBinaryPath', 'get').mockReturnValue('git');
+  });
+
   it('returns configured instanceUrl if the config contains one', async () => {
     (vscode.workspace.getConfiguration as jest.Mock).mockReturnValue({
       instanceUrl: 'https://test.com',

src/utils/get_instance_url.ts

@@ -5,10 +5,11 @@ import { GITLAB_COM_URL } from '../constants';
 import { tokenService } from '../services/token_service';
 import { log } from '../log';
 import { parseGitRemote } from '../git/git_remote_parser';
+import { gitExtensionWrapper } from '../git/git_extension_wrapper';
 
 async function fetch(cmd: string, workspaceFolder: string): Promise<string | null> {
-  const [git, ...args] = cmd.trim().split(' ');
-  const { stdout } = await execa(git, args, {
+  const [, ...args] = cmd.trim().split(' ');
+  const { stdout } = await execa(gitExtensionWrapper.gitBinaryPath, args, {
     cwd: workspaceFolder,
     preferLocal: false,
   });