raain-model 1.10.28 → 1.11.4

package/.travis.deploy.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+set -o errexit -o nounset
+
+if [ "$TRAVIS_BRANCH" != "master" ]; then
+  echo "This commit was made against the $TRAVIS_BRANCH and not the master! No deploy."
+  exit 0
+fi
+
+setup_git() {
+  echo "> Setup Git."
+  git init
+  git config --global user.email "travis@travis-ci.com"
+  git config --global user.name "Travis CI"
+  git remote -v
+  git remote add upstream "https://${GH_TOKEN}@github.com/raainio/raain-model.git"
+
+  REVISION=$(git rev-parse --short HEAD)
+  PACKAGE_VERSION=$(cat package.json |
+    grep version |
+    head -1 |
+    awk -F: '{ print $2 }' |
+    sed 's/[", ]//g')
+}
+
+push_git() {
+  echo "> Commit, tag and push on master."
+  NEXT_VERSION=$(npm version patch -m "[skip ci] travis is OK: v${PACKAGE_VERSION} - ${REVISION}")
+  echo "- ${NEXT_VERSION} : In progress... " >> RELEASE.md
+  git add .
+  git commit -m "[skip ci] ${NEXT_VERSION} : In progress..."
+  # no git tag -a "v${PACKAGE_VERSION}" -m "v${PACKAGE_VERSION}"
+  git push -q upstream HEAD:master --tags
+}
+
+###########
+## Main
+###########
+
+setup_git
+push_git

package/.travis.yml

@@ -0,0 +1,22 @@
+language: node_js
+node_js:
+  - 18
+cache:
+  bundler: true
+  directories:
+    - node_modules
+branches:
+  only:
+    - master
+script:
+  - npm run build
+  - npm test
+after_success:
+  - bash .travis.deploy.sh
+before_deploy:
+  - cd dist
+deploy:
+  provider: npm
+  email: $NPM_USER
+  api_key: $NPM_TOKEN
+  skip_cleanup: true

package/RELEASE.md

@@ -10,3 +10,4 @@
 - v0.4.1 : Cartesian values, Folder reorg (renaming of Polar objects : XX-MeasureValue => XX-PolarMeasureValue )
 - v1.9.x : Cartesian improvements
 - v1.10.x : Object constructor based on json only. Specs added.
+- v1.11.x : Change SpeedMatrixContainer's QualityPoints relation (1.N). Add a SpeedMatrix name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raain-model",
-  "version": "1.10.28",
+  "version": "1.11.4",
   "author": "contact@raain.io",
   "homepage": "https://github.com/raainio/raain-model",
   "description": "raain.io api model",

package/specs/cartesian/Cartesian.spec.ts

@@ -0,0 +1,56 @@
+import {expect} from 'chai';
+import {
+    CartesianMeasureValue,
+    CartesianValue,
+    GaugeMeasure,
+    GaugeNode,
+    ICartesianMeasureValue,
+    LatLng,
+    RadarCartesianMeasureValue
+} from '../../src';
+
+describe('Cartesian', () => {
+
+    it('should create ones', () => {
+
+        const cartesianValue = new CartesianValue({
+            value: 123,
+            lat: 10,
+            lng: 20
+        });
+        const cartesianMeasureValue = new CartesianMeasureValue({
+            cartesianValues: [cartesianValue, cartesianValue],
+            cartesianPixelWidth: {lat: 1.002, lng: 13.0024}
+        });
+        const radarCartesianMeasureValue = new RadarCartesianMeasureValue({
+            cartesianValues: [cartesianValue, cartesianValue],
+            cartesianPixelWidth: new LatLng({lat: 1, lng: 2}),
+            angle: 4
+        });
+        expect(radarCartesianMeasureValue.angle).eq(4);
+        expect(radarCartesianMeasureValue.getCartesianValues().length).eq(2);
+        expect(radarCartesianMeasureValue.getCartesianPixelWidth().lng).eq(2);
+
+        const gaugeNode = new GaugeNode({
+            id: 'GaugeNode looks OK.',
+            name: 'name',
+            links: [],
+            latitude: 1,
+            longitude: 1
+        });
+        expect(gaugeNode.id).eq('GaugeNode looks OK.');
+
+        const gaugeMeasure = new GaugeMeasure({
+            id: 'gaugeMeasure',
+            date: new Date(),
+            timeInSec: 300,
+            values: [cartesianMeasureValue],
+            validity: 1
+        });
+        expect(gaugeMeasure.timeInSec).eq(300);
+        expect((gaugeMeasure.values[0] as ICartesianMeasureValue).getCartesianValue({lat: 10, lng: 20}).value).eq(123);
+        expect((gaugeMeasure.values[0] as ICartesianMeasureValue).getCartesianValue({lat: 10.0001, lng: 20.00001})).eq(null);
+
+    });
+
+});

