iotagent-node-lib 4.3.0 → 4.5.0

package/test/functional/testCases.js

@@ -445,9 +445,1314 @@ const testCases = [
             }
         ]
     },
+    {
+        describeName: '0021 - Simple group with active attributes with metadata',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Boolean',
+                                metadata: {
+                                    accuracy: {
+                                        value: 0.8,
+                                        type: 'Float'
+                                    }
+                                }
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending defined object_ids (measures) through http IT should send measures to Context Broker preserving value types, name mappings and metadatas',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: false
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: false,
+                        type: 'Boolean',
+                        metadata: {
+                            accuracy: {
+                                value: 0.8,
+                                type: 'Float'
+                            }
+                        }
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0022 - Simple group with active attributes and multimeasures',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number'
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending defined object_ids (measures) through http IT should send measures to Context Broker preserving value types and name mappings',
+                type: 'multimeasure',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: [
+                        {
+                            a: 0
+                        },
+                        {
+                            a: 1
+                        },
+                        {
+                            a: 2
+                        },
+                        {
+                            a: 3
+                        },
+                        {
+                            a: 4
+                        },
+                        {
+                            a: 5
+                        },
+                        {
+                            a: 6
+                        }
+                    ]
+                },
+                expectation: {
+                    actionType: 'append',
+                    entities: [
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 0
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 1
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 2
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 3
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 4
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 5
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 6
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        }
+                    ]
+                }
+            },
+            {
+                shouldName:
+                    'A - WHEN sending defined object_ids (measures) through http IT should send measures with TimeInstant to Context Broker preserving value types and name mappings and order',
+                type: 'multimeasure',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: [
+                        {
+                            a: 0,
+                            TimeInstant: '2024-04-10T10:00:00Z'
+                        },
+                        {
+                            a: 1,
+                            TimeInstant: '2024-04-10T10:05:00Z'
+                        },
+                        {
+                            a: 2,
+                            TimeInstant: '2024-04-10T10:10:00Z'
+                        },
+                        {
+                            a: 3,
+                            TimeInstant: '2024-04-10T10:15:00Z'
+                        },
+                        {
+                            a: 4,
+                            TimeInstant: '2024-04-10T10:20:00Z'
+                        },
+                        {
+                            a: 5,
+                            TimeInstant: '2024-04-10T10:25:00Z'
+                        },
+                        {
+                            a: 6,
+                            TimeInstant: '2024-04-10T10:30:00Z'
+                        }
+                    ]
+                },
+                expectation: {
+                    actionType: 'append',
+                    entities: [
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 0
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:00:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 1
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:05:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 2
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:10:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 3
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:15:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 4
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:20:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 5
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:25:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 6
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:30:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        }
+                    ]
+                }
+            },
+            {
+                shouldName:
+                    'A - WHEN sending defined object_ids (measures) through http IT should send measures with TimeInstant to Context Broker preserving value types and name mappings and sorted by TimeInstant',
+                type: 'multimeasure',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: [
+                        {
+                            a: 0,
+                            TimeInstant: '2024-04-10T10:15:00Z'
+                        },
+                        {
+                            a: 1,
+                            TimeInstant: '2024-04-10T10:05:00Z'
+                        },
+                        {
+                            a: 2,
+                            TimeInstant: '2024-04-10T10:20:00Z'
+                        },
+                        {
+                            a: 3,
+                            TimeInstant: '2024-04-10T10:00:00Z'
+                        },
+                        {
+                            a: 4,
+                            TimeInstant: '2024-04-10T10:10:00Z'
+                        },
+                        {
+                            a: 5,
+                            TimeInstant: '2024-04-10T10:30:00Z'
+                        },
+                        {
+                            a: 6,
+                            TimeInstant: '2024-04-10T10:25:00Z'
+                        }
+                    ]
+                },
+                expectation: {
+                    actionType: 'append',
+                    entities: [
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 3
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:00:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 1
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:05:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 4
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:10:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 0
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:15:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 2
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:20:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 6
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:25:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        },
+                        {
+                            attr_a: {
+                                type: 'Number',
+                                value: 5
+                            },
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2024-04-10T10:30:00Z'
+                            },
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type
+                        }
+                    ]
+                }
+            }
+        ]
+    },
     // 0100 - JEXL TESTS
     {
-        describeName: '0100 - Simple group with active attribute + JEXL expression boolean (!)',
+        describeName: '0100 - Simple group with active attribute + JEXL expression boolean (!)',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Boolean',
+                                expression: '!a'
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a boolean value (false) through http IT should send to Context Broker the value true ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: false
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: true,
+                        type: 'Boolean'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'B - WHEN sending a numeric value (3) through http IT should send to Context Broker the value false ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 3
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: false,
+                        type: 'Boolean'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'C - WHEN sending a text value (abcd) through http IT should send to Context Broker the value false ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 'abcd'
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: false,
+                        type: 'Boolean'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'D - WHEN not sending the object ID (undefined) required by the expression through http IT should send to Context Broker the value true ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        b: 1
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: true,
+                        type: 'Boolean'
+                    },
+                    b: {
+                        value: 1,
+                        type: 'Text'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0110 - Simple group with active attribute + JEXL expression numeric (+3)',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number',
+                                expression: 'a+3'
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a boolean value (true) through http IT should send to Context Broker the value 4 ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: true
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 4,
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'B - WHEN sending a boolean value (false) through http IT should send to Context Broker the value 3 ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: false
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 3,
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'C - WHEN sending a numeric value (-7) through http IT should send to Context Broker the value -4 ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: -7
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: -4,
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'D - WHEN sending a text value (abcd) through http IT should send to Context Broker the value abcd3',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 'abcd'
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 'abcd3',
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'E - WHEN not sending the object ID (undefined) required by the expression through http IT should not send that attribute to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        b: 1
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    b: {
+                        value: 1,
+                        type: 'Text'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0120 - Simple group with active attribute + JEXL expression numeric (*3)',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number',
+                                expression: 'a*3'
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a boolean value (true) through http IT should send to Context Broker the value 3 ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: true
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 3,
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'B - WHEN sending a boolean value (false) through http IT should send to Context Broker the value 0',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: false
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 0,
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'C - WHEN sending a numeric value (-7) through http IT should send to Context Broker the value -21 ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: -7
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: -21,
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'D - WHEN sending a text value (abcd) through http IT should not send to anything to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 'abcd'
+                    }
+                },
+                expectation: []
+            },
+            {
+                shouldName:
+                    'E - WHEN not sending the object ID (undefined) required by the expression through http IT should not send that attribute to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        b: 1
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    b: {
+                        value: 1,
+                        type: 'Text'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0130 - Simple group with active attribute + JEXL expression text (a|substr(0,2))',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number',
+                                expression: 'a|substr(0,3)'
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a boolean value (true) through http IT should send to Context Broker the value "tru" ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: true
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 'tru',
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'B - WHEN sending a boolean value (false) through http IT should send to Context Broker the value "fal"',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: false
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 'fal',
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'C - WHEN sending a numeric value (-7) through http IT should send to Context Broker the value "-7" ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: -7
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: '-7',
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'D - WHEN sending a text value (abcd) through http IT should not send to anything to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 'abcd'
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 'abc',
+                        type: 'Number'
+                    }
+                }
+            },
+            {
+                shouldName:
+                    'E - WHEN not sending the object ID (undefined) required by the expression through http IT should not send that attribute to Context Broker',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        b: 1
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 'und',
+                        type: 'Number'
+                    },
+                    b: {
+                        value: 1,
+                        type: 'Text'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName:
+            '0140 - Simple group with active attribute + chained JEXL expression text (a | trim | replacestr("hello","hi"))',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'a',
+                                type: 'Text',
+                                expression: 'a | trim | replacestr("hello","hi")'
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a expected value ("Say hello and smile") through http IT should send to Context Broker the value "Say hi and smile" ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 'Say hello and smile'
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    a: {
+                        value: 'Say hi and smile',
+                        type: 'Text'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0150 - Simple group with active attribute + JEXL expression text reusing previous values)',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number',
+                                expression: 'a*10'
+                            },
+                            {
+                                object_id: 'b',
+                                name: 'attr_b',
+                                type: 'Number',
+                                expression: 'attr_a*10'
+                            }
+                        ],
+                        static_attributes: []
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a value (a:3) through http IT should apply nested expressions and send to Context Broker the value "attr_b=300" ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 3
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 30,
+                        type: 'Number'
+                    },
+                    attr_b: {
+                        value: 300,
+                        type: 'Number'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0160 - Simple group with active attribute + JEXL expression referencing static attributes',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number',
+                                expression: 'a*coef'
+                            }
+                        ],
+                        static_attributes: [
+                            {
+                                name: 'coef',
+                                type: 'Number',
+                                value: 1.5
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a value (a:6) through http IT should apply the expression using the static attribute value and send to Context Broker the value "attr_a:9" ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 6
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 9,
+                        type: 'Number'
+                    },
+                    coef: {
+                        value: 1.5,
+                        type: 'Number'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0170 - Simple group with active attribute + JEXL expression referencing context attributes',
+        skip: 'lib', // Explanation in #1523
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Text',
+                                expression: 'a+":"+service+subservice+id+type'
+                            }
+                        ]
+                    }
+                ]
+            },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
+            {
+                shouldName:
+                    'A - WHEN sending a value (text) through http IT should apply the expression using the context attributes value and send to Context Broker the value "text:smartgondor/gardensTestDeviceTestType" ',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 'text'
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value:
+                            'text:' +
+                            globalEnv.service +
+                            globalEnv.servicePath +
+                            globalEnv.deviceId +
+                            globalEnv.entity_type,
+                        type: 'Text'
+                    }
+                }
+            }
+        ]
+    },
+    {
+        describeName: '0180 - Simple group with active attributes + JEXL multiples expressions at same time',
+        skip: 'lib', // Explanation in #1523
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -465,6 +1770,36 @@ const testCases = [
                                 name: 'attr_a',
                                 type: 'Boolean',
                                 expression: '!a'
+                            },
+                            {
+                                object_id: 'b',
+                                name: 'attr_b',
+                                type: 'Integer',
+                                expression: 'b+1'
+                            },
+                            {
+                                object_id: 'c',
+                                name: 'attr_c',
+                                type: 'Text',
+                                expression: 'c+":"+service+subservice+id+type'
+                            },
+                            {
+                                object_id: 'd',
+                                name: 'attr_d',
+                                type: 'Float',
+                                expression: 'd/2+attr_b'
+                            },
+                            {
+                                object_id: 'e',
+                                name: 'attr_e',
+                                type: 'Array',
+                                expression: 'e|concatarr([3,4])'
+                            },
+                            {
+                                object_id: 'f',
+                                name: 'attr_f',
+                                type: 'Object',
+                                expression: '{coordinates: [f.a,f.b], type: "Point"}'
                             }
                         ],
                         static_attributes: []
