Retry current user request after failure

Clear failed current-user and EMU promise caches so later GitHub operations can retry instead of replaying an activation-time network error.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: chrmarti

src/gitProviders/GitHubContactServiceProvider.ts

@@ -125,7 +125,7 @@ export class GitHubContactServiceProvider implements ContactServiceProvider {
 		}
 		const origin = await this.pullRequestManager.folderManagers[0]?.getOrigin();
 		if (origin) {
-			const currentUser = origin.hub.currentUser ? await origin.hub.currentUser : undefined;
+			const currentUser = await origin.getAuthenticatedUser();
 			if (currentUser) {
 				return currentUser.login;
 			}

src/github/credentials.ts

@@ -551,19 +551,25 @@ export class CredentialStore extends Disposable {
 	}
 
 	public async isCurrentUser(authProviderId: AuthProvider, username: string): Promise<boolean> {
-		const api = authProviderId === AuthProvider.github ? this._githubAPI : this._githubEnterpriseAPI;
-		return (await api?.currentUser)?.login === username;
+		return (await this.getCurrentUser(authProviderId))?.login === username;
 	}
 
 	public async getIsEmu(authProviderId: AuthProvider): Promise<boolean> {
 		const github = this.getHub(authProviderId);
+		this.ensureCurrentUser(github);
 		return !!(await github?.isEmu);
 	}
 
 	public getCurrentUser(authProviderId: AuthProvider): Promise<IAccount> {
 		const github = this.getHub(authProviderId);
-		const octokit = github?.octokit;
-		return (octokit && github?.currentUser)!;
+		this.ensureCurrentUser(github);
+		return github?.currentUser!;
+	}
+
+	private ensureCurrentUser(github: GitHub | undefined): void {
+		if (github && (!github.currentUser || !github.isEmu)) {
+			this.setCurrentUser(github);
+		}
 	}
 
 	private setCurrentUser(github: GitHub): void {
@@ -577,8 +583,28 @@ export class CredentialStore extends Disposable {
 				reject(e);
 			});
 		});
-		github.currentUser = getUser.then(result => convertRESTUserToAccount(result.data));
-		github.isEmu = getUser.then(result => result.data.plan?.name === 'emu_user');
+		let currentUser: Promise<IAccount>;
+		let isEmu: Promise<boolean>;
+		const clearFailedRequest = () => {
+			if (github.currentUser === currentUser && github.isEmu === isEmu) {
+				github.currentUser = undefined;
+				github.isEmu = undefined;
+			}
+		};
+		currentUser = getUser.then(result => convertRESTUserToAccount(result.data), e => {
+			clearFailedRequest();
+			throw e;
+		});
+		isEmu = getUser.then(result => result.data.plan?.name === 'emu_user', e => {
+			clearFailedRequest();
+			throw e;
+		});
+		github.currentUser = currentUser;
+		github.isEmu = isEmu;
+
+		// Both promises share the same request, but callers may only observe one of them.
+		void currentUser.catch(() => undefined);
+		void isEmu.catch(() => undefined);
 	}
 
 	private async getSession(authProviderId: AuthProvider, getAuthSessionOptions: vscode.AuthenticationGetSessionOptions, scopes: string[], requireScopes: boolean): Promise<{ session: vscode.AuthenticationSession | undefined, isNew: boolean, scopes: string[] }> {

src/github/githubRepository.ts

@@ -424,7 +424,7 @@ export class GitHubRepository extends Disposable {
 			repo
 		});
 		Logger.debug(`Fetch metadata for repo ${owner}/${repo} - done`, this.id);
-		const metadata = { ...result.data, currentUser: await this._hub?.currentUser };
+		const metadata = { ...result.data, currentUser: await this.getAuthenticatedUser() };
 		return metadata;
 	}
 

src/test/github/credentials.test.ts

@@ -3,10 +3,15 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { strictEqual, deepStrictEqual } from 'assert';
+import { strictEqual, deepStrictEqual, rejects } from 'assert';
+import { Octokit } from '@octokit/rest';
+import { createSandbox, SinonSandbox } from 'sinon';
 import * as vscode from 'vscode';
 import { AuthProvider } from '../../common/authentication';
-import { findExistingSession } from '../../github/credentials';
+import { CredentialStore, findExistingSession, GitHub } from '../../github/credentials';
+import { LoggingApolloClient, LoggingOctokit, RateLogger } from '../../github/loggingOctokit';
+import { MockExtensionContext } from '../mocks/mockExtensionContext';
+import { MockTelemetry } from '../mocks/mockTelemetry';
 
 const oldestScopes = ['read:user', 'user:email', 'repo'];
 const defaultScopes = [...oldestScopes, 'workflow'];
@@ -29,6 +34,16 @@ function createSession(id: string, accountId: string, scopes: string[]): vscode.
 }
 
 describe('CredentialStore', function () {
+	let sinon: SinonSandbox;
+
+	beforeEach(function () {
+		sinon = createSandbox();
+	});
+
+	afterEach(function () {
+		sinon.restore();
+	});
+
 	describe('findExistingSession', function () {
 		it('keeps broader scope lookup on the preferred account', async function () {
 			const firstAccountAdditional = createSession('first-additional', 'first', additionalScopes);
@@ -99,4 +114,43 @@ describe('CredentialStore', function () {
 			deepStrictEqual(additionalResult?.scopes, additionalScopes);
 		});
 	});
+
+	it('retries the current user request after a failure', async function () {
+		const telemetry = new MockTelemetry();
+		const credentialStore = new CredentialStore(telemetry, new MockExtensionContext());
+		const github: GitHub = {
+			octokit: new LoggingOctokit(new Octokit(), new RateLogger(telemetry, false)),
+			graphql: {} as LoggingApolloClient,
+		};
+		sinon.stub(credentialStore, 'getHub').returns(github);
+		const getAuthenticatedUser = sinon.stub(github.octokit, 'call');
+		const error = new Error('Connect Timeout Error');
+		getAuthenticatedUser.onFirstCall().rejects(error);
+		getAuthenticatedUser.onSecondCall().resolves({
+			data: {
+				login: 'octocat',
+				node_id: 'MDQ6VXNlcjE=',
+				html_url: 'https://github.com/octocat',
+				avatar_url: 'https://github.com/images/error/octocat_happy.gif',
+				type: 'User',
+				plan: { name: 'emu_user' },
+			}
+		});
+
+		await rejects(credentialStore.getCurrentUser(AuthProvider.github), candidate => candidate === error);
+		const [currentUser, isEmu] = await Promise.all([
+			credentialStore.getCurrentUser(AuthProvider.github),
+			credentialStore.getIsEmu(AuthProvider.github),
+		]);
+
+		deepStrictEqual({
+			requests: getAuthenticatedUser.callCount,
+			login: currentUser.login,
+			isEmu,
+		}, {
+			requests: 2,
+			login: 'octocat',
+			isEmu: true,
+		});
+	});
 });