@windward/core 0.0.1

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

@@ -0,0 +1,112 @@
+import { mount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+
+jest.mock('@mindedge/vuetify-player', () => {
+    return jest.fn().mockImplementation(() => {})
+})
+
+import Video from '@/components/Content/Blocks/Video.vue'
+
+Vue.use(Vuetify)
+
+const metadata = {
+    columns: 12,
+    config: {
+        type: 'video',
+        attributes: {
+            autoplay: false,
+            autopictureinpicture: false,
+            controls: true,
+            controlslist: 'nodownload noremoteplayback',
+            crossorigin: 'anonymous',
+            disablepictureinpicture: true,
+            disableremoteplayback: true,
+            height: 'auto',
+            width: '100%',
+            rewind: true,
+            loop: false,
+            muted: false,
+            playsinline: false,
+            poster: '',
+            preload: '',
+            captionsmenu: true,
+            playlistmenu: true,
+            playlistautoadvance: true,
+            playbackrates: [0.5, 1, 1.5, 2],
+        },
+        playlist: [
+            {
+                name: 'preroll_example.mp4',
+                sources: [
+                    {
+                        file_asset_id: '00000000-0000-0000-0000-000000000000',
+                        src: 'https://jest.test/video.mp4',
+                        type: 'video/mp4',
+                    },
+                ],
+            },
+        ],
+    },
+}
+
+describe('Video', () => {
+    test('Video is a Vue instance', () => {
+        const wrapper = mount(Video, {
+            vuetify: new Vuetify(),
+            propsData: {
+                value: { body: 'video', metadata: { config: {} } },
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+
+    test('Video applied metadata correctly', () => {
+        const wrapper = mount(Video, {
+            vuetify: new Vuetify(),
+            propsData: {
+                value: {
+                    body: 'video',
+                    metadata,
+                },
+            },
+            mocks: defaultMocks,
+        })
+
+        expect(wrapper.vm).toBeTruthy()
+        expect(wrapper.vm.$data.block.metadata.config.type).toBe(
+            metadata.config.type
+        )
+        expect(wrapper.vm.$data.block.metadata.config.attributes).toStrictEqual(
+            metadata.config.attributes
+        )
+        expect(wrapper.vm.$data.block.metadata.config.playlist).toStrictEqual(
+            metadata.config.playlist
+        )
+    })
+
+    test('Video config edit mode', async () => {
+        const wrapper = mount(Video, {
+            vuetify: new Vuetify(),
+            propsData: {
+                value: {
+                    body: 'video',
+                    metadata,
+                },
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+
+        // Render mode enabled by default aka non-edit mode
+        expect(wrapper.vm.$data.render).toEqual(true)
+
+        // Turn on edit mode and test
+        await wrapper.vm.onActionPanelEdit()
+
+        expect(wrapper.vm.$data.render).toEqual(false)
+    })
+})

package/test/Components/Settings/AccordionSettings.spec.js

@@ -0,0 +1,45 @@
+import { shallowMount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+import AccordionSettings from '@/components/Settings/AccordionSettings'
+
+Vue.use(Vuetify)
+
+describe('AccordionSettings', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(AccordionSettings, {
+            propsData: {
+                tag: 'core-accordion-settings',
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+
+    test('can add an accordion', () => {
+        const wrapper = shallowMount(AccordionSettings, {
+            propsData: {
+                tag: 'core-accordion-settings',
+            },
+            mocks: defaultMocks,
+        })
+        wrapper.vm.onAddElement()
+        expect(wrapper.vm.$data.block.metadata.config.items).toEqual([
+            { header: '', expand: false, content: '' },
+            { header: '', expand: false, content: '' },
+        ])
+    })
+
+    test('can remove an accordion', () => {
+        const wrapper = shallowMount(AccordionSettings, {
+            propsData: {
+                tag: 'core-accordion-settings',
+            },
+            mocks: defaultMocks,
+        })
+        wrapper.vm.onRemoveElement(0)
+        expect(wrapper.vm.$data.block.metadata.config.items).toEqual([])
+    })
+})

package/test/Components/Settings/ClickableIconsSettings.spec.js

@@ -0,0 +1,20 @@
+import { shallowMount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+import ClickableIconsSettings from '@/components/Settings/ClickableIconsSettings'
+
+Vue.use(Vuetify)
+
+describe('ClickableIconsSettings', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(ClickableIconsSettings, {
+            propsData: {
+                tag: 'core-clickable-icon-setting',
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Components/Settings/FeedbackSettings.spec.js

@@ -0,0 +1,20 @@
+import { shallowMount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+import FeedbackSettings from '@/components/Settings/FeedbackSettings'
+
+Vue.use(Vuetify)
+
+describe('FeedbackSettings', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(FeedbackSettings, {
+            propsData: {
+                tag: 'core-feedback-settings',
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Components/Settings/ImageSettings.spec.js

@@ -0,0 +1,20 @@
+import { shallowMount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+import ImageSettings from '@/components/Settings/ImageSettings'
+
+Vue.use(Vuetify)
+
+describe('ImageSettings', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(ImageSettings, {
+            propsData: {
+                tag: 'core-image-settings',
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Components/Settings/MathSettings.spec.js

@@ -0,0 +1,20 @@
+import { shallowMount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+import MathSettings from '@/components/Settings/MathSettings'
+
+Vue.use(Vuetify)
+
+describe('MathSettings', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(MathSettings, {
+            propsData: {
+                tag: 'core-math-settings',
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Components/Settings/TabSettings.spec.js

@@ -0,0 +1,45 @@
+import { mount, shallowMount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+import TabSettings from '@/components/Settings/TabSettings'
+
+Vue.use(Vuetify)
+
+describe('TabSettings', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(TabSettings, {
+            propsData: {
+                tag: 'core-tab-settings',
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+
+    test('can add a new tab', () => {
+        const wrapper = shallowMount(TabSettings, {
+            propsData: {
+                tag: 'core-tab-settings',
+            },
+            mocks: defaultMocks,
+        })
+        wrapper.vm.onAddElement()
+        expect(wrapper.vm.$data.block.metadata.config.items).toEqual([
+            { tabHeader: '', expand: false, content: '' },
+            { tabHeader: '', expand: false, content: '' },
+        ])
+    })
+
+    test('can remove a tab', () => {
+        const wrapper = shallowMount(TabSettings, {
+            propsData: {
+                tag: 'core-tab-settings',
+            },
+            mocks: defaultMocks,
+        })
+        wrapper.vm.onRemoveElement(0)
+        expect(wrapper.vm.$data.block.metadata.config.items).toEqual([])
+    })
+})

package/test/Components/Settings/UserUploadSettings.spec.js

@@ -0,0 +1,20 @@
+import { shallowMount } from '@vue/test-utils'
+import Vuetify from 'vuetify'
+import Vue from 'vue'
+
+import { defaultMocks } from '@/test/mocks'
+import UserUploadSettings from '@/components/Settings/UserUploadSettings'
+
+Vue.use(Vuetify)
+
+describe('UserUploadSettings', () => {
+    test('is a Vue instance', () => {
+        const wrapper = shallowMount(UserUploadSettings, {
+            propsData: {
+                tag: 'core-accordion-settings',
+            },
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/__mocks__/componentsMock.js

@@ -0,0 +1,83 @@
+jest.mock(
+    '~/components/Dialog.vue',
+    () => {
+        return {
+            props: {},
+            computed: {},
+            methods: {},
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Dialog',
+    () => {
+        return {
+            props: {},
+            computed: {},
+            methods: {},
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Text/TextViewer',
+    () => {
+        return {
+            props: {},
+            computed: {},
+            methods: {},
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Text/TextEditor',
+    () => {
+        return {
+            props: {},
+            computed: {},
+            methods: {},
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Form',
+    () => {
+        return {
+            props: {},
+            computed: {},
+            methods: {},
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Form.vue',
+    () => {
+        return {
+            props: {},
+            computed: {},
+            methods: {},
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/ColorPicker.vue',
+    () => {
+        return {
+            props: {},
+            computed: {},
+            methods: {},
+        }
+    },
+    { virtual: true }
+)

package/test/__mocks__/contentBlockMock.js

@@ -0,0 +1,119 @@
+import mock_ from 'lodash'
+
+jest.mock(
+    '~/components/Content/ActionPanel.vue',
+    () => {
+        return jest.fn().mockImplementation(() => {
+            return { test: () => {} }
+        })
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Content/ContentBlockAsset.vue',
+    () => {
+        return jest.fn().mockImplementation(() => {
+            return { test: () => {} }
+        })
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Content/Blocks/BaseContentBlock',
+    () => {
+        return {
+            props: { value: { body: '', metadata: { config: {} } } },
+            computed: {
+                body() {
+                    if (mock_.isString(this.block.body)) {
+                        try {
+                            // try to parse in case it's a serialized json
+                            return JSON.parse(this.block.body)
+                        } catch (e) {
+                            return this.block.body
+                        }
+                    } else {
+                        return mock_.cloneDeep(this.block.body)
+                    }
+                },
+            },
+            data() {
+                return {
+                    block: {},
+                    render: true,
+                    saveState: true,
+                    completed: false,
+                }
+            },
+            created() {
+                if (typeof this.value.metadata.config === 'undefined') {
+                    this.value.metadata.config = {}
+                }
+                this.block = this.value
+            },
+            methods: {
+                async emitBody(body) {
+                    return await new Promise((resolve) => {
+                        resolve(true)
+                    })
+                },
+            },
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/Text/TextViewer.vue',
+    () => {
+        return {
+            props: {},
+            computed: {
+                body() {
+                    return ''
+                },
+            },
+            data() {
+                return {}
+            },
+        }
+    },
+    { virtual: true }
+)
+jest.mock(
+    '~/components/Text/TextEditor.vue',
+    () => {
+        return {
+            props: {},
+            computed: {
+                body() {
+                    return ''
+                },
+            },
+            data() {
+                return {}
+            },
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/components/FileDropZone.vue',
+    () => {
+        return {
+            props: {},
+            computed: {
+                body() {
+                    return ''
+                },
+            },
+            data() {
+                return {}
+            },
+        }
+    },
+    { virtual: true }
+)

package/test/__mocks__/contentSettingsMock.js

@@ -0,0 +1,54 @@
+jest.mock(
+    '~/components/Content/Tool/BaseContentSettings.js',
+    () => {
+        return {
+            props: {
+                // The stored settings for this settings panel
+                settings: { type: Object, required: false, default: null },
+                // `page` or `block` context
+                context: { type: String, required: false, default: 'block' },
+                // The settings panel tag. Eg `content-blocks-settings-general`
+                tag: { type: String, required: false, default: 'settings-tag' },
+                // The CourseContent model
+                courseContent: {
+                    type: Object,
+                    required: false,
+                    default: () => {
+                        return {}
+                    },
+                },
+                // The Content model
+                content: {
+                    type: Object,
+                    required: false,
+                    default: () => {
+                        return {}
+                    },
+                },
+            },
+            data() {
+                return {
+                    block: {
+                        id: '00000000-0000-0000-0000-000000000000',
+                        content_id: '00000000-0000-0000-0000-000000000001',
+                        tag: '',
+                        body: '',
+                        order: 0,
+                        metadata: {},
+                        created_at: new Date(),
+                        updated_at: new Date(),
+                        deleted_at: null,
+                    },
+                }
+            },
+            methods: {
+                async emitSettings(settings) {
+                    return await new Promise((resolve) => {
+                        resolve(true)
+                    })
+                },
+            },
+        }
+    },
+    { virtual: true }
+)

package/test/__mocks__/fileMock.js

@@ -0,0 +1 @@
+module.exports = 'test-file-stub'

package/test/__mocks__/helpersMock.js

@@ -0,0 +1,53 @@
+jest.mock(
+    '~/helpers/Uuid',
+    () => {
+        return {
+            test() {
+                return true
+            },
+        }
+    },
+    { virtual: true }
+)
+jest.mock(
+    '~/helpers/Download',
+    () => {
+        return jest.fn().mockImplementation(() => {
+            return { resource: () => {} }
+        })
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    '~/helpers/Crypto',
+    () => {
+        return {
+            id: () => {
+                return Math.random().toString()
+            },
+        }
+    },
+    { virtual: true }
+)
+
+jest.mock(
+    'lodash',
+    () => {
+        return {
+            cloneDeep: (v) => {
+                return JSON.parse(JSON.stringify(v))
+            },
+            isEmpty: () => {
+                return jest.fn()
+            },
+            flatten: () => {
+                return jest.fn()
+            },
+            get: () => {
+                return jest.fn()
+            },
+        }
+    },
+    { virtual: true }
+)