WIP - uri handler rework

Author: sdzh-atlassian

__mocks__/vscode.ts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+module.exports = {
+    ...require('jest-mock-vscode').createVSCodeMock(jest),
+    env: {
+        uriScheme: 'vscode'
+    }
+}

jest.config.js

@@ -1,5 +1,5 @@
 module.exports = {
-    roots: ['<rootDir>/src'],
+    roots: ['<rootDir>'],
     testMatch: ['**/test/**/*.+(ts|tsx|js)', '**/?(*.)+(spec|test).+(ts|tsx|js)'],
     transform: {
         '^.+\\.(min.js|ts|tsx)$': [
@@ -9,7 +9,7 @@ module.exports = {
             },
         ],
     },
-    transformIgnorePatterns: ['/node_modules/'],
+    moduleDirectories: ['node_modules', 'src'],
     verbose: true,
     setupFilesAfterEnv: ['<rootDir>/setupTests.js'],
     // coverage configuration

package-lock.json

@@ -1517,6 +1517,7 @@
         "fork-ts-checker-webpack-plugin": "^9.0.2",
         "html-webpack-plugin": "^5.6.0",
         "jest": "^29.7.0",
+        "jest-mock-vscode": "^4.0.4",
         "license-checker": "^25.0.1",
         "mini-css-extract-plugin": "^2.9.1",
         "npm-run-all": "^4.1.5",

package.json

@@ -26,7 +26,7 @@ import { Tokens } from './tokens';
 import crypto from 'crypto';
 import { keychain } from '../util/keychain';
 import { loggedOutEvent } from '../analytics';
-import { Container } from 'src/container';
+import { Container } from '../container';
 const keychainServiceNameV3 = version.endsWith('-insider') ? 'atlascode-insiders-authinfoV3' : 'atlascode-authinfoV3';
 
 enum Priority {

src/atlclients/authStore.ts

@@ -6,7 +6,7 @@ import { AxiosUserAgent } from '../constants';
 import { ConnectionTimeout } from '../util/time';
 import { Container } from '../container';
 import { Disposable } from 'vscode';
-import { Logger } from 'src/logger';
+import { Logger } from '../logger';
 import { addCurlLogging } from './interceptors';
 import { getAgent } from '../jira/jira-client/providers';
 import { strategyForProvider } from './strategy';

src/atlclients/oauthRefresher.ts

@@ -1,6 +1,6 @@
-import { AtlascodeUriHandler, ONBOARDING_URL, SETTINGS_URL } from './uriHandler';
+import { LegacyAtlascodeUriHandler, ONBOARDING_URL, SETTINGS_URL } from './uriHandler/legacyUriHandler';
 import { BitbucketIssue, BitbucketSite, PullRequest, WorkspaceRepo } from './bitbucket/model';
-import { Disposable, ExtensionContext, UriHandler, env, workspace, UIKind } from 'vscode';
+import { Disposable, ExtensionContext, env, workspace, UIKind } from 'vscode';
 import { IConfig, configuration } from './config/configuration';
 
 import { analyticsClient } from './analytics-node-client/src/client.min.js';
@@ -65,8 +65,9 @@ import { VSCWelcomeActionApi } from './webview/welcome/vscWelcomeActionApi';
 import { VSCWelcomeWebviewControllerFactory } from './webview/welcome/vscWelcomeWebviewControllerFactory';
 import { WelcomeAction } from './lib/ipc/fromUI/welcome';
 import { WelcomeInitMessage } from './lib/ipc/toUI/welcome';
-import { FeatureFlagClient } from './util/featureFlags';
+import { FeatureFlagClient, Features } from './util/featureFlags';
 import { EventBuilder } from './util/featureFlags/eventBuilder';
+import { AtlascodeUriHandler } from './uriHandler';
 import { CheckoutHelper } from './bitbucket/interfaces';
 
 const isDebuggingRegex = /^--(debug|inspect)\b(-brk\b|(?!-))=?/;
@@ -86,14 +87,6 @@ export class Container {
             enable: this.getAnalyticsEnable(),
         });
 
-        FeatureFlagClient.initialize({
-            analyticsClient: this._analyticsClient,
-            identifiers: {
-                analyticsAnonymousId: env.machineId,
-            },
-            eventBuilder: new EventBuilder(),
-        });
-
         this._cancellationManager = new Map();
         this._analyticsApi = new VSCAnalyticsApi(this._analyticsClient, this.isRemote, this.isWebUI);
         this._commonMessageHandler = new VSCCommonMessageHandler(this._analyticsApi, this._cancellationManager);
@@ -189,9 +182,6 @@ export class Container {
 
         this._loginManager = new LoginManager(this._credentialManager, this._siteManager, this._analyticsClient);
         this._bitbucketHelper = new BitbucketCheckoutHelper(context.globalState);
-        context.subscriptions.push(
-            (this._uriHandler = new AtlascodeUriHandler(this._analyticsApi, this._bitbucketHelper)),
-        );
 
         if (config.jira.explorer.enabled) {
             context.subscriptions.push((this._jiraExplorer = new JiraContext()));
@@ -206,13 +196,44 @@ export class Container {
         }
 
         context.subscriptions.push((this._helpExplorer = new HelpExplorer()));
+
+        FeatureFlagClient.initialize({
+            analyticsClient: this._analyticsClient,
+            identifiers: {
+                analyticsAnonymousId: env.machineId,
+            },
+            eventBuilder: new EventBuilder(),
+        }).then(() => {
+            this.initializeUriHandler(context, this._analyticsApi, this._bitbucketHelper);
+        });
     }
 
     static getAnalyticsEnable(): boolean {
         const telemetryConfig = workspace.getConfiguration('telemetry');
         return telemetryConfig.get<boolean>('enableTelemetry', true);
     }
 
+    static initializeUriHandler(
+        context: ExtensionContext,
+        analyticsApi: VSCAnalyticsApi,
+        bitbucketHelper: CheckoutHelper,
+    ) {
+        FeatureFlagClient.checkGate(Features.EnableNewUriHandler)
+            .then((enabled) => {
+                if (enabled) {
+                    console.log('Using new URI handler');
+                    context.subscriptions.push(new AtlascodeUriHandler(analyticsApi, bitbucketHelper));
+                } else {
+                    context.subscriptions.push(new LegacyAtlascodeUriHandler(analyticsApi, bitbucketHelper));
+                }
+            })
+            .catch((err) => {
+                // Not likely that we'd land here - but if anything goes wrong, default to legacy handler
+                console.error(`Error checking feature flag ${Features.EnableNewUriHandler}: ${err}`);
+                context.subscriptions.push(new LegacyAtlascodeUriHandler(analyticsApi, bitbucketHelper));
+            });
+    }
+
     static initializeBitbucket(bbCtx: BitbucketContext) {
         this._bitbucketContext = bbCtx;
         this._pipelinesExplorer = new PipelinesExplorer(bbCtx);
@@ -288,11 +309,6 @@ export class Container {
         this._context.globalState.update(ConfigTargetKey, target);
     }
 
-    private static _uriHandler: UriHandler;
-    static get uriHandler() {
-        return this._uriHandler;
-    }
-
     private static _version: string;
     static get version() {
         return this._version;

src/container.ts

@@ -3,7 +3,7 @@ import { AgentProvider, getProxyHostAndPort, shouldTunnelHost } from '@atlassian
 import axios, { AxiosInstance } from 'axios';
 import * as fs from 'fs';
 import * as https from 'https';
-import { Logger } from 'src/logger';
+import { Logger } from '../../logger';
 import * as sslRootCas from 'ssl-root-cas';
 import { DetailedSiteInfo, SiteInfo } from '../../atlclients/authInfo';
 import { BasicInterceptor } from '../../atlclients/basicInterceptor';

src/jira/jira-client/providers.ts

@@ -0,0 +1,54 @@
+import { Uri, window } from 'vscode';
+import { CheckoutBranchUriHandlerAction } from './checkoutBranch';
+
+describe('CheckoutBranchUriHandlerAction', () => {
+    const mockAnalyticsApi = {
+        fireDeepLinkEvent: jest.fn(),
+    };
+    const mockCheckoutHelper = {
+        checkoutRef: jest.fn().mockResolvedValue(true),
+    };
+    let action: CheckoutBranchUriHandlerAction;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        action = new CheckoutBranchUriHandlerAction(mockCheckoutHelper as any, mockAnalyticsApi as any);
+    });
+
+    describe('isAccepted', () => {
+        it('only accepts URIs ending with checkoutBranch', () => {
+            expect(action.isAccepted(Uri.parse('https://some-uri/checkoutBranch'))).toBe(true);
+            expect(action.isAccepted(Uri.parse('https://some-uri/otherThing'))).toBe(false);
+        });
+    });
+
+    describe('handle', () => {
+        it('throws if required query params are missing', async () => {
+            await expect(action.handle(Uri.parse('https://some-uri/checkoutBranch'))).rejects.toThrow();
+            await expect(
+                action.handle(Uri.parse('https://some-uri/checkoutBranch?cloneUrl=...&ref=...')),
+            ).rejects.toThrow();
+            await expect(
+                action.handle(Uri.parse('https://some-uri/checkoutBranch?cloneUrl=...&refType=...')),
+            ).rejects.toThrow();
+            await expect(
+                action.handle(Uri.parse('https://some-uri/checkoutBranch?ref=...&refType=...')),
+            ).rejects.toThrow();
+        });
+
+        it('checks out the branch and fires an event on success', async () => {
+            mockCheckoutHelper.checkoutRef.mockResolvedValue(true);
+            await action.handle(Uri.parse('https://some-uri/checkoutBranch?cloneUrl=one&ref=two&refType=three'));
+
+            expect(mockCheckoutHelper.checkoutRef).toHaveBeenCalledWith('one', 'two', 'three', '');
+            expect(mockAnalyticsApi.fireDeepLinkEvent).toHaveBeenCalled();
+        });
+
+        it('shows an error message on failure', async () => {
+            mockCheckoutHelper.checkoutRef.mockRejectedValue(new Error('oh no'));
+            await action.handle(Uri.parse('https://some-uri/checkoutBranch?cloneUrl=one&ref=two&refType=three'));
+
+            expect(window.showErrorMessage).toHaveBeenCalled();
+        });
+    });
+});

src/uriHandler/actions/checkoutBranch.test.ts

@@ -0,0 +1,41 @@
+import { Uri, window } from 'vscode';
+import { isAcceptedBySuffix, UriHandlerAction } from '../uriHandlerAction';
+import { CheckoutHelper } from '../../bitbucket/interfaces';
+import { AnalyticsApi } from '../../lib/analyticsApi';
+import { Logger } from '../../logger';
+
+export class CheckoutBranchUriHandlerAction implements UriHandlerAction {
+    constructor(
+        private bitbucketHelper: CheckoutHelper,
+        private analyticsApi: AnalyticsApi,
+    ) {}
+
+    isAccepted(uri: Uri): boolean {
+        return isAcceptedBySuffix(uri, 'checkoutBranch');
+    }
+
+    async handle(uri: Uri) {
+        const query = new URLSearchParams(uri.query);
+        const cloneUrl = decodeURIComponent(query.get('cloneUrl') || '');
+        const sourceCloneUrl = decodeURIComponent(query.get('sourceCloneUrl') || ''); //For branches originating from a forked repo
+        const ref = query.get('ref');
+        const refType = query.get('refType');
+        if (!ref || !cloneUrl || !refType) {
+            throw new Error(`Query params are missing data: ${query}`);
+        }
+
+        try {
+            const success = await this.bitbucketHelper.checkoutRef(cloneUrl, ref, refType, sourceCloneUrl);
+
+            if (success) {
+                this.analyticsApi.fireDeepLinkEvent(
+                    decodeURIComponent(query.get('source') || 'unknown'),
+                    'checkoutBranch',
+                );
+            }
+        } catch (e) {
+            Logger.debug('error checkout out branch:', e);
+            window.showErrorMessage('Error checkout out branch (check log for details)');
+        }
+    }
+}

src/uriHandler/actions/checkoutBranch.ts

@@ -0,0 +1,45 @@
+import { Uri, window } from 'vscode';
+import { CloneRepositoryUriHandlerAction } from './cloneRepository';
+
+describe('CloneRepositoryUriHandlerAction', () => {
+    const mockAnalyticsApi = {
+        fireDeepLinkEvent: jest.fn(),
+    };
+    const mockCheckoutHelper = {
+        cloneRepository: jest.fn(),
+    };
+    let action: CloneRepositoryUriHandlerAction;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        action = new CloneRepositoryUriHandlerAction(mockCheckoutHelper as any, mockAnalyticsApi as any);
+    });
+
+    describe('isAccepted', () => {
+        it('only accepts URIs ending with cloneRepository', () => {
+            expect(action.isAccepted(Uri.parse('https://some-uri/cloneRepository'))).toBe(true);
+            expect(action.isAccepted(Uri.parse('https://some-uri/otherThing'))).toBe(false);
+        });
+    });
+
+    describe('handle', () => {
+        it('throws if required query params are missing', async () => {
+            await expect(action.handle(Uri.parse('https://some-uri/cloneRepository'))).rejects.toThrow();
+        });
+
+        it('clones the repo and fires an event on success', async () => {
+            mockCheckoutHelper.cloneRepository.mockResolvedValue(null);
+            await action.handle(Uri.parse('https://some-uri/cloneRepository?q=one'));
+
+            expect(mockCheckoutHelper.cloneRepository).toHaveBeenCalledWith('one');
+            expect(mockAnalyticsApi.fireDeepLinkEvent).toHaveBeenCalled();
+        });
+
+        it('shows an error message on failure', async () => {
+            mockCheckoutHelper.cloneRepository.mockRejectedValue(new Error('oh no'));
+            await action.handle(Uri.parse('https://some-uri/cloneRepository?q=one'));
+
+            expect(window.showErrorMessage).toHaveBeenCalled();
+        });
+    });
+});