bt-core-app 1.4.2 → 1.4.3

package/test/helpers.test.ts

@@ -1,231 +0,0 @@
-import { nestedValue, toCompareString, hasSearch, deepSelect, containsSearch, copyItemByAlphabet, copyDeep, csvContains, toggleCSV, roundTo, isArrayOfLength, isLengthyArray, addWeekday, removeWeekday, appendUrl, getAreaAround, getAreaToLeft, getAreaToRight, getLocationLine, capitalizeWords, fromCamelCase, toCamelCase, weekdayValue, weekdayShortName, containsWeekday, validEmail } from '../src/composables/helpers'
-import { describe, expect, test } from 'vitest'
-
-describe("helpers", () => {
-
-    test('append url', () => {
-        expect(appendUrl('https://test.com/', '/test')).toEqual('https://test.com/test')
-        expect(appendUrl('https://test.com', 'test')).toEqual('https://test.com/test')
-        expect(appendUrl('https://test.com/', 'test')).toEqual('https://test.com/test')
-        expect(appendUrl('https://test.com', '/test')).toEqual('https://test.com/test')
-        expect(appendUrl('https://test.com///', '///test')).toEqual('https://test.com/test')
-    })
-
-    test('get area around', () => {
-        //starts with top left and goes anti-clockwise
-        expect(getAreaAround({ lat: 0, lng: 0 }, 1)).toEqual([{ lat: -1, lng: 1 },{ lat: -1, lng: -1 },{ lat: 1, lng: -1 },{ lat: 1, lng: 1 }])
-        expect(getAreaAround({ lat: 0, lng: 0 }, 2)).toEqual([{ lat: -2, lng: 2 },{ lat: -2, lng: -2 },{ lat: 2, lng: -2 },{ lat: 2, lng: 2 }])
-        expect(getAreaAround({ lat: 2, lng: 6 }, 1)).toEqual([{ lat: 1, lng: 7 },{ lat: 1, lng: 5 },{ lat: 3, lng: 5 },{ lat: 3, lng: 7 }])
-    })
-
-    test('get area to left', () => {
-        //starts with top left and goes anti-clockwise
-        expect(getAreaToLeft({ lat: 0, lng: 0 }, 1)).toEqual([{ lat: -2, lng: 1 },{ lat: -2, lng: -1 },{ lat: 0, lng: -1 },{ lat: 0, lng: 1 }])
-        expect(getAreaToLeft({ lat: 0, lng: 0 }, 2)).toEqual([{ lat: -4, lng: 2 },{ lat: -4, lng: -2 },{ lat: 0, lng: -2 },{ lat: 0, lng: 2 }])
-    })
-
-    test('get area to right', () => {
-        //starts with top left and goes anti-clockwise
-        expect(getAreaToRight({ lat: 0, lng: 0 }, 1)).toEqual([{ lat: 0, lng: 1 },{ lat: 0, lng: -1 },{ lat: 2, lng: -1 },{ lat: 2, lng: 1 }])
-        expect(getAreaToRight({ lat: 2, lng: 0 }, 2)).toEqual([{ lat: 2, lng: 2 },{ lat: 2, lng: -2 },{ lat: 6, lng: -2 },{ lat: 6, lng: 2 }])
-    })
-
-    test('get location line', () => {
-        expect(getLocationLine(null)).toEqual('')
-        expect(getLocationLine({ streetNumber: '9', streetName: 'Morgan St', suburb: 'Timboon', state: 'VIC', postcode: '3268' })).toEqual('9 Morgan St, Timboon VIC 3268')
-    })
-
-    test('from camel case', () => {
-        expect(fromCamelCase('testOneTwo')).toEqual('Test One Two')
-        expect(fromCamelCase('testOne Two')).toEqual('Test One  Two')
-        expect(fromCamelCase('tesTOneTwo')).not.toEqual('Test One Two')
-        expect(fromCamelCase()).toBeUndefined()
-    })
-
-    test('to camel case', () => {
-        expect(toCamelCase(undefined)).toBeUndefined()
-        expect(toCamelCase({ Test: 't' })).not.toEqual({ Test: 't' })
-        expect(toCamelCase({ Test: 't' })).toEqual({ test: 't' })
-    })
-
-    test('capitalize', () => {
-        expect(capitalizeWords('test')).toEqual('Test')
-        expect(capitalizeWords('test one')).toEqual('Test One')
-    })
-    
-    test('weekdays csv string sort value', () => {
-        expect(weekdayValue('sun, wed, sat')).toEqual(1)
-        expect(weekdayValue('wed, sat')).toEqual(4)
-        expect(weekdayValue('')).toEqual(8)
-        expect(weekdayValue()).toEqual(0)
-        expect(weekdayValue('sun, wed, sat, always')).toEqual(0)
-        expect(weekdayValue('Tuesday')).toEqual(3)
-    })
-
-    test('weekday short name conversion', () => {
-        expect(weekdayShortName('Sun, Mon, tuesday')).toEqual('sun,mon,tue')
-        expect(weekdayShortName('Sun, Mon, blah')).toEqual('sun,mon')
-        expect(weekdayShortName('Sun, Fri, Wedne')).toEqual('sun,fri')
-        expect(weekdayShortName('Sunday')).toEqual('sun')
-    })
-
-    test('contains weekday', () => {
-        expect(containsWeekday('sun', 'sun')).toEqual(true)
-        expect(containsWeekday('sun', 'Sunday')).toEqual(true)
-        expect(containsWeekday('sun,mon,tue, wed', 'Tuesday')).toEqual(true)
-        expect(containsWeekday('sun,mon,tuesday, wed', 'Tuesday')).toEqual(true)
-        expect(containsWeekday('sun,mon, wed', 'tue')).toEqual(false)
-    })
-
-    test('add weekday', () => {
-        expect(addWeekday(undefined, 'sun')).toEqual('sun')
-        expect(addWeekday(undefined, 'sun')).toEqual('sun')
-        expect(addWeekday('mon,sun', 'sun')).toEqual('sun,mon')
-        expect(addWeekday('mon,sun, always, m', 'sun')).toEqual('always,sun,mon')
-    })
-
-    test('remove weekday', () => {
-        expect(removeWeekday(undefined, 'sun')).toEqual(undefined)
-        expect(removeWeekday('sun', 'sun')).toEqual(undefined)
-        expect(removeWeekday('sun, thur, tue', 'sun')).toEqual('tue,thu')
-        expect(removeWeekday('always', 'sun')).toEqual('always')
-    })
-
-    test('is array of length', () => {
-        expect(isArrayOfLength([], 0)).toEqual(true)
-        expect(isArrayOfLength([1,1,1], 3)).toEqual(true)
-        expect(isArrayOfLength(undefined, 0)).toEqual(false)
-        expect(isArrayOfLength({}, 0)).toEqual(false)
-    })
-
-    test('is lengthy array', () => {
-        expect(isLengthyArray([])).toEqual(false)
-        expect(isLengthyArray(undefined)).toEqual(false)
-        expect(isLengthyArray([1])).toEqual(true)
-        expect(isLengthyArray([1,1])).toEqual(true)
-        expect(isLengthyArray([1,1], 1)).toEqual(true)
-        expect(isLengthyArray([1,1], 3)).toEqual(false)
-    })
-
-    test('rounding decimal places', () => {
-        expect(roundTo(1, 0)).toEqual(1)
-        expect(roundTo(1.1, 0)).toEqual(1)
-        expect(roundTo(1.6, 0)).toEqual(2)
-        expect(roundTo(2.22567, 3)).toEqual(2.226)
-        expect(roundTo(2.22547, 3)).toEqual(2.225)
-    })
-
-    test('toggle csv', () => {
-        expect(toggleCSV('one,two,three', 'two')).toEqual('one,three')
-        expect(toggleCSV('two', 'two')).toEqual(null)
-    })
-
-    test('csv contains', () => {
-        expect(csvContains('one,two,three', 'two')).toEqual(true)
-        expect(csvContains('one,two,three', 'three')).toEqual(true)
-        expect(csvContains('one,three', 'two')).toEqual(false)
-        expect(csvContains(undefined, 'two')).toEqual(false)
-    })
-
-    test('copy deep', () => {
-        expect(copyDeep(null)).toStrictEqual(null)
-        expect(copyDeep(undefined)).toStrictEqual(undefined)
-        
-        let item = { test: { one: 'treat' } }
-        let copy = copyDeep(item)
-        item.test.one = 'other'
-
-        expect(item.test).not.toEqual(copy.test)
-        expect(item).not.toEqual(copy)
-    })
-
-    test('copy by property alphabet', () => {
-        expect(copyItemByAlphabet(null)).toStrictEqual(null)
-        expect(copyItemByAlphabet(undefined)).toStrictEqual(undefined)
-
-        let item = { test: { b: 'treat', a: 't' }, v: 'a', s: 'a', z: undefined }
-        //consistency
-        expect(JSON.stringify(copyItemByAlphabet(item))).toEqual(JSON.stringify(copyItemByAlphabet(item)))
-        expect(JSON.stringify(copyItemByAlphabet(item))).toEqual(JSON.stringify({ s: 'a', test: { a: 't', b: 'treat' }, v: 'a', z: undefined }))
-        expect(JSON.stringify(copyItemByAlphabet(item))).not.toEqual(JSON.stringify({ s: 'a', test: { b: 'treat', a: 't' }, v: 'a' }))
-    })
-
-    test('contains search', () => {
-        expect(containsSearch(undefined, undefined)).toEqual(true)
-        expect(containsSearch('a', undefined)).toEqual(true)
-        expect(containsSearch('aa', 'aa')).toEqual(true)
-        expect(containsSearch('aa', 'a')).toEqual(true)
-        expect(containsSearch('aa', 'b')).toEqual(false)
-        expect(containsSearch('Testing One Two Three', ' one')).toEqual(true)
-        expect(containsSearch('Testing One Two Three', '  one')).toEqual(false)
-    })
-
-    test('deep select', () => {
-        expect(deepSelect(null)).toEqual([])
-
-        let item = [
-            { a: 'a', b: [{ a: 'd' }] },
-            { a: 'b'},
-            { a: 'c' }
-        ]
-
-        expect(deepSelect(item, x => x.b).length).toEqual(4)
-
-        let ite = [{
-            b: [
-                { a: 'a', b: [{ a: 'b', b: [{ a: 'c' }] }]},
-                { a: 'd' },
-                { a: 'e', b: [{ a: 'f' }]}
-            ]
-        }]
-
-        expect(deepSelect(ite, x => x.b).length).toEqual(7)
-
-        let te = {
-            b: [
-                { a: 'a', b: [{ a: 'b', b: [{ a: 'c' }] }]},
-                { a: 'd' },
-                { a: 'e', b: [{ a: 'f' }]}
-            ]
-        }
-
-        //misses the parent
-        expect(deepSelect(te, x => x.b).length).toEqual(6)
-    })
-
-    test('has search', () => {
-        expect(hasSearch(undefined, 'test', ['a', 'b'])).toEqual(false)
-        expect(hasSearch('test', undefined, ['a', 'b'])).toEqual(true)
-        expect(hasSearch({ test: 'one two three', a: 'one' }, 'four', ['test', 'a'])).toEqual(false)
-        expect(hasSearch({ test: 'two', a: 'one' }, 'one', undefined)).toEqual(false)
-        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'three', ['a', 'b'])).toEqual(false)
-        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'three', ['a', 'b', 'test'])).toEqual(true)
-        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'one', ['b'])).toEqual(false)
-        expect(hasSearch({ test: 'one two three', a: 'one', b: 'two' }, 'one', ['a', 'b'])).toEqual(true)
-    })
-
-    test('to compare string', () => {
-        expect(toCompareString('one')).toEqual('one')
-        expect(toCompareString(undefined)).toStrictEqual(null)
-        expect(toCompareString('one two three')).toEqual('onetwothree')
-    })
-
-    test('nested value', () => {
-        let item = {
-            a: { b: 'b', c: { d: 'd' } },
-            b: 'str'
-        }
-
-        expect(nestedValue(item, 'b')).toEqual('str')
-        expect(nestedValue(item, 'a.c.d')).toEqual('d')
-        expect(nestedValue(item, 'a.b')).toEqual('b')
-    })
-
-    test('valid email', () => {
-        expect(validEmail('andrewderoon@gmail.com')).toEqual(true)
-        expect(validEmail('@gmail.com')).toEqual(false)
-        expect(validEmail('a@')).toEqual(false)
-        expect(validEmail('a@e')).toEqual(true)
-        expect(validEmail('andrewderoon.com')).toEqual(false)
-    })
-})

