raain-model 2.6.10 → 2.6.11

package/specs/quality/QualityPointEdgeCases.spec.ts

@@ -1,215 +0,0 @@
-import {expect} from 'chai';
-import {CartesianValue, QualityPoint, RainComputationQuality, SpeedMatrix, SpeedMatrixContainer} from '../../src';
-
-describe('QualityPoint Edge Cases', () => {
-    it('should handle missing or invalid data in quality points', () => {
-        // Test with missing gauge value
-        const qualityPointMissingGauge = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: new Date(),
-            rainDate: new Date(),
-            gaugeCartesianValue: null,
-            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
-            speed: {x: 1, y: 1},
-            remark: 'missing gauge'
-        });
-
-        expect(qualityPointMissingGauge.getGaugeValue()).eq(undefined);
-        expect(qualityPointMissingGauge.getRainValue()).eq(10);
-        expect(qualityPointMissingGauge.getDelta()).eq(undefined);
-
-        // Test with missing rain values
-        const qualityPointMissingRain = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: new Date(),
-            rainDate: new Date(),
-            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
-            rainCartesianValues: [],
-            speed: {x: 1, y: 1},
-            remark: 'missing rain'
-        });
-
-        expect(qualityPointMissingRain.getGaugeValue()).eq(10);
-        expect(qualityPointMissingRain.getRainValue()).eq(0);
-        expect(qualityPointMissingRain.getDelta()).eq(10);
-
-        // Test with null dates
-        const qualityPointNullDates = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: null,
-            rainDate: null,
-            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
-            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
-            speed: {x: 1, y: 1},
-            remark: 'null dates'
-        });
-
-        // Check that dates are set to Unix epoch when constructed with null
-        expect(qualityPointNullDates.gaugeDate.getTime()).to.equal(0);
-        expect(qualityPointNullDates.rainDate.getTime()).to.equal(0);
-        // getTimeDeltaInMinutes should return 0 for equal dates
-        expect(qualityPointNullDates.getTimeDeltaInMinutes()).to.equal(0);
-    });
-
-    it('should handle extreme value differences between gauge and rain', () => {
-        const qualityPointExtreme = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: new Date(),
-            rainDate: new Date(),
-            gaugeCartesianValue: new CartesianValue({value: 1000, lat: 1, lng: 1}),
-            rainCartesianValues: [new CartesianValue({value: 1, lat: 1, lng: 1})],
-            speed: {x: 1, y: 1},
-            remark: 'extreme difference'
-        });
-
-        expect(qualityPointExtreme.getGaugeValue()).eq(1000);
-        expect(qualityPointExtreme.getRainValue()).eq(1);
-        expect(qualityPointExtreme.getDelta()).eq(999);
-        expect(qualityPointExtreme.getRatio()).eq(0.001);
-    });
-
-    it('should handle multiple rain values with significant variance', () => {
-        const qualityPointMultiRain = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: new Date(),
-            rainDate: new Date(),
-            gaugeCartesianValue: new CartesianValue({value: 50, lat: 1, lng: 1}),
-            rainCartesianValues: [
-                new CartesianValue({value: 10, lat: 1, lng: 1}),
-                new CartesianValue({value: 20, lat: 1, lng: 1}),
-                new CartesianValue({value: 100, lat: 1, lng: 1})
-            ],
-            speed: {x: 1, y: 1},
-            remark: 'varied rain values'
-        });
-
-        expect(qualityPointMultiRain.getRainValue()).to.be.approximately(43.33, 0.01);
-        expect(qualityPointMultiRain.getDelta()).to.be.approximately(6.67, 0.01);
-    });
-});
-
-describe('SpeedMatrix Edge Cases', () => {
-    it('should handle empty quality points', () => {
-        const speedMatrix = new SpeedMatrix('test', '', []);
-        expect(speedMatrix.getQualityPoints().length).eq(0);
-        expect(speedMatrix.getMaxRain()).eq(-1);
-        expect(speedMatrix.getMaxGauge()).eq(-1);
-    });
-
-    it('should handle quality points with extreme speeds', () => {
-        const qualityPoint = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: new Date(),
-            rainDate: new Date(),
-            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
-            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
-            speed: {x: 1000, y: 1000}, // Extreme speed
-            remark: 'extreme speed'
-        });
-
-        const speedMatrix = new SpeedMatrix('test', '', [qualityPoint]);
-        expect(speedMatrix.getQualityPoints().length).eq(1);
-        expect(SpeedMatrix.ComputeQualityIndicator(speedMatrix.getQualityPoints())).eq(0);
-    });
-});
-
-describe('SpeedMatrixContainer Quality Tests', () => {
-    it('should handle merging of conflicting matrices', () => {
-        const date1 = new Date();
-        const date2 = new Date(date1.getTime() + 1000); // 1 second later
-
-        const qualityPoint1 = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: date1,
-            rainDate: date1,
-            gaugeCartesianValue: new CartesianValue({value: 10, lat: 1, lng: 1}),
-            rainCartesianValues: [new CartesianValue({value: 10, lat: 1, lng: 1})],
-            speed: {x: 1, y: 1},
-            remark: 'first point'
-        });
-
-        const qualityPoint2 = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: date2,
-            rainDate: date2,
-            gaugeCartesianValue: new CartesianValue({value: 20, lat: 1, lng: 1}),
-            rainCartesianValues: [new CartesianValue({value: 20, lat: 1, lng: 1})],
-            speed: {x: -1, y: -1}, // Opposite direction
-            remark: 'second point'
-        });
-
-        const matrix1 = new SpeedMatrix('1', '', [qualityPoint1]);
-        const matrix2 = new SpeedMatrix('2', '', [qualityPoint2]);
-
-        const container = new SpeedMatrixContainer({matrices: [matrix1]});
-        container.merge(new SpeedMatrixContainer({matrices: [matrix2]}));
-
-        // Verify the merge result
-        expect(container.getQualityPoints().length).eq(2);
-        expect(container.getMaxGauge()).eq(20);
-        expect(container.getMaxRain()).eq(20);
-    });
-
-    it('should handle boundary conditions', () => {
-        const qualityPoint = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: new Date(),
-            rainDate: new Date(),
-            gaugeCartesianValue: new CartesianValue({value: 0, lat: 1, lng: 1}), // Zero gauge value
-            rainCartesianValues: [new CartesianValue({value: 0, lat: 1, lng: 1})], // Zero rain value
-            speed: {x: 0, y: 0}, // Zero speed
-            remark: 'boundary case'
-        });
-
-        const container = new SpeedMatrixContainer({matrices: [new SpeedMatrix('test', '', [qualityPoint])]});
-        expect(container.getMaxGauge()).eq(0);
-        expect(container.getMaxRain()).eq(0);
-    });
-});
-
-describe('RainComputationQuality Edge Cases', () => {
-    it('should handle quality computation with minimal data', () => {
-        const rainComputationQuality = new RainComputationQuality({
-            id: 'test',
-            date: new Date(),
-            isReady: true,
-            qualitySpeedMatrixContainer: new SpeedMatrixContainer({matrices: []})
-        });
-
-        expect(rainComputationQuality.isReady).eq(true);
-        expect(rainComputationQuality.qualitySpeedMatrixContainer.getQualityPoints().length).eq(0);
-    });
-
-    it('should handle quality computation with inconsistent data', () => {
-        const qualityPoint = new QualityPoint({
-            gaugeId: 'gauge1',
-            gaugeLabel: 'test gauge',
-            gaugeDate: new Date(),
-            rainDate: new Date(),
-            gaugeCartesianValue: new CartesianValue({value: 100, lat: 1, lng: 1}),
-            rainCartesianValues: [new CartesianValue({value: 1, lat: 1, lng: 1})], // Very different from gauge
-            speed: {x: 1, y: 1},
-            remark: 'inconsistent data'
-        });
-
-        const container = new SpeedMatrixContainer({matrices: [new SpeedMatrix('test', '', [qualityPoint])]});
-        const rainComputationQuality = new RainComputationQuality({
-            id: 'test',
-            date: new Date(),
-            isReady: true,
-            qualitySpeedMatrixContainer: container
-        });
-
-        expect(rainComputationQuality.isReady).eq(true);
-        expect(SpeedMatrix.ComputeQualityIndicator(rainComputationQuality.qualitySpeedMatrixContainer.getQualityPoints())).eq(99);
-    });
-});

