chore: vscode formatter config

Signed-off-by: Adam Setch <adam.setch@outlook.com>

Author: setchy

src/renderer/__helpers__/auth-helpers.ts

@@ -169,6 +169,7 @@ export const LoginWithDeviceFlowRoute: FC = () => {
           />
         )}
 
+        {/** GitHub Device Code Flow session */}
         {session ? (
           <Stack direction="vertical" gap="normal">
             <Stack direction="vertical" gap="condensed">
@@ -278,7 +279,7 @@ export const LoginWithDeviceFlowRoute: FC = () => {
               icon={SyncIcon}
               size="large"
               variant="invisible"
-            />{' '}
+            />
             <Text>Initializing authentication...</Text>
           </Stack>
         )}

src/renderer/routes/LoginWithDeviceFlow.tsx

@@ -20,7 +20,6 @@ import { RequestError } from '@octokit/request-error';
 
 import type { MockedFunction } from 'vitest';
 
-import { simulateDeviceFlow } from '../../__helpers__/auth-helpers';
 import { mockGitHubCloudAccount } from '../../__mocks__/account-mocks';
 import { mockAuth } from '../../__mocks__/state-mocks';
 import { mockRawUser } from '../api/__mocks__/response-mocks';
@@ -81,127 +80,91 @@ describe('renderer/utils/auth/utils.ts', () => {
     vi.clearAllMocks();
   });
 
-  describe('device OAuth orchestration (test helper)', () => {
-    it('should authenticate using device flow for GitHub app', async () => {
-      createDeviceCodeMock.mockResolvedValueOnce({
-        data: {
-          device_code: 'device-code',
-          user_code: 'user-code',
-          verification_uri: 'https://github.com/login/device',
-          expires_in: 900,
-          interval: 5,
-        },
-      } as unknown as Awaited<ReturnType<typeof createDeviceCode>>);
-
-      exchangeDeviceCodeMock.mockResolvedValueOnce({
-        authentication: {
-          token: 'device-token',
-        },
-      } as unknown as Awaited<ReturnType<typeof exchangeDeviceCode>>);
-
-      const token = await simulateDeviceFlow();
-
-      expect(createDeviceCodeMock).toHaveBeenCalledWith({
-        clientType: 'oauth-app',
-        clientId: 'FAKE_CLIENT_ID_123',
-        scopes: getRecommendedScopeNames(),
-        request: expect.any(Function),
-      });
+  describe('Gitify GitHub OAuth - Device Code Flow', () => {
+    describe('startGitHubDeviceFlow', () => {
+      it('should request a device code and return a session', async () => {
+        createDeviceCodeMock.mockResolvedValueOnce({
+          data: {
+            device_code: 'device-code-xyz',
+            user_code: 'user-code-xyz',
+            verification_uri: 'https://github.com/login/device',
+            expires_in: 600,
+            interval: 5,
+          },
+        } as unknown as Awaited<ReturnType<typeof createDeviceCode>>);
 
-      expect(exchangeDeviceCodeMock).toHaveBeenCalledWith({
-        clientType: 'oauth-app',
-        clientId: 'FAKE_CLIENT_ID_123',
-        code: 'device-code',
-        request: expect.any(Function),
-      });
+        const session = await authUtils.startGitHubDeviceFlow();
 
-      expect(token).toBe('device-token');
-    });
-  });
+        expect(createDeviceCodeMock).toHaveBeenCalledWith({
+          clientType: 'oauth-app',
+          clientId: 'FAKE_CLIENT_ID_123',
+          scopes: getRecommendedScopeNames(),
+          request: expect.any(Function),
+        });
 
-  describe('startGitHubDeviceFlow', () => {
-    it('should request a device code and return a session', async () => {
-      createDeviceCodeMock.mockResolvedValueOnce({
-        data: {
-          device_code: 'device-code-xyz',
-          user_code: 'user-code-xyz',
-          verification_uri: 'https://github.com/login/device',
-          expires_in: 600,
-          interval: 5,
-        },
-      } as unknown as Awaited<ReturnType<typeof createDeviceCode>>);
-
-      const session = await authUtils.startGitHubDeviceFlow();
-
-      expect(createDeviceCodeMock).toHaveBeenCalledWith({
-        clientType: 'oauth-app',
-        clientId: 'FAKE_CLIENT_ID_123',
-        scopes: getRecommendedScopeNames(),
-        request: expect.any(Function),
+        expect(session.deviceCode).toBe('device-code-xyz');
+        expect(session.userCode).toBe('user-code-xyz');
+        expect(session.verificationUri).toBe('https://github.com/login/device');
+        expect(session.intervalSeconds).toBe(5);
+        expect(session.expiresAt).toBeGreaterThan(Date.now());
       });
-
-      expect(session.deviceCode).toBe('device-code-xyz');
-      expect(session.userCode).toBe('user-code-xyz');
-      expect(session.verificationUri).toBe('https://github.com/login/device');
-      expect(session.intervalSeconds).toBe(5);
-      expect(session.expiresAt).toBeGreaterThan(Date.now());
     });
-  });
-
-  describe('pollGitHubDeviceFlow', () => {
-    const baseSession = {
-      hostname: 'github.com',
-      clientId: 'FAKE_CLIENT_ID_123',
-      deviceCode: 'device-code',
-      userCode: 'user-code',
-      verificationUri: 'https://github.com/login/device',
-      intervalSeconds: 5,
-      expiresAt: Date.now() + 10000,
-    } as const;
-
-    it('returns token on successful exchange', async () => {
-      exchangeDeviceCodeMock.mockResolvedValueOnce({
-        authentication: { token: 'device-token-xyz' },
-      } as unknown as Awaited<ReturnType<typeof exchangeDeviceCode>>);
-
-      const token = await authUtils.pollGitHubDeviceFlow(
-        baseSession as DeviceFlowSession,
-      );
 
-      expect(exchangeDeviceCodeMock).toHaveBeenCalledWith({
-        clientType: 'oauth-app',
+    describe('pollGitHubDeviceFlow', () => {
+      const baseSession = {
+        hostname: 'github.com',
         clientId: 'FAKE_CLIENT_ID_123',
-        code: 'device-code',
-        request: expect.any(Function),
-      });
+        deviceCode: 'device-code',
+        userCode: 'user-code',
+        verificationUri: 'https://github.com/login/device',
+        intervalSeconds: 5,
+        expiresAt: Date.now() + 10000,
+      } as const;
+
+      it('returns token on successful exchange', async () => {
+        exchangeDeviceCodeMock.mockResolvedValueOnce({
+          authentication: { token: 'device-token-xyz' },
+        } as unknown as Awaited<ReturnType<typeof exchangeDeviceCode>>);
+
+        const token = await authUtils.pollGitHubDeviceFlow(
+          baseSession as DeviceFlowSession,
+        );
 
-      expect(token).toBe('device-token-xyz');
-    });
+        expect(exchangeDeviceCodeMock).toHaveBeenCalledWith({
+          clientType: 'oauth-app',
+          clientId: 'FAKE_CLIENT_ID_123',
+          code: 'device-code',
+          request: expect.any(Function),
+        });
 
-    it('returns null when authorization is pending or slow_down', async () => {
-      const pendingErr = Object.create(RequestError.prototype);
-      pendingErr.response = { data: { error: 'authorization_pending' } };
+        expect(token).toBe('device-token-xyz');
+      });
 
-      exchangeDeviceCodeMock.mockRejectedValueOnce(pendingErr);
+      it('returns null when authorization is pending or slow_down', async () => {
+        const pendingErr = Object.create(RequestError.prototype);
+        pendingErr.response = { data: { error: 'authorization_pending' } };
 
-      const token = await authUtils.pollGitHubDeviceFlow(
-        baseSession as DeviceFlowSession,
-      );
+        exchangeDeviceCodeMock.mockRejectedValueOnce(pendingErr);
 
-      expect(token).toBeNull();
-    });
+        const token = await authUtils.pollGitHubDeviceFlow(
+          baseSession as DeviceFlowSession,
+        );
 
-    it('throws on other errors', async () => {
-      const otherErr = new Error('boom');
+        expect(token).toBeNull();
+      });
 
-      exchangeDeviceCodeMock.mockRejectedValueOnce(otherErr);
+      it('throws on other errors', async () => {
+        const otherErr = new Error('boom');
 
-      await expect(
-        async () =>
-          await authUtils.pollGitHubDeviceFlow(
-            baseSession as DeviceFlowSession,
-          ),
-      ).rejects.toThrow('boom');
+        exchangeDeviceCodeMock.mockRejectedValueOnce(otherErr);
+
+        await expect(
+          async () =>
+            await authUtils.pollGitHubDeviceFlow(
+              baseSession as DeviceFlowSession,
+            ),
+        ).rejects.toThrow('boom');
+      });
     });
   });