data-quality: schedule: Check scheduleEventType is a valid event subClass

Author: Jared Parnell

src/errors/validation-error-type.js

@@ -43,6 +43,7 @@ const ValidationErrorType = {
   BELOW_MIN_VALUE_INCLUSIVE: 'below_min_value_inclusive',
   URI_TEMPLATE_MISSING_PLACEHOLDER: 'uri_template_missing_placeholder',
   EXCEPTION_DATES_NOT_IN_SCHEDULE: 'exception_dates_not_in_schedule',
+  INVALID_SCHEDULE_EVENT_TYPE: 'invalid_schedule_event_type',
 };
 
 module.exports = Object.freeze(ValidationErrorType);

src/rules/data-quality/scheduleeventype-is-valid-event-subclass-rule-spec.js

@@ -0,0 +1,118 @@
+const ScheduleEventTypeIsEventSubclass = require('./scheduleeventype-is-valid-event-subclass-rule');
+const Model = require('../../classes/model');
+const ModelNode = require('../../classes/model-node');
+const ValidationErrorType = require('../../errors/validation-error-type');
+const ValidationErrorSeverity = require('../../errors/validation-error-severity');
+
+describe('ScheduleEventTypeIsEventSubclass', () => {
+  let rule;
+
+  beforeEach(() => {
+    rule = new ScheduleEventTypeIsEventSubclass();
+  });
+
+  it('should target models of any type', () => {
+    const model = new Model({
+      type: 'Schedule',
+    }, 'latest');
+
+    const isTargeted = rule.isModelTargeted(model);
+    expect(isTargeted).toBe(true);
+  });
+
+  it('should return no errors if scheduleEventType is a subClass of Event', async () => {
+    const model = new Model({
+      type: 'Schedule',
+      subClassGraph: ['#Event'],
+    }, 'latest');
+
+    const data = {
+      scheduledEventType: 'ScheduledSession',
+    };
+
+    const nodeToTest = new ModelNode(
+      '$',
+      data,
+      null,
+      model,
+    );
+    const errors = await rule.validate(nodeToTest);
+
+    expect(errors.length).toBe(0);
+  });
+
+  it('should return errors if scheduleEventType is not a subClass of Event', async () => {
+    const model = new Model({
+      type: 'Schedule',
+      subClassGraph: ['#Event'],
+    }, 'latest');
+
+    const data = {
+      scheduledEventType: 'Place',
+    };
+
+    const nodeToTest = new ModelNode(
+      '$',
+      data,
+      null,
+      model,
+    );
+    const errors = await rule.validate(nodeToTest);
+
+    expect(errors.length).toBe(1);
+    for (const error of errors) {
+      expect(error.type).toBe(ValidationErrorType.INVALID_SCHEDULE_EVENT_TYPE);
+      expect(error.severity).toBe(ValidationErrorSeverity.FAILURE);
+    }
+  });
+
+  it('should return errors if scheduleEventType does not have a valid model', async () => {
+    const model = new Model({
+      type: 'Schedule',
+      subClassGraph: ['#Event'],
+    }, 'latest');
+
+    const data = {
+      scheduledEventType: 'Banana',
+    };
+
+    const nodeToTest = new ModelNode(
+      '$',
+      data,
+      null,
+      model,
+    );
+    const errors = await rule.validate(nodeToTest);
+
+    expect(errors.length).toBe(1);
+    for (const error of errors) {
+      expect(error.type).toBe(ValidationErrorType.INVALID_SCHEDULE_EVENT_TYPE);
+      expect(error.severity).toBe(ValidationErrorSeverity.FAILURE);
+    }
+  });
+
+  it('should return errors if scheduleEventType does not have a subClassGraph', async () => {
+    const model = new Model({
+      type: 'Schedule',
+      subClassGraph: ['#Event'],
+    }, 'latest');
+
+    const data = {
+      scheduledEventType: 'DownloadData',
+    };
+
+    const nodeToTest = new ModelNode(
+      '$',
+      data,
+      null,
+      model,
+    );
+    const errors = await rule.validate(nodeToTest);
+
+    expect(errors.length).toBe(1);
+    for (const error of errors) {
+      expect(error.type).toBe(ValidationErrorType.INVALID_SCHEDULE_EVENT_TYPE);
+      expect(error.severity).toBe(ValidationErrorSeverity.FAILURE);
+    }
+  });
+});

