chore: added untit tests to increase coverage

Author: georgiy.rusanov

test/unit/SupabaseClient.test.ts

@@ -104,6 +104,18 @@ describe('SupabaseClient', () => {
       // @ts-ignore
       expect(client.storageKey).toBe(customStorageKey)
     })
+
+    test('should handle undefined storageKey and headers', () => {
+      const client = createClient(URL, KEY, {
+        auth: { storageKey: undefined },
+        global: { headers: undefined },
+      })
+      expect(client).toBeDefined()
+      // @ts-ignore
+      expect(client.storageKey).toBe('')
+      // @ts-ignore
+      expect(client.headers).toHaveProperty('X-Client-Info')
+    })
   })
 
   describe('Client Methods', () => {
@@ -166,6 +178,14 @@ describe('SupabaseClient', () => {
     })
   })
 
+  describe('Table/View Queries', () => {
+    test('should query table with string relation', () => {
+      const client = createClient<Database>(URL, KEY)
+      const queryBuilder = client.from('users')
+      expect(queryBuilder).toBeDefined()
+    })
+  })
+
   describe('RPC Calls', () => {
     test('should make RPC call with arguments', () => {
       const client = createClient<Database>(URL, KEY)
@@ -179,4 +199,125 @@ describe('SupabaseClient', () => {
       expect(rpcCall).toBeDefined()
     })
   })
+
+  describe('Access Token Handling', () => {
+    test('should use custom accessToken when provided', async () => {
+      const customToken = 'custom-jwt-token'
+      const client = createClient(URL, KEY, {
+        accessToken: async () => customToken,
+      })
+
+      // Access the private method through the client instance
+      const accessToken = await (client as any)._getAccessToken()
+      expect(accessToken).toBe(customToken)
+    })
+
+    test('should fallback to session access token when no custom accessToken', async () => {
+      const client = createClient(URL, KEY)
+
+      // Mock the auth.getSession method
+      const mockSession = {
+        data: {
+          session: {
+            access_token: 'session-jwt-token',
+          },
+        },
+      }
+      client.auth.getSession = jest.fn().mockResolvedValue(mockSession)
+
+      const accessToken = await (client as any)._getAccessToken()
+      expect(accessToken).toBe('session-jwt-token')
+    })
+
+    test('should fallback to supabaseKey when no session', async () => {
+      const client = createClient(URL, KEY)
+
+      // Mock the auth.getSession method to return no session
+      const mockSession = {
+        data: {
+          session: null,
+        },
+      }
+      client.auth.getSession = jest.fn().mockResolvedValue(mockSession)
+
+      const accessToken = await (client as any)._getAccessToken()
+      expect(accessToken).toBe(KEY)
+    })
+  })
+
+  describe('Auth Event Handling', () => {
+    test('should handle TOKEN_REFRESHED event', () => {
+      const client = createClient(URL, KEY)
+      const newToken = 'new-refreshed-token'
+
+      // Mock realtime.setAuth
+      client.realtime.setAuth = jest.fn()
+      ;(client as any)._handleTokenChanged('TOKEN_REFRESHED', 'CLIENT', newToken)
+
+      expect((client as any).changedAccessToken).toBe(newToken)
+    })
+
+    test('should listen for auth events', () => {
+      const client = createClient(URL, KEY)
+
+      // Mock auth.onAuthStateChange
+      const mockCallback = jest.fn()
+      client.auth.onAuthStateChange = jest.fn().mockReturnValue(mockCallback)
+
+      // Call the private method
+      const result = (client as any)._listenForAuthEvents()
+
+      expect(client.auth.onAuthStateChange).toHaveBeenCalled()
+      expect(result).toBe(mockCallback)
+    })
+
+    test('should handle SIGNED_IN event', () => {
+      const client = createClient(URL, KEY)
+      const newToken = 'new-signed-in-token'
+
+      // Mock realtime.setAuth
+      client.realtime.setAuth = jest.fn()
+      ;(client as any)._handleTokenChanged('SIGNED_IN', 'CLIENT', newToken)
+
+      expect((client as any).changedAccessToken).toBe(newToken)
+    })
+
+    test('should not update token if it is the same', () => {
+      const client = createClient(URL, KEY)
+      const existingToken = 'existing-token'
+      ;(client as any).changedAccessToken = existingToken
+
+      // Mock realtime.setAuth
+      client.realtime.setAuth = jest.fn()
+      ;(client as any)._handleTokenChanged('TOKEN_REFRESHED', 'CLIENT', existingToken)
+
+      expect((client as any).changedAccessToken).toBe(existingToken)
+    })
+
+    test('should handle SIGNED_OUT event from CLIENT source', () => {
+      const client = createClient(URL, KEY)
+      ;(client as any).changedAccessToken = 'old-token'
+
+      // Mock realtime.setAuth
+      client.realtime.setAuth = jest.fn()
+      ;(client as any)._handleTokenChanged('SIGNED_OUT', 'CLIENT')
+
+      expect(client.realtime.setAuth).toHaveBeenCalled()
+      expect((client as any).changedAccessToken).toBeUndefined()
+    })
+
+    test('should handle SIGNED_OUT event from STORAGE source', () => {
+      const client = createClient(URL, KEY)
+      ;(client as any).changedAccessToken = 'old-token'
+
+      // Mock realtime.setAuth and auth.signOut
+      client.realtime.setAuth = jest.fn()
+      client.auth.signOut = jest.fn()
+      ;(client as any)._handleTokenChanged('SIGNED_OUT', 'STORAGE')
+
+      expect(client.realtime.setAuth).toHaveBeenCalled()
+      expect(client.auth.signOut).toHaveBeenCalled()
+      expect((client as any).changedAccessToken).toBeUndefined()
+    })
+  })
 })

