cnx-public/scorm-again
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial push, working on test cases

Browse Source
This commit is contained in:
Jonathan Putney
2019-11-10 12:29:43 -05:00
parent 377d9f977a
commit da4af1edba
18 changed files with 9571 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
test/Scorm12API.spec.js Normal file
View File

@@ -0,0 +1,282 @@
import { expect, assert } from 'chai';
import {describe, it, before, beforeEach, after, afterEach, } from "mocha";
import Scorm12API from "../src/Scorm12API";
import {scorm12_constants, scorm12_error_codes} from "../src/constants";
let API;
const checkFieldConstraintSize = (fieldName: String, limit: Number, expectedValue: String = '') => {
describe(`Field: ${fieldName}`, () => {
it(`Should be able to read from ${fieldName}`, () => {
expect(eval(`API.${fieldName}`)).to.equal(expectedValue);
});
it(`Should be able to write upto ${limit} characters to ${fieldName}`, () => {
eval(`API.${fieldName} = 'x'.repeat(${limit})`);
expect(0).to.equal(API.lastErrorCode);
});
it(`Should fail to write more than ${limit} characters to ${fieldName}`, () => {
eval(`API.${fieldName} = 'x'.repeat(${limit + 1})`);
expect(scorm12_error_codes.TYPE_MISMATCH + '').to.equal(API.lastErrorCode);
});
});
};
const checkInvalidSet = (fieldName: String, expectedValue: String = '') => {
describe(`Field: ${fieldName}`, () => {
it(`Should be able to read from ${fieldName}`, () => {
expect(eval(`API.${fieldName}`)).to.equal(expectedValue);
});
it(`Should fail to write to ${fieldName}`, () => {
eval(`API.${fieldName} = 'xxx'`);
expect(API.lastErrorCode).to.equal(scorm12_error_codes.INVALID_SET_VALUE + '');
});
});
};
const checkReadOnly = (fieldName: String, expectedValue: String = '') => {
describe(`Field: ${fieldName}`, () => {
it(`Should be able to read from ${fieldName}`, () => {
expect(eval(`API.${fieldName}`)).to.equal(expectedValue);
});
it(`Should fail to write to ${fieldName}`, () => {
eval(`API.${fieldName} = 'xxx'`);
expect(API.lastErrorCode).to.equal(scorm12_error_codes.READ_ONLY_ELEMENT + '');
});
});
};
const checkRead = (fieldName: String, expectedValue: String = '') => {
describe(`Field: ${fieldName}`, () => {
it(`Should be able to read from ${fieldName}`, () => {
expect(eval(`API.${fieldName}`)).to.equal(expectedValue);
});
});
};
const checkWriteOnly = (fieldName: String, valueToTest: String = 'xxx') => {
describe(`Field: ${fieldName}`, () => {
it(`Should fail to read from ${fieldName}`, () => {
eval(`API.${fieldName}`);
expect(API.lastErrorCode).to.equal(scorm12_error_codes.WRITE_ONLY_ELEMENT + '');
});
it(`Should successfully write to ${fieldName}`, () => {
eval(`API.${fieldName} = '${valueToTest}'`);
expect(API.lastErrorCode).to.equal(0);
});
});
};
const checkWrite = (fieldName: String, valueToTest: String = 'xxx') => {
describe(`Field: ${fieldName}`, () => {
it(`Should successfully write to ${fieldName}`, () => {
eval(`API.${fieldName} = '${valueToTest}'`);
expect(API.lastErrorCode).to.equal(0);
});
});
};
const checkValidValues = (fieldName: String, expectedError: Number, validValues: Array, invalidValues: Array) => {
describe(`Field: ${fieldName}`, () => {
for(let idx in validValues) {
it(`Should successfully write '${validValues[idx]}' to ${fieldName}`, () => {
eval(`API.${fieldName} = '${validValues[idx]}'`);
expect(API.lastErrorCode).to.equal(0);
});
}
for(let idx in invalidValues) {
it(`Should fail to write '${invalidValues[idx]}' to ${fieldName}`, () => {
eval(`API.${fieldName} = '${invalidValues[idx]}'`);
expect(API.lastErrorCode).to.equal(expectedError + '');
});
}
});
};
describe('SCORM 1.2 API Tests', () => {
describe('CMI Spec Tests', () => {
describe('Post-LMSInitialize Tests', () => {
beforeEach('Create the API object', () => {
API = new Scorm12API();
API.LMSInitialize();
});
afterEach('Destroy API object', () => {
API = null;
});
it('LMSInitialize should create CMI object', () => {
assert(API.cmi !== undefined, 'CMI object is created');
});
it('Exporting CMI to JSON produces proper Object', () => {
expect(
JSON.parse(API.renderCMIToJSON())
).to.hasOwnProperty('core')
});
/**
* Base CMI Properties
*/
checkInvalidSet('cmi._version', '3.4');
checkInvalidSet('cmi._children', scorm12_constants.cmi_children);
checkFieldConstraintSize('cmi.suspend_data', 4096);
checkReadOnly('cmi.launch_data');
checkFieldConstraintSize('cmi.comments', 4096);
checkReadOnly('cmi.comments_from_lms');
/**
* cmi.core Properties
*/
checkInvalidSet('cmi.core._children', scorm12_constants.core_children);
checkReadOnly('cmi.core.student_id');
checkReadOnly('cmi.core.student_name');
checkFieldConstraintSize('cmi.core.lesson_location', 255);
checkReadOnly('cmi.core.credit');
checkRead('cmi.core.lesson_status');
checkValidValues('cmi.core.lesson_status', scorm12_error_codes.TYPE_MISMATCH, [
'passed',
'completed',
'failed',
'incomplete',
'browsed'
], [
'Passed',
'P',
'F',
'p',
'true',
'false',
'complete'
]);
checkReadOnly('cmi.core.entry');
checkReadOnly('cmi.core.total_time');
checkReadOnly('cmi.core.lesson_mode', 'normal');
checkWrite('cmi.core.exit', 'suspend');
checkValidValues('cmi.core.exit', scorm12_error_codes.TYPE_MISMATCH, [
'time-out',
'suspend',
'logout',
], [
'complete',
'exit'
]);
checkWriteOnly('cmi.core.session_time', '00:00:00');
checkValidValues('cmi.core.session_time', scorm12_error_codes.TYPE_MISMATCH, [
'10:06:57',
'00:00:01.56',
'23:59:59',
'47:59:59',
], [
'06:5:13',
'23:59:59.123',
'P1DT23H59M59S'
]);
/**
* cmi.core.score Properties
*/
checkInvalidSet('cmi.core.score._children', scorm12_constants.score_children);
checkValidValues('cmi.core.score.raw', scorm12_error_codes.VALUE_OUT_OF_RANGE, [
'0',
'25.1',
'50.5',
'75',
'100',
], [
'-1',
'101'
]);
checkValidValues('cmi.core.score.min', scorm12_error_codes.VALUE_OUT_OF_RANGE, [
'0',
'25.1',
'50.5',
'75',
'100',
], [
'-1',
'101'
]);
checkValidValues('cmi.core.score.max', scorm12_error_codes.VALUE_OUT_OF_RANGE, [
'0',
'25.1',
'50.5',
'75',
'100',
], [
'-1',
'101'
]);
/**
* cmi.objectives Properties
*/
checkInvalidSet('cmi.objectives._children', scorm12_constants.objectives_children);
checkInvalidSet('cmi.objectives._count', 0);
/**
* cmi.student_data Properties
*/
checkInvalidSet('cmi.student_data._children', scorm12_constants.student_data_children);
checkReadOnly('cmi.student_data.mastery_score');
checkReadOnly('cmi.student_data.max_time_allowed');
checkReadOnly('cmi.student_data.time_limit_action');
/**
* cmi.student_preference Properties
*/
checkInvalidSet('cmi.student_preference._children', scorm12_constants.student_preference_children);
checkValidValues('cmi.student_preference.audio', scorm12_error_codes.TYPE_MISMATCH, [
'1',
'-1',
'50',
'100',
], [
'invalid',
'a100'
]);
checkValidValues('cmi.student_preference.audio', scorm12_error_codes.VALUE_OUT_OF_RANGE, [], [
'101',
'5000000',
'-500'
]);
checkFieldConstraintSize('cmi.student_preference.language', 255);
checkValidValues('cmi.student_preference.speed', scorm12_error_codes.TYPE_MISMATCH, [
'1',
'-100',
'50',
'100',
], [
'invalid',
'a100'
]);
checkValidValues('cmi.student_preference.speed', scorm12_error_codes.VALUE_OUT_OF_RANGE, [], [
'101',
'-101',
'5000000',
'-500'
]);
checkValidValues('cmi.student_preference.text', scorm12_error_codes.TYPE_MISMATCH, [
'1',
'-1'
], [
'invalid',
'a100'
]);
checkValidValues('cmi.student_preference.text', scorm12_error_codes.VALUE_OUT_OF_RANGE, [], [
'2',
'-2'
]);
/**
* cmi.interactions Properties
*/
checkInvalidSet('cmi.interactions._children', scorm12_constants.interactions_children);
checkInvalidSet('cmi.interactions._count', 0);
});
});
});