@@ -479,7 +1814,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a boolean value (false) through http IT should send to Context Broker the value true ',
+                    'A - WHEN sending multiples object_ids (measures) through http IT should send measures to Context Broker applying all expressions at same time',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -489,7 +1824,12 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: false
+                        a: false,
+                        b: 10,
+                        c: 'text',
+                        d: 10.5,
+                        e: [1, 2],
+                        f: { a: 1, b: 2 }
                     }
                 },
                 expectation: {
@@ -498,13 +1838,84 @@ const testCases = [
                     attr_a: {
                         value: true,
                         type: 'Boolean'
+                    },
+                    attr_b: {
+                        value: 11,
+                        type: 'Integer'
+                    },
+                    attr_c: {
+                        type: 'Text',
+                        value:
+                            'text:' +
+                            globalEnv.service +
+                            globalEnv.servicePath +
+                            globalEnv.deviceId +
+                            globalEnv.entity_type
+                    },
+                    attr_d: {
+                        type: 'Float',
+                        value: 16.25
+                    },
+                    attr_e: {
+                        type: 'Array',
+                        value: [1, 2, 3, 4]
+                    },
+                    attr_f: {
+                        type: 'Object',
+                        value: { coordinates: [1, 2], type: 'Point' }
                     }
                 }
+            }
+        ]
+    },
+    {
+        describeName:
+            '0190 - Simple group with JEXL expression using static attribute - addressing structured values (JSON)',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Boolean',
+                                expression: 'a?threshold[90|tostring].max:true'
+                            }
+                        ],
+                        static_attributes: [
+                            {
+                                name: 'threshold',
+                                type: 'Object',
+                                value: {
+                                    '90': { max: 10, min: 1 },
+                                    '92': { max: 12, min: 2 },
+                                    '93': { max: 13, min: 3 }
+                                }
+                            }
+                        ],
+                        explicitAttrs: "['attr_a']"
+                    }
+                ]
             },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
             {
                 shouldName:
-                    'B - WHEN sending a numeric value (3) through http IT should send to Context Broker the value false ',
+                    'A - WHEN sending a numeric value () through http IT should send to Context Broker the value true ',
                 type: 'single',
+                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -513,22 +1924,61 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 3
+                        a: false
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: false,
+                        value: true,
                         type: 'Boolean'
                     }
                 }
+            }
+        ]
+    },
+    {
+        describeName: '0191 - Simple group with JEXL expression in metadata',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Boolean',
+                                expression: 'a?threshold[90|tostring].max:true',
+                                metadata: {
+                                    unit: {
+                                        type: 'Text',
+                                        expression: '"hola" + "adios"'
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
             },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
             {
                 shouldName:
-                    'C - WHEN sending a text value (abcd) through http IT should send to Context Broker the value false ',
+                    'A - WHEN sending a measure  through http IT should send to Context Broker expanded metadata value  ',
                 type: 'single',
+                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -537,22 +1987,63 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 'abcd'
+                        a: false
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: false,
-                        type: 'Boolean'
+                        value: true,
+                        type: 'Boolean',
+                        metadata: {
+                            unit: {
+                                type: 'Text',
+                                value: 'holaadios'
+                            }
+                        }
                     }
                 }
+            }
+        ]
+    },
+    // 0200 - COMMANDS TESTS
+    {
+        describeName: '0200 - Simple group with commands',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [
+                            {
+                                name: 'cmd1',
+                                type: 'command'
+                            }
+                        ],
+                        endpoint: 'http://myendpoint.com',
+                        transport: 'http',
+                        lazy: [],
+                        attributes: [],
+                        static_attributes: []
+                    }
+                ]
             },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
             {
                 shouldName:
-                    'D - WHEN not sending the object ID (undefined) required by the expression through http IT should send to Context Broker the value true ',
+                    'A - WHEN sending not provisioned object_ids (measures) through http IT should store commands into Context Broker',
                 type: 'single',
+                skip: '!lib', // there is not CB registration mock
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -561,26 +2052,24 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        b: 1
+                        b: 10
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: true,
-                        type: 'Boolean'
-                    },
                     b: {
-                        value: 1,
+                        value: 10,
                         type: 'Text'
                     }
                 }
             }
         ]
     },