package/test/navigation.test.ts

@@ -1,99 +0,0 @@
-import { createNavigation } from '../src/composables/navigation'
-import { describe, expect, test } from 'vitest'
-
-describe("navigation", () => {
-    const nav = createNavigation({
-        defaultCacheExpiryHours: 3,
-        navItems: [
-            {
-                name: 'test-nav'
-            },
-            {
-                name: 'navA',
-                background: 'b',
-                displayName: 'discs',
-                hideAppBar: true,
-                hideNavigation: true,
-                hesitate: true,
-                icon: 'mdi-plus',
-                path: '/testing/one',
-                children: [
-                    {
-                        name: 'navB',
-                        cacheExpiryHours: 4,
-                        children: [
-                            {
-                                archiveName: 'nav-archive',
-                                aliases: ['nav-alias', 'nav-alia'],
-                                name: 'navC',
-                                path: '/test/alias'
-                            }
-                        ],
-                        singleName: 'navone'
-                    }
-                ]
-            }
-        ]
-    })
-
-    test('find archive name', () => {
-        expect(nav.findArchiveName('navC')).toEqual('nav-archive')
-        expect(nav.findArchiveName('navB')).toEqual(undefined)
-        expect(nav.findArchiveName('navD')).toEqual(undefined)
-    })
-
-    test('find cache length', () => {
-        expect(nav.findCacheHours('navC')).toEqual(3)
-        expect(nav.findCacheHours('navB')).toEqual(4)
-    })
-
-    test('find display', () => {
-        expect(nav.findDisplay('test-nav')).toEqual(undefined)
-        expect(nav.findDisplay('navA')).toEqual('discs')
-    })
-
-    test('find icon', () => {
-        expect(nav.findIcon('test-nav')).toEqual(undefined)
-        expect(nav.findIcon('navA')).toEqual('mdi-plus')
-    })
-
-    test('find item', () => {
-        expect(nav.findItem('test-nav')).not.toBeNull()
-        expect(nav.findItem('test-navs')).toBeNull()
-        expect(nav.findItem('test-nav')?.name).toEqual('test-nav')
-        expect(nav.findItem('nav-alias')?.name).toEqual('navC')
-    })
-
-    test('find store name', () => {
-        expect(nav.findStoreName('navA')).toEqual('navA')
-        expect(nav.findStoreName('navB')).toEqual('navB')
-        expect(nav.findStoreName('test-nav')).toEqual('test-nav')
-    })
-
-    test('find path', () => {
-        expect(nav.findPath('test-nav')).toEqual('')
-        expect(nav.findPath('navA')).toEqual('/testing/one')
-        expect(nav.findPath('nav-alias')).toEqual('/test/alias')
-    })
-
-    test('find single display', () => {
-        expect(nav.findSingleDisplay('navA')).toEqual('disc')
-        expect(nav.findSingleDisplay('navB')).toEqual('navone')
-    })
-
-    test('update nav props', () => {
-        nav.updateNavigationProperties('test-nav')
-
-        expect(nav.showAppBar.value).toEqual(true)
-        expect(nav.showAppNavigation.value).toEqual(true)
-        expect(nav.backgroundName.value).toEqual(undefined)
-        expect(nav.hesitate.value).toEqual(false)
-
-        nav.updateNavigationProperties('navA')
-
-        expect(nav.showAppBar.value).toEqual(false)
-        expect(nav.showAppNavigation.value).toEqual(false)
-        expect(nav.backgroundName.value).toEqual('b')
-        expect(nav.hesitate.value).toEqual(true)
-    })
-})

