@windward/integrations 0.0.1

package/plugin.js

@@ -0,0 +1,110 @@
+import enUS from './i18n/en-US'
+import AdminVendorsPage from './pages/admin/vendors.vue'
+import AdminImportCoursePage from './pages/admin/importCourse.vue'
+import ImportContentPage from './pages/course/importContent.vue'
+import IntegrationHelper from './helpers/IntegrationHelper'
+
+export default {
+    name: 'windward.integrations.name',
+    hooks: {
+        beforeContent: (body) => {
+            return body
+        },
+        beforeDestroy: () => {},
+        beforeNavigate: () => {},
+        onNavigate: () => {},
+        onLoad: (page) => {},
+        onContent: () => {},
+    },
+    i18n: {
+        'en-US': enUS,
+    },
+    pages: [
+        {
+            page: 'admin-integrations',
+            path: '/admin/integrations/vendors',
+            i18n: 'windward.integrations.menu.integrations',
+            name: 'PluginIntegrationsAdminVendorsPage',
+            template: AdminVendorsPage,
+        },
+        {
+            page: 'admin-integrations',
+            path: '/admin/integrations/import-course',
+            i18n: 'windward.integrations.components.navigation.integrations.import_course',
+            name: 'PluginIntegrationsAdminImportCoursePage',
+            template: AdminImportCoursePage,
+        },
+        {
+            page: 'admin-integrations',
+            path: '/course/:course/integrations/import-content',
+            i18n: 'windward.integrations.components.navigation.integrations.import_content',
+            name: 'PluginIntegrationsImportContentPage',
+            template: ImportContentPage,
+        },
+    ],
+    components: {
+        menu: [
+            {
+                ref_page: 'admin',
+                children: [
+                    {
+                        i18n: 'windward.integrations.components.navigation.integrations.manage_integrations',
+                        path: '/admin/integrations/vendors',
+                        context: ['home'],
+                        permissions: {
+                            'plugin.windward.integrations.organization.integration':
+                                {
+                                    writable: true,
+                                },
+                        },
+                    },
+                    {
+                        i18n: 'windward.integrations.components.navigation.integrations.import_course',
+                        path: '/admin/integrations/import-course',
+                        context: ['home'],
+                        permissions: {
+                            'plugin.windward.integrations.course': {
+                                writable: true,
+                            },
+                        },
+                    },
+                    {
+                        i18n: 'windward.integrations.components.navigation.integrations.import_content',
+                        path: '/course/{course.id}/integrations/import-content',
+                        context: ['course'],
+                        permissions: {
+                            'plugin.windward.integrations.course': {
+                                writable: true,
+                            },
+                        },
+                    },
+                    /*
+                    {
+                        i18n: 'windward.integrations.components.navigation.integrations.manage_lti',
+                        path: '/admin/integrations/lti',
+                        context: ['home'],
+                        permissions: {
+                            'plugin.windward.integrations.organization.integration': {
+                                writable: true,
+                            },
+                        },
+                    },
+                    {
+                        i18n: 'windward.integrations.components.navigation.integrations.manage_lti_links',
+                        path: '/course/{course.id}/integrations/lti',
+                        context: ['course'],
+                        permissions: {
+                            'plugin.windward.integrations.organization.integration': {
+                                writable: true,
+                            },
+                        },
+                    },
+                    */
+                ],
+            },
+        ],
+    },
+    services: {
+        Integration: IntegrationHelper,
+    },
+}

package/test/Helpers/IntegrationHelper.spec.js

