iotagent-node-lib 2.23.0 → 2.24.0

package/test/unit/ngsi-ld/ngsiService/unsupported-endpoints-test.js

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2022 Telefonica Investigación y Desarrollo, S.A.U
+ *
+ * This file is part of fiware-iotagent-lib
+ *
+ * fiware-iotagent-lib is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * fiware-iotagent-lib is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public
+ * License along with fiware-iotagent-lib.
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ * For those usages not covered by the GNU Affero General Public License
+ * please contact with::daniel.moranjimenez@telefonica.com
+ *
+ * Modified by: Jason Fox - FIWARE Foundation
+ */
+
+/* eslint-disable no-unused-vars */
+
+const iotAgentLib = require('../../../../lib/fiware-iotagent-lib');
+const utils = require('../../../tools/utils');
+const request = utils.request;
+const should = require('should');
+
+let contextBrokerMock;
+const iotAgentConfig = {
+    contextBroker: {
+        host: '192.168.1.1',
+        port: '1026',
+        ngsiVersion: 'ld',
+        jsonLdContext: 'http://context.json-ld'
+    },
+    server: {
+        port: 4041
+    },
+    types: {},
+    service: 'smartgondor',
+    subservice: 'gardens',
+    providerUrl: 'http://smartgondor.com'
+};
+
+describe('NGSI-LD - Unsupported Endpoints', function () {
+    beforeEach(function (done) {
+        iotAgentLib.activate(iotAgentConfig, function () {
+            iotAgentLib.clearAll(function () {
+                done();
+            });
+        });
+    });
+
+    afterEach(function (done) {
+        iotAgentLib.clearAll(function () {
+            iotAgentLib.deactivate(done);
+        });
+    });
+
+    describe('When accessing an Unsupported Endpoint', function () {
+        it('GET /entities should return a valid NSGI-LD error message', function (done) {
+            const options = {
+                url: 'http://localhost:' + iotAgentConfig.server.port + '/ngsi-ld/v1/entities',
+                method: 'GET'
+            };
+            request(options, function (error, response, body) {
+                response.statusCode.should.equal(501);
+                done();
+            });
+        });
+        it('POST /entities should return a valid NSGI-LD error message', function (done) {
+            const options = {
+                url: 'http://localhost:' + iotAgentConfig.server.port + '/ngsi-ld/v1/entities',
+                method: 'POST',
+                json: {}
+            };
+            request(options, function (error, response, body) {
+                response.statusCode.should.equal(501);
+                done();
+            });
+        });
+        it('DELETE /entities/<entity-id> should return a valid NSGI-LD error message', function (done) {
+            const options = {
+                url: 'http://localhost:' + iotAgentConfig.server.port + '/ngsi-ld/v1/entities/urn:ngsi-ld:entity',
+                method: 'DELETE'
+            };
+            request(options, function (error, response, body) {
+                response.statusCode.should.equal(501);
+                done();
+            });
+        });
+        it('DELETE /entities/<entity-id>/attrs/<attr-name> should return a valid NSGI-LD error message', function (done) {
+            const options = {
+                url:
+                    'http://localhost:' +
+                    iotAgentConfig.server.port +
+                    '/ngsi-ld/v1/entities/urn:ngsi-ld:entity/attrs/att',
+                method: 'DELETE'
+            };
+            request(options, function (error, response, body) {
+                response.statusCode.should.equal(501);
+                done();
+            });
+        });
+    });
+});

package/test/unit/ngsi-ld/plugins/bidirectional-plugin_test.js

@@ -264,6 +264,227 @@ describe('NGSI-LD - Bidirectional data plugin', function () {
         });
     });
 