package/specs/quality/QualityTools.spec.ts

@@ -1,67 +0,0 @@
-import {expect} from 'chai';
-import {CartesianTools, LatLng, Position, QualityTools} from '../../src';
-
-describe('QualityTools', () => {
-
-    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: CartesianTools.DEFAULT_SCALE, lng: CartesianTools.DEFAULT_SCALE});
-        latLng = QualityTools.MapPositionToLatLng(point);
-        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(11);
-        expect(QualityTools.MapLatLngToPosition(latLng).y).eq(-11.03);
-
-        const cartesianWidth = new LatLng({lat: 0.01426, lng: 0.00898});
-        // expect(QualityTools.MapLatLngToPosition(latLng).y).eq(-11.02298);
-        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(11.0005);
-
-        latLng = new LatLng({lat: 48.86420972077865, lng: 2.2681507839189115});
-        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(2.27194);
-        // expect(QualityTools.MapLatLngToPosition(latLng).y).eq(48.86902);
-        latLng = new LatLng({lat: 48.86423959124331, lng: 2.254480156320581});
-        // expect(QualityTools.MapLatLngToPosition(latLng).x).eq(2.25398);
-        // expect(QualityTools.MapLatLngToPosition(latLng).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

@@ -1,214 +0,0 @@
-import {expect} from 'chai';
-import {CartesianTools, CartesianValue, Position, QualityPoint, RainComputationQuality, SpeedMatrix, SpeedMatrixContainer} from '../../src';
-
-describe('SpeedMatrix', () => {
-
-    const optionalTrace = (...log: any[]) => {
-        // console.log(new Date().toISOString(), log)
-    }
-    const optionalLogger = null; // console;
-
-    it('should SpeedMatrixContainer CreateFromJson, merge and renderMergedMatrix', () => {
-
-        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(2);
-        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);
-
-        expect(speedMatrixContainer.getQualityPointsByHistoricalPosition(0).length).eq(0);
-        expect(speedMatrixContainer.getQualityPointsByHistoricalPosition(2).length).eq(2);
-        expect(speedMatrixContainer.getQualityPointsByHistoricalPosition(20).length).eq(0);
-
-        const mergedMatrix = speedMatrixContainer.renderMergedMatrix();
-        expect(mergedMatrix.length).eq(Math.pow(SpeedMatrix.DEFAULT_MATRIX_RANGE * 2 + 1, 2));
-        expect(mergedMatrix[611].value).eq(1);
-        expect(mergedMatrix[611].x).eq(2);
-        expect(mergedMatrix[611].y).eq(1);
-        speedMatrixContainer.logMergedMatrix({normalize: false, logger: optionalLogger});
-        speedMatrixContainer.logMergedMatrix({normalize: true, logger: optionalLogger});
-    });
-
-    it('should SpeedMatrixContainer merge and compare', async () => {
-
-        const dateG1 = new Date(1.1 * 60 * 1000);
-        const dateG2 = new Date(7.1 * 60 * 1000);
-        const dateG3 = new Date(10.1 * 60 * 1000);
-        const dateR1 = new Date(2.1 * 60 * 1000);
-        const dateR2 = new Date(5.2 * 60 * 1000);
-        const dateR3 = new Date(8.2 * 60 * 1000);
-
-        const speed = {angleInDegrees: 1, pixelsPerPeriod: 2};
-        const qp = {
-            gaugeId: 'gaugeId1',
-            gaugeLabel: 'gaugeLabel',
-            gaugeDate: dateG1,
-            rainDate: dateR1,
-            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(JSON.parse(JSON.stringify(qp)));
-        const qualityPoints1: QualityPoint[] = [qualityPoint1];
-        const roundScale: Position = new Position({x: CartesianTools.DEFAULT_SCALE, y: CartesianTools.DEFAULT_SCALE});
-
-        const flattenPositionRange = {xMin: -4, xMax: 4, yMin: -4, yMax: 4};
-        const speedMatrix1 = new SpeedMatrix('0', '', qualityPoints1, speed, 1, flattenPositionRange, roundScale);
-        const qualitySpeedMatrixContainer1 = new SpeedMatrixContainer({matrices: [speedMatrix1]});
-
-        // 1) Verify creation
-        qualitySpeedMatrixContainer1.logMergedMatrix({normalize: false, logger: optionalLogger});
-        speedMatrix1.logFlatten({logger: optionalLogger, simplify: 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(1);
-
-        // Second and Third container to merge
-        qp.gaugeDate = dateG2;
-        const qualityPoint2_1 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
-        qp.gaugeId = 'gaugeId2';
-        const qualityPoint2_2 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
-        const qualityPoints2: QualityPoint[] = [qualityPoint2_1, qualityPoint2_2];
-        const speedMatrix2 = new SpeedMatrix('-2', '', qualityPoints2, speed, 1, flattenPositionRange, roundScale);
-        const qualitySpeedMatrixContainer2 = new SpeedMatrixContainer({matrices: [speedMatrix2]});
-        qualitySpeedMatrixContainer2.merge(qualitySpeedMatrixContainer1);
-
-        qp.gaugeId = 'gaugeId1';
-        qp.gaugeCartesianValue.value += 0.2;
-        qp.gaugeDate = dateG3;
-        const qualityPoint3_1 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
-        qp.gaugeId = 'gaugeId2';
-        qp.gaugeCartesianValue.value += 0.2;
-        qp.gaugeDate = dateG3;
-        const qualityPoint3_2 = new QualityPoint(JSON.parse(JSON.stringify(qp)));
-        const qualityPoints3: QualityPoint[] = [qualityPoint3_1, qualityPoint3_2];
-        const speedMatrix3 = new SpeedMatrix('3', '', qualityPoints3, speed, 1, flattenPositionRange, roundScale);
-        const qualitySpeedMatrixContainer3 = new SpeedMatrixContainer({matrices: [speedMatrix3]});
-        qualitySpeedMatrixContainer2.merge(qualitySpeedMatrixContainer3);
-
-        // 2) Verify merging
-        qualitySpeedMatrixContainer2.logMergedMatrix({normalize: false, logger: optionalLogger});
-        expect(qualitySpeedMatrixContainer2.getQuality()).eq(0.38000000000000045);
-        expect(qualitySpeedMatrixContainer2.getMaxGauge()).eq(10.399999999999999);
-        expect(qualitySpeedMatrixContainer2.getMaxRain()).eq(10.5);
-        const qps = qualitySpeedMatrixContainer2.getQualityPoints();
-        expect(qps.length).eq(5);
-        expect(qps[0].getGaugeValue()).eq(10);
-        expect(qps[0].getRainValue()).eq(10.5);
-
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('0').length).eq(1);
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('0')[0].getGaugeValue()).eq(10);
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('0')[0].getRainValue()).eq(10.5);
-
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('-2').length).eq(2);
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('-2')[0].getGaugeValue()).eq(10);
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('-2')[0].getRainValue()).eq(10.5);
-
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('3').length).eq(2);
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('3')[0].getGaugeValue()).eq(10.2);
-        expect(qualitySpeedMatrixContainer2.getQualityPoints('3')[0].getRainValue()).eq(10.5);
-
-        // 3) Verify compare
-        const rainComputationQuality1 = new RainComputationQuality({
-            id: 'rcq1',
-            date: dateR1,
-            isReady: true,
-            qualitySpeedMatrixContainer: new SpeedMatrixContainer({matrices: [speedMatrix1, speedMatrix2]})
-        });
-        const rainComputationQuality2 = new RainComputationQuality({
-            id: 'rcq2',
-            date: dateR2,
-            isReady: true,
-            qualitySpeedMatrixContainer: qualitySpeedMatrixContainer2
-        });
-        const rainComputationQuality3 = new RainComputationQuality({
-            id: 'rcq3',
-            date: dateR3,
-            isReady: true,
-            qualitySpeedMatrixContainer: new SpeedMatrixContainer({matrices: [speedMatrix2, speedMatrix3]})
-        });
-        const compares = SpeedMatrixContainer.BuildCompares([rainComputationQuality1, rainComputationQuality2, rainComputationQuality3]);
-
-        // comparesPerDate
-        expect(compares.comparesPerDate.length).eq(3);
-        expect(compares.comparesPerDate[0].date.getTime()).eq(126000);
-        expect(compares.comparesPerDate[1].date.getTime()).eq(312000);
-        expect(compares.comparesPerDate[2].date.getTime()).eq(491999);
-        expect(compares.comparesPerDate[0].compareTimeline.length).eq(2);
-        expect(compares.comparesPerDate[1].compareTimeline.length).eq(3);
-        expect(compares.comparesPerDate[2].compareTimeline.length).eq(1);
-        expect(compares.comparesPerDate[0].compareTimeline[0].name).contains('in 2');
-        expect(compares.comparesPerDate[0].compareTimeline[1].name).contains('in 0');
-        expect(compares.comparesPerDate[1].compareTimeline[0].name).contains('in 2');
-        expect(compares.comparesPerDate[1].compareTimeline[1].name).contains('in 0');
-        expect(compares.comparesPerDate[1].compareTimeline[2].name).contains('since 3');
-        expect(compares.comparesPerDate[2].compareTimeline[0].name).contains('since 3');
-        expect(compares.comparesPerDate[0].compareTimeline[0].qualityPoints.length).eq(2);
-        expect(compares.comparesPerDate[0].compareTimeline[1].qualityPoints.length).eq(1);
-        expect(compares.comparesPerDate[1].compareTimeline[0].qualityPoints.length).eq(0);
-        expect(compares.comparesPerDate[1].compareTimeline[1].qualityPoints.length).eq(0);
-        expect(compares.comparesPerDate[1].compareTimeline[2].qualityPoints.length).eq(2);
-        expect(compares.comparesPerDate[2].compareTimeline[0].qualityPoints.length).eq(0);
-
-        // cumulative
-        expect(compares.compareCumulative.qualityPoints.length).eq(2);
-        expect(compares.compareCumulative.qualityPointsLegacy.length).eq(2);
-        expect(compares.compareCumulative.qualityPoints[0].gaugeId).eq('gaugeId2');
-        expect(compares.compareCumulative.qualityPoints[0].getGaugeValue()).eq(20.4);
-        expect(compares.compareCumulative.qualityPoints[0].getRainValue()).eq(21);
-        expect(compares.compareCumulative.qualityPoints[1].gaugeId).eq('gaugeId1');
-        expect(compares.compareCumulative.qualityPoints[1].getGaugeValue()).eq(30.2);
-        expect(compares.compareCumulative.qualityPoints[1].getRainValue()).eq(31.5);
-        expect(compares.compareCumulative.maxValue).eq(31.5);
-
-    });
-
-});

