iotagent-node-lib 4.5.0 → 4.6.0

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

@@ -156,6 +156,34 @@ const groupCreation = {
         'fiware-servicepath': '/testingPath'
     }
 };
+const configGroupCreation = {
+    url: 'http://localhost:' + iotAgentConfig.server.port + '/iot/groups',
+    method: 'POST',
+    json: {
+        groups: [
+            {
+                resource: '',
+                apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732',
+                entity_type: 'TheLightType',
+                trust: '8970A9078A803H3BL98PINEQRW8342HBAMS',
+                cbHost: 'http://192.168.1.1:1026',
+                commands: [],
+                lazy: [],
+                attributes: [
+                    {
+                        name: 'status',
+                        type: 'Boolean'
+                    }
+                ],
+                static_attributes: []
+            }
+        ]
+    },
+    headers: {
+        'fiware-service': 'testservice',
+        'fiware-servicepath': '/testingPath'
+    }
+};
 const deviceCreation = {
     url: 'http://localhost:' + iotAgentConfig.server.port + '/iot/devices',
     method: 'POST',
@@ -182,7 +210,7 @@ describe('NGSI-v2 - Device Service: utils', function () {
         nock.cleanAll();
         async.series([iotAgentLib.clearAll, iotAgentLib.deactivate], done);
     });
-
+    // #FIXME1649: this test will be removed if at the end /iot/services API (now Deprecated) is removed
     describe('When an existing device tries to be retrieved with retrieveOrCreate()', function () {
         beforeEach(function (done) {
             // This mock does not check the payload since the aim of the test is not to verify
@@ -212,7 +240,39 @@ describe('NGSI-v2 - Device Service: utils', function () {
             });
         });
     });
+    describe('When an existing device tries to be retrieved with retrieveOrCreate()', function () {
+        beforeEach(function (done) {
+            // 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://192.168.1.1:1026')
+                .matchHeader('fiware-service', 'testservice')
+                .matchHeader('fiware-servicepath', '/testingPath')
+                .post('/v2/entities?options=upsert')
+                .reply(204);
+
+            async.series(
+                [
+                    utils.request.bind(utils.request, configGroupCreation),
+                    utils.request.bind(utils.request, deviceCreation)
+                ],
+                function (error, results) {
+                    done();
+                }
+            );
+        });
+
+        it('should return the existing device', function (done) {
+            iotAgentLib.retrieveDevice('Light1', '801230BJKL23Y9090DSFL123HJK09H324HV8732', function (error, device) {
+                should.not.exist(error);
+                should.exist(device);
 
+                device.id.should.equal('Light1');
+                done();
+            });
+        });
+    });
+    // #FIXME1649: this test will be removed if at the end /iot/services API (now Deprecated) is removed
     describe('When an unexisting device tries to be retrieved for an existing APIKey', function () {
         beforeEach(function (done) {
             // This mock does not check the payload since the aim of the test is not to verify
@@ -246,6 +306,39 @@ describe('NGSI-v2 - Device Service: utils', function () {
         });
     });
 
+    describe('When an unexisting device tries to be retrieved for an existing APIKey', function () {
+        beforeEach(function (done) {
+            // 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://192.168.1.1:1026')
+                .matchHeader('fiware-service', 'testservice')
+                .matchHeader('fiware-servicepath', '/testingPath')
+                .post('/v2/entities?options=upsert')
+                .reply(204);
+
+            async.series([utils.request.bind(utils.request, configGroupCreation)], function (error, results) {
+                done();
+            });
+        });
+
+        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);
+
+                    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(

package/test/unit/ngsiv2/general/iotam-autoregistration-test.js

@@ -134,6 +134,43 @@ const optionsCreation = {
         'fiware-servicepath': 'theSubService'
     }
 };
+const configGroupCreation = {
+    url: 'http://localhost:4041/iot/groups',
+    method: 'POST',
+    json: {
+        groups: [
+            {
+                resource: '/deviceTest',
+                apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732',
+                entity_type: 'SensorMachine',
+                trust: '8970A9078A803H3BL98PINEQRW8342HBAMS',
+                cbHost: 'http://unexistentHost:1026',
+                commands: [
+                    {
+                        name: 'wheel1',
+                        type: 'Wheel'
+                    }
+                ],
+                lazy: [
+                    {
+                        name: 'luminescence',
+                        type: 'Lumens'
+                    }
+                ],
+                attributes: [
+                    {
+                        name: 'status',
+                        type: 'Boolean'
+                    }
+                ]
+            }
+        ]
+    },
+    headers: {
+        'fiware-service': 'theservice',
+        'fiware-servicepath': 'theSubService'
+    }
+};
 const optionsCreationStatic = {
     url: 'http://localhost:4041/iot/services',
     method: 'POST',
@@ -172,6 +209,44 @@ const optionsCreationStatic = {
         'fiware-servicepath': 'theSubService'
     }
 };
+const configGroupCreationStatic = {
+    url: 'http://localhost:4041/iot/groups',
+    method: 'POST',
+    json: {
+        groups: [
+            {
+                resource: '/deviceTest',
+                apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732',
+                entity_type: 'SensorMachine',
+                trust: '8970A9078A803H3BL98PINEQRW8342HBAMS',
+                cbHost: 'http://unexistentHost:1026',
+                commands: [
+                    {
+                        name: 'wheel1',
+                        type: 'Wheel'
+                    }
+                ],
+                static_attributes: [
+                    {
+                        name: 'position',
+                        type: 'location',
+                        values: '123,12'
+                    }
+                ],
+                attributes: [
+                    {
+                        name: 'status',
+                        type: 'Boolean'
+                    }
+                ]
+            }
+        ]
+    },
+    headers: {
+        'fiware-service': 'theservice',
+        'fiware-servicepath': 'theSubService'
+    }
+};
 const optionsDelete = {
     url: 'http://localhost:4041/iot/services',
     method: 'DELETE',
@@ -185,6 +260,19 @@ const optionsDelete = {
         apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732'
     }
 };
+const configGroupDelete = {
+    url: 'http://localhost:4041/iot/groups',
+    method: 'DELETE',
+    json: {},
+    headers: {
+        'fiware-service': 'theservice',
+        'fiware-servicepath': 'theSubService'
+    },
+    qs: {
+        resource: '/deviceTest',
+        apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732'
+    }
+};
 let iotamMock;
 
 describe('NGSI-v2 - IoT Manager autoregistration', function () {
@@ -263,6 +351,7 @@ describe('NGSI-v2 - IoT Manager autoregistration', function () {
         });
     });
 
+    // #FIXME1649: this test will be removed if at the end /iot/services API (now Deprecated) is removed
     describe('When a new service is created in the IoT Agent', function () {
         beforeEach(function (done) {
             nock.cleanAll();
@@ -298,6 +387,42 @@ describe('NGSI-v2 - IoT Manager autoregistration', function () {
         });
     });
 
+    describe('When a new configGroup is created in the IoT Agent', function () {
+        beforeEach(function (done) {
+            nock.cleanAll();
+
+            iotamMock = nock('http://mockediotam.com:9876')
+                .post('/protocols', utils.readExampleFile('./test/unit/examples/iotamRequests/registrationEmpty.json'))
+                .reply(200, utils.readExampleFile('./test/unit/examples/iotamResponses/registrationSuccess.json'));
+
+            iotamMock
+                .post(
+                    '/protocols',
+                    utils.readExampleFile('./test/unit/examples/iotamRequests/registrationWithGroups.json')
+                )
+                .reply(200, utils.readExampleFile('./test/unit/examples/iotamResponses/registrationSuccess.json'));
+
+            iotAgentLib.activate(iotAgentConfig, function (error) {
+                done();
+            });
+        });
+
+        afterEach(function (done) {
+            groupRegistryMemory.clear(function () {
+                iotAgentLib.deactivate(done);
+            });
+        });
+
+        it('should update the registration in the IoT Manager', function (done) {
+            request(configGroupCreation, function (error, result, body) {
+                should.not.exist(error);
+                iotamMock.done();
+                done();
+            });
+        });
+    });
+
+    // #FIXME1649: this test will be removed if at the end /iot/services API (now Deprecated) is removed
     describe('When a service is removed from the IoT Agent', function () {
         beforeEach(function (done) {
             nock.cleanAll();
@@ -333,6 +458,42 @@ describe('NGSI-v2 - IoT Manager autoregistration', function () {
         });
     });
 
+    describe('When a configGroup is removed from the IoT Agent', function () {
+        beforeEach(function (done) {
+            nock.cleanAll();
+
+            iotamMock = nock('http://mockediotam.com:9876')
+                .post(
+                    '/protocols',
+                    utils.readExampleFile('./test/unit/examples/iotamRequests/registrationWithGroups.json')
+                )
+                .reply(200, utils.readExampleFile('./test/unit/examples/iotamResponses/registrationSuccess.json'));
+
+            iotamMock
+                .post('/protocols', utils.readExampleFile('./test/unit/examples/iotamRequests/registrationEmpty.json'))
+                .reply(200, utils.readExampleFile('./test/unit/examples/iotamResponses/registrationSuccess.json'));
+
+            groupRegistryMemory.create(groupCreation, function () {
+                iotAgentLib.activate(iotAgentConfig, done);
+            });
+        });
+
+        afterEach(function (done) {
+            groupRegistryMemory.clear(function () {
+                iotAgentLib.deactivate(done);
+            });
+        });
+
+        it('should update the registration in the IoT Manager', function (done) {
+            request(configGroupDelete, function (error, result, body) {
+                should.not.exist(error);
+                iotamMock.done();
+                done();
+            });
+        });
+    });
+
+    // #FIXME1649: this test will be removed if at the end /iot/services API (now Deprecated) is removed
     describe('When a new service with static attributes is created in the IoT Agent', function () {
         beforeEach(function (done) {
             nock.cleanAll();
@@ -367,4 +528,38 @@ describe('NGSI-v2 - IoT Manager autoregistration', function () {
             });
         });
     });
+    describe('When a new configGroup with static attributes is created in the IoT Agent', function () {
+        beforeEach(function (done) {
+            nock.cleanAll();
+
+            iotamMock = nock('http://mockediotam.com:9876')
+                .post('/protocols', utils.readExampleFile('./test/unit/examples/iotamRequests/registrationEmpty.json'))
+                .reply(200, utils.readExampleFile('./test/unit/examples/iotamResponses/registrationSuccess.json'));
+
+            iotamMock
+                .post(
+                    '/protocols',
+                    utils.readExampleFile('./test/unit/examples/iotamRequests/registrationWithStaticGroups.json')
+                )
+                .reply(200, utils.readExampleFile('./test/unit/examples/iotamResponses/registrationSuccess.json'));
+
+            iotAgentLib.activate(iotAgentConfig, function (error) {
+                done();
+            });
+        });
+
+        afterEach(function (done) {
+            groupRegistryMemory.clear(function () {
+                iotAgentLib.deactivate(done);
+            });
+        });
+
+        it('should update the registration in the IoT Manager', function (done) {
+            request(configGroupCreationStatic, function (error, result, body) {
+                should.not.exist(error);
+                iotamMock.done();
+                done();
+            });
+        });
+    });
 });

package/test/unit/ngsiv2/provisioning/device-group-api-test.js

@@ -23,6 +23,8 @@
 
 /* eslint-disable no-unused-vars */
 
+// #FIXME1649: parallel tests in device-provisioning-configGroup-api_test.js.
+
 const iotAgentLib = require('../../../../lib/fiware-iotagent-lib');
 const _ = require('underscore');
 const async = require('async');
@@ -118,6 +120,19 @@ const optionsDelete = {
         apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732'
     }
 };
+const optionsDeleteGroup = {
+    url: 'http://localhost:4041/iot/services',
+    method: 'DELETE',
+    json: {},
+    headers: {
+        'fiware-service': 'Testservice',
+        'fiware-servicepath': '/testingPath'
+    },
+    qs: {
+        resource: '/deviceTest',
+        apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732'
+    }
+};
 const optionsDeleteDevice = {
     url: 'http://localhost:4041/iot/services',
     method: 'DELETE',
@@ -175,6 +190,49 @@ const optionsUpdate = {
         apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732'
     }
 };
+const optionsUpdateGroup = {
+    url: 'http://localhost:4041/iot/services',
+    method: 'PUT',
+    json: {
+        trust: '8970A9078A803H3BL98PINEQRW8342HBAMS',
+        cbHost: 'http://anotherUnexistentHost:1026',
+        transport: 'MQTT',
+        endpoint: 'http://yourendpoint.com',
+        commands: [
+            {
+                name: 'wheel1',
+                type: 'Wheel'
+            }
+        ],
+        lazy: [
+            {
+                name: 'luminescence',
+                type: 'Lumens'
+            }
+        ],
+        attributes: [
+            {
+                name: 'status',
+                type: 'Boolean'
+            }
+        ],
+        static_attributes: [
+            {
+                name: 'identifier',
+                type: 'UUID',
+                value: 'WERTYUIOP234567890'
+            }
+        ]
+    },
+    headers: {
+        'fiware-service': 'Testservice',
+        'fiware-servicepath': '/testingPath'
+    },
+    qs: {
+        resource: '/deviceTest',
+        apikey: '801230BJKL23Y9090DSFL123HJK09H324HV8732'
+    }
+};
 const optionsList = {
     url: 'http://localhost:4041/iot/services',
     method: 'GET',
@@ -194,6 +252,20 @@ const optionsGet = {
     }
 };
 
+// Add new options using the literal groups instead of services
+const configGroupTerm = 'groups';
+
+const newOptionsCreation = JSON.parse(JSON.stringify(optionsCreation));
+newOptionsCreation.url = newOptionsCreation.url.replace('services', configGroupTerm);
+newOptionsCreation.json[configGroupTerm] = newOptionsCreation.json.services;
+delete newOptionsCreation.json.services;
+
+const newOptionsList = JSON.parse(JSON.stringify(optionsList));
+newOptionsList.url = newOptionsList.url.replace('services', configGroupTerm);
+
+const newOptionsGet = JSON.parse(JSON.stringify(optionsGet));
+newOptionsGet.url = newOptionsGet.url.replace('services', configGroupTerm);
+
 describe('NGSI-v2 - Device Group Configuration API', function () {
     beforeEach(function (done) {
         iotAgentLib.activate(iotAgentConfig, function () {
@@ -411,6 +483,33 @@ describe('NGSI-v2 - Device Group Configuration API', function () {
             });
         });
     });
+    describe('When a device group removal request arrives with service-header in uppercase', function () {
+        beforeEach(function (done) {
+            request(optionsCreation, done);
+        });
+
+        it('should return a 204 OK', function (done) {
+            request(optionsDeleteGroup, function (error, response, body) {
+                should.not.exist(error);
+                response.statusCode.should.equal(204);
+                done();
+            });
+        });
+        it('should remove it from the database', function (done) {
+            request(optionsDeleteGroup, function (error, response, body) {
+                request(optionsList, function (error, response, body) {
+                    body.count.should.equal(0);
+                    done();
+                });
+            });
+        });
+        it('should remove it from the configuration', function (done) {
+            request(optionsDeleteGroup, function (error, response, body) {
+                should.not.exist(iotAgentConfig.types.SensorMachine);
+                done();
+            });
+        });
+    });
     describe('When a device group removal request arrives with device=true option', function () {
         let contextBrokerMock;
 
@@ -704,6 +803,83 @@ describe('NGSI-v2 - Device Group Configuration API', function () {
         });
     });
 
+    describe('When a device group update request arrives with service-header in uppercase', function () {
+        beforeEach(function (done) {
+            const optionsCreation1 = _.clone(optionsCreation);
+            const optionsCreation2 = _.clone(optionsCreation);
+            const optionsCreation3 = _.clone(optionsCreation);
+
+            optionsCreation1.json = { services: [] };
+            optionsCreation3.json = { services: [] };
+
+            optionsCreation1.json.services[0] = _.clone(optionsCreation.json.services[0]);
+            optionsCreation3.json.services[0] = _.clone(optionsCreation.json.services[0]);
+
+            optionsCreation1.json.services[0].apikey = 'qwertyuiop';
+            optionsCreation3.json.services[0].apikey = 'lkjhgfds';
+
+            async.series(
+                [
+                    async.apply(request, optionsCreation1),
+                    async.apply(request, optionsCreation2),
+                    async.apply(request, optionsCreation3)
+                ],
+                done
+            );
+        });
+
+        it('should return a 204 OK', function (done) {
+            request(optionsUpdateGroup, function (error, response, body) {
+                should.not.exist(error);
+                response.statusCode.should.equal(204);
+                done();
+            });
+        });
+        it('should update the appropriate values in the database', function (done) {
+            request(optionsUpdateGroup, function (error, response, body) {
+                request(optionsList, function (error, response, body) {
+                    let found = false;
+                    body.count.should.equal(3);
+
+                    for (let i = 0; i < body.services.length; i++) {
+                        if (
+                            body.services[i].apikey === '801230BJKL23Y9090DSFL123HJK09H324HV8732' &&
+                            body.services[i].resource === '/deviceTest'
+                        ) {
+                            body.services[i].cbHost.should.equal('http://anotherUnexistentHost:1026');
+                            body.services[i].static_attributes.length.should.equal(1);
+                            found = true;
+                        }
+                    }
+
+                    found.should.equal(true);
+                    done();
+                });
+            });
+        });
+        it('should call the configuration creation handler', function (done) {
+            let handlerCalled = false;
+
+            iotAgentLib.setConfigurationHandler(function (newConfiguration, callback) {
+                should.exist(newConfiguration);
+                should.exist(callback);
+                newConfiguration.cbHost.should.equal('http://anotherUnexistentHost:1026');
+                newConfiguration.trust.should.equal('8970A9078A803H3BL98PINEQRW8342HBAMS');
+                newConfiguration.service.should.equal('Testservice');
+                newConfiguration.subservice.should.equal('/testingPath');
+                newConfiguration.resource.should.equal('/deviceTest');
+                newConfiguration.apikey.should.equal('801230BJKL23Y9090DSFL123HJK09H324HV8732');
+                handlerCalled = true;
+                callback();
+            });
+
+            request(optionsUpdateGroup, function (error, response, body) {
+                handlerCalled.should.equal(true);
+                done();
+            });
+        });
+    });
+
     describe('When a device group update request arrives declaring a different service', function () {
         beforeEach(function (done) {
             optionsUpdate.headers['fiware-service'] = 'UnexistentService';
@@ -996,4 +1172,87 @@ describe('NGSI-v2 - Device Group Configuration API', function () {
             });
         });
     });
+
+    describe('When a new device group creation request arrives with the NEW API endpoint ', function () {
+        it('should return a 200 OK', function (done) {
+            request(newOptionsCreation, function (error, response, body) {
+                should.not.exist(error);
+                response.statusCode.should.equal(201);
+                done();
+            });
+        });
+        it('should be recovered using the OLD API endpoint', function (done) {
+            request(newOptionsCreation, function (error, response, body) {
+                request(optionsList, function (error, response, body) {
+                    body.count.should.equal(1);
+                    body.services[0].apikey.should.equal('801230BJKL23Y9090DSFL123HJK09H324HV8732');
+                    body.services[0].transport.should.equal('HTTP');
+                    body.services[0].endpoint.should.equal('http://myendpoint.com');
+
+                    body.count.should.equal(1);
+                    should.exist(body.services[0].attributes);
+                    body.services[0].attributes.length.should.equal(1);
+                    body.services[0].attributes[0].name.should.equal('status');
+
+                    should.exist(body.services[0].lazy);
+                    body.services[0].lazy.length.should.equal(1);
+                    body.services[0].lazy[0].name.should.equal('luminescence');
+
+                    should.exist(body.services[0].commands);
+                    body.services[0].commands.length.should.equal(1);
+                    body.services[0].commands[0].name.should.equal('wheel1');
+
+                    should.exist(body.services[0].static_attributes);
+                    body.services[0].static_attributes.length.should.equal(1);
+                    body.services[0].static_attributes[0].name.should.equal('bootstrapServer');
+
+                    body.count.should.equal(1);
+                    body.services[0].service.should.equal('testservice');
+                    body.services[0].subservice.should.equal('/testingPath');
+                    done();
+                });
+            });
+        });
+    });
+    describe('When a new device group creation request arrives with the NEW OLD endpoint ', function () {
+        it('should return a 200 OK', function (done) {
+            request(optionsCreation, function (error, response, body) {
+                should.not.exist(error);
+                response.statusCode.should.equal(201);
+                done();
+            });
+        });
+        it('should be recovered using the NEW API endpoint', function (done) {
+            request(optionsCreation, function (error, response, body) {
+                request(newOptionsList, function (error, response, body) {
+                    body.count.should.equal(1);
+                    body[configGroupTerm][0].apikey.should.equal('801230BJKL23Y9090DSFL123HJK09H324HV8732');
+                    body[configGroupTerm][0].transport.should.equal('HTTP');
+                    body[configGroupTerm][0].endpoint.should.equal('http://myendpoint.com');
+
+                    body.count.should.equal(1);
+                    should.exist(body[configGroupTerm][0].attributes);
+                    body[configGroupTerm][0].attributes.length.should.equal(1);
+                    body[configGroupTerm][0].attributes[0].name.should.equal('status');
+
+                    should.exist(body[configGroupTerm][0].lazy);
+                    body[configGroupTerm][0].lazy.length.should.equal(1);
+                    body[configGroupTerm][0].lazy[0].name.should.equal('luminescence');
+
+                    should.exist(body[configGroupTerm][0].commands);
+                    body[configGroupTerm][0].commands.length.should.equal(1);
+                    body[configGroupTerm][0].commands[0].name.should.equal('wheel1');
+
+                    should.exist(body[configGroupTerm][0].static_attributes);
+                    body[configGroupTerm][0].static_attributes.length.should.equal(1);
+                    body[configGroupTerm][0].static_attributes[0].name.should.equal('bootstrapServer');
+
+                    body.count.should.equal(1);
+                    body[configGroupTerm][0].service.should.equal('testservice');
+                    body[configGroupTerm][0].subservice.should.equal('/testingPath');
+                    done();
+                });
+            });
+        });
+    });
 });