package/specs/gauge/Gauge.spec.ts

@@ -0,0 +1,19 @@
+import {expect} from 'chai';
+import {GaugeMeasure, GaugeNode} from '../../src';
+
+describe('Gauge', () => {
+
+    it('should create ones', () => {
+
+        const gaugeNode = new GaugeNode({
+            id: 'Node looks OK.', name: 'name', links: [], latitude: 1, longitude: 1
+        });
+        expect(gaugeNode.id).eq('Node looks OK.');
+        expect(JSON.stringify(gaugeNode.toJSON())).eq('{"id":"Node looks OK.","links":[],"latitude":1,"longitude":1,"name":"name"}');
+
+        const gaugeMeasure = new GaugeMeasure({id: 'measure', values: [10, 11], configurationAsJSON: {test: true}});
+        expect(JSON.stringify(gaugeMeasure.toJSON())).eq('{"id":"measure","links":[],"validity":-1,"configurationAsJSON":"{\\"test\\":true}","values":[10,11],"timeInSec":-1}');
+
+    });
+
+});

package/specs/organization/Organization.spec.ts

@@ -0,0 +1,32 @@
+import {expect} from 'chai';
+import {EventNode, PeopleNode, TeamNode} from '../../src';
+
+describe('Organization', () => {
+
+    it('should create ones', () => {
+        const user1 = new PeopleNode({
+            id: 'uid1', role: 'user', email: 'user1@null.com', name: 'user1', comments: 'extra info...'
+        });
+        const team1 = new TeamNode({
+            id: 'tid1',
+            name: 'team1',
+            description: 'team...',
+            contracts: ['basic'],
+            contacts: [user1]
+        });
+        expect(team1.contacts[0].email).eq('user1@null.com');
+        expect(team1.contracts[0]).eq('basic');
+
+        const eventNode = new EventNode({
+            id: 'event1',
+            title: 'EventNode looks OK.',
+            status: 0,
+            red: false,
+            description: 'need help on...',
+            created: new Date(),
+            modified: new Date()
+        });
+        expect(eventNode.title).eq('EventNode looks OK.');
+    });
+
+});

package/specs/polar/Polar.spec.ts

@@ -0,0 +1,25 @@
+import {expect} from 'chai';
+import {MeasureValuePolarContainer, PolarMeasureValue, PolarValue} from '../../src';
+
+describe('Polar', () => {
+
+    it('should create ones', () => {
+
+        const polarValue = new PolarValue({value: 12, polarAzimuthInDegrees: 2, polarDistanceInMeters: 4});
+        expect(polarValue.value).eq(12);
+        expect(polarValue.polarAzimuthInDegrees).eq(2);
+        expect(polarValue.polarDistanceInMeters).eq(4);
+
+        const measureValuePolarContainer = new MeasureValuePolarContainer({azimuth: 0, distance: 1, polarEdges: [33, 45.5]});
+        expect(measureValuePolarContainer.polarEdges[0]).eq(33);
+        expect(measureValuePolarContainer.polarEdges[1]).eq(45.5);
+
+        const polarMeasureValue = new PolarMeasureValue({measureValuePolarContainers: [measureValuePolarContainer]});
+        const polarValueFound = polarMeasureValue.getPolarValue({azimuthIndex: 0, edgeIndex: 1, strict: false});
+        expect(polarValueFound.value).eq(45.5);
+        expect(polarValueFound.polarAzimuthInDegrees).eq(0);
+        expect(polarValueFound.polarDistanceInMeters).eq(1);
+
+    });
+
+});

package/specs/quality/Position.spec.ts

