fix: add new method to compare proxy environment settings (#3529)

* fix: add new method to compare proxy environment settings

* fix: fix sonar issue

* fix: remove regex and update test to cover change

* Linting auto fix commit

* removed enum

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: longieirl

.changeset/large-bugs-pump.md

@@ -0,0 +1,5 @@
+---
+'@sap-ux/nodejs-utils': patch
+---
+
+Compare proxy to environment variables

packages/nodejs-utils/src/index.ts

@@ -1,3 +1,4 @@
 export * from './commandRunner';
 export * from './installedCheck';
 export * from './httpsUtils';
+export * from './proxyCheck';

packages/nodejs-utils/src/proxyCheck.ts

@@ -0,0 +1,102 @@
+export const ProxyValidationStatus = {
+    NO_PROXY: 'no-proxy',
+    MATCH: 'match',
+    MISMATCH: 'mismatch',
+    ENV_ONLY: 'env-only',
+    PARAM_ONLY: 'param-only'
+} as const;
+
+export type ProxyValidationStatus = (typeof ProxyValidationStatus)[keyof typeof ProxyValidationStatus];
+
+export interface ProxyValidationResult {
+    isValid: boolean;
+    status: ProxyValidationStatus;
+    message: string;
+    envProxy?: string;
+    providedProxy?: string;
+}
+
+const PROXY_ENV_VARS = ['HTTP_PROXY', 'http_proxy', 'HTTPS_PROXY', 'https_proxy'] as const;
+
+const getEnvProxy = (): string | undefined => {
+    for (const envVar of PROXY_ENV_VARS) {
+        const value = process.env[envVar];
+        if (value && value.trim() !== '') {
+            return value;
+        }
+    }
+    return undefined;
+};
+
+const normalizeProxy = (value?: string): string | undefined => {
+    let result = value?.trim().toLowerCase();
+    while (result?.endsWith('/')) {
+        result = result.slice(0, -1);
+    }
+    return result || undefined;
+};
+
+/**
+ * Validates if the proxy settings match against the process.env proxy settings. Typically used to ensure that the proxy settings in VSCode match those in the environment.
+ *
+ * @param {string} [proxy] - The proxy setting to validate. If not provided, it will check the environment variables.
+ * @returns {ProxyValidationResult} - An object containing the validation result, status, and messages.
+ */
+export function validateProxySettings(proxy?: string): ProxyValidationResult {
+    const envProxy = getEnvProxy();
+    const normalizedEnvProxy = normalizeProxy(envProxy);
+    const normalizedProxy = normalizeProxy(proxy);
+
+    // Exit early if no proxy settings are provided
+    if (!(normalizedEnvProxy || normalizedProxy)) {
+        return {
+            isValid: true,
+            status: ProxyValidationStatus.NO_PROXY,
+            message: 'No proxy settings configured.',
+            providedProxy: undefined,
+            envProxy: envProxy
+        };
+    }
+
+    // Only environment proxy is set
+    if (normalizedEnvProxy && !normalizedProxy) {
+        return {
+            isValid: false,
+            status: ProxyValidationStatus.ENV_ONLY,
+            message: 'Using environment proxy settings.',
+            envProxy: normalizedEnvProxy,
+            providedProxy: undefined
+        };
+    }
+
+    // Only provided proxy is set
+    if (!normalizedEnvProxy && normalizedProxy) {
+        return {
+            isValid: false,
+            status: ProxyValidationStatus.PARAM_ONLY,
+            message: `Using provided (${normalizedProxy}) proxy settings.`,
+            envProxy: undefined,
+            providedProxy: normalizedProxy
+        };
+    }
+
+    // Both exist and match
+    if (normalizedEnvProxy === normalizedProxy) {
+        return {
+            isValid: true,
+            status: ProxyValidationStatus.MATCH,
+            message: `Proxy settings match.`,
+            envProxy: normalizedEnvProxy,
+            providedProxy: normalizedProxy
+        };
+    }
+
+    // Both exist but don't match
+    return {
+        isValid: false,
+        status: ProxyValidationStatus.MISMATCH,
+        message: `Proxy settings conflict between environment (${normalizedEnvProxy}) and parameter (${normalizedProxy}).`,
+        envProxy: normalizedEnvProxy,
+        providedProxy: normalizedProxy
+    };
+}

packages/nodejs-utils/test/unit/proxyCheck.test.ts

@@ -0,0 +1,101 @@
+import { validateProxySettings } from '../../src/proxyCheck';
+
+describe('Proxy check', () => {
+    // Store original environment variables
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        // Clear all proxy-related environment variables before each test
+        jest.resetModules();
+        process.env = { ...originalEnv };
+        delete process.env.HTTP_PROXY;
+        delete process.env.http_proxy;
+        delete process.env.HTTPS_PROXY;
+        delete process.env.https_proxy;
+    });
+
+    afterAll(() => {
+        // Restore original environment variables
+        process.env = originalEnv;
+    });
+
+    it('should return no-proxy status', () => {
+        const result = validateProxySettings();
+        expect(result).toEqual({
+            isValid: true,
+            status: 'no-proxy',
+            message: 'No proxy settings configured.'
+        });
+    });
+
+    it('should return no-proxy status when proxy parameter is empty string', () => {
+        const result = validateProxySettings('');
+        expect(result).toEqual({
+            isValid: true,
+            status: 'no-proxy',
+            message: 'No proxy settings configured.'
+        });
+    });
+
+    it('should return no-proxy status when proxy parameter is only whitespace', () => {
+        const result = validateProxySettings('   ');
+        expect(result).toEqual({
+            isValid: true,
+            status: 'no-proxy',
+            message: 'No proxy settings configured.'
+        });
+    });
+
+    it('should return env-only status with HTTPS_PROXY', () => {
+        process.env.HTTPS_PROXY = 'https://secure-proxy.company.com:8443/';
+        const result = validateProxySettings();
+        expect(result).toEqual({
+            isValid: false,
+            status: 'env-only',
+            message: 'Using environment proxy settings.',
+            envProxy: 'https://secure-proxy.company.com:8443'
+        });
+    });
+
+    it('should return param-only status when only proxy parameter is provided', () => {
+        const result = validateProxySettings('http://param-proxy.com:3128');
+        expect(result).toEqual({
+            isValid: false,
+            status: 'param-only',
+            message: 'Using provided (http://param-proxy.com:3128) proxy settings.',
+            providedProxy: 'http://param-proxy.com:3128'
+        });
+    });
+
+    it('should return mismatch status when proxies differ', () => {
+        process.env.HTTP_PROXY = 'http://env-proxy.com:8080';
+        const result = validateProxySettings('http://param-proxy.com:3128');
+        expect(result).toEqual({
+            isValid: false,
+            status: 'mismatch',
+            message:
+                'Proxy settings conflict between environment (http://env-proxy.com:8080) and parameter (http://param-proxy.com:3128).',
+            envProxy: 'http://env-proxy.com:8080',
+            providedProxy: 'http://param-proxy.com:3128'
+        });
+    });
+
+    it('should detect mismatch with different protocols', () => {
+        process.env.HTTP_PROXY = 'http://proxy.company.com:8080';
+        const result = validateProxySettings('https://proxy.company.com:8080');
+        expect(result.isValid).toBe(false);
+        expect(result.status).toBe('mismatch');
+    });
+
+    it('should return match status when environment and parameter proxies are identical', () => {
+        process.env.HTTP_PROXY = 'http://proxy.company.com:8080';
+        const result = validateProxySettings('http://proxy.company.com:8080');
+        expect(result).toEqual({
+            isValid: true,
+            status: 'match',
+            message: 'Proxy settings match.',
+            envProxy: 'http://proxy.company.com:8080',
+            providedProxy: 'http://proxy.company.com:8080'
+        });
+    });
+});