Serve minimal Thing Description - closes #4

Author: benfrancis

src/server.js

@@ -19,7 +19,13 @@ class ThingServer {
 
     this.app.get('/properties/:name', async (request, response) => {
       const name = request.params.name;
-      const value = await this.thing.readProperty(name);
+      let value;
+      try {
+        value = await this.thing.readProperty(name);
+      } catch {
+        response.status(404).send();
+        return;
+      }
       response.status(200).json(value);
     });
   }

src/thing.js

@@ -1,19 +1,130 @@
+import ValidationError from './validation-error.js';
+
 /**
  * Thing.
  *
  * Represents a W3C WoT Web Thing.
  */
 class Thing {
+  DEFAULT_CONTEXT = 'https://www.w3.org/2022/wot/td/v1.1';
+
   propertyReadHandlers = new Map();
 
   /**
+   * Construct Thing from partial Thing Description.
    *
-   * @param {Object} partialTD A partial Thing Description two which Forms
-   *   will be added.
+   * @param {Record<string, any>} partialTD A partial Thing Description
+   *   to which Forms will be added.
    */
   constructor(partialTD) {
-    // TODO: Parse and validate TD.
-    this.partialTD = partialTD;
+    // Create an empty validation error to collect errors during parsing.
+    let validationError = new ValidationError([]);
+
+    // Parse @context member
+    try {
+      this.parseContextMember(partialTD['@context']);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        validationError.validationErrors.push(...error.validationErrors);
+      } else {
+        throw error;
+      }
+    }
+
+    // Parse title member
+    try {
+      this.parseTitleMember(partialTD.title);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        validationError.validationErrors.push(...error.validationErrors);
+      } else {
+        throw error;
+      }
+    }
+
+    // Hard code the nosec security scheme for now
+    this.securityDefinitions = {
+      nosec_sc: {
+        scheme: 'nosec',
+      },
+    };
+    this.security = 'nosec_sc';
+  }
+
+  /**
+   * Parse the @context member of a Thing Description.
+   *
+   * @param {any} context The @context, if any, provided in the partialTD.
+   * @throws {ValidationError} A validation error.
+   */
+  parseContextMember(context) {
+    // If no @context provided then set it to the default
+    if (context === undefined) {
+      this.context = this.DEFAULT_CONTEXT;
+      return;
+    }
+
+    // If @context is a string but not the default then turn it into an Array
+    // and add the default as well
+    if (typeof context === 'string') {
+      if (context == this.DEFAULT_CONTEXT) {
+        this.context = context;
+        return;
+      } else {
+        this.context = new Array();
+        this.context.push(context);
+        this.context.push(this.DEFAULT_CONTEXT);
+      }
+      return;
+    }
+
+    // If @context is provided and it's an array but doesn't contain the default,
+    // then add the default
+    if (Array.isArray(context)) {
+      // TODO: Check that members of the Array are valid
+      this.context = context;
+      if (!this.context.includes(this.DEFAULT_CONTEXT)) {
+        this.context.push(this.DEFAULT_CONTEXT);
+      }
+      return;
+    }
+
+    // If @context is set but it's not a string or Array then it's invalid
+    throw new ValidationError([
+      {
+        field: 'title',
+        description: 'context member is set but is not a string or Array',
+      },
+    ]);
+  }
+
+  /**
+   * Parse the title member of a Thing Description.
+   *
+   * @param {string} title The title provided in the partialTD.
+   * @throws {ValidationError} A validation error.
+   */
+  parseTitleMember(title) {
+    // Require the user to provide a title
+    if (!title) {
+      throw new ValidationError([
+        {
+          field: '(root)',
+          description: 'Mandatory title member not provided',
+        },
+      ]);
+    }
+
+    if (typeof title !== 'string') {
+      throw new ValidationError([
+        {
+          field: 'title',
+          description: 'title member is not a string',
+        },
+      ]);
+    }
+
+    this.title = title;
   }
 
   /**
@@ -22,8 +133,13 @@ class Thing {
    * @returns {Object} A complete Thing Description for the Thing.
    */
   getThingDescription() {
-    // TODO: Add forms etc.
-    return this.partialTD;
+    const thingDescription = {
+      '@context': this.context,
+      title: this.title,
+      securityDefinitions: this.securityDefinitions,
+      security: this.security,
+    };
+    return thingDescription;
   }
 
   /**

src/validation-error.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * Validation Error.
+ *
+ * An error containing one or more validation errors following the format
+ * described in the W3C WoT Discovery specification
+ * (https://www.w3.org/TR/wot-discovery/#exploration-directory-api-things-validation)
+ */
+class ValidationError extends Error {
+  /**
+   * Constructor
+   *
+   * @param {Array<Object>} validationErrors A list of validation errors, e.g.
+   *  [
+   *    {
+   *      "field": "(root)",
+   *      "description": "security is required"
+   *    },
+   *    {
+   *      "field": "properties.status.forms.0.href",
+   *      "description": "Invalid type. Expected: string, given: integer"
+   *    }
+   *  ]
+   * @param  {...any} params Other Error parameters.
+   */
+  constructor(validationErrors, ...params) {
+    super(...params);
+    this.validationErrors = validationErrors;
+  }
+}
+
+export default ValidationError;