+    // 0300 - STATIC ATTRIBUTES TESTS
     {
-        describeName: '0110 - Simple group with active attribute + JEXL expression numeric (+3)',
+        describeName:
+            '0300 - Simple group with active attributes + Static attributes + JEXL expression using static attribute value',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -597,10 +2086,16 @@ const testCases = [
                                 object_id: 'a',
                                 name: 'attr_a',
                                 type: 'Number',
-                                expression: 'a+3'
+                                expression: 'a*static_a'
                             }
                         ],
-                        static_attributes: []
+                        static_attributes: [
+                            {
+                                name: 'static_a',
+                                type: 'Number',
+                                value: 3
+                            }
+                        ]
                     }
                 ]
             },
@@ -612,7 +2107,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a boolean value (true) through http IT should send to Context Broker the value 4 ',
+                    'A - WHEN sending not provisioned object_ids (measures) through http IT should store static attributes into Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -622,37 +2117,17 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: true
+                        b: 10
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 4,
-                        type: 'Number'
-                    }
-                }
-            },
-            {
-                shouldName:
-                    'B - WHEN sending a boolean value (false) through http IT should send to Context Broker the value 3 ',
-                type: 'single',
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
+                    b: {
+                        value: 10,
+                        type: 'Text'
                     },
-                    json: {
-                        a: false
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
+                    static_a: {
                         value: 3,
                         type: 'Number'
                     }
@@ -660,7 +2135,7 @@ const testCases = [
             },
             {
                 shouldName:
-                    'C - WHEN sending a numeric value (-7) through http IT should send to Context Broker the value -4 ',
+                    'B - WHEN sending provisioned object_ids (measures) through http IT should store static attributes into Context Broker + calculate expression based on static',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -670,45 +2145,63 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: -7
+                        a: 10
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: -4,
+                        value: 30,
                         type: 'Number'
-                    }
-                }
-            },
-            {
-                shouldName:
-                    'D - WHEN sending a text value (abcd) through http IT should send to Context Broker the value abcd3',
-                type: 'single',
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
                     },
-                    json: {
-                        a: 'abcd'
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 'abcd3',
+                    static_a: {
+                        value: 3,
                         type: 'Number'
                     }
                 }
+            }
+        ]
+    },
+    {
+        describeName: '0310 - Simple group with active attributes + JSON value Static attributes ',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [],
+                        static_attributes: [
+                            {
+                                name: 'static_a',
+                                type: 'Number',
+                                value: {
+                                    v1: 1,
+                                    v2: {
+                                        v3: 3,
+                                        v4: 4
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
             },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
             {
                 shouldName:
-                    'E - WHEN not sending the object ID (undefined) required by the expression through http IT should not send that attribute to Context Broker',
+                    'A - WHEN sending measures through http IT should store complex static attributes into Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -718,22 +2211,32 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        b: 1
+                        a: 10
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    b: {
-                        value: 1,
+                    a: {
+                        value: 10,
                         type: 'Text'
+                    },
+                    static_a: {
+                        value: {
+                            v1: 1,
+                            v2: {
+                                v3: 3,
+                                v4: 4
+                            }
+                        },
+                        type: 'Number'
                     }
                 }
             }
         ]
     },
     {
-        describeName: '0120 - Simple group with active attribute + JEXL expression numeric (*3)',
+        describeName: '0320 - Simple group with active attributes + metadata in Static attributes ',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -745,15 +2248,20 @@ const testCases = [
                         entity_type: globalEnv.entity_type,
                         commands: [],
                         lazy: [],
-                        attributes: [
+                        attributes: [],
+                        static_attributes: [
                             {
-                                object_id: 'a',
-                                name: 'attr_a',
+                                name: 'static_a',
                                 type: 'Number',
-                                expression: 'a*3'
+                                value: 4,
+                                metadata: {
+                                    accuracy: {
+                                        value: 0.8,
+                                        type: 'Float'
+                                    }
+                                }
                             }
-                        ],
-                        static_attributes: []
+                        ]
                     }
                 ]
             },
@@ -765,7 +2273,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a boolean value (true) through http IT should send to Context Broker the value 3 ',
+                    'A - WHEN sending measures through http IT should store metatada static attributes into Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -775,69 +2283,64 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: true
+                        a: 10
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 3,
-                        type: 'Number'
-                    }
-                }
-            },
-            {
-                shouldName:
-                    'B - WHEN sending a boolean value (false) through http IT should send to Context Broker the value 0',
-                type: 'single',
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
+                    a: {
+                        value: 10,
+                        type: 'Text'
                     },
-                    json: {
-                        a: false
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 0,
-                        type: 'Number'
+                    static_a: {
+                        value: 4,
+                        type: 'Number',
+                        metadata: {
+                            accuracy: {
+                                value: 0.8,
+                                type: 'Float'
+                            }
+                        }
                     }
                 }
-            },
-            {
-                shouldName:
-                    'C - WHEN sending a numeric value (-7) through http IT should send to Context Broker the value -21 ',
-                type: 'single',
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
-                    },
-                    json: {
-                        a: -7
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: -21,
-                        type: 'Number'
+            }
+        ]
+    },
+    // 0400 - TIMESTAMP TESTS
+    {
+        describeName: '0400 - Simple group with active attribute + timestamp:false',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        timestamp: false,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number'
+                            }
+                        ]
                     }
-                }
+                ]
             },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
             {
                 shouldName:
-                    'D - WHEN sending a text value (abcd) through http IT should not send to anything to Context Broker',
+                    'A - WHEN sending a measure not named TimeInstant through http IT should not add the timestamp to the attributes sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -847,14 +2350,21 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 'abcd'
+                        a: 23
                     }
                 },
-                expectation: []
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 23,
+                        type: 'Number'
+                    }
+                }
             },
             {
                 shouldName:
-                    'E - WHEN not sending the object ID (undefined) required by the expression through http IT should not send that attribute to Context Broker',
+                    'B - WHEN sending a measure named TimeInstant through http IT should not add the timestamp to the other attributes sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -864,22 +2374,27 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        b: 1
+                        TimeInstant: '2015-12-14T08:06:01.468Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    b: {
-                        value: 1,
-                        type: 'Text'
+                    attr_a: {
+                        value: 23,
+                        type: 'Number'
+                    },
+                    TimeInstant: {
+                        value: '2015-12-14T08:06:01.468Z',
+                        type: 'DateTime'
                     }
                 }
             }
         ]
     },
     {
-        describeName: '0130 - Simple group with active attribute + JEXL expression text (a|substr(0,2))',
+        describeName: '0410 - Simple group with active attribute + timestamp:true',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -889,17 +2404,16 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
+                        timestamp: true,
                         commands: [],
                         lazy: [],
                         attributes: [
                             {
                                 object_id: 'a',
                                 name: 'attr_a',
-                                type: 'Number',
-                                expression: 'a|substr(0,3)'
+                                type: 'Number'
                             }
-                        ],
-                        static_attributes: []
+                        ]
                     }
                 ]
             },