220
test/utilities.spec.js Normal file
View File

@@ -0,0 +1,220 @@
import { expect } from 'chai';
import {describe, it} from "mocha";
import * as Utilities from '../src/utilities';
import {scorm12_regex, scorm2004_regex} from "../src/regex";
describe('Utility Tests', () => {
describe('function getSecondsAsHHMMSS()', () => {
it('10 returns 00:00:10', () => {
expect(
Utilities.getSecondsAsHHMMSS(10)
).to.equal('00:00:10');
});
it('60 returns 00:01:00', () => {
expect(
Utilities.getSecondsAsHHMMSS(60)
).to.equal('00:01:00');
});
it('3600 returns 01:00:00', () => {
expect(
Utilities.getSecondsAsHHMMSS(3600)
).to.equal('01:00:00');
});
it('70 returns 00:01:10', () => {
expect(
Utilities.getSecondsAsHHMMSS(70)
).to.equal('00:01:10');
});
it('3670 returns 01:01:10', () => {
expect(
Utilities.getSecondsAsHHMMSS(3670)
).to.equal('01:01:10');
});
it('90000 returns 25:00:00, check for hours greater than 24', () => {
expect(
Utilities.getSecondsAsHHMMSS(90000)
).to.equal('25:00:00');
});
it('-3600 returns 00:00:00, negative time not allowed in SCORM session times', () => {
expect(
Utilities.getSecondsAsHHMMSS(-3600)
).to.equal('00:00:00');
});
it('Empty seconds returns 00:00:00', () => {
expect(
Utilities.getSecondsAsHHMMSS(null)
).to.equal('00:00:00');
});
});
describe('function getSecondsAsISODuration()', () => {
it('10 returns P10S', () => {
expect(
Utilities.getSecondsAsISODuration(10)
).to.equal('P10S');
});
it('60 returns P1M', () => {
expect(
Utilities.getSecondsAsISODuration(60)
).to.equal('P1M');
});
it('3600 returns P1H', () => {
expect(
Utilities.getSecondsAsISODuration(3600)
).to.equal('P1H');
});
it('70 returns P1M10S', () => {
expect(
Utilities.getSecondsAsISODuration(70)
).to.equal('P1M10S');
});
it('3670 returns P1H1M10S', () => {
expect(
Utilities.getSecondsAsISODuration(3670)
).to.equal('P1H1M10S');
});
it('90000 returns P1D1H', () => {
expect(
Utilities.getSecondsAsISODuration(90000)
).to.equal('P1D1H');
});
it('90061 returns P1D1H1M1S', () => {
expect(
Utilities.getSecondsAsISODuration(90061)
).to.equal('P1D1H1M1S');
});
it('-3600 returns P0S, negative time not allowed in SCORM session times', () => {
expect(
Utilities.getSecondsAsISODuration(-3600)
).to.equal('P0S');
});
it('Empty seconds returns P0S', () => {
expect(
Utilities.getSecondsAsISODuration(null)
).to.equal('P0S');
});
});
describe('function getTimeAsSeconds()', () => {
it('00:00:10 returns 10', () => {
expect(
Utilities.getTimeAsSeconds('00:00:10', scorm12_regex.CMITimespan)
).to.equal(10);
});
it('00:01:10 returns 70', () => {
expect(
Utilities.getTimeAsSeconds('00:01:10', scorm12_regex.CMITimespan)
).to.equal(70);
});
it('01:01:10 returns 3670', () => {
expect(
Utilities.getTimeAsSeconds('01:01:10', scorm12_regex.CMITimespan)
).to.equal(3670);
});
it('100:00:00 returns 3670', () => {
expect(
Utilities.getTimeAsSeconds('100:00:00', scorm12_regex.CMITimespan)
).to.equal(360000);
});
it('-01:00:00 returns 0', () => {
expect(
Utilities.getTimeAsSeconds('-01:00:00', scorm12_regex.CMITimespan)
).to.equal(0);
});
it('Number value returns 0', () => {
expect(
Utilities.getTimeAsSeconds(999, scorm12_regex.CMITimespan)
).to.equal(0);
});
it('boolean value returns 0', () => {
expect(
Utilities.getTimeAsSeconds(true, scorm12_regex.CMITimespan)
).to.equal(0);
});
it('Empty value returns 0', () => {
expect(
Utilities.getTimeAsSeconds(null, scorm12_regex.CMITimespan)
).to.equal(0);
});
});
describe('function getDurationAsSeconds()', () => {
it('P0S returns 0', () => {
expect(
Utilities.getDurationAsSeconds('P0S', scorm2004_regex.CMITimespan)
).to.equal(0);
});
it('P70S returns 70', () => {
expect(
Utilities.getDurationAsSeconds('P70S', scorm2004_regex.CMITimespan)
).to.equal(70);
});
it('PT1M10S returns 70', () => {
expect(
Utilities.getDurationAsSeconds('PT1M10S', scorm2004_regex.CMITimespan)
).to.equal(70);
});
it('P1D returns 86400', () => {
expect(
Utilities.getDurationAsSeconds('P1D', scorm2004_regex.CMITimespan)
).to.equal(86400);
});
it('P1M returns number of seconds for one month from now', () => {
const now = new Date();
let oneMonthFromNow = new Date(now);
oneMonthFromNow.setMonth(oneMonthFromNow.getMonth() + 1);
expect(
Utilities.getDurationAsSeconds('P1M', scorm2004_regex.CMITimespan)
).to.equal((oneMonthFromNow - now) / 1000.0);
});
it('P1Y returns number of seconds for one year from now', () => {
const now = new Date();
let oneYearFromNow = new Date(now);
oneYearFromNow.setFullYear(oneYearFromNow.getFullYear() + 1);
expect(
Utilities.getDurationAsSeconds('P1Y', scorm2004_regex.CMITimespan)
).to.equal((oneYearFromNow - now) / 1000.0);
});
it('Invalid duration returns 0', () => {
expect(
Utilities.getDurationAsSeconds('T1M10S', scorm2004_regex.CMITimespan)
).to.equal(0);
});
it('Empty duration returns 0', () => {
expect(
Utilities.getDurationAsSeconds(null, scorm2004_regex.CMITimespan)
).to.equal(0);
});
});
});