test: added unit tests

Author: gallayl

common/src/utils/file-utils.spec.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest'
+import { getFileName, getParentPath, getFullPath } from './file-utils.js'
+import type { PiRatFile } from '../models/pirat-file.js'
+
+describe('file-utils', () => {
+  describe('getFileName', () => {
+    it('should return the file name from a simple path', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'folder/subfolder/movie.mkv' }
+      expect(getFileName(file)).toBe('movie.mkv')
+    })
+
+    it('should return the file name from a deeply nested path', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'a/b/c/d/e/file.txt' }
+      expect(getFileName(file)).toBe('file.txt')
+    })
+
+    it('should return the file name when path has no directories', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'document.pdf' }
+      expect(getFileName(file)).toBe('document.pdf')
+    })
+
+    it('should handle paths with special characters in file name', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'folder/file with spaces.txt' }
+      expect(getFileName(file)).toBe('file with spaces.txt')
+    })
+
+    it('should handle paths with dots in folder names', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'folder.v2/subfolder.test/file.mkv' }
+      expect(getFileName(file)).toBe('file.mkv')
+    })
+  })
+
+  describe('getParentPath', () => {
+    it('should return the parent path from a simple path', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'folder/subfolder/movie.mkv' }
+      expect(getParentPath(file)).toBe('folder/subfolder')
+    })
+
+    it('should return the parent path from a deeply nested path', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'a/b/c/d/e/file.txt' }
+      expect(getParentPath(file)).toBe('a/b/c/d/e')
+    })
+
+    it('should return the file name when path has no parent directory', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'document.pdf' }
+      // PathHelper.getParentPath returns the path itself when there's no parent
+      expect(getParentPath(file)).toBe('document.pdf')
+    })
+
+    it('should handle paths with special characters', () => {
+      const file: PiRatFile = { driveLetter: 'A', path: 'folder with spaces/file.txt' }
+      expect(getParentPath(file)).toBe('folder with spaces')
+    })
+  })
+
+  describe('getFullPath', () => {
+    it('should combine parent path and file name', () => {
+      expect(getFullPath('folder/subfolder', 'movie.mkv')).toBe('folder/subfolder/movie.mkv')
+    })
+
+    it('should handle empty parent path', () => {
+      expect(getFullPath('', 'document.pdf')).toBe('document.pdf')
+    })
+
+    it('should normalize paths with trailing slashes', () => {
+      expect(getFullPath('folder/', 'file.txt')).toBe('folder/file.txt')
+    })
+
+    it('should handle paths with special characters', () => {
+      expect(getFullPath('folder with spaces', 'file name.txt')).toBe('folder with spaces/file name.txt')
+    })
+
+    it('should normalize paths with double slashes', () => {
+      const result = getFullPath('folder', '/file.txt')
+      expect(result).toBe('folder/file.txt')
+    })
+  })
+})

common/src/utils/url-encode-decode.spec.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect } from 'vitest'
+import { encode, decode } from './url-encode-decode.js'
+
+describe('url-encode-decode', () => {
+  describe('encode', () => {
+    it('should encode a simple string', () => {
+      const encoded = encode('hello')
+      expect(typeof encoded).toBe('string')
+      expect(encoded.length).toBeGreaterThan(0)
+    })
+
+    it('should encode an object', () => {
+      const encoded = encode({ foo: 'bar' })
+      expect(typeof encoded).toBe('string')
+      expect(encoded.length).toBeGreaterThan(0)
+    })
+
+    it('should encode a number', () => {
+      const encoded = encode(42)
+      expect(typeof encoded).toBe('string')
+      expect(encoded.length).toBeGreaterThan(0)
+    })
+
+    it('should encode a boolean', () => {
+      const encoded = encode(true)
+      expect(typeof encoded).toBe('string')
+      expect(encoded.length).toBeGreaterThan(0)
+    })
+
+    it('should encode null', () => {
+      const encoded = encode(null)
+      expect(typeof encoded).toBe('string')
+      expect(encoded.length).toBeGreaterThan(0)
+    })
+
+    it('should encode an array', () => {
+      const encoded = encode([1, 2, 3])
+      expect(typeof encoded).toBe('string')
+      expect(encoded.length).toBeGreaterThan(0)
+    })
+
+    it('should produce URL-safe output', () => {
+      const encoded = encode({ complex: 'value with spaces & special=chars' })
+      // URL-safe characters should not need further encoding
+      expect(encoded).not.toContain(' ')
+      expect(encoded).not.toContain('&')
+      expect(encoded).not.toContain('=')
+    })
+  })
+
+  describe('decode', () => {
+    it('should decode back to a simple string', () => {
+      const original = 'hello'
+      const encoded = encode(original)
+      const decoded = decode<string>(encoded)
+      expect(decoded).toBe(original)
+    })
+
+    it('should decode back to an object', () => {
+      const original = { foo: 'bar', baz: 123 }
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+
+    it('should decode back to a number', () => {
+      const original = 42
+      const encoded = encode(original)
+      const decoded = decode<number>(encoded)
+      expect(decoded).toBe(original)
+    })
+
+    it('should decode back to a boolean', () => {
+      const original = true
+      const encoded = encode(original)
+      const decoded = decode<boolean>(encoded)
+      expect(decoded).toBe(original)
+    })
+
+    it('should decode back to null', () => {
+      const encoded = encode(null)
+      const decoded = decode<null>(encoded)
+      expect(decoded).toBeNull()
+    })
+
+    it('should decode back to an array', () => {
+      const original = [1, 2, 3, 'four']
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+  })
+
+  describe('roundtrip', () => {
+    it('should handle unicode characters', () => {
+      const original = { message: 'Hello 世界' }
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+
+    it('should handle emoji', () => {
+      const original = { foo: 'bar😉' }
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+
+    it('should handle complex nested objects', () => {
+      const original = {
+        user: {
+          name: 'John Doe',
+          settings: {
+            theme: 'dark',
+            notifications: true,
+          },
+        },
+        items: [1, 2, { nested: 'value' }],
+      }
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+
+    it('should handle special characters', () => {
+      const original = {
+        query: 'search?q=test&page=1',
+        path: '/folder/file.txt',
+        special: '<script>alert("xss")</script>',
+      }
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+
+    it('should handle empty string', () => {
+      const original = ''
+      const encoded = encode(original)
+      const decoded = decode<string>(encoded)
+      expect(decoded).toBe(original)
+    })
+
+    it('should handle empty object', () => {
+      const original = {}
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+
+    it('should handle empty array', () => {
+      const original: unknown[] = []
+      const encoded = encode(original)
+      const decoded = decode<typeof original>(encoded)
+      expect(decoded).toEqual(original)
+    })
+  })
+})