1264 lines
48 KiB
JavaScript
1264 lines
48 KiB
JavaScript
defineSuite([
|
|
'DataSources/GeoJsonDataSource',
|
|
'Core/Cartesian3',
|
|
'Core/Color',
|
|
'Core/Event',
|
|
'Core/JulianDate',
|
|
'Core/PolygonHierarchy',
|
|
'Core/RuntimeError',
|
|
'DataSources/CallbackProperty',
|
|
'DataSources/ConstantProperty',
|
|
'DataSources/EntityCollection',
|
|
'Scene/HeightReference',
|
|
'ThirdParty/when'
|
|
], function(
|
|
GeoJsonDataSource,
|
|
Cartesian3,
|
|
Color,
|
|
Event,
|
|
JulianDate,
|
|
PolygonHierarchy,
|
|
RuntimeError,
|
|
CallbackProperty,
|
|
ConstantProperty,
|
|
EntityCollection,
|
|
HeightReference,
|
|
when) {
|
|
'use strict';
|
|
|
|
var defaultMarkerSize;
|
|
var defaultSymbol;
|
|
var defaultMarkerColor;
|
|
var defaultStroke;
|
|
var defaultStrokeWidth;
|
|
var defaultFill;
|
|
var defaultClampToGround;
|
|
|
|
beforeAll(function() {
|
|
defaultMarkerSize = GeoJsonDataSource.markerSize;
|
|
defaultSymbol = GeoJsonDataSource.markerSymbol;
|
|
defaultMarkerColor = GeoJsonDataSource.markerColor;
|
|
defaultStroke = GeoJsonDataSource.stroke;
|
|
defaultStrokeWidth = GeoJsonDataSource.strokeWidth;
|
|
defaultFill = GeoJsonDataSource.fill;
|
|
defaultClampToGround = GeoJsonDataSource.clampToGround;
|
|
});
|
|
|
|
beforeEach(function() {
|
|
GeoJsonDataSource.markerSize = defaultMarkerSize;
|
|
GeoJsonDataSource.markerSymbol = defaultSymbol;
|
|
GeoJsonDataSource.markerColor = defaultMarkerColor;
|
|
GeoJsonDataSource.stroke = defaultStroke;
|
|
GeoJsonDataSource.strokeWidth = defaultStrokeWidth;
|
|
GeoJsonDataSource.fill = defaultFill;
|
|
GeoJsonDataSource.clampToGround = defaultClampToGround;
|
|
});
|
|
|
|
var time = new JulianDate();
|
|
|
|
function coordinatesToCartesian(coordinates) {
|
|
return Cartesian3.fromDegrees(coordinates[0], coordinates[1], coordinates[2]);
|
|
}
|
|
|
|
function coordinatesArrayToCartesian(coordinates) {
|
|
var result = [];
|
|
for (var i = 0; i < coordinates.length; i++) {
|
|
result.push(coordinatesToCartesian(coordinates[i]));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function multiLineToCartesian(geometry) {
|
|
var coordinates = geometry.coordinates;
|
|
var result = [];
|
|
for (var i = 0; i < coordinates.length; i++) {
|
|
result.push(coordinatesArrayToCartesian(coordinates[i]));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function polygonCoordinatesToCartesian(coordinates) {
|
|
return coordinatesArrayToCartesian(coordinates);
|
|
}
|
|
|
|
function multiPolygonCoordinatesToCartesian(coordinates) {
|
|
var result = [];
|
|
for (var i = 0; i < coordinates.length; i++) {
|
|
result.push(coordinatesArrayToCartesian(coordinates[i][0]));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
var point = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5]
|
|
};
|
|
|
|
var pointNamedCrs = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
crs : {
|
|
type : 'name',
|
|
properties : {
|
|
name : 'EPSG:4326'
|
|
}
|
|
}
|
|
};
|
|
|
|
var pointNamedCrsOgc = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
crs : {
|
|
type : 'name',
|
|
properties : {
|
|
name : 'urn:ogc:def:crs:OGC:1.3:CRS84'
|
|
}
|
|
}
|
|
};
|
|
|
|
var pointNamedCrsEpsg = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
crs : {
|
|
type : 'name',
|
|
properties : {
|
|
name : 'urn:ogc:def:crs:EPSG::4326'
|
|
}
|
|
}
|
|
};
|
|
|
|
var pointCrsLinkHref = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
crs : {
|
|
type : 'link',
|
|
properties : {
|
|
href : 'http://crs.invalid'
|
|
}
|
|
}
|
|
};
|
|
|
|
var pointCrsEpsg = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
crs : {
|
|
type : 'EPSG',
|
|
properties : {
|
|
code : 4326
|
|
}
|
|
}
|
|
};
|
|
|
|
var lineString = {
|
|
type : 'LineString',
|
|
coordinates : [[100.0, 0.0], [101.0, 1.0]]
|
|
};
|
|
|
|
var polygon = {
|
|
type : 'Polygon',
|
|
coordinates : [[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]]
|
|
};
|
|
|
|
var polygonWithHoles = {
|
|
type : 'Polygon',
|
|
coordinates : [[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]], [[100.2, 0.2], [100.8, 0.2], [100.8, 0.8], [100.2, 0.8], [100.2, 0.2]]]
|
|
};
|
|
|
|
var polygonWithHeights = {
|
|
type : 'Polygon',
|
|
coordinates : [[[100.0, 0.0, 1.0], [101.0, 0.0, 2.0], [101.0, 1.0, 1.0], [100.0, 1.0, 2.0], [100.0, 0.0, 3.0]]]
|
|
};
|
|
|
|
var multiPoint = {
|
|
type : 'MultiPoint',
|
|
coordinates : [[100.0, 0.0], [101.0, 1.0], [101.0, 3.0]]
|
|
};
|
|
|
|
var multiLineString = {
|
|
type : 'MultiLineString',
|
|
coordinates : [[[100.0, 0.0], [101.0, 1.0]], [[102.0, 2.0], [103.0, 3.0]]]
|
|
};
|
|
|
|
var multiPolygon = {
|
|
type : 'MultiPolygon',
|
|
coordinates : [[[[102.0, 2.0], [103.0, 2.0], [103.0, 3.0], [102.0, 3.0], [102.0, 2.0]]], [[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]]]
|
|
};
|
|
|
|
var geometryCollection = {
|
|
type : 'GeometryCollection',
|
|
geometries : [{
|
|
type : 'Point',
|
|
coordinates : [100.0, 0.0]
|
|
}, {
|
|
type : 'LineString',
|
|
coordinates : [[101.0, 0.0], [102.0, 1.0]]
|
|
}]
|
|
};
|
|
|
|
var feature = {
|
|
type : 'Feature',
|
|
geometry : point
|
|
};
|
|
|
|
var featureWithNullName = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
properties : {
|
|
name : null
|
|
}
|
|
};
|
|
|
|
var featureWithId = {
|
|
id : 'myId',
|
|
type : 'Feature',
|
|
geometry : geometryCollection
|
|
};
|
|
|
|
var featureUndefinedGeometry = {
|
|
type : 'Feature'
|
|
};
|
|
|
|
var featureNullGeometry = {
|
|
type : 'Feature',
|
|
geometry : null
|
|
};
|
|
|
|
var unknownGeometry = {
|
|
type : 'TimeyWimey',
|
|
coordinates : [0, 0]
|
|
};
|
|
|
|
var featureUnknownGeometry = {
|
|
type : 'Feature',
|
|
geometry : unknownGeometry
|
|
};
|
|
|
|
var geometryCollectionUnknownType = {
|
|
type : 'GeometryCollection',
|
|
geometries : [unknownGeometry]
|
|
};
|
|
|
|
var topoJson = {
|
|
type : 'Topology',
|
|
transform : {
|
|
scale : [1, 1],
|
|
translate : [0, 0]
|
|
},
|
|
objects : {
|
|
polygon : {
|
|
type : 'Polygon',
|
|
arcs : [[0, 1, 2, 3]],
|
|
properties : {
|
|
myProps : 0
|
|
}
|
|
},
|
|
lineString : {
|
|
type : 'LineString',
|
|
arcs : [4],
|
|
properties : {
|
|
myProps : 1
|
|
}
|
|
}
|
|
},
|
|
arcs : [[[0, 0], [1, 0], [0, 1], [-1, 0], [0, -1]], [[0, 0], [1, 0], [0, 1]], [[1, 1], [-1, 0], [0, -1]], [[1, 1]], [[0, 0]]]
|
|
};
|
|
|
|
var mixedGeometries = {
|
|
type : 'GeometryCollection',
|
|
geometries : [lineString, polygon, point]
|
|
};
|
|
|
|
it('default constructor has expected values', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
expect(dataSource.changedEvent).toBeInstanceOf(Event);
|
|
expect(dataSource.errorEvent).toBeInstanceOf(Event);
|
|
expect(dataSource.clock).toBeUndefined();
|
|
expect(dataSource.name).toBeUndefined();
|
|
expect(dataSource.entities).toBeInstanceOf(EntityCollection);
|
|
expect(dataSource.entities.values.length).toEqual(0);
|
|
expect(dataSource.show).toBe(true);
|
|
});
|
|
|
|
it('setting name raises changed event', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
|
|
var spy = jasmine.createSpy('changedEvent');
|
|
dataSource.changedEvent.addEventListener(spy);
|
|
|
|
var newName = 'chester';
|
|
dataSource.name = newName;
|
|
expect(dataSource.name).toEqual(newName);
|
|
expect(spy.calls.count()).toEqual(1);
|
|
expect(spy).toHaveBeenCalledWith(dataSource);
|
|
});
|
|
|
|
it('show sets underlying entity collection show.', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
|
|
dataSource.show = false;
|
|
expect(dataSource.show).toBe(false);
|
|
expect(dataSource.show).toEqual(dataSource.entities.show);
|
|
|
|
dataSource.show = true;
|
|
expect(dataSource.show).toBe(true);
|
|
expect(dataSource.show).toEqual(dataSource.entities.show);
|
|
});
|
|
|
|
it('Works with null geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureNullGeometry).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(featureNullGeometry.properties);
|
|
expect(entity.position).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('Works with feature', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(feature).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(feature.properties);
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(feature.geometry.coordinates));
|
|
expect(entity.billboard).toBeDefined();
|
|
});
|
|
});
|
|
|
|
it('Creates default description from properties', function() {
|
|
var featureWithProperties = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
properties : {
|
|
prop1 : 'dog',
|
|
prop2 : 'cat',
|
|
prop3 : 'liger'
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureWithProperties).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.description).toBeDefined();
|
|
var description = entity.description.getValue(time);
|
|
expect(description).toContain('prop1');
|
|
expect(description).toContain('prop2');
|
|
expect(description).toContain('prop3');
|
|
expect(description).toContain('dog');
|
|
expect(description).toContain('cat');
|
|
expect(description).toContain('liger');
|
|
});
|
|
});
|
|
|
|
it('Creates custom description string from properties', function() {
|
|
var featureWithProperties = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
properties : {
|
|
prop1 : 'dog',
|
|
prop2 : 'cat'
|
|
}
|
|
};
|
|
|
|
function testDescribe(properties) {
|
|
var desc = '';
|
|
for (var key in properties) {
|
|
if (properties.hasOwnProperty(key)) {
|
|
var value = properties[key];
|
|
desc += key + ' = ' + value + '. ';
|
|
}
|
|
}
|
|
return desc;
|
|
}
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
var options = {
|
|
describe: testDescribe
|
|
};
|
|
return dataSource.load(featureWithProperties, options).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.description).toBeDefined();
|
|
var description = entity.description.getValue(time);
|
|
expect(description).toContain('prop1 = dog.');
|
|
expect(description).toContain('prop2 = cat.');
|
|
});
|
|
});
|
|
|
|
it('Creates custom description from properties, using a describeProperty', function() {
|
|
var featureWithProperties = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
properties : {
|
|
prop1 : 'dog',
|
|
prop2 : 'cat'
|
|
}
|
|
};
|
|
|
|
function testDescribe(properties) {
|
|
var desc = '';
|
|
for (var key in properties) {
|
|
if (properties.hasOwnProperty(key)) {
|
|
var value = properties[key];
|
|
desc += key + ' = ' + value + '; ';
|
|
}
|
|
}
|
|
return desc;
|
|
}
|
|
function createDescriptionCallback(describe, properties, nameProperty) {
|
|
var description;
|
|
return function(time, result) {
|
|
if (!description) {
|
|
description = describe(properties, nameProperty);
|
|
}
|
|
return description;
|
|
};
|
|
}
|
|
function testDescribeProperty(properties, nameProperty) {
|
|
return new CallbackProperty(createDescriptionCallback(testDescribe, properties, nameProperty), true);
|
|
}
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
var options = {
|
|
describe: testDescribeProperty
|
|
};
|
|
return dataSource.load(featureWithProperties, options).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.description).toBeDefined();
|
|
var description = entity.description.getValue(time);
|
|
expect(description).toContain('prop1 = dog;');
|
|
expect(description).toContain('prop2 = cat;');
|
|
});
|
|
});
|
|
|
|
it('Uses description if present', function() {
|
|
var featureWithDescription = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
properties : {
|
|
prop1 : 'dog',
|
|
prop2 : 'cat',
|
|
prop3 : 'liger',
|
|
description : 'This is my descriptiong!'
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureWithDescription).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.description).toBeDefined();
|
|
expect(entity.description.getValue(time)).toEqual(featureWithDescription.properties.description);
|
|
});
|
|
});
|
|
|
|
it('Handles null description', function() {
|
|
var featureWithNullDescription = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
properties : {
|
|
description : null
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureWithNullDescription).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.description).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('Does not use "name" property as the object\'s name if it is null', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureWithNullName).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.name).toBeUndefined();
|
|
expect(entity.properties.name.getValue()).toBe(featureWithNullName.properties.name);
|
|
expect(entity.properties.getValue(time)).toEqual(featureWithNullName.properties);
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(featureWithNullName.geometry.coordinates));
|
|
expect(entity.billboard).toBeDefined();
|
|
});
|
|
});
|
|
|
|
it('Works with feature with id', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureWithId).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.id).toEqual(featureWithId.id);
|
|
entity = entityCollection.values[1];
|
|
expect(entity.id).toEqual(featureWithId.id + '_2');
|
|
});
|
|
});
|
|
|
|
it('Works with null id', function() {
|
|
var geojson = {
|
|
id : null,
|
|
type : 'Feature',
|
|
geometry : null
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geojson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.id).not.toEqual(null);
|
|
});
|
|
});
|
|
|
|
it('Works with null properties', function() {
|
|
var geojson = {
|
|
type : 'Feature',
|
|
geometry : null,
|
|
properties : null
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geojson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
it('Has entity collection with link to data source', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureWithId).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
expect(entityCollection.owner).toEqual(dataSource);
|
|
});
|
|
});
|
|
|
|
it('Has entity with link to entity collection', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureWithId).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.entityCollection).toEqual(entityCollection);
|
|
});
|
|
});
|
|
|
|
it('Works with point geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(point).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(point.properties);
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(point.coordinates));
|
|
expect(entity.billboard).toBeDefined();
|
|
expect(entity.billboard.image).toBeDefined();
|
|
});
|
|
});
|
|
|
|
it('Works with point geometry clamped to ground', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(point, {
|
|
clampToGround: true
|
|
}).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(point.properties);
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(point.coordinates));
|
|
expect(entity.billboard).toBeDefined();
|
|
expect(entity.billboard.image).toBeDefined();
|
|
expect(entity.billboard.heightReference.getValue(time)).toBe(HeightReference.CLAMP_TO_GROUND);
|
|
});
|
|
});
|
|
|
|
it('Works with point geometry with simplystyle', function() {
|
|
var geojson = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
properties : {
|
|
'marker-size' : 'large',
|
|
'marker-symbol' : 'bus',
|
|
'marker-color' : '#ffffff'
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geojson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.billboard).toBeDefined();
|
|
return when(dataSource._pinBuilder.fromMakiIconId('bus', Color.WHITE, 64)).then(function(image) {
|
|
expect(entity.billboard.image.getValue()).toBe(image);
|
|
});
|
|
});
|
|
});
|
|
|
|
it('Works with point geometry with null simplystyle', function() {
|
|
var geojson = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
properties : {
|
|
'marker-size' : null,
|
|
'marker-symbol' : null,
|
|
'marker-color' : null
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geojson).then(function() {
|
|
var image = dataSource._pinBuilder.fromColor(GeoJsonDataSource.markerColor, GeoJsonDataSource.markerSize);
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.billboard).toBeDefined();
|
|
expect(entity.billboard.image.getValue()).toBe(image);
|
|
});
|
|
});
|
|
|
|
it('Works with point geometry and unknown simplystyle', function() {
|
|
var geojson = {
|
|
type : 'Point',
|
|
coordinates : [102.0, 0.5],
|
|
properties : {
|
|
'marker-size' : 'large',
|
|
'marker-symbol' : 'notAnIcon',
|
|
'marker-color' : '#ffffff'
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geojson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.billboard).toBeDefined();
|
|
return when(dataSource._pinBuilder.fromColor(Color.WHITE, 64)).then(function(image) {
|
|
expect(entity.billboard.image.getValue()).toBe(image);
|
|
});
|
|
});
|
|
});
|
|
|
|
it('Works with multipoint geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(multiPoint).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
var expectedPositions = coordinatesArrayToCartesian(multiPoint.coordinates);
|
|
for (var i = 0; i < multiPoint.coordinates.length; i++) {
|
|
var entity = entities[i];
|
|
expect(entity.properties).toBe(multiPoint.properties);
|
|
expect(entity.position.getValue(time)).toEqual(expectedPositions[i]);
|
|
expect(entity.billboard).toBeDefined();
|
|
expect(entity.billboard.image).toBeDefined();
|
|
}
|
|
});
|
|
});
|
|
|
|
it('Works with multipoint geometry clamped to ground', function() {
|
|
GeoJsonDataSource.clampToGround = true;
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(multiPoint).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
var expectedPositions = coordinatesArrayToCartesian(multiPoint.coordinates);
|
|
for (var i = 0; i < multiPoint.coordinates.length; i++) {
|
|
var entity = entities[i];
|
|
expect(entity.properties).toBe(multiPoint.properties);
|
|
expect(entity.position.getValue(time)).toEqual(expectedPositions[i]);
|
|
expect(entity.billboard).toBeDefined();
|
|
expect(entity.billboard.image).toBeDefined();
|
|
expect(entity.billboard.heightReference.getValue()).toBe(HeightReference.CLAMP_TO_GROUND);
|
|
}
|
|
});
|
|
});
|
|
|
|
it('Works with lineString geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(lineString).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(lineString.properties);
|
|
expect(entity.polyline.positions.getValue(time)).toEqual(coordinatesArrayToCartesian(lineString.coordinates));
|
|
expect(entity.polyline.material.color.getValue(time)).toEqual(GeoJsonDataSource.stroke);
|
|
expect(entity.polyline.width.getValue(time)).toEqual(2);
|
|
});
|
|
});
|
|
|
|
it('Works with lineString geometry clamped to ground', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(lineString, {
|
|
clampToGround: true
|
|
}).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(lineString.properties);
|
|
expect(entity.polyline.positions.getValue(time)).toEqual(coordinatesArrayToCartesian(lineString.coordinates));
|
|
expect(entity.polyline.material.color.getValue(time)).toEqual(GeoJsonDataSource.stroke);
|
|
expect(entity.polyline.width.getValue(time)).toEqual(2);
|
|
expect(entity.polyline.clampToGround.getValue(time)).toEqual(true);
|
|
});
|
|
});
|
|
|
|
it('Works with multiLineString geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(multiLineString).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
var lines = multiLineToCartesian(multiLineString);
|
|
for (var i = 0; i < multiLineString.coordinates.length; i++) {
|
|
var entity = entities[i];
|
|
expect(entity.properties).toBe(multiLineString.properties);
|
|
expect(entity.polyline.positions.getValue(time)).toEqual(lines[i]);
|
|
expect(entity.polyline.material.color.getValue(time)).toEqual(Color.YELLOW);
|
|
expect(entity.polyline.width.getValue(time)).toEqual(2);
|
|
}
|
|
});
|
|
});
|
|
|
|
it('Works with multiLineString geometry clamped to ground', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(multiLineString, {
|
|
clampToGround: true
|
|
}).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
var lines = multiLineToCartesian(multiLineString);
|
|
for (var i = 0; i < multiLineString.coordinates.length; i++) {
|
|
var entity = entities[i];
|
|
expect(entity.properties).toBe(multiLineString.properties);
|
|
expect(entity.polyline.positions.getValue(time)).toEqual(lines[i]);
|
|
expect(entity.polyline.material.color.getValue(time)).toEqual(Color.YELLOW);
|
|
expect(entity.polyline.width.getValue(time)).toEqual(2);
|
|
expect(entity.polyline.clampToGround.getValue(time)).toEqual(true);
|
|
}
|
|
});
|
|
});
|
|
|
|
it('Works with polygon geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(polygon).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(polygon.properties);
|
|
expect(entity.polygon.hierarchy.getValue(time)).toEqual(new PolygonHierarchy(polygonCoordinatesToCartesian(polygon.coordinates[0])));
|
|
expect(entity.polygon.perPositionHeight).toBeUndefined();
|
|
expect(entity.polygon.material.color.getValue(time)).toEqual(GeoJsonDataSource.fill);
|
|
expect(entity.polygon.outline.getValue(time)).toEqual(true);
|
|
expect(entity.polygon.outlineWidth.getValue(time)).toEqual(GeoJsonDataSource.strokeWidth);
|
|
expect(entity.polygon.outlineColor.getValue(time)).toEqual(GeoJsonDataSource.stroke);
|
|
expect(entity.polygon.height).toBeInstanceOf(ConstantProperty);
|
|
});
|
|
});
|
|
|
|
it('Works with polygon geometry clamped to ground', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(polygon, {
|
|
clampToGround: true
|
|
}).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(polygon.properties);
|
|
expect(entity.polygon.hierarchy.getValue(time)).toEqual(new PolygonHierarchy(polygonCoordinatesToCartesian(polygon.coordinates[0])));
|
|
expect(entity.polygon.perPositionHeight).toBeUndefined();
|
|
expect(entity.polygon.material.color.getValue(time)).toEqual(GeoJsonDataSource.fill);
|
|
expect(entity.polygon.outline.getValue(time)).toEqual(true);
|
|
expect(entity.polygon.outlineWidth.getValue(time)).toEqual(GeoJsonDataSource.strokeWidth);
|
|
expect(entity.polygon.outlineColor.getValue(time)).toEqual(GeoJsonDataSource.stroke);
|
|
expect(entity.polygon.height).toBeUndefined();
|
|
|
|
});
|
|
});
|
|
|
|
it('Works with polygon geometry with Heights', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(polygonWithHeights).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(polygonWithHeights.properties);
|
|
expect(entity.polygon.hierarchy.getValue(time)).toEqual(new PolygonHierarchy(polygonCoordinatesToCartesian(polygonWithHeights.coordinates[0])));
|
|
expect(entity.polygon.perPositionHeight.getValue(time)).toBe(true);
|
|
expect(entity.polygon.material.color.getValue(time)).toEqual(GeoJsonDataSource.fill);
|
|
expect(entity.polygon.outline.getValue(time)).toEqual(true);
|
|
expect(entity.polygon.outlineWidth.getValue(time)).toEqual(GeoJsonDataSource.strokeWidth);
|
|
expect(entity.polygon.outlineColor.getValue(time)).toEqual(GeoJsonDataSource.stroke);
|
|
});
|
|
});
|
|
|
|
it('Works with polygon geometry with holes', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(polygonWithHoles).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(polygonWithHoles.properties);
|
|
expect(entity.polygon.hierarchy.getValue(time)).toEqual(new PolygonHierarchy(polygonCoordinatesToCartesian(polygonWithHoles.coordinates[0]), [new PolygonHierarchy(polygonCoordinatesToCartesian(polygonWithHoles.coordinates[1]))]));
|
|
});
|
|
});
|
|
|
|
it('Works with multiPolygon geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(multiPolygon).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
var positions = multiPolygonCoordinatesToCartesian(multiPolygon.coordinates);
|
|
for (var i = 0; i < multiPolygon.coordinates.length; i++) {
|
|
var entity = entities[i];
|
|
expect(entity.properties).toBe(multiPolygon.properties);
|
|
expect(entity.polygon.hierarchy.getValue(time)).toEqual(new PolygonHierarchy(positions[i]));
|
|
}
|
|
});
|
|
});
|
|
|
|
it('Works with topojson geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(topoJson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
|
|
var polygon = entities[0];
|
|
expect(polygon.properties.myProps.getValue()).toBe(topoJson.objects.polygon.properties.myProps);
|
|
expect(polygon.properties.getValue(time)).toEqual(topoJson.objects.polygon.properties);
|
|
|
|
expect(polygon.polygon.hierarchy).toBeDefined();
|
|
|
|
var lineString = entities[1];
|
|
expect(lineString.properties.myProps.getValue()).toBe(topoJson.objects.lineString.properties.myProps);
|
|
expect(lineString.properties.getValue(time)).toEqual(topoJson.objects.lineString.properties);
|
|
|
|
expect(lineString.polyline).toBeDefined();
|
|
});
|
|
});
|
|
|
|
it('Can provide base styling options', function() {
|
|
var options = {
|
|
markerSize : 10,
|
|
markerSymbol : 'bus',
|
|
markerColor : Color.GREEN,
|
|
stroke : Color.ORANGE,
|
|
strokeWidth : 8,
|
|
fill : Color.RED
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(mixedGeometries, options).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
|
|
var entity = entities[0];
|
|
expect(entity.polyline.material.color.getValue()).toEqual(options.stroke);
|
|
expect(entity.polyline.width.getValue()).toEqual(options.strokeWidth);
|
|
|
|
entity = entities[1];
|
|
expect(entity.polygon.material.color.getValue()).toEqual(options.fill);
|
|
expect(entity.polygon.outlineColor.getValue()).toEqual(options.stroke);
|
|
expect(entity.polygon.outlineWidth.getValue()).toEqual(options.strokeWidth);
|
|
|
|
entity = entities[2];
|
|
var expectedImage = dataSource._pinBuilder.fromMakiIconId(options.markerSymbol, options.markerColor, options.markerSize);
|
|
expect(entity.billboard.image.getValue()).toEqual(expectedImage);
|
|
});
|
|
});
|
|
|
|
it('Can set default graphics', function() {
|
|
GeoJsonDataSource.markerSize = 10;
|
|
GeoJsonDataSource.markerSymbol = 'bus';
|
|
GeoJsonDataSource.markerColor = Color.GREEN;
|
|
GeoJsonDataSource.stroke = Color.ORANGE;
|
|
GeoJsonDataSource.strokeWidth = 8;
|
|
GeoJsonDataSource.fill = Color.RED;
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(mixedGeometries).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
|
|
var entity = entities[0];
|
|
expect(entity.polyline.material.color.getValue()).toEqual(GeoJsonDataSource.stroke);
|
|
expect(entity.polyline.width.getValue()).toEqual(GeoJsonDataSource.strokeWidth);
|
|
|
|
entity = entities[1];
|
|
expect(entity.polygon.material.color.getValue()).toEqual(GeoJsonDataSource.fill);
|
|
expect(entity.polygon.outlineColor.getValue()).toEqual(GeoJsonDataSource.stroke);
|
|
expect(entity.polygon.outlineWidth.getValue()).toEqual(GeoJsonDataSource.strokeWidth);
|
|
|
|
entity = entities[2];
|
|
var expectedImage = dataSource._pinBuilder.fromMakiIconId(GeoJsonDataSource.markerSymbol, GeoJsonDataSource.markerColor, GeoJsonDataSource.markerSize);
|
|
expect(entity.billboard.image.getValue()).toEqual(expectedImage);
|
|
});
|
|
});
|
|
|
|
it('Generates description', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(topoJson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entities = entityCollection.values;
|
|
var polygon = entities[0];
|
|
expect(polygon.description).toBeDefined();
|
|
});
|
|
});
|
|
|
|
it('Works with geometrycollection', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geometryCollection).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.properties).toBe(geometryCollection.properties);
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(geometryCollection.geometries[0].coordinates));
|
|
expect(entity.billboard).toBeDefined();
|
|
|
|
entity = entityCollection.values[1];
|
|
expect(entity.properties).toBe(geometryCollection.properties);
|
|
expect(entity.polyline.positions.getValue(time)).toEqual(coordinatesArrayToCartesian(geometryCollection.geometries[1].coordinates));
|
|
});
|
|
});
|
|
|
|
it('Works with named crs', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(pointNamedCrs).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(point.coordinates));
|
|
});
|
|
});
|
|
|
|
it('Works with named crs OGC:1.3:CRS84', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(pointNamedCrsOgc).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(point.coordinates));
|
|
});
|
|
});
|
|
|
|
it('Works with named crs EPSG::4326', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(pointNamedCrsEpsg).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(point.coordinates));
|
|
});
|
|
});
|
|
|
|
it('Works with link crs href', function() {
|
|
var projectedPosition = new Cartesian3(1, 2, 3);
|
|
GeoJsonDataSource.crsLinkHrefs[pointCrsLinkHref.crs.properties.href] = function(properties) {
|
|
expect(properties).toBe(pointCrsLinkHref.crs.properties);
|
|
return when(properties.href).then(function(href) {
|
|
return function(coordinate) {
|
|
expect(coordinate).toBe(pointCrsLinkHref.coordinates);
|
|
return projectedPosition;
|
|
};
|
|
});
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(pointCrsLinkHref).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.position.getValue(time)).toEqual(projectedPosition);
|
|
});
|
|
});
|
|
|
|
it('Works with EPSG crs', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
|
|
return dataSource.load(pointCrsEpsg).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.position.getValue(time)).toEqual(coordinatesToCartesian(point.coordinates));
|
|
});
|
|
});
|
|
|
|
it('Works with polyline using simplestyle', function() {
|
|
var geoJson = {
|
|
type : 'Feature',
|
|
geometry : {
|
|
type : 'LineString',
|
|
coordinates : [[100.0, 0.0], [101.0, 1.0]]
|
|
},
|
|
properties : {
|
|
title : 'textMarker',
|
|
description : 'My description',
|
|
stroke : '#aabbcc',
|
|
'stroke-opacity' : 0.5,
|
|
'stroke-width' : 5
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geoJson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.name).toEqual(geoJson.properties.title);
|
|
expect(entity.description.getValue(time)).toEqual(geoJson.properties.description);
|
|
|
|
var expectedColor = Color.fromCssColorString(geoJson.properties.stroke);
|
|
expectedColor.alpha = geoJson.properties['stroke-opacity'];
|
|
expect(entity.polyline.material.color.getValue(time)).toEqual(expectedColor);
|
|
expect(entity.polyline.width.getValue(time)).toEqual(geoJson.properties['stroke-width']);
|
|
});
|
|
});
|
|
|
|
it('Works with polyline using null simplestyle values', function() {
|
|
var geoJson = {
|
|
type : 'Feature',
|
|
geometry : {
|
|
type : 'LineString',
|
|
coordinates : [[100.0, 0.0], [101.0, 1.0]]
|
|
},
|
|
properties : {
|
|
title : null,
|
|
description : null,
|
|
stroke : null,
|
|
'stroke-opacity' : null,
|
|
'stroke-width' : null
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geoJson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.name).toBeUndefined();
|
|
expect(entity.description).toBeUndefined();
|
|
expect(entity.polyline.material.color.getValue(time)).toEqual(GeoJsonDataSource.stroke);
|
|
expect(entity.polyline.width.getValue(time)).toEqual(GeoJsonDataSource.strokeWidth);
|
|
});
|
|
});
|
|
|
|
it('Works with polygon using simplestyle', function() {
|
|
var geoJson = {
|
|
type : 'Feature',
|
|
geometry : {
|
|
type : 'Polygon',
|
|
coordinates : [[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]]
|
|
},
|
|
properties : {
|
|
title : 'textMarker',
|
|
description : 'My description',
|
|
stroke : '#aabbcc',
|
|
'stroke-opacity' : 0.5,
|
|
'stroke-width' : 5,
|
|
fill : '#ccaabb',
|
|
'fill-opacity' : 0.25
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geoJson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.name).toEqual(geoJson.properties.title);
|
|
expect(entity.description.getValue(time)).toEqual(geoJson.properties.description);
|
|
|
|
var expectedFill = Color.fromCssColorString(geoJson.properties.fill);
|
|
expectedFill.alpha = geoJson.properties['fill-opacity'];
|
|
|
|
var expectedOutlineColor = Color.fromCssColorString(geoJson.properties.stroke);
|
|
expectedOutlineColor.alpha = geoJson.properties['stroke-opacity'];
|
|
|
|
expect(entity.polygon.material.color.getValue(time)).toEqual(expectedFill);
|
|
expect(entity.polygon.outline.getValue(time)).toEqual(true);
|
|
expect(entity.polygon.outlineWidth.getValue(time)).toEqual(5);
|
|
expect(entity.polygon.outlineColor.getValue(time)).toEqual(expectedOutlineColor);
|
|
});
|
|
});
|
|
|
|
it('Works with polygon using null simplestyle', function() {
|
|
var geoJson = {
|
|
type : 'Feature',
|
|
geometry : {
|
|
type : 'Polygon',
|
|
coordinates : [[[100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0]]]
|
|
},
|
|
properties : {
|
|
title : null,
|
|
description : null,
|
|
stroke : null,
|
|
'stroke-opacity' : null,
|
|
'stroke-width' : null,
|
|
fill : null,
|
|
'fill-opacity' : null
|
|
}
|
|
};
|
|
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geoJson).then(function() {
|
|
var entityCollection = dataSource.entities;
|
|
var entity = entityCollection.values[0];
|
|
expect(entity.name).toBeUndefined();
|
|
expect(entity.description).toBeUndefined();
|
|
expect(entity.polygon.material.color.getValue(time)).toEqual(GeoJsonDataSource.fill);
|
|
expect(entity.polygon.outline.getValue(time)).toEqual(true);
|
|
expect(entity.polygon.outlineWidth.getValue(time)).toEqual(GeoJsonDataSource.strokeWidth);
|
|
expect(entity.polygon.outlineColor.getValue(time)).toEqual(GeoJsonDataSource.stroke);
|
|
});
|
|
});
|
|
|
|
it('load works with a URL', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load('Data/test.geojson').then(function() {
|
|
expect(dataSource.name).toEqual('test.geojson');
|
|
});
|
|
});
|
|
|
|
it('Fails when encountering unknown geometry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureUnknownGeometry).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function() {
|
|
});
|
|
});
|
|
|
|
it('Fails with undefined geomeetry', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(featureUndefinedGeometry).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function() {
|
|
});
|
|
});
|
|
|
|
it('Fails with unknown geomeetry in geometryCollection', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
return dataSource.load(geometryCollectionUnknownType).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function() {
|
|
});
|
|
});
|
|
|
|
it('load throws with undefined geoJson', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
expect(function() {
|
|
dataSource.load(undefined);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('rejects unknown geometry', function() {
|
|
return GeoJsonDataSource.load(unknownGeometry).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function(error) {
|
|
expect(error).toBeInstanceOf(RuntimeError);
|
|
expect(error.message).toContain('Unsupported GeoJSON object type: TimeyWimey');
|
|
});
|
|
});
|
|
|
|
it('rejects invalid url', function() {
|
|
return GeoJsonDataSource.load('invalid.geojson').then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function(error) {
|
|
expect(error.statusCode).toBe(404);
|
|
});
|
|
});
|
|
|
|
it('rejects null CRS', function() {
|
|
var featureWithNullCrs = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
crs : null
|
|
};
|
|
|
|
return GeoJsonDataSource.load(featureWithNullCrs).then(function(dataSource) {
|
|
expect(dataSource.entities.values.length).toBe(0);
|
|
});
|
|
});
|
|
|
|
it('rejects unknown CRS', function() {
|
|
var featureWithUnknownCrsType = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
crs : {
|
|
type : 'potato',
|
|
properties : {}
|
|
}
|
|
};
|
|
|
|
return GeoJsonDataSource.load(featureWithUnknownCrsType).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function(error) {
|
|
expect(error).toBeInstanceOf(RuntimeError);
|
|
expect(error.message).toContain('Unknown crs type: potato');
|
|
});
|
|
});
|
|
|
|
it('rejects undefined CRS properties', function() {
|
|
var featureWithUndefinedCrsProperty = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
crs : {
|
|
type : 'name'
|
|
}
|
|
};
|
|
|
|
return GeoJsonDataSource.load(featureWithUndefinedCrsProperty).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function(error) {
|
|
expect(error).toBeInstanceOf(RuntimeError);
|
|
expect(error.message).toContain('crs.properties is undefined.');
|
|
});
|
|
});
|
|
|
|
it('rejects unknown CRS name', function() {
|
|
var featureWithUnknownCrsType = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
crs : {
|
|
type : 'name',
|
|
properties : {
|
|
name : 'failMe'
|
|
}
|
|
}
|
|
};
|
|
|
|
return GeoJsonDataSource.load(featureWithUnknownCrsType).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function(error) {
|
|
expect(error).toBeInstanceOf(RuntimeError);
|
|
expect(error.message).toContain('Unknown crs name: failMe');
|
|
});
|
|
});
|
|
|
|
it('rejects unknown CRS link', function() {
|
|
var featureWithUnknownCrsType = {
|
|
type : 'Feature',
|
|
geometry : point,
|
|
crs : {
|
|
type : 'link',
|
|
properties : {
|
|
href : 'failMe',
|
|
type : 'failMeTwice'
|
|
}
|
|
}
|
|
};
|
|
|
|
return GeoJsonDataSource.load(featureWithUnknownCrsType).then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function(error) {
|
|
expect(error).toBeInstanceOf(RuntimeError);
|
|
expect(error.message).toContain('Unable to resolve crs link: {"href":"failMe","type":"failMeTwice"}');
|
|
});
|
|
});
|
|
|
|
it('load rejects loading non json file', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
var spy = jasmine.createSpy('errorEvent');
|
|
dataSource.errorEvent.addEventListener(spy);
|
|
|
|
// Blue.png is not JSON
|
|
return dataSource.load('Data/Images/Blue.png').then(function() {
|
|
fail('should not be called');
|
|
}).otherwise(function() {
|
|
expect(spy).toHaveBeenCalledWith(dataSource, jasmine.any(Error));
|
|
});
|
|
});
|
|
|
|
it('load raises loading event', function() {
|
|
var dataSource = new GeoJsonDataSource();
|
|
var spy = jasmine.createSpy('loadingEvent');
|
|
dataSource.loadingEvent.addEventListener(spy);
|
|
|
|
var promise = dataSource.load('Data/test.geojson');
|
|
expect(spy).toHaveBeenCalledWith(dataSource, true);
|
|
expect(dataSource.isLoading).toBe(true);
|
|
|
|
return promise.then(function() {
|
|
expect(spy).toHaveBeenCalledWith(dataSource, false);
|
|
expect(dataSource.isLoading).toBe(false);
|
|
});
|
|
});
|
|
});
|