test/server.test.js

@@ -22,6 +22,7 @@ describe('ThingServer', () => {
     const thing = new Thing(partialTD);
     thing.setPropertyReadHandler('on', async () => true);
     server = new ThingServer(thing);
+    // Listen on a random available port to avoid port conflicts
     await new Promise((resolve) => {
       server.server = server.app.listen(0, () => {
         const port = server.server.address().port;
@@ -41,8 +42,11 @@ describe('ThingServer', () => {
       assert.strictEqual(response.status, 200);
       const td = await response.json();
       assert.strictEqual(td.title, 'Test Lamp');
-      assert.strictEqual(td.description, 'A test lamp');
-      assert.ok(td.properties);
+      assert.equal(td['@context'], 'https://www.w3.org/2022/wot/td/v1.1');
+      assert.deepEqual(td.securityDefinitions, {
+        nosec_sc: { scheme: 'nosec' },
+      });
+      assert.equal(td.security, 'nosec_sc');
     });
   });
 
@@ -54,4 +58,11 @@ describe('ThingServer', () => {
       assert.strictEqual(value, true);
     });
   });
+
+  describe('GET /properties/:invalidname', () => {
+    it('should return 404 for an invalid property name', async () => {
+      const response = await fetch(baseUrl + '/properties/foo');
+      assert.strictEqual(response.status, 404);
+    });
+  });
 });

test/thing.test.js

@@ -15,17 +15,27 @@ describe('Thing', () => {
   };
 
   describe('constructor', () => {
-    it('should store the partial Thing Description', () => {
+    it('should parse and populate mandatory members of the Thing', () => {
       const thing = new Thing(partialTD);
-      assert.deepStrictEqual(thing.partialTD, partialTD);
+      assert.equal(thing.context, 'https://www.w3.org/2022/wot/td/v1.1');
+      assert.equal(thing.title, partialTD.title);
+      assert.deepEqual(thing.securityDefinitions, {
+        nosec_sc: { scheme: 'nosec' },
+      });
+      assert.equal(thing.security, 'nosec_sc');
     });
   });
 
   describe('getThingDescription', () => {
     it('should return the Thing Description', () => {
       const thing = new Thing(partialTD);
       const td = thing.getThingDescription();
-      assert.deepStrictEqual(td, partialTD);
+      assert.deepEqual(td, {
+        '@context': 'https://www.w3.org/2022/wot/td/v1.1',
+        title: 'Test Thing',
+        securityDefinitions: { nosec_sc: { scheme: 'nosec' } },
+        security: 'nosec_sc',
+      });
     });
   });