fix(context.team): Validate null team values

Author: ht2

src/helpers/getUsedIfis.ts

@@ -1,4 +1,7 @@
+import { isPlainObject } from 'lodash';
+
 export default (data: any): string[] => {
+  if (!isPlainObject(data)) return [];
   const ifis = ['mbox', 'mbox_sha1sum', 'openid', 'account'];
   const keys = Object.keys(data);
   return ifis.filter(ifi => keys.includes(ifi));

src/helpers/statementRules.ts

@@ -1,10 +1,11 @@
 import { composeRules, Rule } from 'rulr';
 import ContextPropWarning from '../warnings/ContextPropWarning';
 import VoidWarning from '../warnings/VoidWarning';
-import { isObject } from 'lodash';
+import { isObject, isPlainObject } from 'lodash';
 
 export default composeRules([
   (data, path) => {
+    if (!isPlainObject(data)) return [];
     const objectIsActivity = (
       isObject(data.object) &&
       (data.object.objectType === 'Activity' || data.object.objectType === undefined)
@@ -17,6 +18,7 @@ export default composeRules([
     return invalidContext ? [new ContextPropWarning(data, path)] : [];
   },
   (data, path) => {
+    if (!isPlainObject(data)) return [];
     const voidVerbId = 'http://adlnet.gov/expapi/verbs/voided';
     const objectIsStatementRef = (
       data.object && data.object.objectType === 'StatementRef'

src/schemaRules/agent.ts

@@ -1,12 +1,15 @@
 import { composeRules, restrictToSchema, Rule } from 'rulr';
 import agentSchema from '../helpers/agentSchema';
 import getUsedIfis from '../helpers/getUsedIfis';
+import { isPlainObject } from 'lodash';
+
 import IfiCountWarning from '../warnings/IfiCountWarning';
 import NoIfiWarning from '../warnings/NoIfiWarning';
 
 export default composeRules([
   restrictToSchema(agentSchema),
   (data, path) => {
+    if (!isPlainObject(data)) return [];
     const usedIfis = getUsedIfis(data);
     if (usedIfis.length > 1) return [new IfiCountWarning(data, path, usedIfis)];
     if (usedIfis.length === 0) return [new NoIfiWarning(data, path)];

src/schemaRules/definition.ts

@@ -1,6 +1,7 @@
 import {
   restrictToSchema, restrictToCollection, composeRules, optional, Rule, Warning
 } from 'rulr';
+import { isPlainObject } from 'lodash';
 import InvalidComponentsWarning from '../warnings/InvalidComponentsWarning';
 import MissingInteractionTypeWarning from '../warnings/MissingInteractionTypeWarning';
 import {
@@ -56,7 +57,7 @@ export default composeRules([
     steps: optional(restrictToCollection(() => interactionComponent)),
   }),
   (data, path): Warning[] => {
-    if (data == null || data.constructor !== Object) return [];
+    if (!isPlainObject(data)) return [];
     const interactionType = data.interactionType;
     const unsupportedComponents = getUnsupportedComponents(interactionType);
     const invalidComponents = unsupportedComponents.filter(
@@ -68,7 +69,7 @@ export default composeRules([
     return [];
   },
   (data, path): Warning[] => {
-    if (data == null || data.constructor !== Object) return [];
+    if (!isPlainObject(data)) return [];
     const missingInteractionType = (
       data.correctResponsesPattern !== undefined &&
       data.interactionType === undefined

src/schemaRules/group.ts

@@ -5,6 +5,7 @@ import {
   optional,
   Rule,
 } from 'rulr';
+import { isPlainObject } from 'lodash';
 import agentSchema from '../helpers/agentSchema';
 import getUsedIfis from '../helpers/getUsedIfis';
 import restrictToValue from '../helpers/restrictToValue';
@@ -18,6 +19,7 @@ export default composeRules([
     member: optional(restrictToCollection(() => actor)),
   })),
   (data, path) => {
+    if (!isPlainObject(data)) return [];
     const usedIfis = getUsedIfis(data);
     const usedMember = (
       data.member != null &&

src/schemaRules/groupAuthority.ts

@@ -3,15 +3,15 @@ import { actor } from '../factory';
 import MembersTypeWarning from '../warnings/MembersTypeWarning';
 import MembersLengthWarning from '../warnings/MembersLengthWarning';
 import restrictToValue from '../helpers/restrictToValue';
-import { isObject } from 'lodash';
+import { isPlainObject } from 'lodash';
 
 export default composeRules([
   restrictToSchema({
     objectType: optional(restrictToValue('Group')),
     member: optional(restrictToCollection(() => actor))
   }),
   (data, path) => {
-    if (!isObject(data)) return [];
+    if (!isPlainObject(data)) return [];
     const members = Array.isArray(data.member) ? data.member.length : 0;
 
     if (members !== 2) return [new MembersTypeWarning(data, path)];

src/schemaRules/result.ts

@@ -7,25 +7,29 @@ import {
   duration,
   extensions,
 } from '../factory';
+import { isPlainObject } from 'lodash';
 import RawLessThanMinWarning from '../warnings/RawLessThanMinWarning';
 import RawMoreThanMaxWarning from '../warnings/RawMoreThanMaxWarning';
 import MinMoreThanMaxWarning from '../warnings/MinMoreThanMaxWarning';
 
 const checkRawMoreThanMin = (data: any, path: string[]): Warning[] => {
+  if (!isPlainObject(data)) return [];
   if (data.raw !== undefined && data.min !== undefined && data.raw < data.min) {
     return [new RawLessThanMinWarning(data, path, data.raw, data.min)];
   }
   return [];
 };
 
 const checkRawLessThanMax = (data: any, path: string[]): Warning[] => {
+  if (!isPlainObject(data)) return [];
   if (data.raw !== undefined && data.max !== undefined && data.raw > data.max) {
     return [new RawMoreThanMaxWarning(data, path, data.raw, data.max)];
   }
   return [];
 };
 
 const checkMinLessThanMax = (data: any, path: string[]): Warning[] => {
+  if (!isPlainObject(data)) return [];
   if (data.min !== undefined && data.max !== undefined && data.min > data.max) {
     return [new MinMoreThanMaxWarning(data, path, data.min, data.max)];
   }

src/schemaRules/subStatement.ts

@@ -3,13 +3,15 @@ import statementSchema from '../helpers/statementSchema';
 import statementRules from '../helpers/statementRules';
 import restrictToValue from '../helpers/restrictToValue';
 import SubStatementWarning from '../warnings/SubStatementWarning';
+import { isPlainObject } from 'lodash';
 
 export default composeRules([
   restrictToSchema(Object.assign({}, statementSchema, {
     objectType: optional(restrictToValue('SubStatement')),
   })),
   statementRules,
   (data, path) => {
+    if (!isPlainObject(data)) return [];
     const objectIsSubStatement = (
       data.object && data.object.objectType === 'SubStatement'
     );

src/tests/schemaRules/context.ts

@@ -36,6 +36,7 @@ const validData = {
 
 export default (test: Test) => {
   itsInvalid(10, 'not an object', test);
+  itsInvalid({ team: null }, 'team must be an object', test);
   describeOptionalProp('registration', uuid, validData, test);
   describeOptionalProp('instructor', actor, validData, test);
   describeOptionalProp('team', (test: Test) => {