package/test/stores-last-update.test.ts

@@ -1,138 +0,0 @@
-import { setActivePinia, createPinia } from 'pinia'
-import { createSessionStoreDefinition, createWholeLastUpdateStoreDefinition } from '../src/composables/stores'
-import { createApi } from '../src/composables/api'
-import { describe, test, expect, beforeEach, afterAll, afterEach, beforeAll } from 'vitest'
-import { setupServer } from 'msw/node'
-import { http, HttpResponse } from 'msw'
-import { createApp } from 'vue'
-import { withSetup } from './utils'
-
-const handlers = [
-    http.get('https://api/get/1', () => {
-        return HttpResponse.json({
-            data: { test: 'g' }
-        })
-    }),
-    http.get('https://api/getAll', () => {
-        return HttpResponse.json({
-            data: [{ test: 'a', id: '1' }, { test: 'b', id: '2' }],
-            count: 2,
-            filters: ['test', 'test two']
-        })
-    }),
-    http.post('https://api/post', () => {
-        return HttpResponse.json({ data: { test: 'd', id: '11' } })
-    }),
-    http.patch('https://api/patch', () => {
-        return HttpResponse.json({ data: { test: 'e', rowVersion: 2 } })
-    })
-]
-
-const server = setupServer(...handlers)
-
-beforeAll(() => server.listen({ onUnhandledRequest: 'error' }))
-
-afterAll(() => server.close())
-
-afterEach(() => {
-    server.resetHandlers()
-})
-
-describe('use last update store no api no caching', () => {
-    const [api, app] = withSetup(() => createApi({
-        findPath: () => 'https://api/',
-        defaultThrowError: false
-    }))
-
-    const pinia = createPinia()
-    app.use(pinia)
-
-    setActivePinia(pinia)
-
-    const store = createWholeLastUpdateStoreDefinition({
-        api: undefined,
-        storageMode: 'session',
-        storeName: 'whole'
-    })()
-
-    test('all session activity', async () => {
-
-        await store.post<any>({ data: { id: '1', test: 'a' }})
-        await store.post<any>({ data: { id: '2', test: 'b' }})
-        await store.post<any>({ data: { id: '3', test: 'c' }})
-
-        let postRes = await store.get<any>({ id: '1' })
-        expect(postRes.data).toEqual({ id: '1', test: 'a' })
-
-        await store.patch<any>({ data: { id: '1', test: 'd' }})
-        postRes = await store.get<any>({ id: '1' })
-        expect(postRes.data).toEqual({ id: '1', test: 'd' })
-
-        let getAll = await store.getAll<any>({})
-        expect(getAll.data.length).toEqual(3)
-        expect(getAll.count).toEqual(3)
-
-
-        await store.deleteItem({ data: { id: '1' }})
-        postRes = await store.get<any>({ id: '1' })
-        expect(postRes.data).toEqual(undefined)
-
-        getAll = await store.getAll<any>({})
-        expect(getAll.data.length).toEqual(2)
-        expect(getAll.count).toEqual(2)
-    })
-
-})
-
-
-describe('use last update store with api no caching', () => {
-    const [api, app] = withSetup(() => createApi({
-        findPath: () => 'https://api/',
-        defaultThrowError: false
-    }))
-
-    const pinia = createPinia()
-        app.use(pinia)
-        setActivePinia(pinia)
-
-    const store = createWholeLastUpdateStoreDefinition({
-        storageMode: 'session',
-        api: api,
-        storeName: 'whole-api'
-    })()
-
-
-    test('get', async () => {
-        const res = await store.get<any>({ id: '1' })
-        expect(res.data).toEqual({ test: 'a', id: '1' })
-        let getAll = await store.getAll<any>({})
-        expect(getAll.data.length).toEqual(2)
-        expect(getAll.count).toEqual(2)
-    })
-
-
-    test('get all', async () => {
-        const res = await store.getAll<any>({})
-        expect(res).toEqual({
-            data: [{test: 'a', id: '1' },{test: 'b', id: '2' }],
-            count: 2,
-            filters: []
-        })
-    })
-    
-    test('post', async () => {
-        const res = await store.post<any>({ data: { test: 'a', id: '11' }})
-        expect(res).not.toBeNull()
-        
-        //gets api post return
-        let getRes = await store.get<any>({ id: '11' })
-        expect(getRes.data).toEqual({ test: 'd', id: '11' })
-    })
-
-    test('patch', async () => {
-        const res = await store.patch<any>({ data: { test: 'a', id: '1', rowVersion: 1 }})
-        let getRes = await store.get<any>({ id: '1' })
-        expect(getRes.data.rowVersion).toEqual(2)
-    })
-
-})