@@ -911,8 +2425,9 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a boolean value (true) through http IT should send to Context Broker the value "tru" ',
+                    'A - WHEN sending a measure not named TimeInstant through http IT should add the timestamp to the attributes sent to Context Broker',
                 type: 'single',
+                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -921,45 +2436,31 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: true
+                        a: 21
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: 'tru',
-                        type: 'Number'
-                    }
-                }
-            },
-            {
-                shouldName:
-                    'B - WHEN sending a boolean value (false) through http IT should send to Context Broker the value "fal"',
-                type: 'single',
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
+                        value: 21,
+                        type: 'Number',
+                        metadata: {
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: _.isDateString
+                            }
+                        }
                     },
-                    json: {
-                        a: false
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 'fal',
-                        type: 'Number'
+                    TimeInstant: {
+                        type: 'DateTime',
+                        value: _.isDateString
                     }
                 }
             },
             {
                 shouldName:
-                    'C - WHEN sending a numeric value (-7) through http IT should send to Context Broker the value "-7" ',
+                    'B - WHEN sending a measure named TimeInstant through http IT should not add the timestamp to the other attributes sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -969,21 +2470,63 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: -7
+                        TimeInstant: '2015-12-14T08:06:01.468Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: '-7',
-                        type: 'Number'
+                        value: 23,
+                        type: 'Number',
+                        metadata: {
+                            TimeInstant: {
+                                type: 'DateTime',
+                                value: '2015-12-14T08:06:01.468Z'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2015-12-14T08:06:01.468Z',
+                        type: 'DateTime'
                     }
                 }
+            }
+        ]
+    },
+    {
+        describeName: '0420 - Simple group with active attribute + timestamp not defined',
+        provision: {
+            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
+            method: 'POST',
+            json: {
+                services: [
+                    {
+                        resource: '/iot/json',
+                        apikey: globalEnv.apikey,
+                        entity_type: globalEnv.entity_type,
+                        commands: [],
+                        lazy: [],
+                        attributes: [
+                            {
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number'
+                            }
+                        ]
+                    }
+                ]
             },
+            headers: {
+                'fiware-service': globalEnv.service,
+                'fiware-servicepath': globalEnv.servicePath
+            }
+        },
+        should: [
             {
                 shouldName:
-                    'D - WHEN sending a text value (abcd) through http IT should not send to anything to Context Broker',
+                    'A - WHEN sending a measure not named TimeInstant through http IT should not add the timestamp to the attributes or metadata sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -993,21 +2536,21 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 'abcd'
+                        a: 21
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: 'abc',
+                        value: 21,
                         type: 'Number'
                     }
                 }
             },
             {
                 shouldName:
-                    'E - WHEN not sending the object ID (undefined) required by the expression through http IT should not send that attribute to Context Broker',
+                    'B - WHEN sending a measure named TimeInstant through http IT should not add the timestamp to the other attributes sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1017,26 +2560,27 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        b: 1
+                        TimeInstant: '2015-12-14T08:06:01.468Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: 'und',
+                        value: 23,
                         type: 'Number'
                     },
-                    b: {
-                        value: 1,
-                        type: 'Text'
+                    TimeInstant: {
+                        value: '2015-12-14T08:06:01.468Z',
+                        type: 'DateTime'
                     }
                 }
             }
         ]
     },
     {
-        describeName: '0140 - Simple group with active attribute + chained JEXL expression text (a|substr(0,2))',
+        describeName: '0430 - Simple group with active attribute + timestamp mapping defined',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1045,18 +2589,17 @@ const testCases = [
                     {
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
+                        timestamp: true,
                         entity_type: globalEnv.entity_type,
                         commands: [],
                         lazy: [],
                         attributes: [
                             {
-                                object_id: 'a',
-                                name: 'a',
-                                type: 'Text',
-                                expression: 'a | trim | replacestr("hello","hi")'
+                                object_id: 'mydatetime',
+                                name: 'TimeInstant',
+                                type: 'DateTime'
                             }
-                        ],
-                        static_attributes: []
+                        ]
                     }
                 ]
             },
@@ -1068,7 +2611,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a expected value ("Say hello and smile") through http IT should send to Context Broker the value "Say hi and smile" ',
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1078,61 +2621,34 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 'Say hello and smile'
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     a: {
-                        value: 'Say hi and smile',
-                        type: 'Text'
-                    }
-                }
-            }
-        ]
-    },
-    {
-        describeName: '0150 - Simple group with active attribute + JEXL expression text reusing previous values)',
-        provision: {
-            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
-            method: 'POST',
-            json: {
-                services: [
-                    {
-                        resource: '/iot/json',
-                        apikey: globalEnv.apikey,
-                        entity_type: globalEnv.entity_type,
-                        commands: [],
-                        lazy: [],
-                        attributes: [
-                            {
-                                object_id: 'a',
-                                name: 'attr_a',
-                                type: 'Number',
-                                expression: 'a*10'
-                            },
-                            {
-                                object_id: 'b',
-                                name: 'attr_b',
-                                type: 'Number',
-                                expression: 'attr_a*10'
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
                             }
-                        ],
-                        static_attributes: []
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
                     }
-                ]
+                }
             },
-            headers: {
-                'fiware-service': globalEnv.service,
-                'fiware-servicepath': globalEnv.servicePath
-            }
-        },
-        should: [
             {
                 shouldName:
-                    'A - WHEN sending a value (a:3) through http IT should apply nested expressions and send to Context Broker the value "attr_b=300" ',
+                    'A - WHEN sending a measure without timestamp through http IT should use system timestamp for mapped attribute and use it for timestmap and other metadata attributes sent to Context Broker',
                 type: 'single',
+                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -1141,64 +2657,31 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 3
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 30,
-                        type: 'Number'
-                    },
-                    attr_b: {
-                        value: 300,
-                        type: 'Number'
-                    }
-                }
-            }
-        ]
-    },
-    {
-        describeName: '0160 - Simple group with active attribute + JEXL expression referencing static attributes',
-        provision: {
-            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
-            method: 'POST',
-            json: {
-                services: [
-                    {
-                        resource: '/iot/json',
-                        apikey: globalEnv.apikey,
-                        entity_type: globalEnv.entity_type,
-                        commands: [],
-                        lazy: [],
-                        attributes: [
-                            {
-                                object_id: 'a',
-                                name: 'attr_a',
-                                type: 'Number',
-                                expression: 'a*coef'
-                            }
-                        ],
-                        static_attributes: [
-                            {
-                                name: 'coef',
-                                type: 'Number',
-                                value: 1.5
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: _.isDateString,
+                                type: 'DateTime'
                             }
-                        ]
+                        }
+                    },
+                    TimeInstant: {
+                        value: _.isDateString,
+                        type: 'DateTime'
                     }
-                ]
+                }
             },
-            headers: {
-                'fiware-service': globalEnv.service,
-                'fiware-servicepath': globalEnv.servicePath
-            }
-        },
-        should: [
             {
                 shouldName:
-                    'A - WHEN sending a value (a:6) through http IT should apply the expression using the static attribute value and send to Context Broker the value "attr_a:9" ',
+                    'A - WHEN sending a measure with timestamp through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1208,27 +2691,34 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 6
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        TimeInstant: '2033-03-03T03:33:33.333Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 9,
-                        type: 'Number'
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        }
                     },
