cozy-bar 1.17.1

package/test/lib/stack-client/stack-client.getapp.spec.js

@@ -0,0 +1,72 @@
+import CozyClient from 'cozy-client'
+import stack from 'lib/stack-client'
+import mockStackClient from '../mockStackClient'
+
+describe('stack client', () => {
+  describe('getApp', () => {
+    const slug = 'testapp'
+
+    const stackClient = {
+      ...mockStackClient,
+      fetch: jest.fn().mockResolvedValue({
+        status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => {
+          // example from https://docs.cozy.io/en/cozy-stack/apps/
+          return {
+            data: {
+              id: '4cfbd8be-8968-11e6-9708-ef55b7c20863',
+              type: 'io.cozy.apps',
+              meta: {
+                rev: '2-bbfb0fc32dfcdb5333b28934f195b96a'
+              },
+              attributes: {
+                name: 'calendar',
+                state: 'ready',
+                slug: 'calendar'
+              },
+              links: {
+                self: '/apps/calendar',
+                icon: '/apps/calendar/icon',
+                related: 'https://calendar.alice.example.com/'
+              }
+            }
+          }
+        }
+      })
+    }
+
+    const cozyClient = new CozyClient({
+      stackClient
+    })
+
+    const params = {
+      cozyClient,
+      onCreateApp: function() {},
+      onDeleteApp: function() {}
+    }
+
+    beforeAll(async () => {
+      await stack.init(params)
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should return the `data` content', async () => {
+      const data = await stack.get.app(slug)
+      expect(data.id).toBe('4cfbd8be-8968-11e6-9708-ef55b7c20863')
+    })
+
+    it('should have called cozy-client', async () => {
+      await stack.get.app(slug)
+      expect(cozyClient.getStackClient().fetch).toHaveBeenCalled()
+    })
+
+    it('should not throw', async () => {
+      expect(() => stack.get.app(slug)).not.toThrow()
+      await expect(stack.get.app(slug)).resolves.not.toBe(false)
+    })
+  })
+})

package/test/lib/stack-client/stack-client.getapps.spec.js

@@ -0,0 +1,72 @@
+import CozyClient from 'cozy-client'
+import stack from 'lib/stack-client'
+import mockStackClient from '../mockStackClient'
+
+describe('stack client', () => {
+  describe('getApps', () => {
+    const stackClient = {
+      ...mockStackClient,
+      fetch: jest.fn().mockResolvedValue({
+        status: 200,
+        headers: { get: () => 'application/json' },
+        json: () => {
+          // example from https://docs.cozy.io/en/cozy-stack/apps/
+          return {
+            data: [
+              {
+                id: '4cfbd8be-8968-11e6-9708-ef55b7c20863',
+                type: 'io.cozy.apps',
+                meta: {
+                  rev: '2-bbfb0fc32dfcdb5333b28934f195b96a'
+                },
+                attributes: {
+                  name: 'calendar',
+                  state: 'ready',
+                  slug: 'calendar'
+                },
+                links: {
+                  self: '/apps/calendar',
+                  icon: '/apps/calendar/icon',
+                  related: 'https://calendar.alice.example.com/'
+                }
+              }
+            ]
+          }
+        }
+      })
+    }
+
+    const cozyClient = new CozyClient({
+      stackClient
+    })
+
+    const params = {
+      cozyClient,
+      onCreateApp: function() {},
+      onDeleteApp: function() {}
+    }
+
+    beforeAll(async () => {
+      await stack.init(params)
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should return the `data` content', async () => {
+      const data = await stack.get.apps()
+      expect(data[0].id).toBe('4cfbd8be-8968-11e6-9708-ef55b7c20863')
+    })
+
+    it('should have called cozy-client', async () => {
+      await stack.get.apps()
+      expect(cozyClient.getStackClient().fetch).toHaveBeenCalled()
+    })
+
+    it('should not throw', async () => {
+      expect(() => stack.get.apps()).not.toThrow()
+      await expect(stack.get.apps()).resolves.not.toBe(false)
+    })
+  })
+})

package/test/lib/stack-client/stack-client.getcontext.spec.js