@@ -0,0 +1,92 @@
+import { shallowMount } from '@vue/test-utils'
+import Vue from 'vue'
+import Vuetify from 'vuetify'
+import { defaultMocks } from '@/test/mocks'
+
+import '../__mocks__/vuexMock'
+import '../__mocks__/modelMock'
+import '../__mocks__/lodashMock'
+import '@windward/core/test/__mocks__/componentsMock.js'
+import IntegrationHelper from '@/helpers/IntegrationHelper'
+
+Vue.use(Vuetify)
+
+const Helper = new IntegrationHelper(null)
+// Hard set _vendors since we can't load via api
+Helper._vendors = [
+    {
+        id: '00000000-0000-0000-0000-000000000000',
+        product_code: 'atutor',
+    },
+]
+Helper._loaded = true
+
+describe('IntegrationHelper ', () => {
+    test('get vendors', () => {
+        const vendors = Helper.getVendors()
+
+        expect(vendors).toBeTruthy()
+        expect(vendors.length > 0).toBeTruthy()
+    })
+
+    test('getVendorConfig', () => {
+        const config = Helper.getVendorConfig(
+            '00000000-0000-0000-0000-000000000000'
+        )
+
+        expect(config).toBeTruthy()
+    })
+
+    test('getVendorConfig check for driver', () => {
+        const config = Helper.getVendorConfig(
+            '00000000-0000-0000-0000-000000000000'
+        )
+
+        expect(config).toBeTruthy()
+        expect(config.driver).toBeTruthy()
+    })
+
+    test('getVendorDriver', () => {
+        const driver = Helper.getVendorDriver(
+            '00000000-0000-0000-0000-000000000000'
+        )
+
+        expect(driver).toBeTruthy()
+    })
+
+    test('check vendor driver for components', () => {
+        const driver = Helper.getVendorDriver(
+            '00000000-0000-0000-0000-000000000000'
+        )
+
+        expect(driver.components).toBeTruthy()
+        const components = driver.components()
+        expect(components.Manage).toBeTruthy()
+    })
+
+    test('check vendor driver component mount', () => {
+        const driver = Helper.getVendorDriver(
+            '00000000-0000-0000-0000-000000000000'
+        )
+        const components = driver.components()
+
+        const wrapper = shallowMount(components.Manage, {
+            vuetify: new Vuetify(),
+            mocks: defaultMocks,
+            propsData: {
+                vendor: {
+                    id: '00000000-0000-0000-0000-000000000000',
+                },
+            },
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+
+    test('getVendorManageComponent', () => {
+        const component = Helper.getVendorManageComponent(
+            '00000000-0000-0000-0000-000000000000'
+        )
+
+        expect(component).toBeTruthy()
+    })
+})

package/test/Pages/Admin/ImportCourse.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 ImportCoursePage from '@/pages/admin/importCourse.vue'
+
+Vue.use(Vuetify)
+
+describe('ImportCoursePage', () => {
+    test('ImportCoursePage is a Vue instance', () => {
+        const wrapper = shallowMount(ImportCoursePage, {
+            vuetify: new Vuetify(),
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Pages/Admin/vendors.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 VendorsPage from '@/pages/admin/vendors.vue'
+
+Vue.use(Vuetify)
+
+describe('VendorsPage', () => {
+    test('VendorsPage is a Vue instance', () => {
+        const wrapper = shallowMount(VendorsPage, {
+            vuetify: new Vuetify(),
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/Pages/Course/importContent.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 ImportContentPage from '@/pages/course/importContent.vue'
+
+Vue.use(Vuetify)
+
+describe('ImportContentPage', () => {
+    test('ImportContentPage is a Vue instance', () => {
+        const wrapper = shallowMount(ImportContentPage, {
+            vuetify: new Vuetify(),
+            mocks: defaultMocks,
+        })
+        expect(wrapper.vm).toBeTruthy()
+    })
+})

package/test/__mocks__/lodashMock.js

@@ -0,0 +1,31 @@
+jest.mock(
+    'lodash',
+    () => {
+        return {
+            cloneDeep: (v) => {
+                return JSON.parse(JSON.stringify(v))
+            },
+            isEmpty: () => {
+                return jest.fn()
+            },
+            flatten: () => {
+                return jest.fn()
+            },
+            get(obj, path) {
+                const paths = path.split('.')
+                let current = obj
+                let i
+
+                for (i = 0; i < paths.length; ++i) {
+                    if (typeof current[paths[i]] === 'undefined') {
+                        return undefined
+                    } else {
+                        current = current[paths[i]]
+                    }
+                }
+                return current
+            },
+        }
+    },
+    { virtual: true }
+)

package/test/__mocks__/modelMock.js

@@ -0,0 +1,101 @@
+import { Model as mockModel } from 'vue-api-query'
+
+import axios from 'axios'
+jest.mock('axios')
+mockModel.$http = axios
+
+jest.mock('axios')
+
+// Define any new model mocks here. The imports / mocks will be auto-generated below
+const mockVirtualModels = []
+
+const mockModels = [
+    { path: '../../models/Organization', resource: 'organizations' },
+    {
+        path: '../../models/OrganizationIntegration',
+        resource: 'organization-integrations',
+    },
+    {
+        path: '../../models/CourseSectionIntegration',
+        resource: 'section-integrations',
+    },
+    { path: '../../models/IntegrationJob', resource: 'integration-jobs' },
+    { path: '../../models/RemoteContent', resource: 'remote-content' },
+    { path: '../../models/RemoteCourse', resource: 'remote-courses' },
+    {
+        path: '../../models/RemoteOrganization',
+        resource: 'remote-organizations',
+    },
+    { path: '../../models/Vendor', resource: 'vendors' },
+]
+
+// DO NOT ALTER THE BELOW CODE
+jest.mock('', () => {
+    return {
+        __esModule: true,
+        default: class Model {},
+    }
+})
+class mockBaseModel extends mockModel {
+    baseURL() {
+        return 'http://windwardapi.local'
+    }
+
+    request(config) {
+        return new Promise((resolve) => {
+            resolve({ data: {} })
+        })
+    }
+}
+
+jest.mock(
+    '~/models/Model',
+    () => {
+        return {
+            __esModule: true,
+            default: class Model extends mockBaseModel {},
+        }
+    },
+    { virtual: true }
+)
+
+for (let mockI = 0; mockI < mockVirtualModels.length; mockI++) {
+    jest.mock(
+        mockVirtualModels[mockI].path,
+        () => {
+            return {
+                __esModule: true,
+                default: class Model extends mockBaseModel {
+                    resource() {
+                        return (
+                            mockVirtualModels[mockI].resource ||
+                            this.constructor.name
+                        )
+                    }
+                },
+            }
+        },
+        { virtual: true }
+    )
+}
+
+for (let mockJ = 0; mockJ < mockModels.length; mockJ++) {
+    jest.mock(mockModels[mockJ].path, () => {
+        return {
+            __esModule: true,
+            default: class Model extends mockBaseModel {
+                resource() {
+                    return mockModels[mockJ].resource || this.constructor.name
+                }
+
+                integrations() {
+                    return this
+                }
+
+                get() {
+                    return []
+                }
+            },
+        }
+    })
+}

package/test/__mocks__/vuexMock.js

@@ -0,0 +1,31 @@
+jest.mock(
+    'vuex',
+    () => {
+        return {
+            __esModule: true,
+            mapGetters(obj) {
+                const getters = {}
+                for (const [key, value] of Object.entries(obj)) {
+                    // Return a function getter since mapGetters only work in the computed section
+                    getters[key] = () => {
+                        return { id: '00000000-0000-0000-0000-000000000000' }
+                    }
+                }
+                // Just return an empty object
+                return getters
+            },
+            mapMutations(obj) {
+                const getters = {}
+                for (const [key, value] of Object.entries(obj)) {
+                    // Return a function getter since mapGetters only work in the computed section
+                    getters[key] = () => {
+                        return { id: '00000000-0000-0000-0000-000000000000' }
+                    }
+                }
+                // Just return an empty object
+                return getters
+            },
+        }
+    },
+    { virtual: true }
+)

package/test/mocks.js

@@ -0,0 +1,18 @@
+import { defaultMocks as mocks } from '@windward/core/test/mocks'
+
+require('./__mocks__/modelMock')
+
+mocks.$Integration = {
+    async load() {
+        return await new Promise((resolve) => {
+            resolve(true)
+        })
+    },
+    async getVendors() {
+        return await new Promise((resolve) => {
+            resolve([])
+        })
+    },
+}
+
+export const defaultMocks = mocks

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+    "compilerOptions": {
+        "target": "ES2018",
+        "module": "ESNext",
+        "moduleResolution": "Node",
+        "lib": ["ESNext", "ESNext.AsyncIterable", "DOM"],
+        "esModuleInterop": true,
+        "allowJs": true,
+        "sourceMap": true,
+        "strict": true,
+        "noEmit": true,
+        "experimentalDecorators": true,
+        "baseUrl": ".",
+        "paths": {
+            "~/*": ["./*"],
+            "@/*": ["./*"]
+        },
+        "types": ["@types/node"]
+    },
+    "exclude": ["node_modules", ".nuxt", "dist"]
+}