iotagent-node-lib 2.21.0 → 2.24.0

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/lazyAndCommands/polling-commands-test.js

@@ -98,6 +98,18 @@ const iotAgentConfig = {
             lazy: [],
             staticAttributes: [],
             active: []
+        },
+        RobotExp: {
+            commands: [
+                {
+                    name: 'positionExp',
+                    type: 'Array',
+                    expression: '[22]'
+                }
+            ],
+            lazy: [],
+            staticAttributes: [],
+            active: []
         }
     },
     deviceRegistry: {
@@ -122,6 +134,14 @@ const device3 = {
     subservice: 'gardens',
     polling: true
 };
+const device4 = {
+    id: 'r2d4',
+    type: 'RobotExp',
+    service: 'smartgondor',
+    subservice: 'gardens',
+    polling: true,
+    expressionLanguage: 'jexl'
+};
 
 describe('NGSI-v2 - Polling commands', function () {
     beforeEach(function (done) {
@@ -386,3 +406,134 @@ describe('NGSI-v2 - Polling commands', function () {
         });
     });
 });
+
+describe('NGSI-v2 - Polling commands expressions', function () {
+    beforeEach(function (done) {
+        logger.setLevel('FATAL');
+
+        nock.cleanAll();
+
+        contextBrokerMock = nock('http://192.168.1.1:1026')
+            .matchHeader('fiware-service', 'smartgondor')
+            .matchHeader('fiware-servicepath', 'gardens')
+            .post('/v2/registrations')
+            .reply(201, null, { Location: '/v2/registrations/6319a7f5254b05844116584m' });
+
+        contextBrokerMock
+            .matchHeader('fiware-service', 'smartgondor')
+            .matchHeader('fiware-servicepath', 'gardens')
+            .post('/v2/entities?options=upsert')
+            .reply(204);
+
+        iotAgentConfig.pollingExpiration = 0;
+        iotAgentConfig.pollingDaemonFrequency = 0;
+        iotAgentLib.activate(iotAgentConfig, done);
+    });
+
+    afterEach(function (done) {
+        delete device4.registrationId;
+        iotAgentLib.clearAll(function () {
+            iotAgentLib.deactivate(function () {
+                mongoUtils.cleanDbs(function () {
+                    nock.cleanAll();
+                    iotAgentLib.setDataUpdateHandler();
+                    iotAgentLib.setCommandHandler();
+                    done();
+                });
+            });
+        });
+    });
+
+    describe('When a command update arrives to the IoT Agent for a device with polling', function () {
+        const options = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/v2/op/update',
+            method: 'POST',
+            json: {
+                actionType: 'update',
+                entities: [
+                    {
+                        id: 'RobotExp:r2d4',
+                        type: 'RobotExp',
+                        positionExp: {
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': 'smartgondor',
+                'fiware-servicepath': 'gardens'
+            }
+        };
+
+        beforeEach(function (done) {
+            statusAttributeMock = nock('http://192.168.1.1:1026')
+                .matchHeader('fiware-service', 'smartgondor')
+                .matchHeader('fiware-servicepath', 'gardens')
+                .patch(
+                    '/v2/entities/RobotExp:r2d4/attrs?type=RobotExp',
+                    utils.readExampleFile(
+                        './test/unit/ngsiv2/examples/contextRequests/updateContextCommandStatus2.json'
+                    )
+                )
+                .reply(204);
+
+            iotAgentLib.register(device4, function (error) {
+                done();
+            });
+        });
+
+        it('should not call the client handler', function (done) {
+            let handlerCalled = false;
+
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                handlerCalled = true;
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'positionExp',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    ]
+                });
+            });
+
+            request(options, function (error, response, body) {
+                should.not.exist(error);
+                handlerCalled.should.equal(false);
+                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);
+            });
+
+            request(options, function (error, response, body) {
+                should.not.exist(error);
+                statusAttributeMock.done();
+                done();
+            });
+        });
+        it('should store the commands in the queue', function (done) {
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                callback(null);
+            });
+
+            request(options, function (error, response, body) {
+                iotAgentLib.commandQueue('smartgondor', 'gardens', 'r2d4', function (error, listCommands) {
+                    should.not.exist(error);
+                    listCommands.count.should.equal(1);
+                    listCommands.commands[0].name.should.equal('positionExp');
+                    listCommands.commands[0].type.should.equal('Array');
+                    listCommands.commands[0].value[0].should.equal(22);
+                    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',

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

@@ -215,6 +215,31 @@ const iotAgentConfig = {
                 }
             ]
         },
+        WeatherStation9: {
+            commands: [],
+            type: 'WeatherStation',
+            name: 'ws9b',
+            lazy: [],
+            active: [
+                {
+                    object_id: 'p',
+                    name: 'pressure',
+                    type: 'Hgmm'
+                },
+                {
+                    object_id: 'h',
+                    name: 'humidity',
+                    type: 'Percentage',
+                    entity_type: 'Higrometer',
+                    metadata: {
+                        unitCode: {
+                            type: 'Text',
+                            value: 'Hgmm'
+                        }
+                    }
+                }
+            ]
+        },
         WeatherStation8Jexl: {
             commands: [],
             type: 'WeatherStation',
@@ -581,6 +606,44 @@ describe('NGSI-v2 - Multi-entity plugin', function () {
         });
     });
 
+    describe('When an update comes for a multientity measurement based on entity_type', function () {
+        const values = [
+            {
+                name: 'p',
+                type: 'centigrades',
+                value: '52'
+            },
+            {
+                name: 'h',
+                type: 'Percentage',
+                value: '12'
+            }
+        ];
+
+        beforeEach(function () {
+            nock.cleanAll();
+
+            contextBrokerMock = nock('http://192.168.1.1:1026')
+                .matchHeader('fiware-service', 'smartgondor')
+                .matchHeader('fiware-servicepath', 'gardens')
+                .post(
+                    '/v2/op/update',
+                    utils.readExampleFile(
+                        './test/unit/ngsiv2/examples/contextRequests/updateContextMultientityPlugin17.json'
+                    )
+                )
+                .reply(204);
+        });
+
+        it('should send two context elements, one for each entity', function (done) {
+            iotAgentLib.update('ws9b', 'WeatherStation9', '', values, function (error) {
+                should.not.exist(error);
+                contextBrokerMock.done();
+                done();
+            });
+        });
+    });
+
     describe('When an update comes for a multientity measurement with same attribute name', function () {
         const values = [
             {

package/test/unit/ngsiv2/provisioning/device-provisioning-api_test.js

@@ -705,6 +705,66 @@ describe('NGSI-v2 - Device provisioning API: Provision devices', function () {
         }
     );
 
+    describe('When a device provisioning request arrives to the IoTA and entityNameExp was configured at group level', function () {
+        const options = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/iot/devices',
+            method: 'POST',
+            json: utils.readExampleFile('./test/unit/examples/deviceProvisioningRequests/provisionMinimumDevice4.json'),
+            headers: {
+                'fiware-service': 'smartgondor',
+                'fiware-servicepath': '/gardens'
+            }
+        };
+        const groupCreation = {
+            url: 'http://localhost:4041/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/Thing',
+                        apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732',
+                        /*jshint camelcase: false */
+                        entity_type: 'MicroLights',
+                        entityNameExp: 'EntityNameByExp',
+                        cbroker: 'http://192.168.1.1:1026'
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': 'smartgondor',
+                'fiware-servicepath': '/gardens'
+            }
+        };
+
+        beforeEach(function (done) {
+            nock.cleanAll();
+            contextBrokerMock = nock('http://192.168.1.1:1026')
+                .matchHeader('fiware-service', 'smartgondor')
+                .matchHeader('fiware-servicepath', '/gardens')
+                .post(
+                    '/v2/entities?options=upsert',
+                    utils.readExampleFile(
+                        './test/unit/ngsiv2/examples/contextRequests/createMinimumProvisionedDevice4.json'
+                    )
+                )
+                .reply(204);
+
+            done();
+        });
+
+        it('should store the entity name defined by expression', function (done) {
+            request(groupCreation, function (error, response, body) {
+                request(options, function (error, response, body) {
+                    iotAgentLib.listDevices('smartgondor', '/gardens', function (error, results) {
+                        should.exist(results.devices[0].name);
+                        results.devices[0].name.should.equal('EntityNameByExp');
+                        done();
+                    });
+                });
+            });
+        });
+    });
+
     describe(
         'When a device provisioning request with static attributes arrives to the IoTA' +
             ' and same static attribute is also configured at group level',

package/test/unit/ngsiv2/provisioning/updateProvisionedDevices-test.js

@@ -484,10 +484,11 @@ describe('NGSI-v2 - Device provisioning API: Update provisioned devices', functi
 
         it('should provision the explicitAttrs attribute appropriately', function (done) {
             request(optionsUpdate, function (error, response, body) {
+                should.not.exist(error);
+                response.statusCode.should.equal(204);
                 request(optionsGetDevice, function (error, response, body) {
                     should.not.exist(error);
                     response.statusCode.should.equal(200);
-
                     body.explicitAttrs.should.equal(false);
                     done();
                 });