@@ -0,0 +1,96 @@
+import stack from 'lib/stack-client'
+import CozyClient from 'cozy-client'
+import { NotFoundException, UnauthorizedStackException } from 'lib/exceptions'
+import mockStackClient from '../mockStackClient'
+
+describe('stack client', () => {
+  describe('getContext', () => {
+    const context404 = new NotFoundException()
+
+    const context500 = new UnauthorizedStackException()
+
+    const context200 = {
+      status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => {
+        return {
+          data: {
+            type: 'io.cozy.settings',
+            id: 'io.cozy.settings.context',
+            attributes: {
+              default_redirection: 'drive/#/files',
+              help_link: 'https://forum.cozy.io/',
+              onboarded_redirection: 'collect/#/discovery/?intro'
+            },
+            links: {
+              self: '/settings/context'
+            }
+          }
+        }
+      }
+    }
+
+    const stackClient = {
+      ...mockStackClient,
+      fetch: jest.fn()
+    }
+
+    const cozyClient = new CozyClient({
+      stackClient
+    })
+
+    const params = {
+      cozyClient,
+      onCreateApp: function() {},
+      onDeleteApp: function() {}
+    }
+
+    beforeAll(async () => {
+      await stack.init(params)
+    })
+
+    beforeEach(() => {
+      stackClient.fetch.mockClear()
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should not cache 500 errors', async () => {
+      stackClient.fetch.mockRejectedValue(context500)
+      await stack.get.context().catch(() => undefined)
+      await stack.get.context().catch(() => undefined)
+      expect(stackClient.fetch).toHaveBeenCalledTimes(2)
+    })
+
+    it('should return the raw json content', async () => {
+      stackClient.fetch.mockResolvedValue(context200)
+      const data = await stack.get.context()
+      expect(data.data.id).toBe('io.cozy.settings.context')
+    })
+
+    it('should be cached', async () => {
+      stackClient.fetch.mockResolvedValue(context200)
+      const data1 = await stack.get.context()
+      // If we did not called mockClear, we
+      // would have 0 or 1 call to the mock
+      // depending on preceding tests.
+      // Here we always should expect 0
+      // in the next lines
+      stackClient.fetch.mockClear()
+      stackClient.fetch.mockRejectedValue(context404)
+      const data2 = await stack.get.context()
+      expect(data1).toBe(data2)
+      expect(stackClient.fetch).toHaveBeenCalledTimes(0)
+    })
+
+    xit('should return the default value for a 404', async () => {
+      // @TODO deactivated because the previous tests already
+      // set the cache and the tested function is statefull
+      stackClient.fetch.mockRejectedValue(context404)
+      const data = await stack.get.context()
+      expect(data).toEqual({})
+    })
+  })
+})

package/test/lib/stack-client/stack-client.getstoragedata.spec.js

@@ -0,0 +1,85 @@
+import stack from 'lib/stack-client'
+import CozyClient from 'cozy-client'
+import mockStackClient from '../mockStackClient'
+
+describe('stack client', () => {
+  describe('getStorageData', () => {
+    const r200 = {
+      status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => {
+        return {
+          data: {
+            type: 'io.cozy.settings',
+            id: 'io.cozy.settings.disk-usage',
+            attributes: {
+              is_limited: true,
+              quota: '123456789',
+              used: '12345678'
+            }
+          }
+        }
+      }
+    }
+
+    const r200noquota = {
+      status: 200,
+      headers: { get: () => 'application/json' },
+      json: () => {
+        return {
+          data: {
+            type: 'io.cozy.settings',
+            id: 'io.cozy.settings.disk-usage',
+            attributes: {
+              is_limited: false,
+              used: '2000111222333' // 2To
+            }
+          }
+        }
+      }
+    }
+
+    const stackClient = {
+      ...mockStackClient,
+      fetch: jest.fn()
+    }
+
+    const cozyClient = new CozyClient({
+      stackClient
+    })
+
+    const params = {
+      cozyClient,
+      onCreateApp: function() {},
+      onDeleteApp: function() {}
+    }
+
+    beforeAll(async () => {
+      await stack.init(params)
+    })
+
+    beforeEach(() => {
+      stackClient.fetch.mockClear()
+      stackClient.fetch.mockResolvedValue(r200)
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should return a decidated object', async () => {
+      const data = await stack.get.storageData()
+      expect(data.usage).toBe(12345678)
+      expect(data.quota).toBe(123456789)
+      expect(data.isLimited).toBe(true)
+    })
+
+    it('when no quota is provided, one should be given', async () => {
+      stackClient.fetch.mockResolvedValue(r200noquota)
+      const data = await stack.get.storageData()
+      expect(data.usage).toBe(2000111222333)
+      expect(data.quota).toBeGreaterThanOrEqual(data.usage)
+      expect(data.isLimited).toBe(false)
+    })
+  })
+})