@@ -0,0 +1,18 @@
+import {expect} from 'chai';
+import {Position} from '../../src';
+
+describe('Position', () => {
+
+
+    it('should getXYScaled', () => {
+
+        const pos1 = new Position({x: 10.0001, y: 12.1});
+        expect(pos1.getXYScaled(0.01).x).eq(10);
+        expect(pos1.getXYScaled(0.01).y).eq(12.1);
+
+        const pos2 = new Position({x: 10.0001, y: 12.1});
+        expect(pos2.getXYScaled(0.0001).x).eq(10.0001);
+        expect(pos2.getXYScaled(0.0001).y).eq(12.1);
+    });
+
+});

package/specs/quality/QualityTools.spec.ts

@@ -0,0 +1,120 @@
+import {expect} from 'chai';
+import {LatLng, Position, QualityTools} from '../../src';
+
+describe('QualityTools', () => {
+
+    it('should get roundLatLng', () => {
+        expect(QualityTools.RoundLatLng(12.1234)).eq(12.120000000000001);
+        expect(QualityTools.RoundLatLng(12.1234, 0.005)).eq(12.125);
+        expect(QualityTools.RoundLatLng(12.1234, 0.001)).eq(12.123000000000001); // => needPrecision
+        expect(QualityTools.RoundLatLng(12.1234, 0.001, true)).eq(12.123);
+        expect(QualityTools.RoundLatLng(12.1234, 0.01, true)).eq(12.12);
+        expect(QualityTools.RoundLatLng(12.1234, 0.1, true)).eq(12.1);
+        expect(QualityTools.RoundLatLng(12.1234, 1)).eq(12);
+
+        expect(QualityTools.RoundLatLng(-2.8000000000000003, 0.1, true)).eq(-2.8);
+        expect(QualityTools.RoundLatLng(-2.8000000000000003, 0.002, true)).eq(-2.8);
+
+        expect(QualityTools.RoundLatLng(-23.8000000000000003, 10)).eq(-20);
+        expect(QualityTools.RoundLatLng(345.1200000000000003, 200)).eq(400);
+    });
+
+    it('should isAroundLatLng', () => {
+        const center = new LatLng({lat: 12.3456, lng: 1.234});
+
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 0)).eq(true);
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3457, lng: 1.234}), 0)).eq(true);
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.0006, lng: 1.234}), 0)).eq(false);
+
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 0, 0.1)).eq(true);
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3556, lng: 1.234}), 0, 0.1)).eq(false);
+
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 1, 0.1)).eq(true);
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3457, lng: 1.234}), 1, 0.1)).eq(true);
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3457, lng: 1.434}), 1, 0.1)).eq(false);
+
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 6, 0.01)).eq(true);
+        expect(QualityTools.IsAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.299}), 6, 0.01)).eq(false);
+    });
+
+    it('should isNotAroundLatLng', () => {
+        const center = new LatLng({lat: 12.3456, lng: 1.234});
+
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 0)).eq(false);
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3457, lng: 1.234}), 0)).eq(false);
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.0006, lng: 1.234}), 0)).eq(true);
+
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 0, 0.1)).eq(false);
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3556, lng: 1.234}), 0, 0.1)).eq(true);
+
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 1, 0.1)).eq(false);
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3457, lng: 1.234}), 1, 0.1)).eq(false);
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3457, lng: 1.434}), 1, 0.1)).eq(true);
+
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.234}), 6, 0.01)).eq(false);
+        expect(QualityTools.IsNotAroundLatLng(center, new LatLng({lat: 12.3456, lng: 1.299}), 6, 0.01)).eq(true);
+    });
+
+
+    it('should MapPositionToLatLng and MapLatLngToPosition', () => {
+
+        let point = new Position({x: 0, y: 0});
+        let latLng = QualityTools.MapPositionToLatLng(point);
+        expect(QualityTools.MapLatLngToPosition(latLng).x).eq(point.x);
+        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(point.y);
+        expect(latLng.lat).eq(0);
+        expect(latLng.lng).eq(0);
+
+        point = new Position({x: 10, y: -10});
+        latLng = QualityTools.MapPositionToLatLng(point);
+        expect(QualityTools.MapLatLngToPosition(latLng).x).eq(point.x);
+        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(point.y);
+        expect(latLng.lat).eq(-10);
+        expect(latLng.lng).eq(10);
+
+        point = new Position({x: 11.0003, y: -11.03});
+        latLng = QualityTools.MapPositionToLatLng(point);
+        expect(QualityTools.MapLatLngToPosition(latLng).x).eq(point.x);
+        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(point.y);
+
+        point = new Position({x: 11.0003, y: -11.03});
+        const cartesianWidthDefault = new LatLng({lat: QualityTools.DEFAULT_SCALE, lng: QualityTools.DEFAULT_SCALE});
+        latLng = QualityTools.MapPositionToLatLng(point);
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidthDefault).x).eq(11);
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidthDefault).y).eq(-11.03);
+
+        const cartesianWidth = new LatLng({lat: 0.01426, lng: 0.00898});
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidth).y).eq(-11.02298);
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidth).x).eq(11.0005);
+
+        latLng = new LatLng({lat: 48.86420972077865, lng: 2.2681507839189115});
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidth).x).eq(2.27194);
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidth).y).eq(48.86902);
+        latLng = new LatLng({lat: 48.86423959124331, lng: 2.254480156320581});
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidth).x).eq(2.25398);
+        expect(QualityTools.MapLatLngToPosition(latLng, true, cartesianWidth).y).eq(48.86902);
+
+    });
+
+    it('should CreateNDimArray', () => {
+        const createdEmptyNDimArray = QualityTools.CreateNDimArray([1, 2, 3]);
+        expect(createdEmptyNDimArray.length).eq(1);
+        expect(createdEmptyNDimArray[0].length).eq(2);
+        expect(createdEmptyNDimArray[0][1].length).eq(3);
+        expect(createdEmptyNDimArray[0][1][2]).eq(undefined);
+
+        const createdFilledNDimArray = QualityTools.CreateNDimArray([1, 2, 3], 4321);
+        expect(createdFilledNDimArray.length).eq(1);
+        expect(createdFilledNDimArray[0].length).eq(2);
+        expect(createdFilledNDimArray[0][1].length).eq(3);
+        expect(createdFilledNDimArray[0][1][2]).eq(4321);
+
+        const createdFilledWithZeroNDimArray = QualityTools.CreateNDimArray([1, 2, 3], 0);
+        expect(createdFilledWithZeroNDimArray[0][1][2]).eq(0);
+
+        const createdFilledWithAnyNDimArray = QualityTools.CreateNDimArray([1, 2, 3], []);
+        createdFilledWithAnyNDimArray[0][1][2].push('test');
+        expect(createdFilledWithAnyNDimArray[0][1][2][0]).eq('test');
+    });
+
+});

