@windward/core 0.14.0 → 0.16.0

package/store/glossary.js

@@ -0,0 +1,57 @@
+import _ from 'lodash'
+import Course from '~/models/Course'
+import CourseGlossaryTerm from '../models/CourseGlossaryTerm'
+
+export default {
+    // Required so these states / methods are placed under glossary/get and not just get
+    namespaced: true,
+    state: () => ({
+        glossary: {
+            course: null,
+            terms: [],
+        },
+    }),
+
+    getters: {
+        get(state) {
+            return state.glossary
+        },
+        getCourse(state) {
+            return state.glossary.course
+        },
+        getTerms(state) {
+            return state.glossary.terms
+        },
+    },
+
+    mutations: {
+        setTerms(state, terms) {
+            state.glossary.terms = _.cloneDeep(terms)
+        },
+        setCourse(state, course) {
+            state.glossary.course = _.cloneDeep(course)
+        },
+    },
+
+    actions: {
+        clear(context) {
+            context.commit('setTerms', [])
+            context.commit('setCourse', null)
+        },
+        async load(context, course) {
+            try {
+                // Store the course that these terms are in context to
+                context.commit('setCourse', course)
+
+                const terms = await CourseGlossaryTerm.custom(
+                    new Course(course),
+                    new CourseGlossaryTerm()
+                ).get()
+
+                context.commit('setTerms', terms)
+            } catch (e) {
+                console.error('Error loading glossary terms:', e)
+            }
+        },
+    },
+}

package/test/Components/Content/Blocks/Feedback.spec.js

@@ -18,7 +18,9 @@ describe('Feedback', () => {
                         config: {
                             definition: {
                                 metadata: {
-                                    definition: { body: 'test', response: '' },
+                                    definition: [
+                                        { body: 'test', response: '' },
+                                    ],
                                 },
                             },
                         },

package/test/Components/Content/Blocks/Video.spec.js

@@ -1,7 +1,6 @@
 import { mount } from '@vue/test-utils'
-import Vuetify from 'vuetify'
 import Vue from 'vue'
-
+import Vuetify from 'vuetify'
 import { defaultMocks } from '@/test/mocks'
 
 jest.mock('@mindedge/vuetify-player', () => {
@@ -47,6 +46,7 @@ const metadata = {
                         type: 'video/mp4',
                     },
                 ],
+                tracks: [],
             },
         ],
     },

package/test/Components/Glossary/GlossaryVerification.spec.js

