iotagent-node-lib 2.19.0 → 2.22.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "iotagent-node-lib",
   "license": "AGPL-3.0-only",
   "description": "IoT Agent library to interface with NGSI Context Broker",
-  "version": "2.19.0",
+  "version": "2.22.0",
   "homepage": "https://github.com/telefonicaid/iotagent-node-lib",
   "keywords": [
     "fiware",
@@ -21,17 +21,13 @@
   "bugs": {
     "url": "https://github.com/telefonicaid/iotagent-node-lib/issues"
   },
-  "bin": {
-    "agentConsole": "bin/agentConsole.js",
-    "iotAgentTester": "bin/iotAgentTester.js"
-  },
   "main": "lib/fiware-iotagent-lib",
   "engines": {
     "node": ">=12"
   },
   "scripts": {
     "clean": "rm -rf package-lock.json && rm -rf node_modules && rm -rf coverage",
-    "lint": "eslint lib/ bin/ test/ --cache --fix",
+    "lint": "eslint lib/ test/ --cache --fix",
     "lint:md": "remark  -f '*.md' 'doc/*.md'",
     "lint:text": "textlint '*.md' 'doc/*.md'",
     "prettier": "prettier --config .prettierrc.json --write '**/**/**/**/*.js' '**/**/**/*.js' '**/**/*.js' '**/*.js' '*.js'",
@@ -46,44 +42,42 @@
     "watch": "watch 'npm test && npm run lint' ./lib ./test"
   },
   "dependencies": {
-    "async": "2.6.2",
-    "body-parser": "~1.19.0",
-    "command-shell-lib": "1.0.0",
-    "express": "~4.16.4",
-    "got": "~11.8.2",
+    "async": "2.6.4",
+    "body-parser": "~1.20.0",
+    "express": "~4.18.1",
+    "got": "~11.8.5",
     "jexl": "2.3.0",
     "jison": "0.4.18",
     "logops": "2.1.2",
-    "moment": "~2.24.0",
-    "moment-timezone": "~0.5.25",
-    "mongodb": "3.6.8",
-    "mongoose": "5.7.7",
-    "mu2": "~0.5.20",
-    "query-string": "6.5.0",
+    "moment": "~2.29.2",
+    "moment-timezone": "~0.5.34",
+    "mongoose": "5.13.14",
+    "query-string": "7.1.1",
     "revalidator": "~0.3.1",
-    "underscore": "~1.12.1",
-    "uuid": "~3.3.2"
+    "underscore": "~1.13.4",
+    "uuid": "~8.3.2"
   },
   "devDependencies": {
-    "coveralls": "~3.1.0",
-    "eslint": "~7.5.0",
-    "eslint-config-tamia": "~7.2.5",
-    "eslint-plugin-prettier": "~3.1.4",
+    "coveralls": "~3.1.1",
+    "eslint": "~8.18.0",
+    "eslint-config-tamia": "~8.0.0",
+    "eslint-plugin-prettier": "~4.0.0",
     "husky": "~4.2.5",
-    "lint-staged": "~10.2.11",
-    "prettier": "~2.0.5",
-    "mocha": "8.0.1",
-    "nock": "13.0.3",
+    "lint-staged": "~12.3.8",
+    "mocha": "10.0.0",
+    "mongodb": "4.7.0",
+    "nock": "13.2.7",
     "nyc": "~15.1.0",
-    "remark-cli": "~8.0.1",
-    "remark-preset-lint-recommended": "~4.0.1",
+    "prettier": "~2.7.1",
+    "remark-cli": "~10.0.1",
+    "remark-preset-lint-recommended": "~6.1.2",
     "should": "13.2.3",
-    "sinon": "~9.0.2",
-    "textlint": "~11.7.6",
+    "sinon": "~14.0.0",
+    "textlint": "~12.2.1",
     "textlint-filter-rule-comments": "~1.2.2",
     "textlint-rule-common-misspellings": "~1.0.1",
-    "textlint-rule-terminology": "~2.1.4",
-    "textlint-rule-write-good": "~1.6.2",
+    "textlint-rule-terminology": "~3.0.2",
+    "textlint-rule-write-good": "~2.0.0",
     "timekeeper": "2.2.0",
     "watch": "~1.0.2"
   },

package/test/unit/examples/deviceProvisioningRequests/provisionMinimumDevice4.json

@@ -0,0 +1,14 @@
+{
+  "devices": [
+    {
+      "device_id": "MicroLight1",
+      "protocol": "GENERIC_PROTO",
+      "attributes": [
+        {
+          "name": "attr_name",
+          "type": "string"
+        }
+      ]
+    }
+  ]
+}

package/test/unit/mongodb/mongoDBUtils.js

@@ -29,7 +29,7 @@ const async = require('async');
 function cleanDb(host, name, callback) {
     const url = 'mongodb://' + host + ':27017/' + name;
 
-    MongoClient.connect(url, { useNewUrlParser: true }, function (err, db) {
+    MongoClient.connect(url, function (err, db) {
         if (db && db.db()) {
             db.db().dropDatabase(function (err, result) {
                 db.close();
@@ -46,7 +46,7 @@ function cleanDbs(callback) {
 function populate(host, dbName, entityList, collectionName, callback) {
     const url = 'mongodb://' + host + ':27017/' + dbName;
 
-    MongoClient.connect(url, { useNewUrlParser: true }, function (err, db) {
+    MongoClient.connect(url, function (err, db) {
         if (db) {
             db.db()
                 .collection(collectionName)

package/test/unit/mongodb/mongodb-group-registry-test.js

@@ -179,7 +179,7 @@ describe('MongoDB Group Registry test', function () {
     beforeEach(function (done) {
         mongoUtils.cleanDbs(function () {
             iotAgentLib.activate(iotAgentConfig, function () {
-                mongo.connect('mongodb://localhost:27017/iotagent', { useNewUrlParser: true }, function (err, db) {
+                mongo.connect('mongodb://localhost:27017/iotagent', function (err, db) {
                     iotAgentDb = db;
                     done();
                 });

package/test/unit/mongodb/mongodb-registry-test.js

@@ -25,7 +25,6 @@
 
 const iotAgentLib = require('../../../lib/fiware-iotagent-lib');
 const utils = require('../../tools/utils');
-const request = utils.request;
 const should = require('should');
 const logger = require('logops');
 const mongo = require('mongodb').MongoClient;
@@ -191,7 +190,7 @@ describe('NGSI-v2 - MongoDB Device Registry', function () {
         logger.setLevel('FATAL');
 
         mongoUtils.cleanDbs(function () {
-            mongo.connect('mongodb://localhost:27017/iotagent', { useNewUrlParser: true }, function (err, db) {
+            mongo.connect('mongodb://localhost:27017/iotagent', function (err, db) {
                 iotAgentDb = db;
                 done();
             });
@@ -204,7 +203,7 @@ describe('NGSI-v2 - MongoDB Device Registry', function () {
             iotAgentDb
                 .db()
                 .collection('devices')
-                .deleteOne(function (error) {
+                .deleteOne({}, function (error) {
                     iotAgentDb.close(function (error) {
                         mongoUtils.cleanDbs(done);
                     });

package/test/unit/ngsi-ld/examples/contextAvailabilityRequests/registerIoTAgentCommands.json

@@ -10,7 +10,8 @@
                 }
             ],
             "properties": [
-                "position"
+                "position",
+                "orientation"
             ]
         }
     ],

package/test/unit/ngsi-ld/examples/contextRequests/updateContextLanguageProperties1.json

@@ -0,0 +1,15 @@
+[
+  {
+    "@context": "http://context.json-ld",
+    "name": {
+      "type": "LanguageProperty",
+      "languageMap": {
+        "el": "Κωνσταντινούπολις",
+        "en": "Constantinople",
+        "tr": "İstanbul"
+      }
+    },
+    "id": "urn:ngsi-ld:Light:light1",
+    "type": "Light"
+  }
+]

package/test/unit/ngsi-ld/lazyAndCommands/command-test.js

@@ -94,6 +94,10 @@ const iotAgentConfig = {
                 {
                     name: 'position',
                     type: 'Array'
+                },
+                {
+                    name: 'orientation',
+                    type: 'Array'
                 }
             ],
             lazy: [],
@@ -158,7 +162,114 @@ describe('NGSI-LD - Command functionalities', function () {
             });
         });
     });
-    describe('When a command update arrives to the IoT Agent as Context Provider', function () {
+
+    describe('When multiple command updates via PATCH /attrs arrive to the IoT Agent as Context Provider', function () {
+        const options = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/ngsi-ld/v1/entities/urn:ngsi-ld:Robot:r2d2/attrs',
+            method: 'PATCH',
+            json: {
+                orientation: {
+                    type: 'Property',
+                    value: [1, 2, 3]
+                },
+                position: {
+                    type: 'Property',
+                    value: [28, -104, 23]
+                }
+            },
+            headers: {
+                'fiware-service': 'smartgondor',
+                'content-type': 'application/ld+json'
+            }
+        };
+
+        beforeEach(function (done) {
+            logger.setLevel('ERROR');
+            iotAgentLib.register(device3, function (error) {
+                done();
+            });
+        });
+
+        it('should call the client handler once', function (done) {
+            let handlerCalled = 0;
+
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                id.should.equal('urn:ngsi-ld:' + device3.type + ':' + device3.id);
+                type.should.equal(device3.type);
+                attributes[0].name.should.equal('position');
+                attributes[1].name.should.equal('orientation');
+                JSON.stringify(attributes[0].value).should.equal('[28,-104,23]');
+                JSON.stringify(attributes[1].value).should.equal('[1,2,3]');
+                handlerCalled++;
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        },
+                        {
+                            name: 'orientation',
+                            type: 'Array',
+                            value: '[1, 2, 3]'
+                        }
+                    ]
+                });
+            });
+
+            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 serviceReceived = false;
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                serviceReceived = service === 'smartgondor';
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    ]
+                });
+            });
+
+            request(options, function (error, response, body) {
+                serviceReceived.should.equal(true);
+                done();
+            });
+        });
+    });
+
+    describe('When a command update PATCH attrs/attr-name arrives to the IoT Agent as Context Provider', function () {
         const options = {
             url:
                 'http://localhost:' +
@@ -253,6 +364,209 @@ describe('NGSI-LD - Command functionalities', function () {
             });
         });
     });
+
+    describe('When multiple command overwrites via PUT  /attrs arrive to the IoT Agent as Context Provider', function () {
+        const options = {
+            url: 'http://localhost:' + iotAgentConfig.server.port + '/ngsi-ld/v1/entities/urn:ngsi-ld:Robot:r2d2/attrs',
+            method: 'PUT',
+            json: {
+                orientation: {
+                    type: 'Property',
+                    value: [1, 2, 3]
+                },
+                position: {
+                    type: 'Property',
+                    value: [28, -104, 23]
+                }
+            },
+            headers: {
+                'fiware-service': 'smartgondor',
+                'content-type': 'application/ld+json'
+            }
+        };
+
+        beforeEach(function (done) {
+            logger.setLevel('ERROR');
+            iotAgentLib.register(device3, function (error) {
+                done();
+            });
+        });
+
+        it('should call the client handler once', function (done) {
+            let handlerCalled = 0;
+
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                id.should.equal('urn:ngsi-ld:' + device3.type + ':' + device3.id);
+                type.should.equal(device3.type);
+                attributes[0].name.should.equal('position');
+                attributes[1].name.should.equal('orientation');
+                JSON.stringify(attributes[0].value).should.equal('[28,-104,23]');
+                JSON.stringify(attributes[1].value).should.equal('[1,2,3]');
+                handlerCalled++;
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        },
+                        {
+                            name: 'orientation',
+                            type: 'Array',
+                            value: '[1, 2, 3]'
+                        }
+                    ]
+                });
+            });
+
+            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 serviceReceived = false;
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                serviceReceived = service === 'smartgondor';
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    ]
+                });
+            });
+
+            request(options, function (error, response, body) {
+                serviceReceived.should.equal(true);
+                done();
+            });
+        });
+    });
+
+    describe('When a command overwrite PUT  attrs/attr-name arrives to the IoT Agent as Context Provider', function () {
+        const options = {
+            url:
+                'http://localhost:' +
+                iotAgentConfig.server.port +
+                '/ngsi-ld/v1/entities/urn:ngsi-ld:Robot:r2d2/attrs/position',
+            method: 'PUT',
+            json: {
+                type: 'Property',
+                value: [28, -104, 23]
+            },
+            headers: {
+                'fiware-service': 'smartgondor',
+                'content-type': 'application/ld+json'
+            }
+        };
+
+        beforeEach(function (done) {
+            logger.setLevel('ERROR');
+            iotAgentLib.register(device3, function (error) {
+                done();
+            });
+        });
+
+        it('should call the client handler once', function (done) {
+            let handlerCalled = 0;
+
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                id.should.equal('urn:ngsi-ld:' + device3.type + ':' + device3.id);
+                type.should.equal(device3.type);
+                attributes[0].name.should.equal('position');
+                JSON.stringify(attributes[0].value).should.equal('[28,-104,23]');
+                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 serviceReceived = false;
+            iotAgentLib.setCommandHandler(function (id, type, service, subservice, attributes, callback) {
+                serviceReceived = service === 'smartgondor';
+                callback(null, {
+                    id,
+                    type,
+                    attributes: [
+                        {
+                            name: 'position',
+                            type: 'Array',
+                            value: '[28, -104, 23]'
+                        }
+                    ]
+                });
+            });
+
+            request(options, function (error, response, body) {
+                serviceReceived.should.equal(true);
+                done();
+            });
+        });
+    });
+
     describe('When an update arrives from the south bound for a registered command', function () {
         beforeEach(function (done) {
             statusAttributeMock = nock('http://192.168.1.1:1026')

package/test/unit/ngsi-ld/ngsiService/languageProperties-test.js

@@ -0,0 +1,112 @@
+/*
+ * 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::[contacto@tid.es]
+ *
+ * Modified by: Daniel Calvo - ATOS Research & Innovation
+ */
+
+/* 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');
+const logger = require('logops');
+const nock = require('nock');
+let contextBrokerMock;
+const iotAgentConfig = {
+    autocast: true,
+    contextBroker: {
+        host: '192.168.1.1',
+        port: '1026',
+        ngsiVersion: 'ld',
+        jsonLdContext: 'http://context.json-ld'
+    },
+    server: {
+        port: 4041
+    },
+    types: {
+        Light: {
+            commands: [],
+            type: 'Light',
+            active: [
+                {
+                    name: 'name',
+                    type: 'LanguageProperty'
+                }
+            ]
+        }
+    },
+    service: 'smartgondor',
+    subservice: 'gardens',
+    providerUrl: 'http://smartgondor.com'
+};
+
+describe('NGSI-LD - LanguageProperty test', function () {
+    beforeEach(function () {
+        logger.setLevel('FATAL');
+    });
+
+    afterEach(function (done) {
+        iotAgentLib.deactivate(done);
+    });
+
+    describe(
+        'When the IoT Agent receives new exonym from a device name with LanguageProperty type and a JSON object',
+        function () {
+            const values = [
+                {
+                    name: 'name',
+                    type: 'LanguageProperty',
+                    value:  {
+                       el: "Κωνσταντινούπολις",
+                       en: "Constantinople",
+                       tr: "İstanbul"
+                    }
+                }
+            ];
+
+            beforeEach(function (done) {
+                nock.cleanAll();
+
+                contextBrokerMock = nock('http://192.168.1.1:1026')
+                    .matchHeader('fiware-service', 'smartgondor')
+                    .post(
+                        '/ngsi-ld/v1/entityOperations/upsert/?options=update',
+                        utils.readExampleFile(
+                            './test/unit/ngsi-ld/examples/contextRequests/updateContextLanguageProperties1.json'
+                        )
+                    )
+                    .reply(204);
+
+                iotAgentLib.activate(iotAgentConfig, done);
+            });
+
+            it('should change the value of the corresponding attribute in the context broker', function (done) {
+                iotAgentLib.update('light1', 'Light', '', values, function (error) {
+                    should.not.exist(error);
+                    contextBrokerMock.done();
+                    done();
+                });
+            });
+        }
+    );
+});

package/test/unit/ngsi-mixed/provisioning/ngsi-versioning-test.js

@@ -171,7 +171,7 @@ describe('Mixed Mode: ngsiVersion test', function () {
     beforeEach(function (done) {
         mongoUtils.cleanDbs(function () {
             iotAgentLib.activate(iotAgentConfig, function () {
-                mongo.connect('mongodb://localhost:27017/iotagent', { useNewUrlParser: true }, function (err, db) {
+                mongo.connect('mongodb://localhost:27017/iotagent', function (err, db) {
                     iotAgentDb = db;
                     done();
                 });

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

@@ -0,0 +1,8 @@
+{
+  "id": "EntityNameByExp",    
+  "type": "MicroLights",
+  "attr_name": {
+    "type": "string",
+    "value": null
+  }
+}

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

@@ -0,0 +1,6 @@
+{
+  "positionExp_status": {
+    "type": "commandStatus",
+    "value": "PENDING"
+  }
+}

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

@@ -0,0 +1,2 @@
+{
+}

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

@@ -0,0 +1 @@
+{"myattr":{"type": "String","value": "location"}}