+    describe('When a notification with metadata arrives for a bidirectional attribute', function () {
+        const notificationOptions = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/notify',
+            method: 'POST',
+            json: utils.readExampleFile(
+                './test/unit/ngsi-ld/examples/subscriptionRequests/bidirectionalNotificationWithMetadata.json'
+            ),
+            headers: {
+                'fiware-service': 'smartgondor',
+                'fiware-servicepath': '/gardens'
+            }
+        };
+        let executedHandler = false;
+
+        beforeEach(function () {
+            contextBrokerMock
+                .matchHeader('fiware-service', 'smartgondor')
+                .post(
+                    '/ngsi-ld/v1/subscriptions/',
+                    utils.readExampleFile(
+                        './test/unit/ngsi-ld/examples/subscriptionRequests/bidirectionalSubscriptionRequest.json'
+                    )
+                )
+                .reply(201, null, { Location: '/ngsi-ld/v1/subscriptions/51c0ac9ed714fb3b37d7d5a8' });
+
+            contextBrokerMock
+                .matchHeader('fiware-service', 'smartgondor')
+                .post(
+                    '/ngsi-ld/v1/entityOperations/upsert/',
+                    utils.readExampleFile('./test/unit/ngsi-ld/examples/contextRequests/createBidirectionalDevice.json')
+                )
+                .reply(204);
+        });
+
+        afterEach(function () {
+            iotAgentLib.setNotificationHandler();
+        });
+
+        it('should execute the original handler', function (done) {
+            function mockedHandler(device, notification, callback) {
+                notification[0].name.should.equal('location');
+                notification[0].value.should.equal('12.4, -9.6');
+                notification[0].metadata.qos.value.should.equal(1);
+                executedHandler = true;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    executedHandler.should.equal(true);
+                    contextBrokerMock.done();
+                    done();
+                });
+            });
+        });
+
+        it('should return a 200 OK', function (done) {
+            function mockedHandler(device, notification, callback) {
+                executedHandler = true;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    response.statusCode.should.equal(200);
+                    contextBrokerMock.done();
+                    done();
+                });
+            });
+        });
+
+        it('should return the transformed values', function (done) {
+            let transformedHandler = false;
+
+            function mockedHandler(device, values, callback) {
+                let latitudeFound = false;
+                let longitudeFound = false;
+
+                for (let i = 0; i < values.length; i++) {
+                    if (values[i].name === 'latitude' && values[i].type === 'string' && values[i].value === '-9.6') {
+                        latitudeFound = true;
+                    }
+
+                    if (values[i].name === 'longitude' && values[i].type === 'string' && values[i].value === '12.4') {
+                        longitudeFound = true;
+                    }
+                }
+
+                transformedHandler = values.length >= 2 && longitudeFound && latitudeFound;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    contextBrokerMock.done();
+                    transformedHandler.should.equal(true);
+                    done();
+                });
+            });
+        });
+    });
+
+    describe('When a sequential notification with datasetId arrives for a bidirectional attribute', function () {
+        const notificationOptions = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/notify',
+            method: 'POST',
+            json: utils.readExampleFile(
+                './test/unit/ngsi-ld/examples/subscriptionRequests/bidirectionalNotificationWithDatasetId.json'
+            ),
+            headers: {
+                'fiware-service': 'smartgondor',
+                'fiware-servicepath': '/gardens'
+            }
+        };
+        let executedHandler = false;
+
+        beforeEach(function () {
+            contextBrokerMock
+                .matchHeader('fiware-service', 'smartgondor')
+                .post(
+                    '/ngsi-ld/v1/subscriptions/',
+                    utils.readExampleFile(
+                        './test/unit/ngsi-ld/examples/subscriptionRequests/bidirectionalSubscriptionRequest.json'
+                    )
+                )
+                .reply(201, null, { Location: '/ngsi-ld/v1/subscriptions/51c0ac9ed714fb3b37d7d5a8' });
+
+            contextBrokerMock
+                .matchHeader('fiware-service', 'smartgondor')
+                .post(
+                    '/ngsi-ld/v1/entityOperations/upsert/',
+                    utils.readExampleFile('./test/unit/ngsi-ld/examples/contextRequests/createBidirectionalDevice.json')
+                )
+                .reply(204);
+        });
+
+        afterEach(function () {
+            iotAgentLib.setNotificationHandler();
+        });
+
+        it('should execute the original handler', function (done) {
+            function mockedHandler(device, notification, callback) {
+                notification[0].name.should.equal('location');
+                notification[0].value.should.equal('12.4, -9.6');
+                notification[0].datasetId.should.equal('urn:ngsi-ld:Property:do-this');
+
+                notification[1].name.should.equal('location');
+                notification[1].value.should.equal('6, 10');
+                notification[1].datasetId.should.equal('urn:ngsi-ld:Property:then-do-this');
+
+                executedHandler = true;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    executedHandler.should.equal(true);
+                    contextBrokerMock.done();
+                    done();
+                });
+            });
+        });
+
+        it('should return a 200 OK', function (done) {
+            function mockedHandler(device, notification, callback) {
+                executedHandler = true;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    response.statusCode.should.equal(200);
+                    contextBrokerMock.done();
+                    done();
+                });
+            });
+        });
+
+        it('should return the transformed values', function (done) {
+            let transformedHandler = false;
+
+            function mockedHandler(device, values, callback) {
+                let latitudeFound = false;
+                let longitudeFound = false;
+
+                for (let i = 0; i < values.length; i++) {
+                    if (values[i].name === 'latitude' && values[i].type === 'string' && values[i].value === '-9.6') {
+                        latitudeFound = true;
+                    }
+
+                    if (values[i].name === 'longitude' && values[i].type === 'string' && values[i].value === '12.4') {
+                        longitudeFound = true;
+                    }
+                }
+
+                transformedHandler = values.length >= 2 && longitudeFound && latitudeFound;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    contextBrokerMock.done();
+                    transformedHandler.should.equal(true);
+                    done();
+                });
+            });
+        });
+    });
+
     describe('When a new Group provisioning request arrives with bidirectional attributes', function () {
         const provisionGroup = {
             url: 'http://localhost:' + iotAgentConfig.server.port + '/iot/services',

package/test/unit/ngsiv2/examples/subscriptionRequests/bidirectionalNotificationWithMetadata.json

@@ -0,0 +1,19 @@
+{
+  "subscriptionId": "51c0ac9ed714fb3b37d7d5a8",
+  "data": [
+    {
+        "location": {
+            "type": "geo:point",
+            "value": "12.4, -9.6",
+            "metadata": {
+              "qos": {
+                "type": "Number",
+                "value": 1
+              }
+            }
+          },
+        "type": "TheLightType",
+        "id": "TheFirstLight"
+    }
+  ]
+}

package/test/unit/ngsiv2/lazyAndCommands/command-test.js

@@ -311,4 +311,110 @@ describe('NGSI-v2 - Command functionalities', function () {
             });
         });
     });
