iotagent-node-lib 2.23.0 → 2.25.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/ngsi-mixed/provisioning/ngsi-versioning-test.js

@@ -65,7 +65,6 @@ const optionsCreationDefault = {
         services: [
             {
                 apikey: 'default-test',
-                cbroker: 'http://orion:1026',
                 entity_type: 'Device',
                 resource: '/iot/default',
                 attributes: [
@@ -90,7 +89,6 @@ const optionsCreationV2 = {
         services: [
             {
                 apikey: 'v2-test',
-                cbroker: 'http://orion:1026',
                 ngsiVersion: 'v2',
                 entity_type: 'Device',
                 resource: '/iot/v2',
@@ -117,7 +115,6 @@ const optionsCreationLD = {
         services: [
             {
                 apikey: 'ld-test',
-                cbroker: 'http://orion:1026',
                 entity_type: 'Device',
                 ngsiVersion: 'ld',
                 resource: '/iot/ld',

package/test/unit/ngsiv2/examples/contextRequests/updateContextMultientityJexlExpressionPlugin1.json

@@ -0,0 +1,22 @@
+{
+  "actionType":"update",
+  "entities":[
+    {
+    "id":"lightPseudo:id",
+    "type":"Light",
+    "pressure":{
+      "type":"Number",
+      "value":60
+      }
+    },
+    {
+      "id":"Ligth:mymulti",
+      "type":"myType",
+      "pressure":{
+          "type":"Number",
+          "value":90
+        }
+
+    }
+  ]
+}

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/expressions/jexlBasedTransformations-test.js

@@ -437,16 +437,31 @@ describe('Java expression language (JEXL) based transformations plugin', functio
         const values = [
             {
                 name: 'p',
-                type: 'centigrades',
-                value: '52'
+                type: 'Number',
+                value: 1040
             }
         ];
 
-        it('should apply the expression before sending the values', function (done) {
+        beforeEach(function () {
+            nock.cleanAll();
+
+            contextBrokerMock = nock('http://192.168.1.1:1026')
+                .matchHeader('fiware-service', 'smartgondor')
+                .matchHeader('fiware-servicepath', 'gardens')
+                .patch(
+                    '/v2/entities/light1/attrs',
+                    utils.readExampleFile(
+                        './test/unit/ngsiv2/examples/contextRequests/updateContextExpressionPlugin30.json'
+                    )
+                )
+                .query({ type: 'Light' })
+                .reply(204);
+        });
+
+        it('should ignore the expression and send the values', function (done) {
             iotAgentLib.update('light1', 'LightError', '', values, function (error) {
-                should.exist(error);
-                error.name.should.equal('INVALID_EXPRESSION');
-                error.code.should.equal(400);
+                should.not.exist(error);
+                contextBrokerMock.done();
                 done();
             });
         });

package/test/unit/ngsiv2/general/deviceService-test.js

@@ -137,7 +137,7 @@ const groupCreation = {
                 apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732',
                 entity_type: 'TheLightType',
                 trust: '8970A9078A803H3BL98PINEQRW8342HBAMS',
-                cbHost: 'http://unexistentHost:1026',
+                cbHost: 'http://192.168.1.1:1026',
                 commands: [],
                 lazy: [],
                 attributes: [
@@ -187,7 +187,7 @@ describe('NGSI-v2 - Device Service: utils', function () {
             // This mock does not check the payload since the aim of the test is not to verify
             // device provisioning functionality. Appropriate verification is done in tests under
             // provisioning folder
-            contextBrokerMock = nock('http://unexistenthost:1026')
+            contextBrokerMock = nock('http://192.168.1.1:1026')
                 .matchHeader('fiware-service', 'testservice')
                 .matchHeader('fiware-servicepath', '/testingPath')
                 .post('/v2/entities?options=upsert')
@@ -217,7 +217,7 @@ describe('NGSI-v2 - Device Service: utils', function () {
             // This mock does not check the payload since the aim of the test is not to verify
             // device provisioning functionality. Appropriate verification is done in tests under
             // provisioning folder
-            contextBrokerMock = nock('http://unexistenthost:1026')
+            contextBrokerMock = nock('http://192.168.1.1:1026')
                 .matchHeader('fiware-service', 'testservice')
                 .matchHeader('fiware-servicepath', '/testingPath')
                 .post('/v2/entities?options=upsert')
@@ -229,32 +229,34 @@ describe('NGSI-v2 - Device Service: utils', function () {
         });
 
         it('should register the device and return it', function (done) {
-            iotAgentLib.retrieveDevice('UNEXISTENT_DEV', '801230BJKL23Y9090DSFL123HJK09H324HV8732', function (
-                error,
-                device
-            ) {
-                should.not.exist(error);
-                should.exist(device);
+            iotAgentLib.retrieveDevice(
+                'UNEXISTENT_DEV',
+                '801230BJKL23Y9090DSFL123HJK09H324HV8732',
+                function (error, device) {
+                    should.not.exist(error);
+                    should.exist(device);
 
-                device.id.should.equal('UNEXISTENT_DEV');
-                should.exist(device.protocol);
-                device.protocol.should.equal('MQTT_UL');
-                done();
-            });
+                    device.id.should.equal('UNEXISTENT_DEV');
+                    should.exist(device.protocol);
+                    device.protocol.should.equal('MQTT_UL');
+                    done();
+                }
+            );
         });
     });
 
     describe('When an unexisting device tries to be retrieved for an unexisting APIKey', function () {
         it('should raise an error', function (done) {
-            iotAgentLib.retrieveDevice('UNEXISTENT_DEV_AND_GROUP', 'H2332Y909DSF3H346yh20JK092', function (
-                error,
-                device
-            ) {
-                should.exist(error);
-                error.name.should.equal('DEVICE_GROUP_NOT_FOUND');
-                should.not.exist(device);
-                done();
-            });
+            iotAgentLib.retrieveDevice(
+                'UNEXISTENT_DEV_AND_GROUP',
+                'H2332Y909DSF3H346yh20JK092',
+                function (error, device) {
+                    should.exist(error);
+                    error.name.should.equal('DEVICE_GROUP_NOT_FOUND');
+                    should.not.exist(device);
+                    done();
+                }
+            );
         });
     });
 });

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();
+            });
+        });
+    });
 });