-                    coef: {
-                        value: 1.5,
-                        type: 'Number'
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
                     }
                 }
             }
         ]
     },
     {
-        describeName: '0170 - Simple group with active attribute + JEXL expression referencing context attributes',
-        skip: 'lib', // Explanation in #1523
+        describeName: '0431 - Simple group with active attribute + timestamp mapping defined + explicitAttrs',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1237,15 +2727,21 @@ const testCases = [
                     {
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
+                        timestamp: true,
+                        explicitAttrs: true,
                         entity_type: globalEnv.entity_type,
                         commands: [],
                         lazy: [],
                         attributes: [
+                            {
+                                object_id: 'mydatetime',
+                                name: 'TimeInstant',
+                                type: 'DateTime'
+                            },
                             {
                                 object_id: 'a',
-                                name: 'attr_a',
-                                type: 'Text',
-                                expression: 'a+":"+service+subservice+id+type'
+                                name: 'a',
+                                type: 'Text'
                             }
                         ]
                     }
@@ -1259,7 +2755,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a value (text) through http IT should apply the expression using the context attributes value and send to Context Broker the value "text:smartgondor/gardensTestDeviceTestType" ',
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1269,91 +2765,34 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 'text'
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value:
-                            'text:' +
-                            globalEnv.service +
-                            globalEnv.servicePath +
-                            globalEnv.deviceId +
-                            globalEnv.entity_type,
-                        type: 'Text'
-                    }
-                }
-            }
-        ]
-    },
-    {
-        describeName: '0180 - Simple group with active attributes + JEXL multiples expressions at same time',
-        skip: 'lib', // Explanation in #1523
-        provision: {
-            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
-            method: 'POST',
-            json: {
-                services: [
-                    {
-                        resource: '/iot/json',
-                        apikey: globalEnv.apikey,
-                        entity_type: globalEnv.entity_type,
-                        commands: [],
-                        lazy: [],
-                        attributes: [
-                            {
-                                object_id: 'a',
-                                name: 'attr_a',
-                                type: 'Boolean',
-                                expression: '!a'
-                            },
-                            {
-                                object_id: 'b',
-                                name: 'attr_b',
-                                type: 'Integer',
-                                expression: 'b+1'
-                            },
-                            {
-                                object_id: 'c',
-                                name: 'attr_c',
-                                type: 'Text',
-                                expression: 'c+":"+service+subservice+id+type'
-                            },
-                            {
-                                object_id: 'd',
-                                name: 'attr_d',
-                                type: 'Float',
-                                expression: 'd/2+attr_b'
-                            },
-                            {
-                                object_id: 'e',
-                                name: 'attr_e',
-                                type: 'Array',
-                                expression: 'e|concatarr([3,4])'
-                            },
-                            {
-                                object_id: 'f',
-                                name: 'attr_f',
-                                type: 'Object',
-                                expression: '{coordinates: [f.a,f.b], type: "Point"}'
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
                             }
-                        ],
-                        static_attributes: []
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
                     }
-                ]
+                }
             },
-            headers: {
-                'fiware-service': globalEnv.service,
-                'fiware-servicepath': globalEnv.servicePath
-            }
-        },
-        should: [
             {
                 shouldName:
-                    'A - WHEN sending multiples object_ids (measures) through http IT should send measures to Context Broker applying all expressions at same time',
+                    'A - WHEN sending a measure without timestamp through http IT should use system timestamp for mapped attribute and use it for timestmap and other metadata attributes sent to Context Broker',
                 type: 'single',
+                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -1362,98 +2801,32 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: false,
-                        b: 10,
-                        c: 'text',
-                        d: 10.5,
-                        e: [1, 2],
-                        f: { a: 1, b: 2 }
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: true,
-                        type: 'Boolean'
-                    },
-                    attr_b: {
-                        value: 11,
-                        type: 'Integer'
-                    },
-                    attr_c: {
+                    a: {
+                        value: 23,
                         type: 'Text',
-                        value:
-                            'text:' +
-                            globalEnv.service +
-                            globalEnv.servicePath +
-                            globalEnv.deviceId +
-                            globalEnv.entity_type
-                    },
-                    attr_d: {
-                        type: 'Float',
-                        value: 16.25
-                    },
-                    attr_e: {
-                        type: 'Array',
-                        value: [1, 2, 3, 4]
+                        metadata: {
+                            TimeInstant: {
+                                value: _.isDateString,
+                                type: 'DateTime'
+                            }
+                        }
                     },
-                    attr_f: {
-                        type: 'Object',
-                        value: { coordinates: [1, 2], type: 'Point' }
+                    TimeInstant: {
+                        value: _.isDateString,
+                        type: 'DateTime'
                     }
                 }
-            }
-        ]
-    },
-    {
-        describeName:
-            '0190 - Simple group with JEXL expression using static attribute - addressing structured values (JSON)',
-        provision: {
-            url: 'http://localhost:' + config.iota.server.port + '/iot/services',
-            method: 'POST',
-            json: {
-                services: [
-                    {
-                        resource: '/iot/json',
-                        apikey: globalEnv.apikey,
-                        entity_type: globalEnv.entity_type,
-                        commands: [],
-                        lazy: [],
-                        attributes: [
-                            {
-                                object_id: 'a',
-                                name: 'attr_a',
-                                type: 'Boolean',
-                                expression: 'a?threshold[90|tostring].max:true'
-                            }
-                        ],
-                        static_attributes: [
-                            {
-                                name: 'threshold',
-                                type: 'Object',
-                                value: {
-                                    '90': { max: 10, min: 1 },
-                                    '92': { max: 12, min: 2 },
-                                    '93': { max: 13, min: 3 }
-                                }
-                            }
-                        ],
-                        explicitAttrs: "['attr_a']"
-                    }
-                ]
             },
-            headers: {
-                'fiware-service': globalEnv.service,
-                'fiware-servicepath': globalEnv.servicePath
-            }
-        },
-        should: [
             {
                 shouldName:
-                    'A - WHEN sending a numeric value () through http IT should send to Context Broker the value true ',
+                    'A - WHEN sending a measure with timestamp through http IT should map the measure to timestamp attribute and use it for timestmap and other metadata attributes sent to Context Broker',
                 type: 'single',
-                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -1462,23 +2835,34 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: false
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        TimeInstant: '2033-03-03T03:33:33.333Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: true,
-                        type: 'Boolean'
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2022-02-02T02:22:22.222Z',
+                        type: 'DateTime'
                     }
                 }
             }
         ]
     },
-    // 0200 - COMMANDS TESTS
     {
-        describeName: '0200 - Simple group with commands',
+        describeName: '0432 - Simple group with active attribute + bad timestamp mapping defined',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1487,18 +2871,18 @@ const testCases = [
                     {
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
+                        timestamp: true,
                         entity_type: globalEnv.entity_type,
-                        commands: [
+                        commands: [],
+                        lazy: [],
+                        attributes: [
                             {
-                                name: 'cmd1',
-                                type: 'command'
+                                object_id: 'mydatetime',
+                                name: 'TimeInstant',
+                                type: 'DateTime',
+                                expression: '"2033-03-03T" + "03:33:33.333Z"'
                             }
-                        ],
-                        endpoint: 'http://myendpoint.com',
-                        transport: 'http',
-                        lazy: [],
-                        attributes: [],
-                        static_attributes: []
+                        ]
                     }
                 ]
             },