package/test/lib/stack-client/stack-client.init.spec.js

@@ -0,0 +1,56 @@
+import stack from 'lib/stack-client'
+
+import CozyClient from 'cozy-client'
+import initializeRealtime from 'lib/realtime'
+import mockStackClient from '../mockStackClient'
+
+jest.mock('lib/realtime')
+initializeRealtime.mockResolvedValue(Promise.resolve())
+
+const { init } = stack
+
+describe('stack client', () => {
+  describe('init', () => {
+    let cozyClient, params
+
+    const setup = async ({ isLogged, isPublic }) => {
+      if (isLogged === undefined) {
+        throw new Error('Please define explicity isLogged in your tests.')
+      }
+
+      cozyClient = new CozyClient({
+        token: { token: 'mytoken' },
+        uri: 'https://test.mycozy.cloud',
+        stackClient: mockStackClient
+      })
+      cozyClient.isLogged = isLogged
+      params = {
+        cozyClient,
+        isPublic,
+        onCreate: function() {},
+        onDelete: function() {}
+      }
+      await init(params)
+    }
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should not have initialized the realtime if the user is not logged', async () => {
+      await setup({ isLogged: false })
+      expect(initializeRealtime).toHaveBeenCalledTimes(0)
+    })
+
+    it('should not have initialized the realtime if the user is not logged even if isPublic is set to false', async () => {
+      await setup({ isLogged: false, isPublic: false })
+      expect(initializeRealtime).toHaveBeenCalledTimes(0)
+    })
+
+    it('should have initialized the realtime is the user is logged', async () => {
+      await setup({ isLogged: true })
+      expect(initializeRealtime).toHaveBeenCalled()
+      expect(initializeRealtime.mock.calls[0][0].cozyClient).toBe(cozyClient)
+    })
+  })
+})

package/test/lib/stack-client/stack-client.intents.spec.js

@@ -0,0 +1,27 @@
+import { Intents } from 'cozy-interapp'
+import stack from 'lib/stack-client'
+import CozyClient from 'cozy-client'
+import mockStackClient from '../mockStackClient'
+
+describe('stack client', () => {
+  describe('intents', () => {
+    const cozyClient = new CozyClient({
+      stackClient: mockStackClient
+    })
+
+    const params = {
+      cozyClient,
+      onCreateApp: function() {},
+      onDeleteApp: function() {}
+    }
+
+    beforeAll(async () => {
+      await stack.init(params)
+    })
+
+    it('should return correctly the Intents instance', () => {
+      const intents = stack.get.intents()
+      expect(intents).toBeInstanceOf(Intents)
+    })
+  })
+})

package/test/lib/stack-client/stack-client.logout.spec.js

@@ -0,0 +1,40 @@
+import stack from 'lib/stack-client'
+import CozyClient from 'cozy-client'
+import mockStackClient from '../mockStackClient'
+
+describe('stack client', () => {
+  describe('logout', () => {
+    const stackClient = {
+      ...mockStackClient,
+      fetch: jest.fn().mockResolvedValue({ status: 200 })
+    }
+
+    const cozyClient = new CozyClient({
+      stackClient
+    })
+
+    const params = {
+      cozyClient,
+      onCreateApp: function() {},
+      onDeleteApp: function() {}
+    }
+
+    beforeAll(async () => {
+      await stack.init(params)
+      await stack.logout()
+    })
+
+    afterAll(() => {
+      jest.restoreAllMocks()
+    })
+
+    it('should have called cozy-client', () => {
+      expect(cozyClient.getStackClient().fetch).toHaveBeenCalled()
+    })
+
+    it('should not throw', async () => {
+      expect(() => stack.logout()).not.toThrow()
+      await expect(stack.logout()).resolves.not.toBe(false)
+    })
+  })
+})

