fix: Server in subdirectory (#1820)

* Reduce the number of parent directories in server URL resolution

* Add tests to resolveServerUrl

* Add tests to "servers/fetch-info"

* Remove side-effects from renderer modules

* Remove extra console.log()

Author: tassoevan

jest.config.js

@@ -5,7 +5,10 @@ module.exports = {
       errorOnDeprecated: true,
       runner: '@jest-runner/electron',
       testEnvironment: '@jest-runner/electron/environment',
-      testMatch: ['<rootDir>/src/*/!(main)/**/*.(spec|test).{js,ts,tsx}'],
+      testMatch: [
+        '<rootDir>/src/*/!(main)/**/*.(spec|test).{js,ts,tsx}',
+        '<rootDir>/src/**/renderer.(spec|test).{js,ts,tsx}',
+      ],
       globals: {
         'ts-jest': {
           tsConfig: {

src/notifications/renderer.ts

@@ -19,7 +19,7 @@ const inferContentTypeFromImageData = (data: ArrayBuffer): string | null => {
   }
 };
 
-handle('notifications/fetch-icon', async (urlHref: string) => {
+const fetchIcon = async (urlHref: string): Promise<string> => {
   if (iconCache.has(urlHref)) {
     return iconCache.get(urlHref);
   }
@@ -31,4 +31,8 @@ handle('notifications/fetch-icon', async (urlHref: string) => {
   const dataUri = `data:${ contentType };base64,${ base64String }`;
   iconCache.set(urlHref, dataUri);
   return dataUri;
-});
+};
+
+export default (): void => {
+  handle('notifications/fetch-icon', fetchIcon);
+};

src/rootWindow.ts

@@ -15,10 +15,10 @@ const start = async (): Promise<void> => {
   setupRendererErrorHandling('rootWindow');
   await setupI18n();
 
-  await Promise.all([
+  (await Promise.all([
     import('./notifications/renderer'),
     import('./servers/renderer'),
-  ]);
+  ])).forEach((module) => module.default());
 
   const container = document.getElementById('root');
 

src/servers/main.spec.ts

@@ -1,4 +1,5 @@
-import { convertToURL } from './main';
+import { ServerUrlResolutionStatus } from './common';
+import { convertToURL, resolveServerUrl } from './main';
 
 describe('convertToUrl', () => {
   it.each([
@@ -17,3 +18,38 @@ describe('convertToUrl', () => {
     expect(result.href).toBe(expected);
   });
 });
+
+jest.mock('../ui/main/rootWindow', () => ({
+  __esModule: true,
+  getRootWindow: jest.fn(() => ({ webContents: null })),
+}));
+
+jest.mock('../ipc/main', () => ({
+  __esModule: true,
+  invoke: jest.fn(async (_webContents, channel, ...args) => {
+    if (channel === 'servers/fetch-info') {
+      return [args[0], '3.8.0'];
+    }
+
+    return null;
+  }),
+}));
+
+describe('resolveServerUrl', () => {
+  it.each([
+    ['localhost', 'https://localhost/'],
+    ['localhost:3000', 'https://localhost:3000/'],
+    ['https://localhost', 'https://localhost/'],
+    ['http://localhost', 'http://localhost/'],
+    ['https://localhost/', 'https://localhost/'],
+    ['http://localhost/', 'http://localhost/'],
+    ['https://localhost/subdir', 'https://localhost/subdir/'],
+    ['http://localhost:80', 'http://localhost/'],
+    ['https://localhost:443', 'https://localhost/'],
+  ])('resolves %s as %s', async (input, expected) => {
+    const [serverUrl, status, error] = await resolveServerUrl(input);
+    expect(serverUrl).toBe(expected);
+    expect(status).toBe(ServerUrlResolutionStatus.OK);
+    expect(error).toBe(undefined);
+  });
+});

src/servers/main.ts

@@ -63,7 +63,7 @@ export const resolveServerUrl = async (input: string): Promise<ServerUrlResoluti
       return resolveServerUrl(`https://${ input }.rocket.chat`);
     }
 
-    if (error.name === 'AbortError') {
+    if (error?.name === 'AbortError') {
       return [url.href, ServerUrlResolutionStatus.TIMEOUT, error];
     }
 

src/servers/renderer.spec.ts

@@ -0,0 +1,70 @@
+import { createServer, Server } from 'http';
+
+import { fetchInfo } from './renderer';
+
+describe('servers/fetch-info', () => {
+  const serverVersion = Array.from({ length: 3 }, () => Math.round(Math.random() * 9)).join('.');
+  let server: Server;
+
+  beforeEach(() => {
+    server = createServer((req, res) => {
+      if (req.url === '/' || /^(\/subdir)+\/$/.test(req.url)) {
+        res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.write('Home');
+        res.end();
+        return;
+      }
+
+      if (req.url === '/api/info' || /^(\/subdir)+\/api\/info$/.test(req.url)) {
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.write(JSON.stringify({
+          success: true,
+          version: serverVersion,
+        }));
+        res.end();
+        return;
+      }
+
+      if (req.url === '/redirect') {
+        res.writeHead(302, { Location: 'http://localhost:3000/subdir/' });
+        res.end();
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.write('Not found!');
+      res.end();
+    });
+
+    server.listen(3000);
+  });
+
+  afterEach(() => {
+    server.close();
+    server = null;
+  });
+
+  it('reaches the server at root directory', async () => {
+    const [effectiveUrl, version] = await fetchInfo('http://localhost:3000/');
+    expect(effectiveUrl).toStrictEqual('http://localhost:3000/');
+    expect(version).toStrictEqual(serverVersion);
+  });
+
+  it('reaches the server at subdirectory', async () => {
+    const [effectiveUrl, version] = await fetchInfo('http://localhost:3000/subdir/');
+    expect(effectiveUrl).toStrictEqual('http://localhost:3000/subdir/');
+    expect(version).toStrictEqual(serverVersion);
+  });
+
+  it('reaches the server at deep subdirectory', async () => {
+    const [effectiveUrl, version] = await fetchInfo('http://localhost:3000/subdir/subdir/subdir/');
+    expect(effectiveUrl).toStrictEqual('http://localhost:3000/subdir/subdir/subdir/');
+    expect(version).toStrictEqual(serverVersion);
+  });
+
+  it('reaches the server after redirection', async () => {
+    const [effectiveUrl, version] = await fetchInfo('http://localhost:3000/redirect');
+    expect(effectiveUrl).toStrictEqual('http://localhost:3000/subdir/');
+    expect(version).toStrictEqual(serverVersion);
+  });
+});

src/servers/renderer.ts

@@ -5,7 +5,7 @@ import { dispatch, watch } from '../store';
 import { RootState } from '../store/rootReducer';
 import { ROOT_WINDOW_ICON_CHANGED } from '../ui/actions';
 
-handle('servers/fetch-info', async (urlHref): Promise<[urlHref: string, version: string]> => {
+export const fetchInfo = async (urlHref: string): Promise<[urlHref: string, version: string]> => {
   const url = new URL(urlHref);
 
   const { username, password } = url;
@@ -15,25 +15,31 @@ handle('servers/fetch-info', async (urlHref): Promise<[urlHref: string, version:
     headers.append('Authorization', `Basic ${ btoa(`${ username }:${ password }`) }`);
   }
 
-  const endpoint = new URL('api/info', url);
+  const homeResponse = await fetch(url.href, { headers });
 
-  const response = await fetch(endpoint.href, { headers });
+  if (!homeResponse.ok) {
+    throw new Error(homeResponse.statusText);
+  }
+
+  const endpoint = new URL('api/info', homeResponse.url);
+
+  const apiInfoResponse = await fetch(endpoint.href, { headers });
 
-  if (!response.ok) {
-    throw new Error(response.statusText);
+  if (!apiInfoResponse.ok) {
+    throw new Error(apiInfoResponse.statusText);
   }
 
   const responseBody: {
     success: boolean;
     version: string;
-  } = await response.json();
+  } = await apiInfoResponse.json();
 
   if (!responseBody.success) {
     throw new Error();
   }
 
-  return [new URL('../..', response.url).href, responseBody.version];
-});
+  return [new URL('..', apiInfoResponse.url).href, responseBody.version];
+};
 
 type RootWindowIconParams = {
   badge: '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '+9' | '•' | undefined;
@@ -240,10 +246,14 @@ const updateRootWindowIconForWindows = async ({ badge, favicon }: RootWindowIcon
   });
 };
 
-if (process.platform === 'linux') {
-  watch(selectBadgeAndFavicon, updateRootWindowIconForLinux);
-}
+export default (): void => {
+  handle('servers/fetch-info', fetchInfo);
 
-if (process.platform === 'win32') {
-  watch(selectBadgeAndFavicon, updateRootWindowIconForWindows);
-}
+  if (process.platform === 'linux') {
+    watch(selectBadgeAndFavicon, updateRootWindowIconForLinux);
+  }
+
+  if (process.platform === 'win32') {
+    watch(selectBadgeAndFavicon, updateRootWindowIconForWindows);
+  }
+};