metaowl 0.1.3 → 0.2.0

package/test/odoo-rpc.test.js

@@ -0,0 +1,547 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  OdooService,
+  configure,
+  isConfigured,
+  isAuthenticated,
+  getSession,
+  getConfig,
+  onAuthChange,
+  authenticate,
+  logout,
+  searchRead,
+  call,
+  read,
+  create,
+  write,
+  unlink,
+  searchCount,
+  listDatabases,
+  versionInfo
+} from '../modules/odoo-rpc.js'
+
+describe('Odoo RPC Service', () => {
+  beforeEach(() => {
+    // Reset state
+    logout()
+    localStorage.clear()
+    vi.restoreAllMocks()
+  })
+
+  describe('Configuration', () => {
+    it('should configure with valid config', () => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db',
+        username: 'admin',
+        password: 'admin'
+      })
+
+      expect(isConfigured()).toBe(true)
+      expect(getConfig()).toMatchObject({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db',
+        username: 'admin',
+        password: 'admin',
+        persistSession: true
+      })
+    })
+
+    it('should not be configured without baseUrl', () => {
+      configure({
+        database: 'test_db'
+      })
+      expect(isConfigured()).toBe(false)
+    })
+
+    it('should not be configured without database', () => {
+      configure({
+        baseUrl: 'https://test.odoo.com'
+      })
+      expect(isConfigured()).toBe(false)
+    })
+
+    it('should allow apiKey instead of password', () => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db',
+        username: 'admin',
+        apiKey: 'test-api-key-123'
+      })
+
+      expect(getConfig().apiKey).toBe('test-api-key-123')
+      expect(getConfig().password).toBeUndefined()
+    })
+
+    it('should support disabling session persistence', () => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db',
+        persistSession: false
+      })
+
+      expect(getConfig().persistSession).toBe(false)
+    })
+  })
+
+  describe('Authentication', () => {
+    beforeEach(() => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db',
+        username: 'admin',
+        password: 'admin'
+      })
+    })
+
+    it('should authenticate successfully', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: 1  // User ID
+        })
+      }).mockResolvedValueOnce({  // For user info search_read
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: [{
+            id: 1,
+            name: 'Administrator',
+            partner_id: [3, 'Administrator'],
+            lang: 'en_US',
+            tz: 'Europe/Brussels'
+          }]
+        })
+      })
+
+      const session = await authenticate()
+
+      expect(session.uid).toBe(1)
+      expect(session.username).toBe('admin')
+      expect(session.name).toBe('Administrator')
+      expect(isAuthenticated()).toBe(true)
+    })
+
+    it('should throw error without credentials', async () => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db'
+      })
+
+      await expect(authenticate()).rejects.toThrow('requires username and password')
+    })
+
+    it('should allow custom credentials in authenticate()', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: 2
+        })
+      }).mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: []
+        })
+      })
+
+      const session = await authenticate('custom_user', 'custom_pass')
+      expect(session.username).toBe('custom_user')
+    })
+
+    it('should handle authentication failure', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: false  // Authentication failed
+        })
+      })
+
+      await expect(authenticate()).rejects.toThrow('invalid credentials')
+    })
+
+    it('should logout and clear session', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: 1
+        })
+      }).mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: []
+        })
+      })
+
+      await authenticate()
+      expect(isAuthenticated()).toBe(true)
+
+      logout()
+      expect(isAuthenticated()).toBe(false)
+      expect(getSession()).toBeNull()
+    })
+
+    it('should notify auth listeners on change', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: 1
+        })
+      }).mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: []
+        })
+      })
+
+      const listener = vi.fn()
+      const unsubscribe = onAuthChange(listener)
+
+      await authenticate()
+      expect(listener).toHaveBeenCalledTimes(1)
+      expect(listener).toHaveBeenCalledWith(expect.objectContaining({ uid: 1 }))
+
+      unsubscribe()
+    })
+  })
+
+  describe('RPC Operations', () => {
+    beforeEach(() => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db',
+        username: 'admin',
+        password: 'admin'
+      })
+
+      // Mock successful authentication
+      global.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: 1
+        })
+      })
+    })
+
+    it('should throw if not authenticated', async () => {
+      await expect(searchRead('res.partner')).rejects.toThrow('Not authenticated')
+    })
+
+    it('should perform search_read', async () => {
+      const mockResult = [
+        { id: 1, name: 'Partner 1' },
+        { id: 2, name: 'Partner 2' }
+      ]
+
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: 1
+        })
+      }).mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: []
+        })
+      }).mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: mockResult
+        })
+      })
+
+      await authenticate()
+      const partners = await searchRead('res.partner', {
+        domain: [['is_company', '=', true]],
+        fields: ['name', 'email'],
+        limit: 10
+      })
+
+      expect(partners).toEqual(mockResult)
+    })
+
+    it('should call model methods', async () => {
+      global.fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 42 })
+        })
+
+      await authenticate()
+      const result = await call('res.partner', 'custom_method', [['arg1']])
+
+      expect(result).toBe(42)
+    })
+
+    it('should read specific records', async () => {
+      global.fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({
+            jsonrpc: '2.0',
+            id: 123,
+            result: [{ id: 1, name: 'Partner 1' }]
+          })
+        })
+
+      await authenticate()
+      const records = await read('res.partner', [1], ['name', 'email'])
+
+      expect(records).toEqual([{ id: 1, name: 'Partner 1' }])
+    })
+
+    it('should create records', async () => {
+      global.fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 123 })
+        })
+
+      await authenticate()
+      const newId = await create('res.partner', { name: 'New Partner' })
+
+      expect(newId).toBe(123)
+    })
+
+    it('should update records', async () => {
+      global.fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: true })
+        })
+
+      await authenticate()
+      const result = await write('res.partner', [1], { name: 'Updated Partner' })
+
+      expect(result).toBe(true)
+    })
+
+    it('should delete records', async () => {
+      global.fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: true })
+        })
+
+      await authenticate()
+      const result = await unlink('res.partner', [1])
+
+      expect(result).toBe(true)
+    })
+
+    it('should get search count', async () => {
+      global.fetch = vi.fn()
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 1 })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: [] })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers(),
+          json: async () => ({ jsonrpc: '2.0', id: 123, result: 42 })
+        })
+
+      await authenticate()
+      const count = await searchCount('res.partner', [['is_company', '=', true]])
+
+      expect(count).toBe(42)
+    })
+  })
+
+  describe('Database Operations', () => {
+    beforeEach(() => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db'
+      })
+    })
+
+    it('should list databases', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          result: ['db1', 'db2', 'db3']
+        })
+      })
+
+      const dbs = await listDatabases()
+      expect(dbs).toEqual(['db1', 'db2', 'db3'])
+    })
+
+    it('should get version info', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          result: {
+            server_version: '16.0',
+            server_version_info: [16, 0, 0, 'final', 0],
+            protocol_version: 1
+          }
+        })
+      })
+
+      const version = await versionInfo()
+      expect(version.server_version).toBe('16.0')
+    })
+  })
+
+  describe('Error Handling', () => {
+    beforeEach(() => {
+      configure({
+        baseUrl: 'https://test.odoo.com',
+        database: 'test_db',
+        username: 'admin',
+        password: 'admin'
+      })
+    })
+
+    it('should handle RPC errors', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+        json: async () => ({
+          jsonrpc: '2.0',
+          id: 123,
+          error: {
+            message: 'Access Denied',
+            data: { message: 'You do not have permission' }
+          }
+        })
+      })
+
+      await expect(authenticate()).rejects.toThrow('Access Denied')
+    })
+
+    it('should handle HTTP errors', async () => {
+      global.fetch = vi.fn().mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        headers: new Headers(),
+        json: async () => ({})
+      })
+
+      await expect(authenticate()).rejects.toThrow('HTTP 500')
+    })
+
+    it('should throw if not configured', async () => {
+      // Reset configuration by configuring with empty values
+      configure({ baseUrl: '', database: '' })
+      
+      await expect(listDatabases()).rejects.toThrow('not configured')
+    })
+  })
+
+  describe('OdooService Namespace', () => {
+    it('should expose all methods via namespace', () => {
+      expect(OdooService.configure).toBe(configure)
+      expect(OdooService.authenticate).toBe(authenticate)
+      expect(OdooService.logout).toBe(logout)
+      expect(OdooService.searchRead).toBe(searchRead)
+      expect(OdooService.call).toBe(call)
+      expect(OdooService.isAuthenticated).toBe(isAuthenticated)
+    })
+  })
+})

