169 lines
5.8 KiB
JavaScript
169 lines
5.8 KiB
JavaScript
t = db.borders
|
|
t.drop()
|
|
|
|
epsilon = 0.0001;
|
|
|
|
// For these tests, *required* that step ends exactly on max
|
|
min = -1
|
|
max = 1
|
|
step = 1
|
|
numItems = 0;
|
|
|
|
for ( var x = min; x <= max; x += step ) {
|
|
for ( var y = min; y <= max; y += step ) {
|
|
t.insert( { loc : { x : x, y : y } } )
|
|
numItems++;
|
|
}
|
|
}
|
|
|
|
overallMin = -1
|
|
overallMax = 1
|
|
|
|
// Create a point index slightly smaller than the points we have
|
|
t.ensureIndex( { loc : "2d" }, { max : overallMax - epsilon / 2, min : overallMin + epsilon / 2 } )
|
|
assert( db.getLastError() )
|
|
|
|
// Create a point index only slightly bigger than the points we have
|
|
t.ensureIndex( { loc : "2d" }, { max : overallMax + epsilon, min : overallMin - epsilon } )
|
|
assert.isnull( db.getLastError() )
|
|
|
|
// ************
|
|
// Box Tests
|
|
// ************
|
|
|
|
// If the bounds are bigger than the box itself, just clip at the borders
|
|
assert.eq( numItems, t.find(
|
|
{ loc : { $within : { $box : [
|
|
[ overallMin - 2 * epsilon, overallMin - 2 * epsilon ],
|
|
[ overallMax + 2 * epsilon, overallMax + 2 * epsilon ] ] } } } ).count() );
|
|
|
|
// Check this works also for bounds where only a single dimension is off-bounds
|
|
assert.eq( numItems - 5, t.find(
|
|
{ loc : { $within : { $box : [
|
|
[ overallMin - 2 * epsilon, overallMin - 0.5 * epsilon ],
|
|
[ overallMax - epsilon, overallMax - epsilon ] ] } } } ).count() );
|
|
|
|
// Make sure we can get at least close to the bounds of the index
|
|
assert.eq( numItems, t.find(
|
|
{ loc : { $within : { $box : [
|
|
[ overallMin - epsilon / 2, overallMin - epsilon / 2 ],
|
|
[ overallMax + epsilon / 2, overallMax + epsilon / 2 ] ] } } } ).count() );
|
|
|
|
// Make sure we can get at least close to the bounds of the index
|
|
assert.eq( numItems, t.find(
|
|
{ loc : { $within : { $box : [
|
|
[ overallMax + epsilon / 2, overallMax + epsilon / 2 ],
|
|
[ overallMin - epsilon / 2, overallMin - epsilon / 2 ] ] } } } ).count() );
|
|
|
|
// Check that swapping min/max has good behavior
|
|
assert.eq( numItems, t.find(
|
|
{ loc : { $within : { $box : [
|
|
[ overallMax + epsilon / 2, overallMax + epsilon / 2 ],
|
|
[ overallMin - epsilon / 2, overallMin - epsilon / 2 ] ] } } } ).count() );
|
|
|
|
assert.eq( numItems, t.find(
|
|
{ loc : { $within : { $box : [
|
|
[ overallMax + epsilon / 2, overallMin - epsilon / 2 ],
|
|
[ overallMin - epsilon / 2, overallMax + epsilon / 2 ] ] } } } ).count() );
|
|
|
|
// **************
|
|
// Circle tests
|
|
// **************
|
|
|
|
center = ( overallMax + overallMin ) / 2
|
|
center = [ center, center ]
|
|
radius = overallMax
|
|
|
|
offCenter = [ center[0] + radius, center[1] + radius ]
|
|
onBounds = [ offCenter[0] + epsilon, offCenter[1] + epsilon ]
|
|
offBounds = [ onBounds[0] + epsilon, onBounds[1] + epsilon ]
|
|
onBoundsNeg = [ -onBounds[0], -onBounds[1] ]
|
|
|
|
// Make sure we can get all points when radius is exactly at full bounds
|
|
assert.lt( 0, t.find( { loc : { $within : { $center : [ center, radius + epsilon ] } } } ).count() );
|
|
|
|
// Make sure we can get points when radius is over full bounds
|
|
assert.lt( 0, t.find( { loc : { $within : { $center : [ center, radius + 2 * epsilon ] } } } ).count() );
|
|
|
|
// Make sure we can get points when radius is over full bounds, off-centered
|
|
assert.lt( 0, t.find( { loc : { $within : { $center : [ offCenter, radius + 2 * epsilon ] } } } ).count() );
|
|
|
|
// Make sure we get correct corner point when center is in bounds
|
|
// (x bounds wrap, so could get other corner)
|
|
cornerPt = t.findOne( { loc : { $within : { $center : [ offCenter, step / 2 ] } } } );
|
|
assert.eq( cornerPt.loc.y, overallMax )
|
|
|
|
// Make sure we get correct corner point when center is on bounds
|
|
// NOTE: Only valid points on MIN bounds
|
|
cornerPt = t
|
|
.findOne( { loc : { $within : { $center : [ onBoundsNeg, Math.sqrt( 2 * epsilon * epsilon ) + ( step / 2 ) ] } } } );
|
|
assert.eq( cornerPt.loc.y, overallMin )
|
|
|
|
// Make sure we can't get corner point when center is over bounds
|
|
try {
|
|
t.findOne( { loc : { $within : { $center : [ offBounds, Math.sqrt( 8 * epsilon * epsilon ) + ( step / 2 ) ] } } } );
|
|
assert( false )
|
|
} catch (e) {
|
|
}
|
|
|
|
// Make sure we can't get corner point when center is on max bounds
|
|
try {
|
|
t.findOne( { loc : { $within : { $center : [ onBounds, Math.sqrt( 8 * epsilon * epsilon ) + ( step / 2 ) ] } } } );
|
|
assert( false )
|
|
} catch (e) {
|
|
}
|
|
|
|
// ***********
|
|
// Near tests
|
|
// ***********
|
|
|
|
// Make sure we can get all nearby points to point in range
|
|
assert.eq( overallMax, t.find( { loc : { $near : offCenter } } ).next().loc.y );
|
|
|
|
// Make sure we can get all nearby points to point on boundary
|
|
assert.eq( overallMin, t.find( { loc : { $near : onBoundsNeg } } ).next().loc.y );
|
|
|
|
// Make sure we can't get all nearby points to point over boundary
|
|
try {
|
|
t.findOne( { loc : { $near : offBounds } } )
|
|
assert( false )
|
|
} catch (e) {
|
|
}
|
|
// Make sure we can't get all nearby points to point on max boundary
|
|
try {
|
|
t.findOne( { loc : { $near : onBoundsNeg } } )
|
|
assert( false )
|
|
} catch (e) {
|
|
}
|
|
|
|
// Make sure we can get all nearby points within one step (4 points in top
|
|
// corner)
|
|
assert.eq( 4, t.find( { loc : { $near : offCenter, $maxDistance : step * 1.9 } } ).count() );
|
|
|
|
// **************
|
|
// Command Tests
|
|
// **************
|
|
// Make sure we can get all nearby points to point in range
|
|
assert.eq( overallMax, db.runCommand( { geoNear : "borders", near : offCenter } ).results[0].obj.loc.y );
|
|
|
|
// Make sure we can get all nearby points to point on boundary
|
|
assert.eq( overallMin, db.runCommand( { geoNear : "borders", near : onBoundsNeg } ).results[0].obj.loc.y );
|
|
|
|
// Make sure we can't get all nearby points to point over boundary
|
|
try {
|
|
db.runCommand( { geoNear : "borders", near : offBounds } ).results.length
|
|
assert( false )
|
|
} catch (e) {
|
|
}
|
|
|
|
// Make sure we can't get all nearby points to point on max boundary
|
|
try {
|
|
db.runCommand( { geoNear : "borders", near : onBounds } ).results.length
|
|
assert( false )
|
|
} catch (e) {
|
|
}
|
|
|
|
// Make sure we can get all nearby points within one step (4 points in top
|
|
// corner)
|
|
assert.eq( 4, db.runCommand( { geoNear : "borders", near : offCenter, maxDistance : step * 1.5 } ).results.length );
|