test(database): options tests

Author: posva

old_tests/vuefire/rtdb/index.spec.ts

@@ -10,15 +10,6 @@ import {
   _GlobalDatabaseRefOptions,
 } from './subscribe'
 
-/**
- * Returns the original reference of a Firebase reference or query across SDK versions.
- *
- * @param refOrQuery
- */
-function getRef(refOrQuery: DatabaseReference | Query): DatabaseReference {
-  return refOrQuery.ref
-}
-
 /**
  * Options for the Firebase Database Plugin that enables the Options API such as `$rtdbBind` and `$rtdbUnbind`.
  */
@@ -78,8 +69,8 @@ declare module '@vue/runtime-core' {
   }
 }
 
-type VueFirebaseObject = Record<string, Query | DatabaseReference>
-type FirebaseOption = VueFirebaseObject | (() => VueFirebaseObject)
+export type VueFirebaseObject = Record<string, Query | DatabaseReference>
+export type FirebaseOption = VueFirebaseObject | (() => VueFirebaseObject)
 
 export const rtdbUnbinds = new WeakMap<
   object,
@@ -151,7 +142,7 @@ export function databasePlugin(
     // this._firebaseSources[key] = source
     // we make it readonly for the user but we must change it. Maybe there is a way to have an internal type here but expose a readonly type through a d.ts
     ;(this.$firebaseRefs as Mutable<Record<string, DatabaseReference>>)[key] =
-      getRef(source)
+      source.ref
 
     return promise
   }

old_tests/vuefire/rtdb/merging.spec.ts

@@ -12,7 +12,11 @@ export type {
 } from './database/utils'
 
 export { databasePlugin } from './database/optionsApi'
-export type { DatabasePluginOptions } from './database/optionsApi'
+export type {
+  DatabasePluginOptions,
+  VueFirebaseObject,
+  FirebaseOption,
+} from './database/optionsApi'
 
 export { useCollection, useDocument } from './firestore'
 export type {

old_tests/vuefire/rtdb/options.spec.ts

@@ -5,12 +5,13 @@ import {
   databasePlugin,
   DatabasePluginOptions,
   DatabaseSnapshotSerializer,
+  FirebaseOption,
 } from '../../src'
 import { setupDatabaseRefs } from '../utils'
 
 const component = defineComponent({
   template: 'no',
-  data: () => ({ items: [], item: null }),
+  data: () => ({ itemList: [], item: null }),
 })
 
 describe('RTDB: plugin options', () => {
@@ -40,14 +41,14 @@ describe('RTDB: plugin options', () => {
 
       const itemListRef = databaseRef()
 
-      const p = vm.$rtdbBind('items', itemListRef)
+      const p = vm.$rtdbBind('itemList', itemListRef)
       await push(itemListRef, { text: 'foo' })
 
       expect(serialize).toHaveBeenCalledTimes(1)
       expect(serialize).toHaveBeenCalledWith(
         expect.objectContaining({ val: expect.any(Function) })
       )
-      expect(vm.items).toEqual([{ foo: 'bar', id: '2' }])
+      expect(vm.itemList).toEqual([{ foo: 'bar', id: '2' }])
     })
 
     it('can override serialize with local option', async () => {
@@ -60,17 +61,46 @@ describe('RTDB: plugin options', () => {
         bar: 'bar',
       }))
 
-      vm.$rtdbBind('items', items, { serialize: spy })
+      vm.$rtdbBind('itemList', items, { serialize: spy })
       await push(items, { text: 'foo' })
 
       expect(serialize).not.toHaveBeenCalled()
       expect(spy).toHaveBeenCalledTimes(1)
       expect(spy).toHaveBeenCalledWith(
         expect.objectContaining({ val: expect.any(Function) })
       )
-      expect(vm.items).toEqual([{ bar: 'bar', id: '3' }])
+      expect(vm.itemList).toEqual([{ bar: 'bar', id: '3' }])
     })
   })
 
-  // describe('firebase option', () => {})
+  describe('firebase option', () => {
+    function factory(
+      firebase: FirebaseOption,
+      pluginOptions?: DatabasePluginOptions
+    ) {
+      return mount(component, {
+        firebase,
+        global: {
+          plugins: [[databasePlugin, pluginOptions]],
+        },
+      })
+    }
+
+    it('setups $firebaseRefs', async () => {
+      const itemSource = databaseRef()
+      const itemListSource = databaseRef()
+      const { vm } = factory({ item: itemSource, itemList: itemListSource })
+      expect(Object.keys(vm.$firebaseRefs).sort()).toEqual(['item', 'itemList'])
+      expect(vm.$firebaseRefs.item.key).toBe(itemSource.key)
+      expect(vm.$firebaseRefs.itemList.key).toBe(itemListSource.key)
+    })
+
+    it('clears $firebaseRefs on unmount', async () => {
+      const itemSource = databaseRef()
+      const itemListSource = databaseRef()
+      const wrapper = factory({ item: itemSource, itemList: itemListSource })
+      wrapper.unmount()
+      expect(wrapper.vm.$firebaseRefs).toEqual(null)
+    })
+  })
 })