@situm/cordova 3.0.0

package/tests/js/resources/startPositioning/0_starting.json

@@ -0,0 +1,4 @@
+{
+  "statusName": "STARTING",
+  "statusOrdinal": 0
+}

package/tests/js/resources/startPositioning/1_preparingPositioningModel.json

@@ -0,0 +1,4 @@
+{
+  "statusName": "PREPARING_POSITIONING_MODEL",
+  "statusOrdinal": 1
+}

package/tests/js/resources/startPositioning/2_startingPositioning.json

@@ -0,0 +1,4 @@
+{
+  "statusName": "STARTING_POSITIONING",
+  "statusOrdinal": 5
+}

package/tests/js/resources/startPositioning/3_calculating.json

@@ -0,0 +1,4 @@
+{
+  "statusName": "CALCULATING",
+  "statusOrdinal": 7
+}

package/tests/js/resources/startPositioning/4_position.json

@@ -0,0 +1,48 @@
+{
+  "accuracy": 4.978759765625,
+  "bearing": {
+    "degrees": 377.089663436474,
+    "degreesClockwise": -17.089663436473984,
+    "radians": 6.5814562022037455,
+    "radiansMinusPiPi": 0.29827089502415927
+  },
+  "bearingQuality": "LOW",
+  "buildingIdentifier": "3468",
+  "cartesianBearing": {
+    "degrees": 242.75607299804685,
+    "degreesClockwise": 117.24392700195315,
+    "radians": 4.23689275302762,
+    "radiansMinusPiPi": -2.0462925541519663
+  },
+  "cartesianCoordinate": {
+    "x": 59.19538879394531,
+    "y": 27.70305824279785
+  },
+  "coordinate": {
+    "latitude": 42.87225305601186,
+    "longitude": -8.56352392324924
+  },
+  "floorIdentifier": "5762",
+  "position": {
+    "buildingIdentifier": "3468",
+    "cartesianCoordinate": {
+      "x": 59.19538879394531,
+      "y": 27.70305824279785
+    },
+    "coordinate": {
+      "latitude": 42.87225305601186,
+      "longitude": -8.56352392324924
+    },
+    "floorIdentifier": "5762",
+    "isIndoor": true,
+    "isOutdoor": false
+  },
+  "provider": "SITUM_PROVIDER",
+  "quality": "LOW",
+  "hasBearing": false,
+  "timestamp": 1525334289892,
+  "hasCartesianBearing": false,
+  "isIndoor": true,
+  "isOutdoor": false,
+  "deviceId": "168162735961687"
+}

package/tests/js/resources/startPositioning/5_position.json

@@ -0,0 +1,48 @@
+{
+  "accuracy": 4.118940830230713,
+  "bearing": {
+    "degrees": 380.73318686808227,
+    "degreesClockwise": -20.73318686808227,
+    "radians": 6.645047682458873,
+    "radiansMinusPiPi": 0.3618623752792871
+  },
+  "bearingQuality": "LOW",
+  "buildingIdentifier": "3468",
+  "cartesianBearing": {
+    "degrees": 239.11254882812497,
+    "degreesClockwise": 120.88745117187503,
+    "radians": 4.17330125988649,
+    "radiansMinusPiPi": -2.1098840472930966
+  },
+  "cartesianCoordinate": {
+    "x": 61.504093170166016,
+    "y": 26.361942291259766
+  },
+  "coordinate": {
+    "latitude": 42.87226127534791,
+    "longitude": -8.563554629285758
+  },
+  "floorIdentifier": "5762",
+  "position": {
+    "buildingIdentifier": "3468",
+    "cartesianCoordinate": {
+      "x": 61.504093170166016,
+      "y": 26.361942291259766
+    },
+    "coordinate": {
+      "latitude": 42.87226127534791,
+      "longitude": -8.563554629285758
+    },
+    "floorIdentifier": "5762",
+    "isIndoor": true,
+    "isOutdoor": false
+  },
+  "provider": "SITUM_PROVIDER",
+  "quality": "LOW",
+  "hasBearing": false,
+  "timestamp": 1525334292895,
+  "hasCartesianBearing": false,
+  "isIndoor": true,
+  "isOutdoor": false,
+  "deviceId": "168162735961687"
+}

package/tests/js/test.js