package/specs/quality/SpeedMatrix.spec.ts

@@ -0,0 +1,125 @@
+import {expect} from 'chai';
+import {CartesianValue, Position, QualityPoint, QualityTools, SpeedMatrix, SpeedMatrixContainer} from '../../src';
+
+describe('SpeedMatrix', () => {
+
+
+    it('should manipulate SpeedMatrixContainer', () => {
+
+        const speedMatrices = [];
+        speedMatrices.push(new SpeedMatrix('1', []));
+        speedMatrices.push(new SpeedMatrix('2', []));
+        const speedMatrixContainer = new SpeedMatrixContainer({matrices: speedMatrices});
+
+        const speedMatrixContainerTwin = SpeedMatrixContainer.CreateFromJson(speedMatrixContainer.toJSON());
+        const optionsForFairCompare = {
+            removeFlatten: true,
+            removeMatrices: true,
+            removeIndicators: true,
+        };
+
+        expect(JSON.stringify(speedMatrixContainer.toJSON(optionsForFairCompare)))
+            .equal(JSON.stringify(speedMatrixContainerTwin.toJSON(optionsForFairCompare)));
+
+        const qualityPoint1 = new QualityPoint({
+            gaugeId: 'id1',
+            gaugeLabel: 'label1',
+            gaugeDate: null,
+            rainDate: null,
+            gaugeCartesianValue: new CartesianValue({value: 1, lat: 0, lng: 0}),
+            rainCartesianValues: [new CartesianValue({value: 2, lat: 0, lng: 0}), new CartesianValue({value: 3, lat: 0.01, lng: 0.02})],
+            speed: null,
+            remark: 'none',
+        });
+        const qualityPoint2 = new QualityPoint({
+            gaugeId: 'id2',
+            gaugeLabel: 'label2',
+            gaugeDate: null,
+            rainDate: null,
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 0, lng: 0}),
+            rainCartesianValues: [new CartesianValue({value: 20, lat: 0, lng: 0}), new CartesianValue({value: 30, lat: 0.01, lng: 0.02})],
+            speed: null,
+            remark: 'none',
+        });
+        const qualityPoints = [qualityPoint1, qualityPoint2];
+
+        const speedMatrixContainerToMerge = SpeedMatrixContainer.CreateFromJson({
+            matrices: [new SpeedMatrix('3', qualityPoints)],
+            trustedIndicator: 0.85
+        });
+        speedMatrixContainer.merge(speedMatrixContainerToMerge);
+
+        expect(speedMatrixContainer.getQualityPoints().length).eq(0);
+        expect(speedMatrixContainer.getQualityPoints('1').length).eq(0);
+        expect(speedMatrixContainer.getQualityPoints('2').length).eq(0);
+        expect(speedMatrixContainer.getQualityPoints('3').length).eq(2);
+        expect(speedMatrixContainer.getQualityPoints('3')[0].rainCartesianValues.length).eq(2);
+
+        const mergedMatrix = speedMatrixContainer.renderMergedMatrix();
+        expect(mergedMatrix.length).eq(Math.pow(SpeedMatrix.DEFAULT_MATRIX_RANGE * 2 + 1, 2));
+        expect(mergedMatrix[179].value).eq(1);
+        expect(mergedMatrix[179].x).eq(2);
+        expect(mergedMatrix[179].y).eq(1);
+        speedMatrixContainer.logMergedMatrix({normalize: false});
+        speedMatrixContainer.logMergedMatrix({normalize: true});
+    });
+
+    it('should manipulate SpeedMatrixContainer - other approach', async () => {
+
+        const speed = {angleInDegrees: 1, pixelsPerPeriod: 2};
+        const qp = {
+            gaugeId: 'id',
+            gaugeLabel: 'gaugeLabel',
+            gaugeDate: new Date(100000),
+            rainDate: new Date(200000),
+            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 2}),
+            rainCartesianValues: [new CartesianValue({value: 8, lat: 1, lng: 2}), new CartesianValue({value: 13, lat: 1.01, lng: 2.02})],
+            speed: {x: 1, y: 2},
+            remark: 'none',
+        };
+        const qualityPoint1 = new QualityPoint(qp);
+        const qualityPoints1: QualityPoint[] = [qualityPoint1];
+        const roundScale: Position = new Position({x: QualityTools.DEFAULT_SCALE, y: QualityTools.DEFAULT_SCALE});
+
+        const flattenPositionRange = {xMin: -4, xMax: 4, yMin: -4, yMax: 4};
+        const speedMatrix1 = new SpeedMatrix('1', qualityPoints1, speed, 1, flattenPositionRange, roundScale);
+        const qualitySpeedMatrixContainer1 = new SpeedMatrixContainer({matrices: [speedMatrix1]});
+
+        // Verify creation
+        qualitySpeedMatrixContainer1.logMergedMatrix({normalize: false});
+        expect(qualitySpeedMatrixContainer1.getQuality()).eq(0.5);
+        expect(qualitySpeedMatrixContainer1.getMaxGauge()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getMaxRain()).eq(10.5);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints().length).eq(1);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints()[0].getGaugeValue()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints()[0].getRainValue()).eq(10.5);
+        expect(qualityPoint1.getTimeDeltaInMinutes()).eq(2);
+
+        // Second container to merge
+        qp.gaugeId = 'otherGaugeId';
+        const qualityPoint2 = new QualityPoint(qp);
+        const qualityPoints2: QualityPoint[] = [qualityPoint1, qualityPoint2];
+        const speedMatrix2 = new SpeedMatrix('2', qualityPoints2, speed, 1, flattenPositionRange, roundScale);
+        const qualitySpeedMatrixContainer2 = new SpeedMatrixContainer({matrices: [speedMatrix2]});
+        qualitySpeedMatrixContainer1.merge(qualitySpeedMatrixContainer2);
+
+        // Verify merging
+        qualitySpeedMatrixContainer1.logMergedMatrix({normalize: false});
+        expect(qualitySpeedMatrixContainer1.getQuality()).eq(0.5);
+        expect(qualitySpeedMatrixContainer1.getMaxGauge()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getMaxRain()).eq(10.5);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints().length).eq(1);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints()[0].getGaugeValue()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints()[0].getRainValue()).eq(10.5);
+
+        expect(qualitySpeedMatrixContainer1.getQualityPoints('1').length).eq(1);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints('1')[0].getGaugeValue()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints('1')[0].getRainValue()).eq(10.5);
+
+        expect(qualitySpeedMatrixContainer1.getQualityPoints('2').length).eq(2);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints('2')[0].getGaugeValue()).eq(10);
+        expect(qualitySpeedMatrixContainer1.getQualityPoints('2')[0].getRainValue()).eq(10.5);
+
+    });
+
+});

