:gear: adding frontend tests

frontend/src/entities/chat-message/chat-message.schema.js

 const chatMessageSchema = {
     type: 'object',
     properties: Joi.object().keys({
-        description: Joi.string(),
+        description: Joi.string().required(),
+        type: Joi.string().required(),
     }),
     /** fields required before saving */
     required: ['description'],

frontend/src/entities/chat-message/chat-message.spec.js

+import test from 'ava'
+import { ChatMessage } from './index.js'
+
+test('instantiate a ChatMessage', async t => {
+    const m = new ChatMessage('foobar')
+    t.is(m.description, 'foobar')
+    t.is(m.type, 'chatmessage')
+    t.is(m.isValid(), true)
+})
+
+test('instantiate a bad ChatMessage', async t => {
+    const m = new ChatMessage()
+    t.is(m.isValid(), false)
+})

frontend/src/entities/grouping/grouping.spec.js

+import test from 'ava'
+import { Profile } from '../profile/index.js'
+import { Grouping } from './index.js'
+
+test('instantiate a Grouping', async t => {
+    const membershipInfoToTest = {
+        grouping_id: 8675309,
+        is_paired: false,
+        grouping_type: 'tester',
+    }
+    membershipInfoToTest.profile = new Profile({ email: 'grouping@test.com' })
+    const g = new Grouping(membershipInfoToTest)
+    t.is(g.grouping_id, membershipInfoToTest.grouping_id)
+    t.is(g.is_paired, membershipInfoToTest.is_paired)
+    t.is(g.isValid(), true)
+
+    t.is(g.profile.email, membershipInfoToTest.profile.email)
+    t.is(g.profile.type, 'profile')
+    t.is(g.profile.isValid(), true)
+})
+
+test('instantiate a bad Grouping', async t => {
+    const membershipInfoToTest = {
+        grouping_id: null,
+        is_paired: false,
+        grouping_type: 'tester',
+    }
+    membershipInfoToTest.profile = new Profile({ email: 'grouping@test.com' })
+    const g = new Grouping(membershipInfoToTest)
+    t.is(g.grouping_id, membershipInfoToTest.grouping_id)
+    t.is(g.is_paired, membershipInfoToTest.is_paired)
+    t.is(g.isValid(), false)
+
+    t.is(g.profile.email, membershipInfoToTest.profile.email)
+    t.is(g.profile.type, 'profile')
+    t.is(g.profile.isValid(), true)
+})

frontend/src/entities/profile/profile.spec.js

     const profToTest = { email: 'fake@email.com', user_name: 'bob' }
     const p = new Profile(profToTest)
     t.is(p.user_name, profToTest.user_name)
+    t.is(p.isValid(), true)
 })

frontend/src/entities/survey/survey.spec.js

+import test from 'ava'
+
+test('check survey entity', async t => {
+    t.pass()
+})

frontend/src/services/chat.service.js

 import PubNub from 'pubnub'
 
-import { ChatMessage } from '../entities'
+import { ChatMessage } from '../entities/index.js'
 
 const MAIN_CHANNEL = 'Channel-Siimee'
 
 /**
  * Breaking out as much pubnub specific flavor
  */
-const _setupPubnub = async uuid => {
-    const publishKey = import.meta.env.VITE_PUBNUB_PUBLISH_KEY
-    const subscribeKey = import.meta.env.VITE_PUBNUB_SUBSCRIBE_KEY
-
+const _setupPubnub = async (uuid, publishKey, subscribeKey) => {
     if (!uuid) return console.error('no pubnub uuid set')
 
     const pubnubClient = await new PubNub({
         this.listeners.message = cb
     }
 
-    async setup(uuid, groupings) {
+    async setup(uuid, groupings, testing = false) {
         this.uuid = `${uuid}`
-        this.provider = await _setupPubnub(this.uuid)
+
+        // Pass api keys in ugle fasion for testing purposes
+        // TODO: refactor this with a mock
+        this.provider = testing
+            ? await _setupPubnub(
+                  this.uuid,
+                  testing.publishKey,
+                  testing.subscribeKey,
+              )
+            : await _setupPubnub(
+                  this.uuid,
+                  import.meta.env.VITE_PUBNUB_PUBLISH_KEY,
+                  import.meta.env.VITE_PUBNUB_SUBSCRIBE_KEY,
+              )
 
         //  step_1: build the this.groupings object from the backend
         //  await for the groupings to be fetched before subscribing to channels

frontend/src/views/ChatView.vue

                 if (!grouping) {
                     throw `no match found for ${currentProfile.id.value}`
                 }
-                console.log('grouping :', grouping)
                 this.target = grouping.profile
             } catch (err) {
                 console.error(err)

frontend/tests/chat.service.spec.js

+import test from 'ava'
+import { Chatter, MAIN_CHANNEL } from '../src/services/chat.service.js'
+
+test('Make sure we can instantiate Chatter', async t => {
+    const chatter = new Chatter()
+    t.is(chatter._subscriptions.length, 1)
+    t.is(chatter._subscriptions[0], MAIN_CHANNEL)
+
+    const testCb = () => {
+        const a = 'foo'
+        return a
+    }
+    chatter.setOnMessage(testCb)
+    t.is(chatter.listeners.message, testCb)
+
+    chatter._setupAllChannels([
+        { grouping_name: 'test-channel-01' },
+        { grouping_name: 'test-channel-02' },
+    ])
+    t.is(chatter.subscriptions.length, 2)
+    t.is(chatter.subscriptions[0], 'test-channel-01')
+    t.is(chatter.subscriptions[1], 'test-channel-02')
+
+    chatter.stop()
+    t.is(chatter._subscriptions[0], MAIN_CHANNEL)
+})
+
+test('Use PubNub via Chatter', async t => {
+    const chatter = new Chatter()
+    t.is(chatter._subscriptions.length, 1)
+    t.is(chatter._subscriptions[0], MAIN_CHANNEL)
+
+    const testUUID = 'test_123_uuid'
+    const subs = await chatter.setup(testUUID, [], {
+        publishKey: 'foo',
+        subscribeKey: 'bar',
+    })
+    t.is(chatter.uuid, testUUID)
+    t.deepEqual(subs, [])
+})