@@ -1510,9 +2894,8 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending not provisioned object_ids (measures) through http IT should store commands into Context Broker',
+                    'A - WHEN sending a measure through http IT should map the measure to fixed timestamp attribute and use it for timestmap sent to Context Broker',
                 type: 'single',
-                skip: '!lib', // there is not CB registration mock
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -1521,24 +2904,33 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        b: 10
+                        mydatetime: '2022-02-02T02:22:22.222Z',
+                        a: 23
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    b: {
-                        value: 10,
-                        type: 'Text'
+                    a: {
+                        value: 23,
+                        type: 'Text',
+                        metadata: {
+                            TimeInstant: {
+                                value: '2033-03-03T03:33:33.333Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    },
+                    TimeInstant: {
+                        value: '2033-03-03T03:33:33.333Z',
+                        type: 'DateTime'
                     }
                 }
             }
         ]
     },
-    // 0300 - STATIC ATTRIBUTES TESTS
     {
-        describeName:
-            '0300 - Simple group with active attributes + Static attributes + JEXL expression using static attribute value',
+        describeName: '0433 - Simple group with active attribute + several timestamp mappings defined in multientity',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1547,22 +2939,45 @@ const testCases = [
                     {
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
+                        timestamp: true,
                         entity_type: globalEnv.entity_type,
                         commands: [],
                         lazy: [],
                         attributes: [
                             {
                                 object_id: 'a',
-                                name: 'attr_a',
-                                type: 'Number',
-                                expression: 'a*static_a'
-                            }
-                        ],
-                        static_attributes: [
+                                name: 'a',
+                                type: 'Text'
+                            },
                             {
-                                name: 'static_a',
-                                type: 'Number',
-                                value: 3
+                                object_id: 'mydatetime1',
+                                name: 'TimeInstant',
+                                type: 'DateTime',
+                                entity_name: 'TestType:TestDevice1',
+                                entity_type: 'TestType'
+                            },
+                            {
+                                object_id: 'mydatetime2',
+                                name: 'TimeInstant',
+                                type: 'DateTime',
+                                entity_name: 'TestType:TestDevice2',
+                                entity_type: 'TestType'
+                            },
+                            {
+                                object_id: 'a1',
+                                name: 'a1',
+                                type: 'Text',
+                                expression: 'a',
+                                entity_name: 'TestType:TestDevice1',
+                                entity_type: 'TestType'
+                            },
+                            {
+                                object_id: 'a2',
+                                name: 'a2',
+                                type: 'Text',
+                                expression: 'a',
+                                entity_name: 'TestType:TestDevice2',
+                                entity_type: 'TestType'
                             }
                         ]
                     }
@@ -1576,8 +2991,9 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending not provisioned object_ids (measures) through http IT should store static attributes into Context Broker',
-                type: 'single',
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attributes and use it for timestmap and other metadata attributes sent to Context Broker',
+                type: 'multientity',
+                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -1586,26 +3002,76 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        b: 10
+                        a: 23,
+                        mydatetime1: '2011-01-01T01:11:11.111Z',
+                        mydatetime2: '2022-02-02T02:22:22.222Z'
                     }
                 },
                 expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    b: {
-                        value: 10,
-                        type: 'Text'
-                    },
-                    static_a: {
-                        value: 3,
-                        type: 'Number'
-                    }
+                    actionType: 'append',
+                    entities: [
+                        {
+                            id: 'TestType:TestDevice1',
+                            type: globalEnv.entity_type,
+                            a1: {
+                                value: 23,
+                                type: 'Text',
+                                metadata: {
+                                    TimeInstant: {
+                                        value: '2011-01-01T01:11:11.111Z',
+                                        type: 'DateTime'
+                                    }
+                                }
+                            },
+                            TimeInstant: {
+                                value: '2011-01-01T01:11:11.111Z',
+                                type: 'DateTime'
+                            }
+                        },
+                        {
+                            id: 'TestType:TestDevice2',
+                            type: globalEnv.entity_type,
+                            a2: {
+                                value: 23,
+                                type: 'Text',
+                                metadata: {
+                                    TimeInstant: {
+                                        value: '2022-02-02T02:22:22.222Z',
+                                        type: 'DateTime'
+                                    }
+                                }
+                            },
+                            TimeInstant: {
+                                value: '2022-02-02T02:22:22.222Z',
+                                type: 'DateTime'
+                            }
+                        },
+                        {
+                            id: globalEnv.entity_name,
+                            type: globalEnv.entity_type,
+                            a: {
+                                value: 23,
+                                type: 'Text',
+                                metadata: {
+                                    TimeInstant: {
+                                        value: _.isDateString,
+                                        type: 'DateTime'
+                                    }
+                                }
+                            },
+                            TimeInstant: {
+                                value: _.isDateString,
+                                type: 'DateTime'
+                            }
+                        }
+                    ]
                 }
             },
             {
                 shouldName:
-                    'B - WHEN sending provisioned object_ids (measures) through http IT should store static attributes into Context Broker + calculate expression based on static',
-                type: 'single',
+                    'A - WHEN sending a measure through http IT should map the measure to timestamp attributes for just mapped entity and sent to Context Broker',
+                type: 'multientity',
+                isRegex: true,
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
                     method: 'POST',
@@ -1614,26 +3080,29 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 10
+                        mydatetime1: '2011-01-01T01:11:11.111Z'
                     }
                 },
                 expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 30,
-                        type: 'Number'
-                    },
-                    static_a: {
-                        value: 3,
-                        type: 'Number'
-                    }
+                    actionType: 'append',
+                    entities: [
+                        {
+                            id: 'TestType:TestDevice1',
+                            type: globalEnv.entity_type,
+                            TimeInstant: {
+                                value: '2011-01-01T01:11:11.111Z',
+                                type: 'DateTime'
+                            }
+                        }
+                    ]
                 }
             }
         ]
     },
+
+    // 0500 - EXPLICIT ATTRIBUTES TESTS
     {
-        describeName: '0310 - Simple group with active attributes + JSON value Static attributes ',
+        describeName: '0500 - Group with explicit attrs:false (boolean) + active atributes',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1643,22 +3112,17 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
+                        explicitAttrs: false,
                         commands: [],
                         lazy: [],
-                        attributes: [],
-                        static_attributes: [
+                        attributes: [
                             {
-                                name: 'static_a',
-                                type: 'Number',
-                                value: {
-                                    v1: 1,
-                                    v2: {
-                                        v3: 3,
-                                        v4: 4
-                                    }
-                                }
+                                object_id: 'a',
+                                name: 'attr_a',
+                                type: 'Number'
                             }
-                        ]
+                        ],
+                        static_attributes: []
                     }
                 ]
             },
@@ -1670,7 +3134,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending measures through http IT should store complex static attributes into Context Broker',
+                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store all attributes into Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1680,33 +3144,27 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 10
+                        a: 3,
+                        b: 10
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    a: {
+                    b: {
                         value: 10,
                         type: 'Text'
                     },
-                    static_a: {
-                        value: {
-                            v1: 1,
-                            v2: {
-                                v3: 3,
-                                v4: 4
-                            }
-                        },
+                    attr_a: {
+                        value: 3,
                         type: 'Number'
                     }
                 }
             }
         ]
     },