@@ -0,0 +1,19 @@
+import { shallowMount } from '@vue/test-utils'
+import Vue from 'vue'
+import Vuetify from 'vuetify'
+import { defaultMocks } from '@/test/mocks'
+import GlossaryVerification from '@/components/Glossary/GlossaryVerification.vue'
+
+Vue.use(Vuetify)
+
+describe('GlossaryVerification component', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(GlossaryVerification, {
+            vuetify: new Vuetify(),
+            mocks: defaultMocks,
+            propsData: {},
+        })
+
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Components/utils/glossary/CourseGlossary.spec.js

@@ -0,0 +1,19 @@
+import { shallowMount } from '@vue/test-utils'
+import Vue from 'vue'
+import Vuetify from 'vuetify'
+import { defaultMocks } from '@/test/mocks'
+import CourseGlossary from '@/components/utils/glossary/CourseGlossary.vue'
+
+Vue.use(Vuetify)
+
+describe('CourseGlossary component', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(CourseGlossary, {
+            vuetify: new Vuetify(),
+            mocks: defaultMocks,
+            propsData: {},
+        })
+
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Components/utils/glossary/CourseGlossaryForm.spec.js

@@ -0,0 +1,28 @@
+import { shallowMount } from '@vue/test-utils'
+import Vue from 'vue'
+import Vuetify from 'vuetify'
+import { defaultMocks } from '@/test/mocks'
+import CourseGlossaryForm from '@/components/utils/glossary/CourseGlossaryForm.vue'
+
+Vue.use(Vuetify)
+
+describe('CourseGlossaryForm component', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(CourseGlossaryForm, {
+            vuetify: new Vuetify(),
+            mocks: defaultMocks,
+            propsData: {
+                value: {
+                    term: '',
+                    definition: '',
+                    alternate_forms: [],
+                    related_terms: [],
+                },
+                glossary: [],
+                editMode: false,
+            },
+        })
+
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/__mocks__/helpersMock.js

@@ -39,27 +39,3 @@ jest.mock(
     },
     { virtual: true }
 )
-
-jest.mock(
-    'lodash',
-    () => {
-        return {
-            cloneDeep: (v) => {
-                return JSON.parse(JSON.stringify(v))
-            },
-            isEmpty: () => {
-                return jest.fn()
-            },
-            isBoolean: () => {
-                return jest.fn()
-            },
-            flatten: () => {
-                return jest.fn()
-            },
-            get: () => {
-                return jest.fn()
-            },
-        }
-    },
-    { virtual: true }
-)

package/test/__mocks__/modelMock.js

@@ -55,7 +55,12 @@ const mockVirtualModels = [
 ]
 
 const mockModels = [
+    { path: '../../models/BaseModel', resource: '' },
     { path: '../../models/UserFileAsset', resource: 'user-files' },
+    {
+        path: '../../models/CourseGlossaryTerm',
+        resource: 'course-glossary-terms',
+    },
 ]
 
 // DO NOT ALTER THE BELOW CODE

package/test/helpers/GlossaryHelper.spec.js

@@ -1,5 +1,6 @@
+import { defaultMocks } from '@/test/mocks'
 import GlossaryHelper from '../../helpers/GlossaryHelper'
-import GlossaryTerm from '../../helpers/GlossaryTerm'
+import CourseGlossaryTerm from '../../models/CourseGlossaryTerm'
 
 const contentHtml =
     '<p>Voluptas est quis ut <strong>consequatur.</strong>' +
@@ -32,14 +33,16 @@ const glossary = [
     {
         term: 'veniam',
         definition: 'venom is venomus',
-        alternate_forms: null,
-        related_term: null,
+        alternate_forms: [],
+        related_terms: [],
     },
     {
         term: 'Architecto',
         definition: 'Architecto is a word that means architect of the universe',
         alternate_forms: ['Architect', 'universe'],
-        related_term: 'a,b,c,d',
+        related_terms: [
+            { id: '00000000-0000-0000-1000-000000000000', term: 'a,b,c,d' },
+        ],
     },
     {
         term: 'Voluptatem',
@@ -47,14 +50,14 @@ const glossary = [
             'Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of ' +
             'classical Latin literature from 45 BC, making it over 2000 years old. Richard McClintock,' +
             ' a Latin professor at Hampden-Sydney College in Virginia',
-        alternate_forms: null,
-        related_term: null,
+        alternate_forms: [],
+        related_terms: [],
     },
     {
         term: 'crisis change',
         definition: 'n/a',
         alternate_forms: ['crisis', 'change'],
-        related_term: null,
+        related_terms: [],
     },
     {
         term: 'valores periféricos',
@@ -62,6 +65,7 @@ const glossary = [
             'Valores que son importantes pero no esenciales para una organización.',
         tags: 'valores periféricos',
         alternate_forms: [],
+        related_terms: [],
     },
 ]
 const glossaryRender =
@@ -72,12 +76,14 @@ const glossaryRender =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term>Architecto</template>' +
     '<template v-slot:definition>Architecto is a word that means architect of the universe</template>' +
+    '<template v-slot:alternate_forms>Architect,universe</template>' +
     '<template v-slot:related_terms>a,b,c,d</template>' +
     '</plugin-core-glossary-tool-tip>'
 const glossaryRenderMultiple =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term>Architecto</template>' +
     '<template v-slot:definition>Architecto is a word that means architect of the universe</template>' +
+    '<template v-slot:alternate_forms>Architect,universe</template>' +
     '<template v-slot:related_terms>a,b,c,d</template>' +
     '</plugin-core-glossary-tool-tip>' +
     '<p>Voluptas est quis ut <strong>consequatur.</strong> ' +
@@ -87,14 +93,16 @@ const glossaryRenderMultiple =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term>Architecto</template>' +
     '<template v-slot:definition>Architecto is a word that means architect of the universe</template>' +
+    '<template v-slot:alternate_forms>Architect,universe</template>' +
     '<template v-slot:related_terms>a,b,c,d</template>' +
     '</plugin-core-glossary-tool-tip>'
 
-const term = new GlossaryTerm(glossary[1])
+const term = new CourseGlossaryTerm(glossary[1])
 const expectedToolTip =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term>Architecto</template>' +
     '<template v-slot:definition>Architecto is a word that means architect of the universe</template>' +
+    '<template v-slot:alternate_forms>Architect,universe</template>' +
     '<template v-slot:related_terms>a,b,c,d</template>' +
     '</plugin-core-glossary-tool-tip>'
 const glossaryRenderCapitalized =
@@ -105,6 +113,7 @@ const glossaryRenderCapitalized =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term>Crisis change</template>' +
     '<template v-slot:definition>n/a</template>' +
+    '<template v-slot:alternate_forms>crisis,change</template>' +
     '</plugin-core-glossary-tool-tip>'
 const glossaryRenderCapitalizedSpaceBefore =
     '<p>Voluptas est quis ut <strong>consequatur.</strong> ' +
@@ -114,6 +123,7 @@ const glossaryRenderCapitalizedSpaceBefore =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term> Crisis change</template>' +
     '<template v-slot:definition>n/a</template>' +
+    '<template v-slot:alternate_forms>crisis,change</template>' +
     '</plugin-core-glossary-tool-tip>'
 const glossaryRenderCapitalizedSpaceAfter =
     '<p>Voluptas est quis ut <strong>consequatur.</strong> ' +
@@ -123,6 +133,7 @@ const glossaryRenderCapitalizedSpaceAfter =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term>Crisis change </template>' +
     '<template v-slot:definition>n/a</template>' +
+    '<template v-slot:alternate_forms>crisis,change</template>' +
     '</plugin-core-glossary-tool-tip>'
 const glossaryRenderCapitalizedSpaceBeforeAfter =
     '<p>Voluptas est quis ut <strong>consequatur.</strong> ' +
@@ -132,6 +143,7 @@ const glossaryRenderCapitalizedSpaceBeforeAfter =
     '<plugin-core-glossary-tool-tip>' +
     '<template v-slot:term> Crisis change </template>' +
     '<template v-slot:definition>n/a</template>' +
+    '<template v-slot:alternate_forms>crisis,change</template>' +
     '</plugin-core-glossary-tool-tip>'
 describe('GlossaryHelper ', () => {
     test('detects text has glossary words', () => {
@@ -162,7 +174,7 @@ describe('GlossaryHelper ', () => {
                 accentedGlossaryTerm + contentHtml,
                 glossary
             )
-        ).toEqual([new GlossaryTerm(glossary[4])])
+        ).toEqual([new CourseGlossaryTerm(glossary[4])])
     })
     test('can retrieve un-verified glossary terms', () => {
         expect(
@@ -170,7 +182,9 @@ describe('GlossaryHelper ', () => {
                 glossaryWord2 + contentHtml + glossaryWord2,
                 glossary
             )
-        ).toEqual([new GlossaryTerm({ term: 'unverified', definition: 'n/a' })])
+        ).toEqual([
+            new CourseGlossaryTerm({ term: 'unverified', definition: 'n/a' }),
+        ])
     })
     test('does not mistake alternate forms for un-verified glossary terms', () => {
         expect(
@@ -178,7 +192,9 @@ describe('GlossaryHelper ', () => {
                 glossaryWord2 + contentHtml + glossaryWord4,
                 glossary
             )
-        ).toEqual([new GlossaryTerm({ term: 'unverified', definition: 'n/a' })])
+        ).toEqual([
+            new CourseGlossaryTerm({ term: 'unverified', definition: 'n/a' }),
+        ])
     })
 
     test('can retrieve un-verified glossary terms with space', () => {
@@ -188,8 +204,8 @@ describe('GlossaryHelper ', () => {
                 glossary
             )
         ).toEqual([
-            new GlossaryTerm({ term: 'Climate', definition: 'n/a' }),
-            new GlossaryTerm({ term: 'unverified', definition: 'n/a' }),
+            new CourseGlossaryTerm({ term: 'Climate', definition: 'n/a' }),
+            new CourseGlossaryTerm({ term: 'unverified', definition: 'n/a' }),
         ])
     })
 
@@ -199,7 +215,9 @@ describe('GlossaryHelper ', () => {
                 glossaryWord2 + contentHtml + glossaryWord,
                 glossary
             )
-        ).toEqual([new GlossaryTerm({ term: 'unverified', definition: 'n/a' })])
+        ).toEqual([
+            new CourseGlossaryTerm({ term: 'unverified', definition: 'n/a' }),
+        ])
     })
     test('can render glossary tooltip component', () => {
         expect(GlossaryHelper.makeToolTip(term, 'Architecto')).toEqual(

package/test/mocks.js

@@ -46,6 +46,17 @@ jest.mock(
                 // Just return an empty object
                 return getters
             },
+            mapActions(obj) {
+                const actions = {}
+                for (const [key, value] of Object.entries(obj)) {
+                    // Return a function  since mapActions only work in the methods section
+                    actions[key] = () => {
+                        return
+                    }
+                }
+                // Just return an empty object
+                return actions
+            },
         }
     },
     { virtual: true }

package/test/setup/before.js

@@ -0,0 +1,15 @@
+// Mocks to run BEFORE any other imports take place
+// window.matchMedia is required for tinyMCE unit tests since it doesn't check if that function exists
+Object.defineProperty(window, 'matchMedia', {
+    writable: true,
+    value: jest.fn().mockImplementation((query) => ({
+        matches: false,
+        media: query,
+        onchange: null,
+        addListener: jest.fn(), // Deprecated
+        removeListener: jest.fn(), // Deprecated
+        addEventListener: jest.fn(),
+        removeEventListener: jest.fn(),
+        dispatchEvent: jest.fn(),
+    })),
+})

package/helpers/GlossaryTerm.ts

@@ -1,31 +0,0 @@
-class GlossaryTerm {
-
-    term!: string
-
-    definition!: string
-
-    alternate_forms: any = null
-
-    related_term: any =null
-
-    private required: string[] = ['term', 'definition']
-
-    constructor(params: any) {
-        this.required.forEach((field) => {
-            if (!params[field]) {
-                throw new Error('Glossary term ' + field + ' is required')
-            }
-        })
-
-        this.term = params.term
-        this.definition = params.definition
-        this.alternate_forms = params.alternate_forms || null
-        this.related_term = params.related_term || null
-    }
-
-    public static toString(){
-
-    }
-}
-
-export default GlossaryTerm