package/test/stores-session.test.ts

@@ -1,118 +0,0 @@
-import { setActivePinia, createPinia } from 'pinia'
-import { createSessionStoreDefinition, createWholeLastUpdateStoreDefinition } from '../src/composables/stores'
-import { createApi } from '../src/composables/api'
-import { describe, test, expect, beforeEach, afterAll, afterEach, beforeAll } from 'vitest'
-import { setupServer } from 'msw/node'
-import { http, HttpResponse } from 'msw'
-import { createApp } from 'vue'
-import { withSetup } from './utils'
-
-const handlers = [
-    http.get('https://test-api/get/1', () => {
-        return HttpResponse.json({
-            data: { test: 'a' }
-        })
-    }),
-    http.get('https://test-api/get/2', () => {
-        return new HttpResponse('not found', {
-            status: 304
-        })
-    }),
-    http.get('https://test-api/getAll', () => {
-        return HttpResponse.json({
-            data: [{ test: 'a' }, { test: 'b' }],
-            count: 2,
-            filters: ['test', 'test two']
-        })
-    }),
-    http.post('https://test-api/post', () => {
-        return HttpResponse.json({ data: { test: 'b' } })
-    }),
-    http.patch('https://test-api/patch', () => {
-        return HttpResponse.json({ data: { test: 'c', rowVersion: 2 } })
-    })
-]
-
-const server = setupServer(...handlers)
-
-beforeAll(() => server.listen({ onUnhandledRequest: 'error' }))
-
-afterAll(() => server.close())
-
-afterEach(() => {
-    server.resetHandlers()
-})
-
-describe('use session store with no api no caching', () => {
-    const [api, app] = withSetup(() => createApi())
-
-    const pinia = createPinia()
-    app.use(pinia)
-    setActivePinia(pinia)
-
-    const store = createSessionStoreDefinition({
-        storageMode: 'session',
-        storeName: 'sesh'
-    })()
-
-    test('all session activity', async () => {
-        await store.post<any>({ data: { id: '1', test: 'a' }})
-        let postRes = await store.get<any>({ id: '1' })
-        expect(postRes.data).toEqual({ id: '1', test: 'a' })
-        await store.patch<any>({ nav: 'test', data: { id: '1', test: 'b' }})
-        postRes = await store.get<any>({ id: '1' })
-        expect(postRes.data).toEqual({ id: '1', test: 'b' })
-        await store.deleteItem({ id: '1' })
-        postRes = await store.get<any>({ id: '1' })
-        expect(postRes).toEqual(undefined)
-    })
-})
-
-describe('use session store with api no caching', () => {
-    const [api, app] = withSetup(() => createApi({
-        findPath: () => 'https://test-api/',
-        defaultThrowError: false
-    }))
-
-    const pinia = createPinia()
-    app.use(pinia)
-
-    setActivePinia(pinia)
-
-    const store = createSessionStoreDefinition({
-        storageMode: 'session',
-        api: api,
-        storeName: 'test'
-    })()
-
-
-    test('get', async () => {
-        const res = await store.get<any>({ nav: 'test', id: '1' })
-        expect(res).toEqual({ data: { test: 'a' }})
-        //expect(store.searchMemory['test_no-user-id_1']).toEqual({ data: { test: 'a' }})
-    })
-
-    test('get all', async () => {
-        const res = await store.getAll<any>({ nav: 'test' })
-        expect(res).toEqual({
-            data: [{test: 'a' },{test: 'b'}],
-            count: 2,
-            filters: ['test', 'test two']
-        })
-    })
-
-    test('post', async () => {
-        const res = await store.post<any>({ nav: 'test', data: { test: 'a', id: '11' }})
-        expect(res).not.toBeNull()
-        //gets api post return
-        let getRes = await store.get<any>({ nav: 'test', id: '11' })
-        expect(getRes.data).toEqual({ test: 'b' })
-    })
-
-    test('patch', async () => {
-        const res = await store.patch<any>({ nav: 'test', data: { test: 'a', id: '1', rowVersion: 1 }})
-        let getRes = await store.get<any>({ nav: 'test', id: '1' })
-        expect(getRes.data.rowVersion).toEqual(2)
-    })
-
-})