-    // 0400 - TIMESTAMP TESTS
     {
-        describeName: '0400 - Simple group with active attribute + timestamp:false',
+        describeName: '0510 - Group without explicit (not defined) + active atributes',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1716,7 +3174,6 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
-                        timestamp: false,
                         commands: [],
                         lazy: [],
                         attributes: [
@@ -1725,7 +3182,8 @@ const testCases = [
                                 name: 'attr_a',
                                 type: 'Number'
                             }
-                        ]
+                        ],
+                        static_attributes: []
                     }
                 ]
             },
@@ -1737,7 +3195,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a measure not named TimeInstant through http IT should not add the timestamp to the attributes sent to Context Broker',
+                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store all attributes into Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1747,51 +3205,27 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 23
+                        a: 3,
+                        b: 10
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 23,
-                        type: 'Number'
-                    }
-                }
-            },
-            {
-                shouldName:
-                    'B - WHEN sending a measure named TimeInstant through http IT should not add the timestamp to the other attributes sent to Context Broker',
-                type: 'single',
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
+                    b: {
+                        value: 10,
+                        type: 'Text'
                     },
-                    json: {
-                        TimeInstant: '2015-12-14T08:06:01.468Z',
-                        a: 23
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
                     attr_a: {
-                        value: 23,
+                        value: 3,
                         type: 'Number'
-                    },
-                    TimeInstant: {
-                        value: '2015-12-14T08:06:01.468Z',
-                        type: 'DateTime'
                     }
                 }
             }
         ]
     },
     {
-        describeName: '0410 - Simple group with active attribute + timestamp:true',
+        describeName: '0520 - Group with explicit attrs:true (boolean) + active atributes',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1801,7 +3235,7 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
-                        timestamp: true,
+                        explicitAttrs: true,
                         commands: [],
                         lazy: [],
                         attributes: [
@@ -1810,7 +3244,8 @@ const testCases = [
                                 name: 'attr_a',
                                 type: 'Number'
                             }
-                        ]
+                        ],
+                        static_attributes: []
                     }
                 ]
             },
@@ -1822,42 +3257,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a measure not named TimeInstant through http IT should add the timestamp to the attributes sent to Context Broker',
-                type: 'single',
-                isRegex: true,
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
-                    },
-                    json: {
-                        a: 21
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 21,
-                        type: 'Number',
-                        metadata: {
-                            TimeInstant: {
-                                type: 'DateTime',
-                                value: _.isDateString
-                            }
-                        }
-                    },
-                    TimeInstant: {
-                        type: 'DateTime',
-                        value: _.isDateString
-                    }
-                }
-            },
-            {
-                shouldName:
-                    'B - WHEN sending a measure named TimeInstant through http IT should not add the timestamp to the other attributes sent to Context Broker',
+                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store all attributes into Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1866,34 +3266,24 @@ const testCases = [
                         i: globalEnv.deviceId,
                         k: globalEnv.apikey
                     },
-                    json: {
-                        TimeInstant: '2015-12-14T08:06:01.468Z',
-                        a: 23
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 23,
-                        type: 'Number',
-                        metadata: {
-                            TimeInstant: {
-                                type: 'DateTime',
-                                value: '2015-12-14T08:06:01.468Z'
-                            }
-                        }
-                    },
-                    TimeInstant: {
-                        value: '2015-12-14T08:06:01.468Z',
-                        type: 'DateTime'
+                    json: {
+                        a: 3,
+                        b: 10
+                    }
+                },
+                expectation: {
+                    id: globalEnv.entity_name,
+                    type: globalEnv.entity_type,
+                    attr_a: {
+                        value: 3,
+                        type: 'Number'
                     }
                 }
             }
         ]
     },
     {
-        describeName: '0420 - Simple group with active attribute + timestamp not defined',
+        describeName: '0530 - Group with explicit attrs:[array] + active attributes + static attributes',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1903,13 +3293,31 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
+                        explicitAttrs: "['attr_a','static_a']",
                         commands: [],
                         lazy: [],
                         attributes: [
                             {
-                                object_id: 'a',
                                 name: 'attr_a',
+                                object_id: 'a',
                                 type: 'Number'
+                            },
+                            {
+                                name: 'attr_b',
+                                object_id: 'b',
+                                type: 'Number'
+                            }
+                        ],
+                        static_attributes: [
+                            {
+                                name: 'static_a',
+                                type: 'Number',
+                                value: 3
+                            },
+                            {
+                                name: 'static_b',
+                                type: 'Number',
+                                value: 4
                             }
                         ]
                     }
@@ -1923,7 +3331,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending a measure not named TimeInstant through http IT should not add the timestamp to the attributes or metadata sent to Context Broker',
+                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store only defined in explicitAttrs array into Context Broker',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -1933,52 +3341,28 @@ const testCases = [
                         k: globalEnv.apikey
                     },
                     json: {
-                        a: 21
+                        a: 3,
+                        b: 10,
+                        c: 11
                     }
                 },
                 expectation: {
                     id: globalEnv.entity_name,
                     type: globalEnv.entity_type,
                     attr_a: {
-                        value: 21,
+                        value: 3,
                         type: 'Number'
-                    }
-                }
-            },
-            {
-                shouldName:
-                    'B - WHEN sending a measure named TimeInstant through http IT should not add the timestamp to the other attributes sent to Context Broker',
-                type: 'single',
-                measure: {
-                    url: 'http://localhost:' + config.http.port + '/iot/json',
-                    method: 'POST',
-                    qs: {
-                        i: globalEnv.deviceId,
-                        k: globalEnv.apikey
                     },
-                    json: {
-                        TimeInstant: '2015-12-14T08:06:01.468Z',
-                        a: 23
-                    }
-                },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 23,
+                    static_a: {
+                        value: 3,
                         type: 'Number'
-                    },
-                    TimeInstant: {
-                        value: '2015-12-14T08:06:01.468Z',
-                        type: 'DateTime'
                     }
                 }
             }
         ]
     },
-    // 0500 - EXPLICIT ATTRIBUTES TESTS
     {
-        describeName: '0500 - Group with explicit attrs:false (boolean) + active atributes',
+        describeName: '0531 - Group with explicit attrs:[ ] (empty array) + active attributes + static attributes',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -1988,17 +3372,33 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
-                        explicitAttrs: false,
+                        explicitAttrs: '[ ]',
                         commands: [],
                         lazy: [],
                         attributes: [
                             {
-                                object_id: 'a',
                                 name: 'attr_a',
+                                object_id: 'a',
+                                type: 'Number'
+                            },
+                            {
+                                name: 'attr_b',
+                                object_id: 'b',
                                 type: 'Number'
                             }
                         ],
-                        static_attributes: []
+                        static_attributes: [
+                            {
+                                name: 'static_a',
+                                type: 'Number',
+                                value: 3
+                            },
+                            {
+                                name: 'static_b',
+                                type: 'Number',
+                                value: 4
+                            }
+                        ]
                     }
                 ]
             },
