swetrix 3.6.1 → 3.7.1

package/tests/initialisation.test.ts

@@ -0,0 +1,91 @@
+import { init } from '../src/index'
+import { Lib } from '../src/Lib'
+
+jest.mock('../src/Lib', () => {
+  const originalModule = jest.requireActual('../src/Lib')
+
+  return {
+    ...originalModule,
+    Lib: class MockLib extends originalModule.Lib {
+      sendRequest = jest.fn().mockResolvedValue(undefined)
+      canTrack = jest.fn().mockReturnValue(true)
+    },
+  }
+})
+
+describe('Library Initialisation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    jest.resetModules()
+
+    Object.defineProperty(window, 'location', {
+      value: {
+        hostname: 'example.com',
+        pathname: '/test-page',
+        hash: '',
+        search: '',
+      },
+      writable: true,
+    })
+
+    Object.defineProperty(navigator, 'doNotTrack', {
+      value: null,
+      writable: true,
+    })
+  })
+
+  test('init should return a Lib instance', () => {
+    // Act
+    const instance = init('test-project-id')
+
+    // Assert
+    expect(instance).toBeInstanceOf(Lib)
+  })
+
+  test('init with devMode should work on localhost', () => {
+    // Arrange
+    Object.defineProperty(window, 'location', {
+      value: {
+        hostname: 'localhost',
+        pathname: '/',
+        hash: '',
+        search: '',
+      },
+      writable: true,
+    })
+
+    // Act
+    const instance = init('test-project-id', { devMode: true })
+
+    // Assert - no error should be thrown
+    expect(instance).toBeInstanceOf(Lib)
+    expect((instance as any).canTrack()).toBe(true)
+  })
+
+  test('init should respect DNT when respectDNT option is true', () => {
+    // Arrange
+    Object.defineProperty(navigator, 'doNotTrack', {
+      value: '1',
+      writable: true,
+    })
+
+    // Act
+    const instance = init('test-project-id', { respectDNT: true })
+
+    // Mock the canTrack method to return false for this instance
+    ;(instance as any).canTrack.mockReturnValue(false)
+
+    // Assert
+    expect((instance as any).canTrack()).toBe(false)
+  })
+
+  test('init should return the same instance when called multiple times', () => {
+    // Act
+    const instance1 = init('test-project-id')
+    const instance2 = init('another-id') // This should be ignored and return the first instance
+
+    // Assert
+    expect(instance1).toBe(instance2)
+  })
+})

package/tests/pageview.test.ts

@@ -0,0 +1,124 @@
+import { init, pageview, trackViews } from '../src/index'
+import { Lib } from '../src/Lib'
+
+jest.mock('../src/Lib', () => {
+  const originalModule = jest.requireActual('../src/Lib')
+
+  return {
+    ...originalModule,
+    Lib: class MockLib extends originalModule.Lib {
+      sendRequest = jest.fn().mockResolvedValue(undefined)
+    },
+  }
+})
+
+describe('Pageview Tracking', () => {
+  const PROJECT_ID = 'test-project-id'
+  let libInstance: Lib
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    libInstance = init(PROJECT_ID, { devMode: true }) as Lib
+
+    Object.defineProperty(window, 'location', {
+      value: {
+        hostname: 'example.com',
+        pathname: '/test-page',
+        hash: '',
+        search: '',
+      },
+      writable: true,
+    })
+
+    Object.defineProperty(document, 'referrer', {
+      value: 'https://google.com',
+      writable: true,
+    })
+  })
+
+  test('pageview function should track a page view', async () => {
+    // Arrange
+    const path = '/test-page'
+
+    // Act
+    pageview({
+      payload: { pg: path },
+      unique: false,
+    })
+
+    // Assert
+    expect((libInstance as any).sendRequest).toHaveBeenCalledTimes(1)
+    expect((libInstance as any).sendRequest).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({
+        pid: PROJECT_ID,
+        pg: path,
+      }),
+    )
+  })
+
+  test('pageview function with unique flag should track unique page view', async () => {
+    // Arrange
+    const path = '/test-page'
+
+    // Act
+    pageview({
+      payload: { pg: path },
+      unique: true,
+    })
+
+    // Assert
+    expect((libInstance as any).sendRequest).toHaveBeenCalledTimes(1)
+    expect((libInstance as any).sendRequest).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({
+        pid: PROJECT_ID,
+        pg: path,
+        unique: true,
+      }),
+    )
+  })
+
+  test('pageview function with metadata should include metadata in request', async () => {
+    // Arrange
+    const path = '/test-page'
+    const metadata = {
+      category: 'blog',
+      author: 'John Doe',
+    }
+
+    // Act
+    pageview({
+      payload: {
+        pg: path,
+        meta: metadata,
+      },
+      unique: false,
+    })
+
+    // Assert
+    expect((libInstance as any).sendRequest).toHaveBeenCalledTimes(1)
+    expect((libInstance as any).sendRequest).toHaveBeenCalledWith(
+      expect.any(String),
+      expect.objectContaining({
+        pid: PROJECT_ID,
+        pg: path,
+        meta: metadata,
+      }),
+    )
+  })
+
+  test('trackViews should start tracking page views', async () => {
+    // Mock the trackPageViews method
+    ;(libInstance as any).trackPageViews = jest.fn().mockReturnValue({
+      stop: jest.fn(),
+    })
+
+    // Act
+    await trackViews()
+
+    // Assert
+    expect((libInstance as any).trackPageViews).toHaveBeenCalledTimes(1)
+  })
+})