package/specs/radar/Radar.spec.ts

@@ -0,0 +1,18 @@
+import {expect} from 'chai';
+import {RadarMeasure, RadarNode} from '../../src';
+
+describe('Radar', () => {
+
+    it('should create ones', () => {
+
+        const radarNode = new RadarNode({
+            id: 'RadarNode looks OK.', name: 'name', links: [], latitude: 1, longitude: 1
+        });
+        expect(radarNode.id).eq('RadarNode looks OK.');
+        expect(JSON.stringify(radarNode.toJSON())).eq('{"id":"RadarNode looks OK.","links":[],"name":"name","latitude":1,"longitude":1}');
+
+        const measure = new RadarMeasure({id: 'measure', values: [10, 11]});
+        expect(JSON.stringify(measure.toJSON())).eq('{"id":"measure","links":[],"validity":-1,"values":[10,11]}');
+    });
+
+});

package/specs/rain/Rain.spec.ts

@@ -0,0 +1,71 @@
+import {expect} from 'chai';
+import {
+    RadarNode,
+    RainComputation,
+    RainComputationQuality,
+    RainMeasure,
+    RainNode,
+    RainPolarMeasureValue,
+    SpeedMatrixContainer
+} from '../../src';
+
+describe('Rain', () => {
+
+    it('should create ones', () => {
+
+        const radarNode = new RadarNode({id: 'any', latitude: 1, longitude: 1});
+        const rainComputationEmpty = new RainComputation({id: 'any', periodBegin: null, periodEnd: null, isReady: null, results: null});
+
+        const rainNode = new RainNode({
+            id: 'RainNode looks OK.',
+            name: 'name',
+            links: [radarNode, rainComputationEmpty, null],
+            latitude: 1,
+            longitude: 1
+        });
+        expect(rainNode.id).eq('RainNode looks OK.');
+        expect(JSON.stringify(rainNode.toJSON())).eq('' +
+            '{"id":"RainNode looks OK.",' +
+            '"links":[{"rel":"radar","href":"../radars/any"},{"rel":"rain-computation","href":"../rain-computations/any"},{"rel":"gauge","href":"../gauges/any"}],' +
+            '"name":"name","status":-1,"quality":-1,"latitude":1,"longitude":1}');
+
+        const rainComputation = new RainComputation({
+            id: 'RainComputation looks OK.',
+            periodBegin: new Date('2022-01-01'),
+            periodEnd: new Date('2022-01-02'),
+            links: [radarNode, radarNode, null],
+            quality: 1,
+            progressIngest: 1,
+            progressComputing: 1,
+            timeSpentInMs: 100,
+            isReady: true,
+            isDoneDate: new Date(),
+            results: [new RainPolarMeasureValue({
+                polars: '[]',
+                version: 'version2'
+            })],
+            launchedBy: 'oneUser',
+            version: 'v1',
+        });
+
+        expect(rainComputation.id).eq('RainComputation looks OK.');
+        expect(rainComputation.getVersion()).eq('v1');
+
+        const rainComputationQuality = new RainComputationQuality({
+            id: 'RainComputationQuality looks OK.',
+            periodBegin: new Date(),
+            periodEnd: new Date(),
+            links: [radarNode],
+            quality: 1,
+            isReady: true,
+            qualitySpeedMatrixContainer: new SpeedMatrixContainer({matrices: []}),
+            version: 'v1'
+        });
+        expect(rainComputationQuality.id).eq('RainComputationQuality looks OK.');
+        expect(rainComputationQuality.getVersion()).eq('v1');
+
+        const measure = new RainMeasure({id: 'measure', values: [10, 11], configurationAsJSON: '{"test": true}'});
+        expect(JSON.stringify(measure.toJSON())).eq('{"id":"measure","links":[],"validity":-1,"configurationAsJSON":"{\\"test\\":true}","values":[10,11]}');
+    });
+
+});

package/specs/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": "./"
+  },
+  "exclude": [
+    "../node_modules"
+  ],
+  "include": [
+    "./**/*.spec.ts"
+  ]
+}