+
+    describe('When a command update with metadata arrives to the IoT Agent as Context Provider', function () {
+        const options = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/v2/op/update',
+            method: 'POST',
+            json: {
+                actionType: 'update',
+                entities: [
+                    {
+                        id: 'Robot:r2d2',
+                        type: 'Robot',
+                        position: {
+                            type: 'Array',
+                            value: '[28, -104, 23]',
+                            metadata: {
+                                qos: 1
+                            }
+                        }
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': 'smartgondor',
+                'fiware-servicepath': 'gardens'
+            }
+        };
+
+        beforeEach(function (done) {
+            iotAgentLib.register(device3, function (error) {
+                done();
+            });
+        });
+
+        it('should call the client handler once including metadata', function (done) {
+            let handlerCalled = 0;
+
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                id.should.equal(device3.type + ':' + device3.id);
+                type.should.equal(device3.type);
+                attributes[0].name.should.equal('position');
+                attributes[0].value.should.equal('[28, -104, 23]');
+                attributes[0].metadata.qos.should.equal(1);
+                handlerCalled++;
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    ]
+                });
+            });
+
+            request(options, function (error, response, body) {
+                should.not.exist(error);
+                handlerCalled.should.equal(1);
+                done();
+            });
+        });
+        it('should create the attribute with the "_status" prefix in the Context Broker', function (done) {
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    ]
+                });
+            });
+
+            request(options, function (error, response, body) {
+                should.not.exist(error);
+                done();
+            });
+        });
+        it('should create the attribute with the "_status" prefix in the Context Broker', function (done) {
+            let serviceAndSubservice = false;
+
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                serviceAndSubservice = service === 'smartgondor' && subservice === 'gardens';
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    ]
+                });
+            });
+
+            request(options, function (error, response, body) {
+                serviceAndSubservice.should.equal(true);
+                done();
+            });
+        });
+    });
 });