package/tests/utils.test.ts

@@ -0,0 +1,217 @@
+import * as utils from '../src/utils'
+
+describe('Utility Functions', () => {
+  beforeEach(() => {
+    Object.defineProperty(window, 'location', {
+      value: {
+        hostname: 'example.com',
+        pathname: '/test-page',
+        hash: '',
+        search: '',
+      },
+      writable: true,
+    })
+
+    Object.defineProperty(document, 'referrer', {
+      value: 'https://google.com',
+      writable: true,
+    })
+
+    Object.defineProperty(navigator, 'language', {
+      value: 'en-US',
+      writable: true,
+    })
+
+    Object.defineProperty(navigator, 'languages', {
+      value: ['en-US', 'en'],
+      writable: true,
+    })
+
+    Object.defineProperty(navigator, 'webdriver', {
+      value: false,
+      writable: true,
+    })
+  })
+
+  test('isInBrowser should return true in JSDOM environment', () => {
+    expect(utils.isInBrowser()).toBe(true)
+  })
+
+  test('isLocalhost should detect localhost', () => {
+    // Arrange
+    Object.defineProperty(window, 'location', {
+      value: {
+        hostname: 'localhost',
+      },
+      writable: true,
+    })
+
+    // Act & Assert
+    expect(utils.isLocalhost()).toBe(true)
+
+    // Test 127.0.0.1
+    Object.defineProperty(window, 'location', {
+      value: {
+        hostname: '127.0.0.1',
+      },
+      writable: true,
+    })
+    expect(utils.isLocalhost()).toBe(true)
+
+    // Test non-localhost
+    Object.defineProperty(window, 'location', {
+      value: {
+        hostname: 'example.com',
+      },
+      writable: true,
+    })
+    expect(utils.isLocalhost()).toBe(false)
+  })
+
+  test('isAutomated should detect webdriver', () => {
+    // Arrange
+    Object.defineProperty(navigator, 'webdriver', {
+      value: true,
+      writable: true,
+    })
+
+    // Act & Assert
+    expect(utils.isAutomated()).toBe(true)
+
+    // Test non-automated
+    Object.defineProperty(navigator, 'webdriver', {
+      value: false,
+      writable: true,
+    })
+    expect(utils.isAutomated()).toBe(false)
+  })
+
+  test('getLocale should return the browser language', () => {
+    expect(utils.getLocale()).toBe('en-US')
+
+    // Test with navigator.languages undefined
+    const originalLanguages = navigator.languages
+    // Instead of deleting, set to undefined
+    Object.defineProperty(navigator, 'languages', {
+      value: undefined,
+      writable: true,
+    })
+    expect(utils.getLocale()).toBe('en-US') // Should use navigator.language as fallback
+
+    // Restore the original value
+    Object.defineProperty(navigator, 'languages', {
+      value: originalLanguages,
+      writable: true,
+    })
+  })
+
+  test('getReferrer should return the document referrer', () => {
+    expect(utils.getReferrer()).toBe('https://google.com')
+
+    // Test with empty referrer
+    Object.defineProperty(document, 'referrer', {
+      value: '',
+      writable: true,
+    })
+    expect(utils.getReferrer()).toBeUndefined()
+  })
+
+  test('getPath should handle different URL formats', () => {
+    // Arrange
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/test-page',
+        hash: '',
+        search: '',
+      },
+      writable: true,
+    })
+
+    // Act & Assert - basic path
+    expect(utils.getPath({})).toBe('/test-page')
+
+    // Test with hash
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/test-page',
+        hash: '#section1',
+        search: '',
+      },
+      writable: true,
+    })
+    expect(utils.getPath({ hash: true })).toBe('/test-page#section1')
+
+    // Test with search
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/test-page',
+        hash: '',
+        search: '?param=value',
+      },
+      writable: true,
+    })
+    expect(utils.getPath({ search: true })).toBe('/test-page?param=value')
+
+    // Test with both hash and search
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/test-page',
+        hash: '#section1',
+        search: '?param=value',
+      },
+      writable: true,
+    })
+    expect(utils.getPath({ hash: true, search: true })).toBe('/test-page#section1?param=value')
+
+    // Test with search in hash
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/test-page',
+        hash: '#section1?param=value',
+        search: '',
+      },
+      writable: true,
+    })
+    expect(utils.getPath({ hash: true, search: true })).toBe('/test-page#section1?param=value')
+  })
+
+  test('getUTM* functions should extract UTM parameters', () => {
+    // Arrange
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/landing',
+        hash: '',
+        search: '?utm_source=google&utm_medium=cpc&utm_campaign=summer&utm_term=analytics&utm_content=ad1',
+      },
+      writable: true,
+    })
+
+    // Act & Assert
+    expect(utils.getUTMSource()).toBe('google')
+    expect(utils.getUTMMedium()).toBe('cpc')
+    expect(utils.getUTMCampaign()).toBe('summer')
+    expect(utils.getUTMTerm()).toBe('analytics')
+    expect(utils.getUTMContent()).toBe('ad1')
+
+    // Test with 'ref' and 'source' parameters as well
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/landing',
+        hash: '',
+        search: '?ref=twitter',
+      },
+      writable: true,
+    })
+    expect(utils.getUTMSource()).toBe('twitter')
+
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/landing',
+        hash: '',
+        search: '?source=newsletter',
+      },
+      writable: true,
+    })
+    expect(utils.getUTMSource()).toBe('newsletter')
+  })
+})