package/specs/radar/Radar.spec.ts

@@ -1,129 +0,0 @@
-import {expect} from 'chai';
-import {MeasureValuePolarContainer, PolarMeasureValue, RadarMeasure, RadarNode, RadarPolarMeasureValue, TeamNode} from '../../src';
-import {promisify} from 'util';
-
-const sleep = promisify(setTimeout);
-
-describe('Radar', () => {
-
-    const optionalTrace = (...log: any[]) => {
-        // console.log(new Date().toISOString(), log)
-    }
-
-    const optionalTable = (a: any[]) => {
-        // console.table(a)
-    }
-
-    it('should create ones', () => {
-        const team1 = new TeamNode({
-            id: 'tid1',
-            name: 'team1',
-            description: 'team...',
-            contracts: ['basic'],
-            contacts: []
-        });
-
-        const radarNode = new RadarNode({
-            id: 'RadarNode looks OK.', name: 'name', links: [],
-            latitude: 1, longitude: 1,
-            team: team1
-        });
-        expect(radarNode.id).eq('RadarNode looks OK.');
-        expect(JSON.stringify(radarNode.toJSON()))
-            .eq('{"id":"RadarNode looks OK.","links":[],"name":"name","latitude":1,"longitude":1,"team":"tid1"}');
-    });
-
-    it('should transform Polar', () => {
-
-        const measureValuePolarContainer = new MeasureValuePolarContainer({azimuth: 0, distance: 1, polarEdges: [33, 45.5]});
-        const polarMeasureValue = new PolarMeasureValue({
-            measureValuePolarContainers: [measureValuePolarContainer],
-            azimuthsCount: 720,
-            polarEdgesCount: 250
-        });
-        const radarPolarMeasureValue1 = new RadarPolarMeasureValue({polarMeasureValue, angle: 1, axis: 0});
-        expect(radarPolarMeasureValue1.getAzimuthsCount()).equal(720);
-        expect(radarPolarMeasureValue1.getPolarEdgesCount()).equal(250);
-
-        const radarPolarMeasureValue2 = new RadarPolarMeasureValue({polarMeasureValue: radarPolarMeasureValue1, angle: 1, axis: 0});
-        expect(radarPolarMeasureValue2.getAzimuthsCount()).equal(720);
-        expect(radarPolarMeasureValue2.getPolarEdgesCount()).equal(250);
-        expect(JSON.stringify(radarPolarMeasureValue2.toJSON({stringify: true})))
-            .eq(JSON.stringify(radarPolarMeasureValue1.toJSON({stringify: true})));
-        expect(JSON.stringify(radarPolarMeasureValue2.toJSON({stringify: true})))
-            .eq('{"polarMeasureValue":"{\\"measureValuePolarContainers\\":\\"[{\\\\\\"azimuth\\\\\\":0,\\\\\\"distance\\\\\\":1,\\\\\\"polarEdges\\\\\\":[33,45.5],\\\\\\"edgeOffset\\\\\\":0}]\\",\\"azimuthsCount\\":720,\\"polarEdgesCount\\":250}","angle":1,"axis":0}');
-
-        const radarPolarMeasureValue3 = new RadarPolarMeasureValue({
-            polarMeasureValue: radarPolarMeasureValue1.toJSONWithPolarStringified(),
-            angle: 1,
-            axis: 0
-        });
-        expect(radarPolarMeasureValue3.getAzimuthsCount()).equal(720);
-        expect(radarPolarMeasureValue3.getPolarEdgesCount()).equal(250);
-        expect(JSON.stringify(radarPolarMeasureValue3.toJSON({stringify: true})))
-            .eq(JSON.stringify(radarPolarMeasureValue1.toJSON({stringify: true})));
-        expect(JSON.stringify(radarPolarMeasureValue3.toJSON({stringify: true})))
-            .eq('{"polarMeasureValue":"{\\"measureValuePolarContainers\\":\\"[{\\\\\\"azimuth\\\\\\":0,\\\\\\"distance\\\\\\":1,\\\\\\"polarEdges\\\\\\":[33,45.5],\\\\\\"edgeOffset\\\\\\":0}]\\",\\"azimuthsCount\\":720,\\"polarEdgesCount\\":250}","angle":1,"axis":0}');
-
-        const radarMeasure = new RadarMeasure({id: 'measureId', values: [polarMeasureValue], date: new Date(100000)});
-        expect(JSON.stringify(radarMeasure.toJSON()))
-            .eq('{"id":"measureId","links":[],"date":"1970-01-01T00:01:40.000Z","validity":-1,"values":[{"measureValuePolarContainers":[{"azimuth":0,"distance":1,"polarEdges":[33,45.5],"edgeOffset":0}],"azimuthsCount":720,"polarEdgesCount":250}]}');
-
-        const polarMeasureValue1 = radarMeasure.values[0] as PolarMeasureValue;
-        const radarPolarMeasureValue4 = new RadarPolarMeasureValue({polarMeasureValue: polarMeasureValue1, angle: 1, axis: 0});
-        expect(JSON.stringify(radarPolarMeasureValue4.toJSON()))
-            .eq('{"polarMeasureValue":{"measureValuePolarContainers":[{"azimuth":0,"distance":1,"polarEdges":[33,45.5],"edgeOffset":0}],"azimuthsCount":720,"polarEdgesCount":250},"angle":1,"axis":0}');
-        expect(radarPolarMeasureValue4.getAzimuthsCount()).equal(720);
-        expect(radarPolarMeasureValue4.getPolarEdgesCount()).equal(250);
-
-        const radarPolarMeasureValue5 = new RadarPolarMeasureValue({
-            polarMeasureValue: JSON.stringify(radarMeasure.values[0]),
-            angle: 1, axis: 90
-        });
-        expect(radarPolarMeasureValue5.getAzimuthsCount()).equal(720);
-        expect(radarPolarMeasureValue5.getPolarEdgesCount()).equal(250);
-
-        const team1 = new TeamNode({
-            id: 'tid1',
-            name: 'team1',
-            description: 'team...',
-            contracts: ['basic'],
-            contacts: []
-        });
-        const radarNode = new RadarNode({
-            id: 'RadarNode looks OK.',
-            name: 'name',
-            links: [radarMeasure],
-            latitude: 1, longitude: 1,
-            team: team1
-        });
-
-        expect(JSON.stringify(radarNode.toJSON()))
-            .eq('{"id":"RadarNode looks OK.","links":[{"rel":"radar-measure","href":"../radar-measures/1970-01-01T00:01:40.000Z/measureId"}],"name":"name","latitude":1,"longitude":1,"team":"tid1"}');
-    });
-
-    it('should use multi-dimension image', async () => {
-
-        const testOneFake = (move: number) => {
-            const radarPolarMeasureValues = RadarPolarMeasureValue.BuildFakeRadarPolarMeasureValues(move);
-            expect(radarPolarMeasureValues.length).equal(6);
-            const polars = radarPolarMeasureValues[0].polarMeasureValue.getPolars();
-            expect(polars.length).equal(720);
-            expect(polars[0].polarEdges.length).equal(250);
-            optionalTable(polars
-                .filter((p, pi) => pi % 10 === 0)
-                .map(m =>
-                    m.polarEdges
-                        .filter((n, ni) => ni % 10 === 0)));
-        }
-
-        // for (let move = 0; move < 90; move++) {
-        testOneFake(0);
-        testOneFake(45);
-        testOneFake(90);
-        // await sleep(1000);
-        // }
-    });
-
-
-});