@@ -2010,7 +3410,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store all attributes into Context Broker',
+                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should NOT store anything into the Context Broker (No request to CB)',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -2021,26 +3421,17 @@ const testCases = [
                     },
                     json: {
                         a: 3,
-                        b: 10
+                        b: 10,
+                        c: 11
                     }
                 },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    b: {
-                        value: 10,
-                        type: 'Text'
-                    },
-                    attr_a: {
-                        value: 3,
-                        type: 'Number'
-                    }
-                }
+                expectation: [] // No payload expected
             }
         ]
     },
     {
-        describeName: '0510 - Group without explicit (not defined) + active atributes',
+        describeName:
+            '0532 - Group with explicit attrs:[ ] (empty array) + active attributes + static attributes + timestamp:true',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -2050,16 +3441,34 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
+                        explicitAttrs: '[ ]',
+                        timestamp: true,
                         commands: [],
                         lazy: [],
                         attributes: [
                             {
-                                object_id: 'a',
                                 name: 'attr_a',
+                                object_id: 'a',
+                                type: 'Number'
+                            },
+                            {
+                                name: 'attr_b',
+                                object_id: 'b',
                                 type: 'Number'
                             }
                         ],
-                        static_attributes: []
+                        static_attributes: [
+                            {
+                                name: 'static_a',
+                                type: 'Number',
+                                value: 3
+                            },
+                            {
+                                name: 'static_b',
+                                type: 'Number',
+                                value: 4
+                            }
+                        ]
                     }
                 ]
             },
@@ -2071,7 +3480,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store all attributes into Context Broker',
+                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should NOT store anything into the Context Broker (No request to CB)',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -2082,26 +3491,37 @@ const testCases = [
                     },
                     json: {
                         a: 3,
-                        b: 10
+                        b: 10,
+                        c: 11
                     }
                 },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    b: {
-                        value: 10,
-                        type: 'Text'
+                expectation: [] // No payload expected
+            },
+            {
+                shouldName:
+                    'B - WHEN sending data and a measure called TimeInstant through http IT should NOT store anything into the Context Broker (No request to CB)',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
                     },
-                    attr_a: {
-                        value: 3,
-                        type: 'Number'
+                    json: {
+                        a: 3,
+                        b: 10,
+                        c: 11,
+                        TimeInstant: '2015-12-14T08:06:01.468Z'
                     }
-                }
+                },
+                expectation: [] // No payload expected
             }
         ]
     },
     {
-        describeName: '0520 - Group with explicit attrs:true (boolean) + active atributes',
+        describeName:
+            '0533 - Group with explicit attrs:[ ] (empty array) + active attributes + TimeInstant attribute + static attributes + timestamp:true',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -2111,17 +3531,44 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
-                        explicitAttrs: true,
+                        explicitAttrs: '[ ]',
+                        timestamp: true,
                         commands: [],
                         lazy: [],
                         attributes: [
                             {
-                                object_id: 'a',
                                 name: 'attr_a',
+                                object_id: 'a',
+                                type: 'Number'
+                            },
+                            {
+                                name: 'attr_b',
+                                object_id: 'b',
                                 type: 'Number'
+                            },
+                            {
+                                name: 'DateIssued',
+                                object_id: 'TimeInstant',
+                                type: 'DateTime'
+                            },
+                            {
+                                name: 'TimeInstant',
+                                object_id: 't',
+                                type: 'DateTime'
                             }
                         ],
-                        static_attributes: []
+                        static_attributes: [
+                            {
+                                name: 'static_a',
+                                type: 'Number',
+                                value: 3
+                            },
+                            {
+                                name: 'static_b',
+                                type: 'Number',
+                                value: 4
+                            }
+                        ]
                     }
                 ]
             },
@@ -2133,7 +3580,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store all attributes into Context Broker',
+                    'A - WHEN sending data and a measure called "t" (defined as TimeInstant attribte) through http IT should NOT store anything into the Context Broker (No request to CB)',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -2144,22 +3591,38 @@ const testCases = [
                     },
                     json: {
                         a: 3,
-                        b: 10
+                        b: 10,
+                        c: 11,
+                        t: '2015-12-14T08:06:01.468Z'
                     }
                 },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 3,
-                        type: 'Number'
+                expectation: []
+            },
+            {
+                shouldName:
+                    'B - WHEN sending data and a measure called TimeInstant through http IT should NOT store anything into the Context Broker (No request to CB)',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
+                    },
+                    json: {
+                        a: 3,
+                        b: 10,
+                        c: 11,
+                        TimeInstant: '2015-12-14T08:06:01.468Z'
                     }
-                }
+                },
+                expectation: [] // No payload expected
             }
         ]
     },
     {
-        describeName: '0530 - Group with explicit attrs:[array] + active attributes + static attributes',
+        describeName:
+            '0534 - Group with explicit attrs:[ ] (empty array) + active attributes + TimeInstant attribute + static attributes + timestamp:false',
         provision: {
             url: 'http://localhost:' + config.iota.server.port + '/iot/services',
             method: 'POST',
@@ -2169,7 +3632,8 @@ const testCases = [
                         resource: '/iot/json',
                         apikey: globalEnv.apikey,
                         entity_type: globalEnv.entity_type,
-                        explicitAttrs: "['attr_a','static_a']",
+                        explicitAttrs: '[ ]',
+                        timestamp: false,
                         commands: [],
                         lazy: [],
                         attributes: [
@@ -2182,6 +3646,16 @@ const testCases = [
                                 name: 'attr_b',
                                 object_id: 'b',
                                 type: 'Number'
+                            },
+                            {
+                                name: 'DateIssued',
+                                object_id: 'TimeInstant',
+                                type: 'DateTime'
+                            },
+                            {
+                                name: 'TimeInstant',
+                                object_id: 't',
+                                type: 'DateTime'
                             }
                         ],
                         static_attributes: [
@@ -2207,7 +3681,7 @@ const testCases = [
         should: [
             {
                 shouldName:
-                    'A - WHEN sending both provisioned and not object_ids (measures) through http IT should store only defined in explicitAttrs array into Context Broker',
+                    'A - WHEN sending data and a measure called "t" (defined as TimeInstant attribte) through http IT should NOT store anything into the Context Broker (No request to CB)',
                 type: 'single',
                 measure: {
                     url: 'http://localhost:' + config.http.port + '/iot/json',
@@ -2219,21 +3693,31 @@ const testCases = [
                     json: {
                         a: 3,
                         b: 10,
-                        c: 11
+                        c: 11,
+                        t: '2015-12-14T08:06:01.468Z'
                     }
                 },
-                expectation: {
-                    id: globalEnv.entity_name,
-                    type: globalEnv.entity_type,
-                    attr_a: {
-                        value: 3,
-                        type: 'Number'
+                expectation: []
+            },
+            {
+                shouldName:
+                    'B - WHEN sending data and a measure called TimeInstant through http IT should NOT store anything into the Context Broker (No request to CB)',
+                type: 'single',
+                measure: {
+                    url: 'http://localhost:' + config.http.port + '/iot/json',
+                    method: 'POST',
+                    qs: {
+                        i: globalEnv.deviceId,
+                        k: globalEnv.apikey
                     },
-                    static_a: {
-                        value: 3,
-                        type: 'Number'
+                    json: {
+                        a: 3,
+                        b: 10,
+                        c: 11,
+                        TimeInstant: '2015-12-14T08:06:01.468Z'
                     }
-                }
+                },
+                expectation: [] // No payload expected
             }
         ]
     },