New: added migration scripts (fixes #79)

migrations/v2.js

@@ -0,0 +1,91 @@
+import { describe, whereContent, whereFromPlugin, mutateContent, checkContent, updatePlugin } from 'adapt-migrations';
+import _ from 'lodash';
+
+const getCourse = content => {
+  const course = content.find(({ _type }) => _type === 'course');
+  return course;
+};
+
+const getGlobals = content => {
+  return getCourse(content)?._globals?._extensions?._glossary;
+};
+
+describe('Glossary - v2.0.3 to v2.1.0', async () => {
+  // https://github.com/adaptlearning/adapt-contrib-glossary/compare/v2.0.3..v2.1.0
+
+  let course;
+
+  whereFromPlugin('Glossary - from v2.0.3', { name: 'adapt-contrib-glossary', version: '<2.1.0' });
+
+  whereContent('Glossary - where configured', async (content) => {
+    course = getCourse(content);
+    return course._glossary;
+  });
+
+  mutateContent('Glossary - add course attribute _drawerOrder', async (content) => {
+    course._glossary._drawerOrder = 0;
+    return true;
+  });
+
+  checkContent('Glossary - check course attribute _drawerOrder', async (content) => {
+    const isValid = course._glossary._drawerOrder === 0;
+    if (!isValid) throw new Error('Glossary - course attribute _drawerOrder');
+    return true;
+  });
+
+  updatePlugin('Glossary - update to v2.1.0', { name: 'adapt-contrib-glossary', version: '2.1.0', framework: '">=2.2.0' });
+});
+
+describe('Glossary - v2.1.0 to v2.1.1', async () => {
+  // https://github.com/adaptlearning/adapt-contrib-glossary/compare/v2.1.0..v2.1.1
+
+  let course, courseGlossaryGlobals;
+
+  whereFromPlugin('Glossary - from v2.1.0', { name: 'adapt-contrib-glossary', version: '<2.1.1' });
+
+  whereContent('Glossary - where configured', async (content) => {
+    course = getCourse(content);
+    return course._glossary;
+  });
+
+  mutateContent('Glossary - add globals if missing', async (content) => {
+    if (!_.has(course, '_globals._extensions._glossary')) _.set(course, '_globals._extensions._glossary', {});
+    courseGlossaryGlobals = course._globals._extensions._glossary;
+    return true;
+  });
+
+  mutateContent('Glossary - add global attribute glossary', async (content) => {
+    courseGlossaryGlobals.glossary = 'Glossary';
+    return true;
+  });
+
+  mutateContent('Glossary - add course attribute clearSearch', async (content) => {
+    course._glossary.clearSearch = '';
+    return true;
+  });
+
+  mutateContent('Glossary - add course attribute searchItemsAlert', async (content) => {
+    course._glossary.searchItemsAlert = '{{filteredItems.length}} found.';
+    return true;
+  });
+
+  checkContent('Glossary - check global attribute glossary', async (content) => {
+    const isValid = getGlobals(content).glossary === 'Glossary';
+    if (!isValid) throw new Error('Glossary - global attribute glossary');
+    return true;
+  });
+
+  checkContent('Glossary - check course attribute clearSearch', async (content) => {
+    const isValid = course._glossary.clearSearch === '';
+    if (!isValid) throw new Error('Glossary - course attribute clearSearch');
+    return true;
+  });
+
+  checkContent('Glossary - check course attribute searchItemsAlert', async (content) => {
+    const isValid = course._glossary.searchItemsAlert === '{{filteredItems.length}} found.';
+    if (!isValid) throw new Error('Glossary - course attribute searchItemsAlert');
+    return true;
+  });
+
+  updatePlugin('Glossary - update to v2.1.1', { name: 'adapt-contrib-glossary', version: '2.1.1', framework: '">=2.2.5' });
+});

migrations/v3.js

@@ -0,0 +1,159 @@
+import { describe, whereContent, whereFromPlugin, mutateContent, checkContent, updatePlugin } from 'adapt-migrations';
+import _ from 'lodash';
+
+const getCourse = content => {
+  const course = content.find(({ _type }) => _type === 'course');
+  return course;
+};
+
+const getGlobals = content => {
+  return getCourse(content)?._globals?._extensions?._glossary;
+};
+
+describe('Glossary - v2.1.3 to v3.0.0', async () => {
+  // https://github.com/adaptlearning/adapt-contrib-glossary/compare/v2.1.3..v3.0.0
+
+  let course, courseGlossaryGlobals;
+
+  whereFromPlugin('Glossary - from v2.1.3', { name: 'adapt-contrib-glossary', version: '<3.0.0' });
+
+  whereContent('Glossary - where configured', async (content) => {
+    course = getCourse(content);
+    return course._glossary;
+  });
+
+  mutateContent('Glossary - add globals if missing', async (content) => {
+    if (!_.has(course, '_globals._extensions._glossary')) _.set(course, '_globals._extensions._glossary', {});
+    courseGlossaryGlobals = course._globals._extensions._glossary;
+    return true;
+  });
+
+  mutateContent('Glossary - add global attribute labelLink', async (content) => {
+    courseGlossaryGlobals.labelLink = 'Terms beginning with';
+    return true;
+  });
+
+  mutateContent('Glossary - add global attribute labelNavigation', async (content) => {
+    courseGlossaryGlobals.labelNavigation = 'Glossary navigation';
+    return true;
+  });
+
+  mutateContent('Glossary - change default title', async (content) => {
+    if (course._glossary.title !== '') return true;
+    course._glossary.title = 'Glossary';
+    return true;
+  });
+
+  mutateContent('Glossary - change default description', async (content) => {
+    if (course._glossary.description !== '') return true;
+    course._glossary.description = 'Select here to view the glossary for this course';
+    return true;
+  });
+
+  mutateContent('Glossary - change default clearSearch', async (content) => {
+    if (course._glossary.clearSearch !== '') return true;
+    course._glossary.clearSearch = 'Clear search';
+    return true;
+  });
+
+  mutateContent('Glossary - change default searchItemsAlert', async (content) => {
+    if (course._glossary.searchItemsAlert !== '{{filteredItems.length}} found.') return true;
+    course._glossary.searchItemsAlert = '{{filteredItems.length}} found';
+    return true;
+  });
+
+  mutateContent('Glossary - change default searchPlaceholder', async (content) => {
+    if (course._glossary.searchPlaceholder !== '') return true;
+    course._glossary.searchPlaceholder = 'Search';
+    return true;
+  });
+
+  mutateContent('Glossary - change default searchWithInDescriptionLabel', async (content) => {
+    if (course._glossary.searchWithInDescriptionLabel !== '') return true;
+    course._glossary.searchWithInDescriptionLabel = 'Search within Description';
+    return true;
+  });
+
+  mutateContent('Glossary - add attribute _isSearchEnabled', async (content) => {
+    course._glossary._isSearchEnabled = true;
+    return true;
+  });
+
+  mutateContent('Glossary - add attribute _isIndexEnabled', async (content) => {
+    course._glossary._isIndexEnabled = false;
+    return true;
+  });
+
+  mutateContent('Glossary - add attribute _isGroupHeadersEnabled', async (content) => {
+    course._glossary._isGroupHeadersEnabled = false;
+    return true;
+  });
+
+  checkContent('Glossary - check global attribute labelLink', async (content) => {
+    const isValid = getGlobals(content).labelLink === 'Terms beginning with';
+    if (!isValid) throw new Error('Glossary - global attribute labelLink');
+    return true;
+  });
+
+  checkContent('Glossary - check global attribute labelNavigation', async (content) => {
+    const isValid = getGlobals(content).labelNavigation === 'Glossary navigation';
+    if (!isValid) throw new Error('Glossary - global attribute labelNavigation');
+    return true;
+  });
+
+  checkContent('Glossary - check course attribute title', async (content) => {
+    const isValid = course._glossary.title !== '';
+    if (!isValid) throw new Error('Glossary - course attribute title');
+    return true;
+  });
+
+  checkContent('Glossary - check course attribute description', async (content) => {
+    const isValid = course._glossary.description !== '';
+    if (!isValid) throw new Error('Glossary - course attribute description');
+    return true;
+  });
+
+  checkContent('Glossary - check default clearSearch', async (content) => {
+    const isValid = course._glossary.clearSearch !== '';
+    if (!isValid) throw new Error('Glossary - course attribute clearSearch');
+    return true;
+  });
+
+  checkContent('Glossary - check default searchItemsAlert', async (content) => {
+    const isValid = course._glossary.searchItemsAlert !== '{{filteredItems.length}} found.';
+    if (!isValid) throw new Error('Glossary - course attribute searchItemsAlert');
+    return true;
+  });
+
+  checkContent('Glossary - check default searchPlaceholder', async (content) => {
+    const isValid = course._glossary.searchPlaceholder !== '';
+    if (!isValid) throw new Error('Glossary - course attribute searchPlaceholder');
+    return true;
+  });
+
+  checkContent('Glossary - check default searchWithInDescriptionLabel', async (content) => {
+    const isValid = course._glossary.searchWithInDescriptionLabel !== '';
+    if (!isValid) throw new Error('Glossary - course attribute searchWithInDescriptionLabel');
+    return true;
+  });
+
+  checkContent('Glossary - check attribute _isSearchEnabled', async (content) => {
+    const isValid = course._glossary._isSearchEnabled === true;
+    if (!isValid) throw new Error('Glossary - course attribute _isSearchEnabled');
+    return true;
+  });
+
+  checkContent('Glossary - check attribute _isIndexEnabled', async (content) => {
+    const isValid = course._glossary._isIndexEnabled === false;
+    if (!isValid) throw new Error('Glossary - course attribute _isIndexEnabled');
+    return true;
+  });
+
+  checkContent('Glossary - check attribute _isGroupHeadersEnabled', async (content) => {
+    const isValid = course._glossary._isGroupHeadersEnabled === false;
+    if (!isValid) throw new Error('Glossary - course attribute _isGroupHeadersEnabled');
+    return true;
+  });
+
+  updatePlugin('Glossary - update to v3.0.0', { name: 'adapt-contrib-glossary', version: '3.0.0', framework: '">=5' });
+});

migrations/v4.js

@@ -0,0 +1,32 @@
+import { describe, whereContent, whereFromPlugin, mutateContent, checkContent, updatePlugin } from 'adapt-migrations';
+
+const getCourse = content => {
+  const course = content.find(({ _type }) => _type === 'course');
+  return course;
+};
+
+describe('Glossary - v4.3.1 to v4.4.0', async () => {
+  // https://github.com/adaptlearning/adapt-contrib-glossary/compare/v4.3.1..v4.4.0
+
+  let course;
+
+  whereFromPlugin('Glossary - from v4.3.1', { name: 'adapt-contrib-glossary', version: '<4.4.0' });
+
+  whereContent('Glossary has items', async content => {
+    course = getCourse(content);
+    return course._glossary?._items?.length;
+  });
+
+  mutateContent('Glossary - add item attribute termAriaLabel', async (content) => {
+    course._glossary._items.forEach(item => (item.termAriaLabel = ''));
+    return true;
+  });
+
+  checkContent('Glossary - check item attribute termAriaLabel', async (content) => {
+    const isValid = course._glossary._items.every(item => item.termAriaLabel === '');
+    if (!isValid) throw new Error('Glossary - item attribute termAriaLabel');
+    return true;
+  });
+
+  updatePlugin('Glossary - update to v4.4.0', { name: 'adapt-contrib-glossary', version: '4.4.0', framework: '">=5.19.1' });
+});