package/test/pwa.test.js

@@ -0,0 +1,154 @@
+import { describe, it, expect } from 'vitest'
+import {
+  generateManifest,
+  isOnline,
+  subscribeToConnectivity,
+  sync,
+  showNotification,
+  cache,
+  checkCapabilities,
+  PWA
+} from '../modules/pwa.js'
+
+describe('PWA', () => {
+  describe('Exports', () => {
+    it('should export all functions', () => {
+      expect(typeof generateManifest).toBe('function')
+      expect(typeof isOnline).toBe('function')
+      expect(typeof subscribeToConnectivity).toBe('function')
+      expect(typeof sync).toBe('function')
+      expect(typeof showNotification).toBe('function')
+      expect(typeof cache).toBe('object')
+      expect(typeof checkCapabilities).toBe('function')
+    })
+
+    it('should export PWA namespace', () => {
+      expect(PWA.generateManifest).toBe(generateManifest)
+      expect(PWA.isOnline).toBe(isOnline)
+      expect(PWA.cache).toBe(cache)
+    })
+  })
+
+  describe('generateManifest', () => {
+    it('should generate basic manifest', () => {
+      const manifest = generateManifest({
+        name: 'My App',
+        shortName: 'MyApp'
+      })
+
+      expect(manifest.name).toBe('My App')
+      expect(manifest.short_name).toBe('MyApp')
+      expect(manifest.display).toBe('standalone')
+      expect(manifest.theme_color).toBe('#000000')
+    })
+
+    it('should include optional fields', () => {
+      const manifest = generateManifest({
+        name: 'Full App',
+        shortName: 'Full',
+        description: 'A complete app',
+        startUrl: '/home',
+        display: 'fullscreen',
+        themeColor: '#007bff',
+        backgroundColor: '#ffffff',
+        scope: '/app',
+        icons: [
+          { src: '/icon.png', sizes: '192x192', type: 'image/png' }
+        ]
+      })
+
+      expect(manifest.description).toBe('A complete app')
+      expect(manifest.start_url).toBe('/home')
+      expect(manifest.display).toBe('fullscreen')
+      expect(manifest.theme_color).toBe('#007bff')
+      expect(manifest.background_color).toBe('#ffffff')
+      expect(manifest.scope).toBe('/app')
+      expect(manifest.icons).toHaveLength(1)
+    })
+
+    it('should use default values', () => {
+      const manifest = generateManifest({
+        name: 'Minimal'
+      })
+
+      expect(manifest.display).toBe('standalone')
+      expect(manifest.theme_color).toBe('#000000')
+      expect(manifest.start_url).toBe('./')
+    })
+
+    it('should include orientation', () => {
+      const manifest = generateManifest({ name: 'Test' })
+      expect(manifest.orientation).toBe('any')
+    })
+  })
+
+  describe('isOnline', () => {
+    it('should return navigator.onLine', () => {
+      const result = isOnline()
+      expect(typeof result).toBe('boolean')
+    })
+  })
+
+  describe('subscribeToConnectivity', () => {
+    it('should return unsubscribe function', () => {
+      const unsubscribe = subscribeToConnectivity({})
+      expect(typeof unsubscribe).toBe('function')
+
+      // Cleanup
+      unsubscribe()
+    })
+
+    it('should not throw without callbacks', () => {
+      const unsubscribe = subscribeToConnectivity({})
+      expect(typeof unsubscribe).toBe('function')
+      unsubscribe()
+    })
+  })
+
+  describe('sync', () => {
+    it('should return false without service worker', async () => {
+      const result = await sync('test-tag')
+      expect(result).toBe(false)
+    })
+  })
+
+  describe('showNotification', () => {
+    it('should not throw', async () => {
+      await showNotification('Test', { body: 'Body' })
+      // Should complete without error
+    })
+  })
+
+  describe('cache', () => {
+    it('should have cache methods', () => {
+      expect(typeof cache.add).toBe('function')
+      expect(typeof cache.remove).toBe('function')
+      expect(typeof cache.clear).toBe('function')
+      expect(typeof cache.info).toBe('function')
+    })
+
+    it('should return empty array for info without caches', async () => {
+      const info = await cache.info()
+      expect(Array.isArray(info)).toBe(true)
+    })
+  })
+
+  describe('checkCapabilities', () => {
+    it('should return capability object', () => {
+      const caps = checkCapabilities()
+
+      expect(typeof caps.serviceWorker).toBe('boolean')
+      expect(typeof caps.push).toBe('boolean')
+      expect(typeof caps.notifications).toBe('boolean')
+      expect(typeof caps.backgroundSync).toBe('boolean')
+      expect(typeof caps.persistentStorage).toBe('boolean')
+      expect(typeof caps.addToHomeScreen).toBe('boolean')
+      expect(typeof caps.offline).toBe('boolean')
+    })
+
+    it('should detect service worker support', () => {
+      const caps = checkCapabilities()
+      expect(caps.serviceWorker).toBeDefined()
+    })
+  })
+})