package/test/unit/ngsiv2/plugins/bidirectional-plugin_test.js

@@ -237,6 +237,120 @@ describe('NGSI-v2 - Bidirectional data plugin', function () {
             });
         });
 
+        it('should return the transformed values', function (done) {
+            let transformedHandler = false;
+
+            function mockedHandler(device, values, callback) {
+
+                let latitudeFound = false;
+                let longitudeFound = false;
+
+                for (let i = 0; i < values.length; i++) {
+                    if (values[i].name === 'latitude' && values[i].type === 'string' && values[i].value === '-9.6') {
+                        latitudeFound = true;
+                    }
+
+                    if (values[i].name === 'longitude' && values[i].type === 'string' && values[i].value === '12.4') {
+                        longitudeFound = true;
+                    }
+                }
+
+                transformedHandler = values.length >= 2 && longitudeFound && latitudeFound;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    contextBrokerMock.done();
+                    transformedHandler.should.equal(true);
+                    done();
+                });
+            });
+        });
+    });
+
+
+    describe('When a notification with metadata arrives for a bidirectional attribute', function () {
+        const notificationOptions = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/notify',
+            method: 'POST',
+            json: utils.readExampleFile(
+                './test/unit/ngsiv2/examples/subscriptionRequests/bidirectionalNotificationWithMetadata.json'
+            ),
+            headers: {
+                'fiware-service': 'smartgondor',
+                'fiware-servicepath': '/gardens'
+            }
+        };
+        let executedHandler = false;
+
+        beforeEach(function () {
+            contextBrokerMock
+                .matchHeader('fiware-service', 'smartgondor')
+                .matchHeader('fiware-servicepath', '/gardens')
+                .post(
+                    '/v2/subscriptions',
+                    utils.readExampleFile(
+                        './test/unit/ngsiv2/examples/subscriptionRequests/bidirectionalSubscriptionRequest.json'
+                    )
+                )
+                .reply(201, null, { Location: '/v2/subscriptions/51c0ac9ed714fb3b37d7d5a8' });
+
+            contextBrokerMock
+                .matchHeader('fiware-service', 'smartgondor')
+                .matchHeader('fiware-servicepath', '/gardens')
+                .post(
+                    '/v2/entities?options=upsert',
+                    utils.readExampleFile('./test/unit/ngsiv2/examples/contextRequests/createBidirectionalDevice.json')
+                )
+                .reply(204);
+        });
+
+        afterEach(function () {
+            iotAgentLib.setNotificationHandler();
+        });
+
+        it('should execute the original handler', function (done) {
+            function mockedHandler(device, notification, callback) {
+
+                notification[0].name.should.equal('location');
+                notification[0].value.should.equal('12.4, -9.6');
+                notification[0].metadata.qos.value.should.equal(1);
+
+                executedHandler = true;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    executedHandler.should.equal(true);
+                    contextBrokerMock.done();
+                    done();
+                });
+            });
+        });
+
+        it('should return a 200 OK', function (done) {
+            function mockedHandler(device, notification, callback) {
+                executedHandler = true;
+                callback();
+            }
+
+            iotAgentLib.setNotificationHandler(mockedHandler);
+
+            request(options, function (error, response, body) {
+                request(notificationOptions, function (error, response, body) {
+                    response.statusCode.should.equal(200);
+                    contextBrokerMock.done();
+                    done();
+                });
+            });
+        });
+
         it('should return the transformed values', function (done) {
             let transformedHandler = false;
 
@@ -270,6 +384,7 @@ describe('NGSI-v2 - Bidirectional data plugin', function () {
         });
     });
 
+
     describe('When a new Group provisioning request arrives with bidirectional attributes', function () {
         const provisionGroup = {
             url: 'http://localhost:' + iotAgentConfig.server.port + '/iot/services',