@@ -0,0 +1,416 @@
+const expect = require("expect.js");
+const buildings = require('./resources/fetchBuildings.json');
+const floors = require('./resources/fetchFloorsFromBuilding.json');
+const indoorPois = require('./resources/fetchIndoorPOIsFromBuilding.json');
+const outdoorPois = require('./resources/fetchOutdoorPOIsFromBuilding.json');
+const events = require('./resources/fetchEventsFromBuilding.json');
+const poiCategories = require('./resources/fetchPoiCategories.json');
+const map = require('./resources/fetchMapFromFloor.json');
+const iconNormal = require('./resources/fetchPoiCategoryIconNormal.json');
+const iconSelected = require('./resources/fetchPoiCategoryIconSelected.json');
+const route = require('./resources/requestDirections.json');
+const starting = require('./resources/startPositioning/0_starting.json');
+const preparePositioningModel = require('./resources/startPositioning/1_preparingPositioningModel.json');
+const startingPositioning = require('./resources/startPositioning/2_startingPositioning.json');
+const calculating = require('./resources/startPositioning/3_calculating.json');
+const position = require('./resources/startPositioning/4_position.json');
+let building, floor, indoorPoi, outdoorPoi, event, poiCategory, edge, indication, node, point, step;
+
+describe('Test fetchBuildings -> ', () => {
+  it('Check reutrned value', () => {
+    expect(buildings).to.be.ok();
+    expect(buildings instanceof Array).to.be(true);
+  });
+  it('Check building', () => {
+    expect(building = buildings[0]);
+    expect(typeof building).to.be('object');
+    expect(typeof building.address).to.be('string');
+    expect(typeof building.bounds).to.be('object');
+    expect(typeof building.boundsRotated).to.be('object');
+    expect(typeof building.center).to.be('object');
+    expect(typeof building.dimensions).to.be('object');
+    expect(typeof building.infoHtml).to.be('string');
+    expect(typeof building.name).to.be('string');
+    expect(typeof building.pictureThumbUrl).to.be('string');
+    expect(typeof building.pictureUrl).to.be('string');
+    expect(typeof building.rotation).to.be('number');
+    expect(typeof building.userIdentifier).to.be('string');
+    expect(typeof building.buildingIdentifier).to.be('string');
+    expect(typeof building.customFields).to.be('object');
+  });
+  it('Check building bounds', () => {
+    testBounds(building.bounds);
+  });
+  it('Check building boundsRotated', () => {
+    testBounds(building.boundsRotated);
+  });
+  it('Check building center', () => {
+    testCoordinate(building.center);
+  });
+  it('Check building dimensions', () => {
+    testDimension(building.dimensions);
+  });
+});
+
+describe('Test fetchFloorsFromBuilding ->', () => {
+  it('Check returned value', () => {
+    expect(floors).to.be.ok();
+    expect(floors instanceof Array).to.be(true);
+  });
+  it('Check floor', () => {
+    expect(floor = floors[0]);
+    expect(typeof floor).to.be('object');
+    expect(typeof floor.altitude).to.be('number');
+    expect(typeof floor.buildingIdentifier).to.be('string');
+    expect(typeof floor.level).to.be('number');
+    expect(typeof floor.mapUrl).to.be('string');
+    expect(typeof floor.scale).to.be('number');
+    expect(typeof floor.floorIdentifier).to.be('string');
+  });
+});
+
+describe('Test fetchIndoorPOIsFromBuilding ->', () => {
+  it('Check returned value', () => {
+    expect(indoorPois).to.be.ok();
+    expect(indoorPois instanceof Array).to.be(true);
+  });
+  it('Check indoorPOI', () => {
+    expect(indoorPoi = indoorPois[0]);
+    expect(typeof indoorPoi).to.be('object');
+    expect(typeof indoorPoi.identifier).to.be('string');
+    expect(typeof indoorPoi.buildingIdentifier).to.be('string');
+    expect(typeof indoorPoi.cartesianCoordinate).to.be('object');
+    expect(typeof indoorPoi.coordinate).to.be('object');
+    expect(typeof indoorPoi.floorIdentifier).to.be('string');
+    expect(typeof indoorPoi.poiName).to.be('string');
+    expect(typeof indoorPoi.position).to.be('object');
+    expect(typeof indoorPoi.isIndoor).to.be('boolean');
+    expect(typeof indoorPoi.isOutdoor).to.be('boolean');
+    expect(typeof indoorPoi.category).to.be('string');
+    expect(typeof indoorPoi.infoHtml).to.be('string');
+    expect(typeof indoorPoi.customFields).to.be('object');
+  });
+  it('Check indoorPOI cartesiansCoordinate', () => {
+    testCartesianCoordinate(indoorPoi.cartesianCoordinate);
+  });
+  it('Check indoorPOI coordinate', () => {
+    testCoordinate(indoorPoi.coordinate);
+  });
+  it('Check indoorPOI position', () => {
+    testPoint(indoorPoi.position)
+  });
+});
+describe('Test fetchOutdoorPOIsFromBuilding ->', () => {
+  it('Check returned value', () => {
+    expect(outdoorPois).to.be.ok();
+    expect(outdoorPois instanceof Array).to.be(true);
+  });
+  it('Check outdoorPOI', () => {
+    expect(outdoorPoi = outdoorPois[0]);
+    expect(typeof outdoorPoi).to.be('object');
+    expect(typeof outdoorPoi.identifier).to.be('string');
+    expect(typeof outdoorPoi.buildingIdentifier).to.be('string');
+    expect(typeof outdoorPoi.cartesianCoordinate).to.be('object');
+    expect(typeof outdoorPoi.coordinate).to.be('object');
+    expect(typeof outdoorPoi.floorIdentifier).to.be('string');
+    expect(typeof outdoorPoi.poiName).to.be('string');
+    expect(typeof outdoorPoi.position).to.be('object');
+    expect(typeof outdoorPoi.isIndoor).to.be('boolean');
+    expect(typeof outdoorPoi.isOutdoor).to.be('boolean');
+    expect(typeof outdoorPoi.category).to.be('string');
+    expect(typeof outdoorPoi.infoHtml).to.be('string');
+    expect(typeof outdoorPoi.customFields).to.be('object');
+  });
+  it('Check outdoorPOI cartesiansCoordinate', () => {
+    testCartesianCoordinate(outdoorPoi.cartesianCoordinate);
+  });
+  it('Check outdoorPOI coordinate', () => {
+    testCoordinate(outdoorPoi.coordinate);
+  });
+  it('Check outdoorPOI position', () => {
+    testPoint(outdoorPoi.position);
+  });
+});
+describe('Test fetchEventsFromBuilding ->', () => {
+  it('Check returned value', () => {
+    expect(events).to.be.ok();
+    expect(events instanceof Array).to.be(true);
+  });
+  it('Check event', () => {
+    expect(event = events[0]);
+    expect(typeof event).to.be('object');
+    expect(typeof event.buildingIdentifier).to.be('number');
+    expect(typeof event.identifier).to.be('number');
+    expect(typeof event.floorIdentifier).to.be('number');
+    expect(typeof event.infoHtml).to.be('string');
+    expect(typeof event.conversionArea).to.be('object');
+    expect(typeof event.customFields).to.be('object');
+    expect(typeof event.radius).to.be('number');
+    expect(typeof event.x).to.be('number');
+    expect(typeof event.y).to.be('number');
+    expect(typeof event.name).to.be('string');
+    expect(typeof event.trigger).to.be('object');
+    expect(typeof event.conversion).to.be('object');
+  });
+  it('Check event conversionArea', () => {
+    testConversionArea(event.conversionArea);
+  });
+  it('Check event conversion', () => {
+      testCircle(event.conversion);
+  });
+  it('Check event trigger', () => {
+      testCircle(event.trigger);
+  });
+});
+describe('Test fetchPoiCategories ->', () => {
+  it('Check returned value', () => {
+    expect(poiCategories).to.be.ok();
+    expect(poiCategories instanceof Array).to.be(true);
+  });
+  it('Check POICategory', () => {
+    expect(poiCategory = poiCategories[0]);
+    expect(typeof poiCategory).to.be('object');
+    expect(typeof poiCategory.poiCategoryCode).to.be('string');
+    expect(typeof poiCategory.poiCategoryName).to.be('string');
+    expect(typeof poiCategory.icon_selected).to.be('string');
+    expect(typeof poiCategory.icon_unselected).to.be('string');
+    expect(typeof poiCategory.public).to.be('boolean');
+  });
+});
+describe('Test fetchMapFromFloor ->', () => {
+  it('Check map', () => {
+    expect(map).to.be.ok();
+    expect(typeof map.data).to.be('string');
+  });
+});
+describe('Test fetchPoiCategoryIconNormal ->', () => {
+  it('Check iconNormal', () => {
+    expect(iconNormal).to.be.ok();
+    expect(typeof iconNormal.data).to.be('string')
+  });
+});
+describe('Test fetchPoiCategoryIconSelected ->', () => {
+  it('Chek iconSelected', () => {
+    expect(iconSelected).to.be.ok();
+    expect(typeof iconSelected.data).to.be('string');
+  });
+});
+describe('Test requestDirections ->', () => {
+  it('Check returned value', () => {
+    expect(route).to.be.ok();
+    expect(typeof route).to.be('object');
+  });
+  it('Check route', () => {
+    expect(route.edges instanceof Array).to.be(true);
+    expect(typeof route.firstStep).to.be('object');
+    expect(typeof route.from).to.be('object');
+    expect(route.indications instanceof Array).to.be(true);
+    expect(typeof route.lastStep).to.be('object');
+    expect(route.nodes instanceof Array).to.be(true);
+    expect(route.points instanceof Array).to.be(true);
+    expect(route.segments instanceof Array).to.be(true);
+    expect(typeof route.TO).to.be('object');
+    expect(route.steps instanceof Array).to.be(true);
+  });
+  it('Check edge route', () => {
+    expect(edge = route.edges[0]);
+    expect(typeof edge).to.be('object');
+    testRouteStep(edge);
+  });
+  it('Check firstStep route', () => {
+    testRouteStep(route.firstStep);
+  });
+  it('Check from route', () => {
+    testPoint(route.from);
+  });
+  it('Check indication route', () => {
+    expect(indication = route.indications[0]);
+    expect(typeof indication).to.be('object');
+    testIndication(indication);
+  });
+  it('Check lastStep route', () => {
+    testRouteStep(route.lastStep);
+  });
+  it('Check node route', () => {
+    expect(node = route.nodes[0]);
+    expect(typeof node).to.be('object');
+    testPoint(node);
+  });
+  it('Check point route', () => {
+    expect(point = route.points[0]);
+    expect(typeof point).to.be('object');
+    testPoint(point);
+  });
+  it('Check segment route', () => {
+    expect(segment = route.segments[0]);
+    expect(typeof segment).to.be('object');
+    testSegment(segment);
+  });
+  it('Check TO route', () => {
+    testPoint(route.TO);
+  });
+  it('Check step route', () => {
+    expect(step = route.steps[0]);
+    expect(typeof step).to.be('object');
+    testRouteStep(step);
+  });
+});
+describe('Test startPositioning ->', () => {
+  it('Check returned value', () => {
+    expect(starting).to.be.ok();
+    expect(typeof starting).to.be('object');
+  });
+  it('Check starting', () => {
+    expect(typeof starting.statusName).to.be('string');
+    expect(typeof starting.statusOrdinal).to.be('number');
+  })
+  it('Check returned value', () => {
+    expect(preparePositioningModel).to.be.ok();
+    expect(typeof preparePositioningModel).to.be('object');
+  });
+  it('Check preparePositioningModel', () => {
+    expect(typeof preparePositioningModel.statusName).to.be('string');
+    expect(typeof preparePositioningModel.statusOrdinal).to.be('number');
+  });
+  it('Check returned value', () => {
+    expect(startingPositioning).to.be.ok();
+    expect(typeof startingPositioning).to.be('object');
+  });
+  it('Check startingPositioning', () => {
+    expect(typeof startingPositioning.statusName).to.be('string');
+    expect(typeof startingPositioning.statusOrdinal).to.be('number');
+  });
+  it('Check returned value', () => {
+    expect(calculating).to.be.ok();
+    expect(typeof calculating).to.be('object');
+  });
+  it('Check calculating', () => {
+    expect(typeof calculating.statusName).to.be('string');
+    expect(typeof calculating.statusOrdinal).to.be('number');
+  });
+  it('Check returned value', () => {
+    expect(position).to.be.ok();
+    expect(typeof position).to.be('object');
+  });
+  it('Check position', () => {
+    expect(typeof position.accuracy).to.be('number');
+    expect(typeof position.bearing).to.be('object');
+    expect(typeof position.bearingQuality).to.be('string');
+    expect(typeof position.buildingIdentifier).to.be('string');
+    expect(typeof position.cartesianBearing).to.be('object');
+    expect(typeof position.cartesianCoordinate).to.be('object');
+    expect(typeof position.coordinate).to.be('object');
+    expect(typeof position.floorIdentifier).to.be('string');
+    expect(typeof position.position).to.be('object');
+    expect(typeof position.provider).to.be('string');
+    expect(typeof position.quality).to.be('string');
+    expect(typeof position.hasBearing).to.be('boolean');
+    expect(typeof position.timestamp).to.be('number');
+    expect(typeof position.hasCartesianBearing).to.be('boolean');
+    expect(typeof position.isIndoor).to.be('boolean');
+    expect(typeof position.isOutdoor).to.be('boolean');
+    expect(typeof position.deviceId).to.be('string');
+  });
+  it('Check position bearing', () => {
+    testBearing(position.bearing);
+  });
+  it('Check position cartesianBearing', () => {
+    testBearing(position.cartesianBearing);
+  });
+  it('Check position cartesianCoordinate', () => {
+    testCartesianCoordinate(position.cartesianCoordinate);
+  });
+  it('Check position coordinate', () => {
+    testCoordinate(position.coordinate);
+  });
+  it('Check position position', () => {
+    testPoint(position.position);
+  });
+})
+
+const testBounds = bounds => {
+  expect(typeof bounds.northEast).to.be('object');
+  expect(typeof bounds.northWest).to.be('object');
+  expect(typeof bounds.southEast).to.be('object');
+  expect(typeof bounds.southWest).to.be('object');
+  testCoordinate(bounds.northEast);
+  testCoordinate(bounds.northWest);
+  testCoordinate(bounds.southEast);
+  testCoordinate(bounds.southWest);
+}
+
+const testCoordinate = coordinate => {
+  expect(typeof coordinate.latitude).to.be('number');
+  expect(typeof coordinate.longitude).to.be('number');
+}
+
+const testDimension = dimension => {
+  expect(typeof dimension.width).to.be('number');
+  expect(typeof dimension.height).to.be('number');
+}
+
+const testCartesianCoordinate = cartesianCoordinate => {
+  expect(typeof cartesianCoordinate.x).to.be('number');
+  expect(typeof cartesianCoordinate.y).to.be('number');
+}
+
+const testPoint = point => {
+  expect(typeof point.buildingIdentifier).to.be('string');
+  expect(typeof point.cartesianCoordinate).to.be('object');
+  expect(typeof point.coordinate).to.be('object');
+  expect(typeof point.floorIdentifier).to.be('string');
+  expect(typeof point.isIndoor).to.be('boolean');
+  expect(typeof point.isOutdoor).to.be('boolean');
+  testCartesianCoordinate(point.cartesianCoordinate);
+  testCoordinate(point.coordinate);
+}
+
+const testConversionArea = conversionArea => {
+  expect(typeof conversionArea.floorIdentifier).to.be('number');
+  expect(typeof conversionArea.topLeft).to.be('string');
+  expect(typeof conversionArea.topRight).to.be('string');
+  expect(typeof conversionArea.bottomLeft).to.be('string');
+  expect(typeof conversionArea.bottomRight).to.be('string');
+}
+
+const testCircle = circle => {
+  expect(typeof circle.radius).to.be('number');
+  expect(typeof circle.center).to.be('object');
+  testPoint(circle.center);
+}
+
+const testRouteStep = routeStep => {
+  expect(typeof routeStep.distance).to.be('number');
+  expect(typeof routeStep.distanceToGoal).to.be('number');
+  expect(typeof routeStep.from).to.be('object');
+  expect(typeof routeStep.id).to.be('number');
+  expect(typeof routeStep.TO).to.be('object');
+  expect(typeof routeStep.isFirst).to.be('boolean');
+  expect(typeof routeStep.isLast).to.be('boolean');
+  testPoint(routeStep.from);
+  testPoint(routeStep.TO);
+}
+
+const testIndication = indication => {
+  expect(typeof indication.distance).to.be('number');
+  expect(typeof indication.distanceToNextLevel).to.be('number');
+  expect(typeof indication.indicationType).to.be('string');
+  expect(typeof indication.orientation).to.be('number');
+  expect(typeof indication.orientationType).to.be('string');
+  expect(typeof indication.stepIdxDestination).to.be('number');
+  expect(typeof indication.stepIdxOrigin).to.be('number');
+  expect(typeof indication.neededLevelChange).to.be('boolean');
+  expect(typeof indication.humanReadableMessage).to.be('string');
+}
+
+const testSegment = segment => {
+  expect(typeof segment.floorIdentifier).to.be('string');
+  expect(segment.points instanceof Array).to.be(true);
+}
+
+const testBearing = bearing => {
+  expect(typeof bearing.degrees).to.be('number');
+  expect(typeof bearing.degreesClockwise).to.be('number');
+  expect(typeof bearing.radians).to.be('number');
+  expect(typeof bearing.radiansMinusPiPi).to.be('number');
+}

package/tests/scripts/clean_android_resources.sh

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+rm -rf src/android/app/src/test/resources/

package/tests/scripts/clean_ios_resources.sh

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+rm -rf src/ios/situmcordovaplugintests/resources/

package/tests/scripts/copy_android_resources.sh

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+cp -r tests/common-resources/ src/android/app/src/test/resources/

package/tests/scripts/copy_ios_resources.sh

@@ -0,0 +1,3 @@
+#! /bin/bash
+
+cp -r tests/common-resources/ src/ios/situmcordovaplugintests/resources/

package/tests/scripts/self-destruct.sh

@@ -0,0 +1 @@
+rm -rf *