639 lines
19 KiB
JavaScript
639 lines
19 KiB
JavaScript
//
|
|
// Big Polygon related tests
|
|
// - Tests the capability for a geo query with a big polygon object (strictCRS)
|
|
// $geoWithin & $geoIntersects
|
|
// - Big polygon objects cannot be stored
|
|
// Try all different shapes queries against various stored geo points, line & polygons
|
|
|
|
var crs84CRS = {type: "name", properties: {name: "urn:ogc:def:crs:OGC:1.3:CRS84"}};
|
|
var epsg4326CRS = {type: "name", properties: {name: "EPSG:4326"}};
|
|
var strictCRS = {type: "name", properties: {name: "urn:x-mongodb:crs:strictwinding:EPSG:4326"}};
|
|
// invalid CRS name
|
|
var badCRS = {type: "name", properties: {name: "urn:x-mongodb:crs:invalid:EPSG:4326"}};
|
|
|
|
// helper to generate a line along a longitudinal
|
|
function genLonLine(lon, startLat, endLat, latStep) {
|
|
var line = [];
|
|
for (var lat = startLat; lat <= endLat; lat += latStep) {
|
|
line.push([lon, lat]);
|
|
}
|
|
return line;
|
|
}
|
|
|
|
// Main program
|
|
// Clear out collection
|
|
var coll = db.geo_bigpoly;
|
|
coll.drop();
|
|
|
|
// GeoJson Objects to be inserted into collection
|
|
// coordinates are longitude, latitude
|
|
// strictCRS (big polygon) cannot be stored in the collection
|
|
var objects = [
|
|
{name: "boat ramp", geo: {type: "Point", coordinates: [-97.927117, 30.327376]}},
|
|
{name: "on equator", geo: {type: "Point", coordinates: [-97.9, 0]}},
|
|
{name: "just north of equator", geo: {type: "Point", coordinates: [-97.9, 0.1]}},
|
|
{name: "just south of equator", geo: {type: "Point", coordinates: [-97.9, -0.1]}},
|
|
{
|
|
name: "north pole - crs84CRS",
|
|
geo: {type: "Point", coordinates: [-97.9, 90.0], crs: crs84CRS}
|
|
},
|
|
{
|
|
name: "south pole - epsg4326CRS",
|
|
geo: {type: "Point", coordinates: [-97.9, -90.0], crs: epsg4326CRS}
|
|
},
|
|
{
|
|
name: "short line string: PA, LA, 4corners, ATX, Mansfield, FL, Reston, NYC",
|
|
geo: {
|
|
type: "LineString",
|
|
coordinates: [
|
|
[-122.1611953, 37.4420407],
|
|
[-118.283638, 34.028517],
|
|
[-109.045223, 36.9990835],
|
|
[-97.850404, 30.3921555],
|
|
[-97.904187, 30.395457],
|
|
[-86.600836, 30.398147],
|
|
[-77.357837, 38.9589935],
|
|
[-73.987723, 40.7575074]
|
|
]
|
|
}
|
|
},
|
|
{
|
|
name: "1024 point long line string from south pole to north pole",
|
|
geo: {type: "LineString", coordinates: genLonLine(2.349902, -90.0, 90.0, 180.0 / 1024)}
|
|
},
|
|
{
|
|
name: "line crossing equator - epsg4326CRS",
|
|
geo: {
|
|
type: "LineString",
|
|
coordinates: [[-77.0451853, -12.0553442], [-76.7784557, 18.0098528]],
|
|
crs: epsg4326CRS
|
|
}
|
|
},
|
|
{
|
|
name: "GeoJson polygon",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates:
|
|
[[[-80.0, 30.0], [-40.0, 30.0], [-40.0, 60.0], [-80.0, 60.0], [-80.0, 30.0]]]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon w/ hole",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [
|
|
[[-80.0, 30.0], [-40.0, 30.0], [-40.0, 60.0], [-80.0, 60.0], [-80.0, 30.0]],
|
|
[[-70.0, 40.0], [-60.0, 40.0], [-60.0, 50.0], [-70.0, 50.0], [-70.0, 40.0]]
|
|
]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon w/ two holes",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [
|
|
[[-80.0, 30.0], [-40.0, 30.0], [-40.0, 60.0], [-80.0, 60.0], [-80.0, 30.0]],
|
|
[[-70.0, 40.0], [-60.0, 40.0], [-60.0, 50.0], [-70.0, 50.0], [-70.0, 40.0]],
|
|
[[-55.0, 40.0], [-45.0, 40.0], [-45.0, 50.0], [-55.0, 50.0], [-55.0, 40.0]]
|
|
]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon covering North pole",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [[[-120.0, 89.0], [0.0, 89.0], [120.0, 89.0], [-120.0, 89.0]]]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon covering South pole",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [[[-120.0, -89.0], [0.0, -89.0], [120.0, -89.0], [-120.0, -89.0]]]
|
|
}
|
|
},
|
|
{
|
|
name: "big polygon/rectangle covering both poles",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates:
|
|
[[[-130.0, 89.0], [-120.0, 89.0], [-120.0, -89.0], [-130.0, -89.0], [-130.0, 89.0]]],
|
|
crs: strictCRS
|
|
}
|
|
},
|
|
{
|
|
name: "polygon (triangle) w/ hole at North pole",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [
|
|
[[-120.0, 80.0], [0.0, 80.0], [120.0, 80.0], [-120.0, 80.0]],
|
|
[[-120.0, 88.0], [0.0, 88.0], [120.0, 88.0], [-120.0, 88.0]]
|
|
]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon with edge on equator",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [[[-120.0, 0.0], [120.0, 0.0], [0.0, 90.0], [-120.0, 0.0]]]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon just inside single hemisphere (Northern) - China, California, Europe",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates:
|
|
[[[120.0, 0.000001], [-120.0, 0.000001], [0.0, 0.000001], [120.0, 0.000001]]]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon inside Northern hemisphere",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [[[120.0, 80.0], [-120.0, 80.0], [0.0, 80.0], [120.0, 80.0]]]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon just inside a single hemisphere (Southern) - Pacific, Indonesia, Africa",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates:
|
|
[[[-120.0, -0.000001], [120.0, -0.000001], [0.0, -0.000001], [-120.0, -0.000001]]]
|
|
}
|
|
},
|
|
{
|
|
name: "polygon inside Southern hemisphere",
|
|
geo: {
|
|
type: "Polygon",
|
|
coordinates: [[[-120.0, -80.0], [120.0, -80.0], [0.0, -80.0], [-120.0, -80.0]]]
|
|
}
|
|
},
|
|
{
|
|
name: "single point (MultiPoint): Palo Alto",
|
|
geo: {type: "MultiPoint", coordinates: [[-122.1611953, 37.4420407]]}
|
|
},
|
|
{
|
|
name: "multiple points(MultiPoint): PA, LA, 4corners, ATX, Mansfield, FL, Reston, NYC",
|
|
geo: {
|
|
type: "MultiPoint",
|
|
coordinates: [
|
|
[-122.1611953, 37.4420407],
|
|
[-118.283638, 34.028517],
|
|
[-109.045223, 36.9990835],
|
|
[-97.850404, 30.3921555],
|
|
[-97.904187, 30.395457],
|
|
[-86.600836, 30.398147],
|
|
[-77.357837, 38.9589935],
|
|
[-73.987723, 40.7575074]
|
|
]
|
|
}
|
|
},
|
|
{
|
|
name: "two points (MultiPoint): Shenzhen, Guangdong, China",
|
|
geo: {type: "MultiPoint", coordinates: [[114.0538788, 22.5551603], [114.022837, 22.44395]]}
|
|
},
|
|
{
|
|
name: "two points (MultiPoint) but only one in: Shenzhen, Guangdong, China",
|
|
geo: {type: "MultiPoint", coordinates: [[114.0538788, 22.5551603], [113.743858, 23.025815]]}
|
|
},
|
|
{
|
|
name: "multi line string: new zealand bays",
|
|
geo: {
|
|
type: "MultiLineString",
|
|
coordinates: [
|
|
[
|
|
[172.803869, -43.592789],
|
|
[172.659335, -43.620348],
|
|
[172.684038, -43.636528],
|
|
[172.820922, -43.605325]
|
|
],
|
|
[
|
|
[172.830497, -43.607768],
|
|
[172.813263, -43.656319],
|
|
[172.823096, -43.660996],
|
|
[172.850943, -43.607609]
|
|
],
|
|
[
|
|
[172.912056, -43.623148],
|
|
[172.887696, -43.670897],
|
|
[172.900469, -43.676178],
|
|
[172.931735, -43.622839]
|
|
]
|
|
]
|
|
}
|
|
},
|
|
{
|
|
name: "multi polygon: new zealand north and south islands",
|
|
geo: {
|
|
type: "MultiPolygon",
|
|
coordinates: [
|
|
[[
|
|
[165.773255, -45.902933],
|
|
[169.398419, -47.261538],
|
|
[174.672744, -41.767722],
|
|
[172.288845, -39.897992],
|
|
[165.773255, -45.902933]
|
|
]],
|
|
[[
|
|
[173.166448, -39.778262],
|
|
[175.342744, -42.677333],
|
|
[179.913373, -37.224362],
|
|
[171.475953, -32.688871],
|
|
[173.166448, -39.778262]
|
|
]]
|
|
]
|
|
}
|
|
},
|
|
{
|
|
name: "geometry collection: point in Australia and triangle around Australia",
|
|
geo: {
|
|
type: "GeometryCollection",
|
|
geometries: [
|
|
{name: "center of Australia", type: "Point", coordinates: [133.985885, -27.240790]},
|
|
{
|
|
name: "Triangle around Australia",
|
|
type: "Polygon",
|
|
coordinates: [[
|
|
[97.423178, -44.735405],
|
|
[169.845050, -38.432287],
|
|
[143.824366, 15.966509],
|
|
[97.423178, -44.735405]
|
|
]]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
];
|
|
|
|
// Test various polygons which are not queryable
|
|
var badPolys = [
|
|
{
|
|
name: "Polygon with bad CRS",
|
|
type: "Polygon",
|
|
coordinates: [[
|
|
[114.0834046, 22.6648202],
|
|
[113.8293457, 22.3819359],
|
|
[114.2736054, 22.4047911],
|
|
[114.0834046, 22.6648202]
|
|
]],
|
|
crs: badCRS
|
|
},
|
|
{
|
|
name: "Open polygon < 3 sides",
|
|
type: "Polygon",
|
|
coordinates: [[[114.0834046, 22.6648202], [113.8293457, 22.3819359]]],
|
|
crs: strictCRS
|
|
},
|
|
{
|
|
name: "Open polygon > 3 sides",
|
|
type: "Polygon",
|
|
coordinates: [[
|
|
[114.0834046, 22.6648202],
|
|
[113.8293457, 22.3819359],
|
|
[114.2736054, 22.4047911],
|
|
[114.1, 22.5]
|
|
]],
|
|
crs: strictCRS
|
|
},
|
|
{
|
|
name: "duplicate non-adjacent points",
|
|
type: "Polygon",
|
|
coordinates: [[
|
|
[114.0834046, 22.6648202],
|
|
[113.8293457, 22.3819359],
|
|
[114.2736054, 22.4047911],
|
|
[113.8293457, 22.3819359],
|
|
[-65.9165954, 22.6648202],
|
|
[114.0834046, 22.6648202]
|
|
]],
|
|
crs: strictCRS
|
|
},
|
|
{
|
|
name: "One hole in polygon",
|
|
type: "Polygon",
|
|
coordinates: [
|
|
[[-80.0, 30.0], [-40.0, 30.0], [-40.0, 60.0], [-80.0, 60.0], [-80.0, 30.0]],
|
|
[[-70.0, 40.0], [-60.0, 40.0], [-60.0, 50.0], [-70.0, 50.0], [-70.0, 40.0]]
|
|
],
|
|
crs: strictCRS
|
|
},
|
|
{
|
|
name: "2 holes in polygon",
|
|
type: "Polygon",
|
|
coordinates: [
|
|
[[-80.0, 30.0], [-40.0, 30.0], [-40.0, 60.0], [-80.0, 60.0], [-80.0, 30.0]],
|
|
[[-70.0, 40.0], [-60.0, 40.0], [-60.0, 50.0], [-70.0, 50.0], [-70.0, 40.0]],
|
|
[[-55.0, 40.0], [-45.0, 40.0], [-45.0, 50.0], [-55.0, 50.0], [-55.0, 40.0]]
|
|
],
|
|
crs: strictCRS
|
|
},
|
|
{
|
|
name: "complex polygon (edges cross)",
|
|
type: "Polygon",
|
|
coordinates: [[[10.0, 10.0], [20.0, 10.0], [10.0, 20.0], [20.0, 20.0], [10.0, 10.0]]],
|
|
crs: strictCRS
|
|
}
|
|
];
|
|
|
|
// Closed polygons used in query (3, 4, 5, 6-sided)
|
|
var polys = [
|
|
{
|
|
name: "3 sided closed polygon",
|
|
type: "Polygon", // triangle
|
|
coordinates: [[[10.0, 10.0], [20.0, 10.0], [15.0, 17.0], [10.0, 10.0]]],
|
|
crs: strictCRS,
|
|
nW: 0,
|
|
nI: 1
|
|
},
|
|
{
|
|
name: "3 sided closed polygon (non-big)",
|
|
type: "Polygon", // triangle
|
|
coordinates: [[[10.0, 10.0], [20.0, 10.0], [15.0, 17.0], [10.0, 10.0]]],
|
|
nW: 0,
|
|
nI: 1
|
|
},
|
|
{
|
|
name: "4 sided closed polygon",
|
|
type: "Polygon", // rectangle
|
|
coordinates: [[[10.0, 10.0], [20.0, 10.0], [20.0, 20.0], [10.0, 20.0], [10.0, 10.0]]],
|
|
crs: strictCRS,
|
|
nW: 0,
|
|
nI: 1
|
|
},
|
|
{
|
|
name: "4 sided closed polygon (non-big)",
|
|
type: "Polygon", // rectangle
|
|
coordinates: [[[10.0, 10.0], [20.0, 10.0], [20.0, 20.0], [10.0, 20.0], [10.0, 10.0]]],
|
|
nW: 0,
|
|
nI: 1
|
|
},
|
|
{
|
|
name: "5 sided closed polygon",
|
|
type: "Polygon", // pentagon
|
|
coordinates:
|
|
[[[10.0, 10.0], [20.0, 10.0], [25.0, 18.0], [15.0, 25.0], [5.0, 18.0], [10.0, 10.0]]],
|
|
crs: strictCRS,
|
|
nW: 0,
|
|
nI: 1
|
|
},
|
|
{
|
|
name: "5 sided closed polygon (non-big)",
|
|
type: "Polygon", // pentagon
|
|
coordinates:
|
|
[[[10.0, 10.0], [20.0, 10.0], [25.0, 18.0], [15.0, 25.0], [5.0, 18.0], [10.0, 10.0]]],
|
|
nW: 0,
|
|
nI: 1
|
|
},
|
|
{
|
|
name: "6 sided closed polygon",
|
|
type: "Polygon", // hexagon
|
|
coordinates: [[
|
|
[10.0, 10.0],
|
|
[15.0, 10.0],
|
|
[22.0, 15.0],
|
|
[15.0, 20.0],
|
|
[10.0, 20.0],
|
|
[7.0, 15.0],
|
|
[10.0, 10.0]
|
|
]],
|
|
crs: strictCRS,
|
|
nW: 0,
|
|
nI: 1
|
|
},
|
|
{
|
|
name: "6 sided closed polygon (non-big)",
|
|
type: "Polygon", // hexagon
|
|
coordinates: [[
|
|
[10.0, 10.0],
|
|
[15.0, 10.0],
|
|
[22.0, 15.0],
|
|
[15.0, 20.0],
|
|
[10.0, 20.0],
|
|
[7.0, 15.0],
|
|
[10.0, 10.0]
|
|
]],
|
|
nW: 0,
|
|
nI: 1
|
|
}
|
|
];
|
|
|
|
// helper function to create n-sided polygon
|
|
function nGonGenerator(N, D, clockwise, LON, LAT) {
|
|
// compute N points on a circle centered at LAT,LON
|
|
// with diameter = D
|
|
// and lat*lat + lon*lon = (D/2)*(D/2)
|
|
// lat range is -10 to +10
|
|
// lon = sqrt( (D/2)*(D/2) - lat*lat )
|
|
// N = number of edges
|
|
// N must be even!
|
|
// edge lengths will be uneven with this quick & dirty approach
|
|
N = (N % 2 == 1) ? N + 1 : N;
|
|
var eps = 2 * D / N;
|
|
var lat = 0;
|
|
var lon = 0;
|
|
var pts = [];
|
|
var i = 0;
|
|
// produce longitude values in pairs
|
|
// traverse with left foot outside the circle (clockwise) to define the big polygon
|
|
for (i = 0, lat = D / 2; i <= N / 2; ++i, lat -= eps) {
|
|
if (lat < (-D / 2)) {
|
|
// set fixing lat
|
|
lat = (-D / 2);
|
|
}
|
|
lon = Math.sqrt((D / 2) * (D / 2) - (lat * lat));
|
|
newlat = lat + LAT;
|
|
newlon = lon + LON;
|
|
conjugateLon = LON - lon;
|
|
pts[i] = [newlon, newlat];
|
|
pts[N - i] = [conjugateLon, newlat];
|
|
}
|
|
// Reverse points if counterclockwise
|
|
if (!clockwise) {
|
|
pts = pts.reverse();
|
|
}
|
|
// ensure we connected the dots
|
|
assert(tojson(pts[0]) == tojson(pts[N]));
|
|
return pts;
|
|
}
|
|
|
|
// helper function to return number of valid objects
|
|
function getNumberOfValidObjects(objects) {
|
|
var i = 0;
|
|
objects.forEach(function(o) {
|
|
// strictCRS cannot be stored
|
|
if (!o.geo.crs || o.geo.crs != strictCRS) {
|
|
i++;
|
|
}
|
|
});
|
|
return i;
|
|
}
|
|
|
|
var totalObjects = getNumberOfValidObjects(objects);
|
|
|
|
// test various n-sided polygons in query, (n: <number of sides>, d: <diameter>)
|
|
// Try them in both clockwise & counterclockwise order
|
|
var nsidedPolys = [
|
|
// Big Polygon centered on 0, 0
|
|
{
|
|
name: "4 sided polygon centered on 0, 0",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(4, 30, true, 0, 0)],
|
|
crs: strictCRS,
|
|
nW: totalObjects - 3,
|
|
nI: totalObjects
|
|
},
|
|
// Non-big polygons have counterclockwise coordinates
|
|
{
|
|
name: "4 sided polygon centered on 0, 0 (non-big)",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(4, 30, false, 0, 0)],
|
|
nW: 0,
|
|
nI: 3
|
|
},
|
|
{
|
|
name: "100 sided polygon centered on 0, 0",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(100, 20, true, 0, 0)],
|
|
crs: strictCRS,
|
|
nW: totalObjects - 3,
|
|
nI: totalObjects
|
|
},
|
|
{
|
|
name: "100 sided polygon centered on 0, 0 (non-big)",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(100, 20, false, 0, 0)],
|
|
nW: 0,
|
|
nI: 3
|
|
},
|
|
{
|
|
name: "5000 sided polygon centered on 0, 0 (non-big)",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(5000, 89.99, false, 0, 0)],
|
|
nW: 0,
|
|
nI: 3
|
|
},
|
|
{
|
|
name: "25000 sided polygon centered on 0, 0",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(25000, 89.99, true, 0, 0)],
|
|
crs: strictCRS,
|
|
nW: totalObjects - 3,
|
|
nI: totalObjects
|
|
},
|
|
// Big polygon centered on Shenzen
|
|
{
|
|
name: "4 sided polygon centered on Shenzen",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(4, 5, true, 114.1, 22.55)],
|
|
crs: strictCRS,
|
|
nW: totalObjects - 3,
|
|
nI: totalObjects - 2
|
|
},
|
|
{
|
|
name: "4 sided polygon centered on Shenzen (non-big)",
|
|
type: "Polygon",
|
|
coordinates: [nGonGenerator(4, 5, false, 114.1, 22.55)],
|
|
crs: strictCRS,
|
|
nW: 2,
|
|
nI: 3
|
|
}
|
|
];
|
|
|
|
// Populate with 2dsphere index
|
|
assert.commandWorked(coll.ensureIndex({geo: "2dsphere"}), "create 2dsphere index");
|
|
|
|
// Insert objects into collection
|
|
objects.forEach(function(o) {
|
|
// strictCRS objects cannot be stored
|
|
if (o.geo.crs && o.geo.crs == strictCRS) {
|
|
assert.writeError(coll.insert(o), "insert " + o.name);
|
|
} else {
|
|
assert.writeOK(coll.insert(o), "insert " + o.name);
|
|
}
|
|
});
|
|
|
|
// Try creating other index types
|
|
assert.commandWorked(coll.ensureIndex({geo: "2dsphere", a: 1}), "compound index, geo");
|
|
// These other index types will fail because of the GeoJSON documents
|
|
assert.commandFailed(coll.ensureIndex({geo: "2dsphere", a: "text"}), "compound index, geo & text");
|
|
assert.commandFailed(coll.ensureIndex({geo: "geoHaystack"}, {bucketSize: 1}), "geoHaystack index");
|
|
assert.commandFailed(coll.ensureIndex({geo: "2d"}), "2d index");
|
|
|
|
totalObjects = coll.count();
|
|
|
|
// Test with none & 2dsphere index
|
|
var indexes = ["none", "2dsphere"];
|
|
|
|
indexes.forEach(function(index) {
|
|
|
|
// Reset indexes on collection
|
|
assert.commandWorked(coll.dropIndexes(), "drop indexes");
|
|
|
|
if (index != "none") {
|
|
// Create index
|
|
assert.commandWorked(coll.ensureIndex({geo: index}), "create " + index + " index");
|
|
}
|
|
|
|
// These polygons should not be queryable
|
|
badPolys.forEach(function(p) {
|
|
|
|
// within
|
|
assert.throws(function() {
|
|
coll.count({geo: {$geoWithin: {$geometry: p}}});
|
|
}, null, "within " + p.name);
|
|
|
|
// intersection
|
|
assert.throws(function() {
|
|
coll.count({geo: {$geoIntersects: {$geometry: p}}});
|
|
}, null, "intersects " + p.name);
|
|
});
|
|
|
|
// Tests for closed polygons
|
|
polys.forEach(function(p) {
|
|
|
|
// geoWithin query
|
|
var docArray = [];
|
|
var q = {geo: {$geoWithin: {$geometry: p}}};
|
|
// Test query in aggregate
|
|
docArray = coll.aggregate({$match: q}).toArray();
|
|
assert.eq(p.nW, docArray.length, "aggregate within " + p.name);
|
|
docArray = coll.find(q).toArray();
|
|
assert.eq(p.nW, docArray.length, "within " + p.name);
|
|
|
|
// geoIntersects query
|
|
q = {geo: {$geoIntersects: {$geometry: p}}};
|
|
// Test query in aggregate
|
|
docArray = coll.aggregate({$match: q}).toArray();
|
|
assert.eq(p.nI, docArray.length, "aggregate intersects " + p.name);
|
|
docArray = coll.find(q).toArray();
|
|
assert.eq(p.nI, docArray.length, p.name + " intersects");
|
|
// Update on matching docs
|
|
var result = coll.update(q, {$set: {stored: ObjectId()}}, {multi: true});
|
|
// only check nModified if write commands are enabled
|
|
if (coll.getMongo().writeMode() == "commands") {
|
|
assert.eq(p.nI, result.nModified, "update " + p.name);
|
|
}
|
|
// Remove & restore matching docs
|
|
assert.eq(p.nI, coll.remove(q).nRemoved, "remove " + p.name);
|
|
var bulk = coll.initializeUnorderedBulkOp();
|
|
docArray.forEach(function(doc) {
|
|
bulk.insert(doc);
|
|
});
|
|
assert.eq(docArray.length, bulk.execute().nInserted, "reinsert " + p.name);
|
|
|
|
});
|
|
|
|
// test the n-sided closed polygons
|
|
nsidedPolys.forEach(function(p) {
|
|
|
|
// within
|
|
assert.eq(p.nW, coll.count({geo: {$geoWithin: {$geometry: p}}}), "within " + p.name);
|
|
|
|
// intersects
|
|
assert.eq(
|
|
p.nI, coll.count({geo: {$geoIntersects: {$geometry: p}}}), "intersection " + p.name);
|
|
|
|
});
|
|
|
|
});
|