src/rules/data-quality/scheduleeventype-is-valid-event-subclass-rule.js

@@ -0,0 +1,82 @@
+const Rule = require('../rule');
+const DataModelHelper = require('../../helpers/data-model');
+const ValidationErrorType = require('../../errors/validation-error-type');
+const ValidationErrorCategory = require('../../errors/validation-error-category');
+const ValidationErrorSeverity = require('../../errors/validation-error-severity');
+
+module.exports = class ScheduleEventTypeIsEventSubclass extends Rule {
+  constructor(options) {
+    super(options);
+    this.targetModels = 'Schedule';
+    this.meta = {
+      name: 'ScheduleEventTypeIsEventSubclass',
+      description: 'The `scheduleEventType` in the `Schedule` is not a subclass of `Event`.',
+      tests: {
+        modelNotRecognised: {
+          message: 'The model described by `scheduleEventType` ({{value}}) is not a valid model type. See the [Inheritence Overview](https://developer.openactive.io/publishing-data/data-feeds/types-of-feed#schema-org-type-inheritance-overview) for more information.',
+          sampleValues: {
+            value: 'BigSwimEvent',
+          },
+          category: ValidationErrorCategory.CONFORMANCE,
+          severity: ValidationErrorSeverity.FAILURE,
+          type: ValidationErrorType.INVALID_SCHEDULE_EVENT_TYPE,
+        },
+        modelHasNoSubClassGraph: {
+          message: 'The model described by `scheduleEventType` ({{value}}) does not list any subclass types. See the [Inheritence Overview](https://developer.openactive.io/publishing-data/data-feeds/types-of-feed#schema-org-type-inheritance-overview) for more information.',
+          sampleValues: {
+            value: 'DownloadData',
+          },
+          category: ValidationErrorCategory.CONFORMANCE,
+          severity: ValidationErrorSeverity.FAILURE,
+          type: ValidationErrorType.INVALID_SCHEDULE_EVENT_TYPE,
+        },
+        modelIsNotEventSubClass: {
+          message: 'The `scheduleEventType` ({{value}}) in `Schedule` does not inherit from `Event`. See the [Inheritence Overview](https://developer.openactive.io/publishing-data/data-feeds/types-of-feed#schema-org-type-inheritance-overview) for more information.',
+          sampleValues: {
+            value: 'ScheduledSession',
+          },
+          category: ValidationErrorCategory.CONFORMANCE,
+          severity: ValidationErrorSeverity.FAILURE,
+          type: ValidationErrorType.INVALID_SCHEDULE_EVENT_TYPE,
+        },
+      },
+    };
+  }
+
+  validateModel(node) {
+    const errors = [];
+    let model;
+    let errorCondition;
+    const scheduledEventType = node.getValue('scheduledEventType');
+
+    try {
+      model = DataModelHelper.loadModel(scheduledEventType, 'latest');
+    } catch (error) {
+      model = undefined;
+    }
+
+    if (typeof model === 'undefined') {
+      errorCondition = 'modelNotRecognised';
+    } else if (typeof model.subClassGraph === 'undefined') {
+      errorCondition = 'modelHasNoSubClassGraph';
+    } else if (model.subClassGraph.indexOf('#Event') === -1) {
+      errorCondition = 'modelIsNotEventSubClass';
+    }
+
+    if (errorCondition === 'modelIsNotEventSubClass') {
+      errors.push(
+        this.createError(
+          errorCondition,
+          {
+            value: scheduledEventType,
+            path: node.getPath('scheduledEventType'),
+          },
+        ),
+      );
+    } else {
+      return [];
+    }
+
+    return errors;
+  }
+};