package/test/lib/stack.spec.js

@@ -0,0 +1,60 @@
+import CozyClient from 'cozy-client'
+import client from 'lib/stack-client.js'
+import stack from 'lib/stack.js'
+import mockStackClient from './mockStackClient'
+
+const onCreate = function() {}
+const onDelete = function() {}
+
+describe('stack proxy', () => {
+  beforeAll(() => {
+    jest.spyOn(client, 'init').mockResolvedValue(undefined)
+    jest.spyOn(client.get, 'app').mockResolvedValue(undefined)
+  })
+
+  afterAll(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe('when initialized with a cozy-client instance', () => {
+    const params = {
+      cozyClient: new CozyClient({ stackClient: mockStackClient }),
+      onCreate: function() {},
+      onDelete: function() {}
+    }
+
+    beforeAll(() => {
+      jest.clearAllMocks()
+
+      stack.init(params)
+      stack.get.app()
+    })
+
+    it('should call the client stack init', () => {
+      expect(client.init).toHaveBeenCalled()
+    })
+
+    it('should forward requests to the cozy-client stack client', () => {
+      expect(client.get.app).toHaveBeenCalled()
+    })
+  })
+
+  it('should throw error if trying to use the stack before init', () => {
+    jest.clearAllMocks()
+    jest.resetModules()
+    const stack = require('lib/stack').default
+
+    expect(() => {
+      stack.getStack()
+    }).toThrowErrorMatchingSnapshot()
+
+    stack.init({
+      cozyClient: new CozyClient({ stackClient: mockStackClient }),
+      onCreate,
+      onDelete
+    })
+    expect(() => {
+      stack.getStack()
+    }).not.toThrowError()
+  })
+})

package/test/store/__snapshots__/index.spec.js.snap

@@ -0,0 +1,14 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`store should keep apps data 1`] = `
+Array [
+  Object {
+    "isCurrentApp": false,
+    "slug": "drive",
+  },
+  Object {
+    "isCurrentApp": false,
+    "slug": "banks",
+  },
+]
+`;

package/test/store/index.spec.js

@@ -0,0 +1,41 @@
+import getOrCreateStore, { createStore } from 'lib/store'
+import { isFetchingApps, getApps, hasFetched } from 'lib/reducers'
+
+describe('store', () => {
+  let store
+
+  beforeEach(() => {
+    store = createStore()
+  })
+
+  const getState = () => store.getState()
+
+  it('should keep fetching status', () => {
+    expect(isFetchingApps(getState())).toBe(true)
+    store.dispatch({ type: 'FETCH_APPS' })
+    expect(isFetchingApps(getState())).toBe(true)
+    store.dispatch({ type: 'RECEIVE_APP_LIST', apps: [] })
+    expect(isFetchingApps(getState())).toBe(false)
+  })
+
+  it('should keep apps data', () => {
+    const apps = [{ slug: 'drive' }, { slug: 'banks' }]
+    expect(getApps(getState())).toEqual([])
+    store.dispatch({ type: 'RECEIVE_APP_LIST', apps: apps })
+    expect(getApps(getState())).toMatchSnapshot()
+  })
+
+  it('should remember it has fetched (ok case)', () => {
+    expect(hasFetched(getState())).toEqual(false)
+    store.dispatch({ type: 'RECEIVE_APP_LIST', apps: [] })
+    expect(hasFetched(getState())).toEqual(true)
+  })
+})
+
+describe('singleton', () => {
+  it('should work as a singleton', () => {
+    const store = getOrCreateStore()
+    const store2 = getOrCreateStore()
+    expect(store).toEqual(store2)
+  })
+})