package/test/track.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from "vitest"
-import { withSetup } from './utils'
-import { useTracker } from '../src/composables/track'
-import { twiddleThumbs } from "../src/composables/helpers"
-
-describe("track", () => {
-    test('tracker test', async () => {
-
-        const item = { test: 'a' }
-        const [{ asyncItem, isChanged, restartTracker }] = withSetup(() => useTracker(item))
-
-        
-        expect(isChanged.value).toEqual(false)
-        asyncItem.value.test = 'b'
-        await twiddleThumbs(500)
-        expect(isChanged.value).toEqual(true)
-        asyncItem.value.test = 'a'
-        await twiddleThumbs(500)
-        expect(isChanged.value).toEqual(false)
-        asyncItem.value.test = 'b'
-        await twiddleThumbs(500)
-        expect(isChanged.value).toEqual(true)
-        restartTracker()
-        await twiddleThumbs(500)
-        expect(isChanged.value).toEqual(false)
-        
-    })
-    
-})

package/test/urls.test.ts

@@ -1,42 +0,0 @@
-import { describe, test, expect } from 'vitest'
-import { createUrl, useDbName, useAuthUrl, useDataUrl } from '../src/composables/urls'
-
-describe('default urls', () => {
-    const url = createUrl({
-        production: {
-            auth: 'pauth',
-            data: 'pdata',
-            localDbName: 'pdb',
-            other: {
-                ordering: 'pordering',
-                stock: 'pstock'
-            }
-        },
-        staging: {
-            auth: 'sauth',
-            data: 'sdata',
-            localDbName: 'sdb',
-            other: {
-                ordering: 'sordering',
-                stock: 'sstock'
-            }
-        },
-        development: {
-            auth: 'dauth',
-            data: 'ddata',
-            localDbName: 'ddb',
-            other: {
-                ordering: 'dordering',
-                stock: 'dstock'
-            }
-        }
-    })
-    
-    test('use prod db name', () => {
-        const d = useDbName()
-        expect(useDbName()).toEqual('ddb')
-        expect(useAuthUrl()).toEqual('dauth')
-        expect(useDataUrl()).toEqual('ddata')
-        expect(useDataUrl('stock')).toEqual('dstock')
-    })
-})

package/test/utils.ts

@@ -1,15 +0,0 @@
-import { createApp } from 'vue'
-
-export function withSetup(composable) {
-    let result
-    const app = createApp({
-        setup() {
-            result = composable()
-            return () => {}
-        }
-    })
-
-    app.mount(document.createElement('div'))
-
-    return [result, app]
-}