test/unit/constants.test.ts

@@ -1,23 +1,105 @@
-import { DEFAULT_HEADERS } from '../../src/lib/constants'
+import {
+  DEFAULT_HEADERS,
+  DEFAULT_GLOBAL_OPTIONS,
+  DEFAULT_DB_OPTIONS,
+  DEFAULT_AUTH_OPTIONS,
+  DEFAULT_REALTIME_OPTIONS,
+} from '../../src/lib/constants'
 import { version } from '../../src/lib/version'
 
-test('it has the correct type of returning with the correct value', () => {
-  let JS_ENV = ''
-  // @ts-ignore
-  if (typeof Deno !== 'undefined') {
-    JS_ENV = 'deno'
-  } else if (typeof document !== 'undefined') {
-    JS_ENV = 'web'
-  } else if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-    JS_ENV = 'react-native'
-  } else {
-    JS_ENV = 'node'
-  }
-  const expected = {
-    'X-Client-Info': `supabase-js-${JS_ENV}/${version}`,
-  }
-  expect(DEFAULT_HEADERS).toEqual(expected)
-  expect(typeof DEFAULT_HEADERS).toBe('object')
-  expect(typeof DEFAULT_HEADERS['X-Client-Info']).toBe('string')
-  expect(Object.keys(DEFAULT_HEADERS).length).toBe(1)
+describe('constants', () => {
+  const originalEnv = process.env
+  const originalWindow = global.window
+  const originalDocument = global.document
+  const originalNavigator = global.navigator
+  const originalDeno = (global as any).Deno
+
+  beforeEach(() => {
+    jest.resetModules()
+    // Reset globals
+    delete (global as any).window
+    delete (global as any).document
+    delete (global as any).navigator
+    delete (global as any).Deno
+  })
+
+  afterEach(() => {
+    // Restore globals
+    if (originalWindow) global.window = originalWindow
+    if (originalDocument) global.document = originalDocument
+    if (originalNavigator) global.navigator = originalNavigator
+    if (originalDeno) (global as any).Deno = originalDeno
+  })
+
+  test('DEFAULT_HEADERS should contain X-Client-Info', () => {
+    expect(DEFAULT_HEADERS).toHaveProperty('X-Client-Info')
+    expect(DEFAULT_HEADERS['X-Client-Info']).toMatch(/^supabase-js-.*\/.*$/)
+  })
+
+  test('DEFAULT_GLOBAL_OPTIONS should contain headers', () => {
+    expect(DEFAULT_GLOBAL_OPTIONS).toHaveProperty('headers')
+    expect(DEFAULT_GLOBAL_OPTIONS.headers).toBe(DEFAULT_HEADERS)
+  })
+
+  test('DEFAULT_DB_OPTIONS should have schema set to public', () => {
+    expect(DEFAULT_DB_OPTIONS).toHaveProperty('schema')
+    expect(DEFAULT_DB_OPTIONS.schema).toBe('public')
+  })
+
+  test('DEFAULT_AUTH_OPTIONS should have correct default values', () => {
+    expect(DEFAULT_AUTH_OPTIONS).toHaveProperty('autoRefreshToken')
+    expect(DEFAULT_AUTH_OPTIONS.autoRefreshToken).toBe(true)
+    expect(DEFAULT_AUTH_OPTIONS).toHaveProperty('persistSession')
+    expect(DEFAULT_AUTH_OPTIONS.persistSession).toBe(true)
+    expect(DEFAULT_AUTH_OPTIONS).toHaveProperty('detectSessionInUrl')
+    expect(DEFAULT_AUTH_OPTIONS.detectSessionInUrl).toBe(true)
+    expect(DEFAULT_AUTH_OPTIONS).toHaveProperty('flowType')
+    expect(DEFAULT_AUTH_OPTIONS.flowType).toBe('implicit')
+  })
+
+  test('DEFAULT_REALTIME_OPTIONS should be an empty object', () => {
+    expect(DEFAULT_REALTIME_OPTIONS).toEqual({})
+  })
+
+  describe('JS_ENV detection', () => {
+    test('should detect Deno environment', () => {
+      ;(global as any).Deno = {}
+
+      // Re-import to trigger the detection logic
+      jest.resetModules()
+      const { DEFAULT_HEADERS: newHeaders } = require('../../src/lib/constants')
+
+      expect(newHeaders['X-Client-Info']).toContain('supabase-js-deno')
+    })
+
+    test('should detect web environment', () => {
+      global.document = {} as any
+
+      // Re-import to trigger the detection logic
+      jest.resetModules()
+      const { DEFAULT_HEADERS: newHeaders } = require('../../src/lib/constants')
+
+      expect(newHeaders['X-Client-Info']).toContain('supabase-js-web')
+    })
+
+    test('should detect React Native environment', () => {
+      global.navigator = { product: 'ReactNative' } as any
+
+      // Re-import to trigger the detection logic
+      jest.resetModules()
+      const { DEFAULT_HEADERS: newHeaders } = require('../../src/lib/constants')
+
+      expect(newHeaders['X-Client-Info']).toContain('supabase-js-react-native')
+    })
+
+    test('should default to node environment when no specific environment is detected', () => {
+      // No globals set
+
+      // Re-import to trigger the detection logic
+      jest.resetModules()
+      const { DEFAULT_HEADERS: newHeaders } = require('../../src/lib/constants')
+
+      expect(newHeaders['X-Client-Info']).toContain('supabase-js-node')
+    })
+  })
 })