activerecord-spatial 0.0.1

data/test/spatial_scopes_tests.rb

@@ -0,0 +1,444 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class SpatialScopesTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :foo3d)
+  end
+
+  def ids_tester(method, args, ids = [], klass = Foo)
+    geoms = klass.send(method, *Array.wrap(args)).all
+    assert_equal(ids.sort, geoms.collect(&:id).sort)
+  end
+
+  def test_contains
+    ids_tester(:st_contains, 'POINT(3 3)', [ 3 ])
+  end
+
+  def test_containsproperly
+    ids_tester(:st_containsproperly, 'LINESTRING(-4 -4, 4 4)', [ 3 ])
+  end
+
+  def test_covers
+    ids_tester(:st_covers, 'LINESTRING(-4 -4, 4 4)', [ 3 ])
+  end
+
+  def test_coveredby
+    ids_tester(:st_coveredby, 'POLYGON((-6 -6, -6 6, 6 6, 6 -6, -6 -6))', [ 1, 3 ])
+  end
+
+  def test_crosses
+    ids_tester(:st_crosses, 'LINESTRING(-6 -6, 4 4)', [ 3 ])
+  end
+
+  def test_disjoint
+    ids_tester(:st_disjoint, 'POINT(100 100)', [ 1, 2, 3 ])
+  end
+
+  def test_equal
+    ids_tester(:st_equals, 'POLYGON((-5 -5, -5 5, 5 5, 5 -5, -5 -5))', [ 3 ])
+  end
+
+  def test_intersects
+    ids_tester(:st_intersects, 'LINESTRING(-5 -5, 10 10)', [ 1, 2, 3 ])
+  end
+
+  def test_orderingequals
+    ids_tester(:st_orderingequals, 'POLYGON((-5 -5, -5 5, 5 5, 5 -5, -5 -5))', [ 3 ])
+  end
+
+  def test_overlaps
+    ids_tester(:st_overlaps, 'POLYGON((-6 -6, -5 0, 0 0, 0 -5, -6 -6))', [ 3 ])
+  end
+
+  def test_touches
+    ids_tester(:st_touches, 'POLYGON((-5 -5, -5 -10, -10 -10, -10 -5, -5 -5))', [ 3 ])
+  end
+
+  def test_within
+    ids_tester(:st_within, 'POLYGON((-5 -5, 5 10, 20 20, 10 5, -5 -5))', [ 1, 2 ])
+  end
+
+  def test_dwithin
+    ids_tester(:st_dwithin, [ 'POINT(5 5)', 10 ], [ 1, 2, 3 ])
+  end
+
+  def test_dfullywithin
+    ids_tester(:st_dfullywithin, [ 'POINT(5 5)', 10 ], [ 1, 2 ])
+  end
+
+  def test_geometry_type
+    ids_tester(:st_geometry_type, 'ST_Point', [ 1, 2 ])
+    ids_tester(:st_geometry_type, [ 'ST_Point', 'ST_Polygon' ], [ 1, 2, 3 ])
+    ids_tester(:st_geometry_type, [ 'ST_MultiLineString' ], [])
+  end
+
+  def test_allow_null
+    begin
+      foo = Foo.create(:name => 'four')
+      ids_tester(:st_contains, [ 'POINT(3 3)', { :allow_null => true } ], [ 3, foo.id ])
+    ensure
+      Foo.find_by_name('four').destroy
+    end
+  end
+
+  def test_nil_relationship
+    assert_equal([ 1, 2, 3 ], Foo.st_within(nil).all.collect(&:id).sort)
+  end
+
+  def test_with_column
+    assert_equal([1, 2, 3], Foo.st_disjoint('POINT(100 100)', :column => :the_other_geom).all.collect(&:id).sort)
+  end
+
+  def test_with_srid_switching
+    assert_equal([1, 2, 3], Foo.st_disjoint('SRID=4326; POINT(100 100)').all.collect(&:id).sort)
+  end
+
+  def test_with_srid_default
+    assert_equal([1, 2, 3], Foo.st_disjoint('SRID=default; POINT(100 100)').all.collect(&:id).sort)
+    assert_equal([3], Foo.st_contains('SRID=default; POINT(-3 -3)').all.collect(&:id).sort)
+  end
+
+  def test_with_srid_transform
+    assert_equal([1, 2, 3], Foo.st_disjoint('SRID=4269; POINT(100 100)', :column => :the_other_geom).all.collect(&:id).sort)
+    assert_equal([3], Foo.st_contains('SRID=4269; POINT(7 7)', :column => :the_other_geom).all.collect(&:id).sort)
+  end
+
+  def test_order_by_st_distance
+    assert_equal([3, 1, 2], Foo.order_by_st_distance('POINT(1 1)').all.collect(&:id))
+  end
+
+  def test_order_by_st_distance_desc
+    assert_equal([2, 1, 3], Foo.order_by_st_distance('POINT(1 1)', :desc => true).all.collect(&:id))
+  end
+
+  def test_order_by_st_distance_sphere
+    assert_equal([3, 1, 2], Foo.order_by_st_distance_sphere('POINT(1 1)').all.collect(&:id))
+  end
+
+  def test_order_by_st_distance_sphere_desc
+    assert_equal([2, 1, 3], Foo.order_by_st_distance_sphere('POINT(1 1)', :desc => true).all.collect(&:id))
+  end
+
+  def test_order_by_st_max_distance
+    assert_equal([1, 3, 2], Foo.order_by_st_maxdistance('POINT(1 1)').all.collect(&:id))
+  end
+
+  def test_order_by_st_max_distance_desc
+    assert_equal([2, 3, 1], Foo.order_by_st_maxdistance('POINT(1 1)', :desc => true).all.collect(&:id))
+  end
+
+  def test_order_by_st_area
+    assert_equal([1, 2, 3], Foo.order_by_st_area.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_area_desc
+    assert_equal([3, 1, 2], Foo.order_by_st_area(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_ndims
+    assert_equal([1, 2, 3], Foo.order_by_st_ndims.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_ndims_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_ndims(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_npoints
+    assert_equal([1, 2, 3], Foo.order_by_st_npoints.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_npoints_desc
+    assert_equal([3, 1, 2], Foo.order_by_st_npoints(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_nrings
+    assert_equal([1, 2, 3], Foo.order_by_st_nrings.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_nrings_desc
+    assert_equal([3, 1, 2], Foo.order_by_st_nrings(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numgeometries
+    assert_equal([1, 2, 3], Foo.order_by_st_numgeometries.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numgeometries_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_numgeometries(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numinteriorring
+    assert_equal([3, 1, 2], Foo.order_by_st_numinteriorring.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numinteriorring_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_numinteriorring(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numinteriorrings
+    assert_equal([3, 1, 2], Foo.order_by_st_numinteriorrings.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numinteriorrings_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_numinteriorrings(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numpoints
+    assert_equal([1, 2, 3], Foo.order_by_st_numpoints.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_numpoints_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_numpoints(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length3d
+    assert_equal([1, 2, 3], Foo.order_by_st_length3d.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length3d_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_length3d(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length
+    assert_equal([1, 2, 3], Foo.order_by_st_length.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_length(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length2d
+    assert_equal([1, 2, 3], Foo.order_by_st_length2d.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length2d_desc
+    assert_equal([1, 2, 3], Foo.order_by_st_length2d(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length3d_spheroid
+    assert_equal([1, 2, 3], Foo.order_by_st_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length3d_spheroid_desc
+    expected = if ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
+      [3, 1, 2]
+    else
+      [1, 2, 3]
+    end
+
+    assert_equal(expected, Foo.order_by_st_length3d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length2d_spheroid
+    assert_equal([1, 2, 3], Foo.order_by_st_length2d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length2d_spheroid_desc
+    assert_equal([3, 1, 2], Foo.order_by_st_length2d_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length_spheroid
+    assert_equal([1, 2, 3], Foo.order_by_st_length_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_length_spheroid_desc
+    expected = if ActiveRecordSpatial::POSTGIS[:lib] >= '2.0'
+      [3, 1, 2]
+    else
+      [1, 2, 3]
+    end
+
+    assert_equal(expected, Foo.order_by_st_length_spheroid('SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter
+    assert_equal([1, 2, 3], Foo.order_by_st_perimeter.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter_desc
+    assert_equal([3, 1, 2], Foo.order_by_st_perimeter(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter2d
+    assert_equal([1, 2, 3], Foo.order_by_st_perimeter2d.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter2d_desc
+    assert_equal([3, 1, 2], Foo.order_by_st_perimeter2d(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter3d
+    assert_equal([1, 2, 3], Foo.order_by_st_perimeter3d.order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_perimeter3d_desc
+    assert_equal([3, 1, 2], Foo.order_by_st_perimeter3d(:desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_hausdorffdistance
+    assert_equal([1, 3, 2], Foo.order_by_st_hausdorffdistance('POINT(1 1)').all.collect(&:id))
+  end
+
+  def test_order_by_st_hausdorffdistance_desc
+    assert_equal([2, 3, 1], Foo.order_by_st_hausdorffdistance('POINT(1 1)', :desc => true).all.collect(&:id))
+  end
+
+  def test_order_by_st_hausdorffdistance_with_densify_frac
+    assert_equal([1, 3, 2], Foo.order_by_st_hausdorffdistance('POINT(1 1)', 0.314).all.collect(&:id))
+  end
+
+  def test_order_by_st_distance_spheroid
+    assert_equal([2, 3, 1], Foo.order_by_st_distance_spheroid('POINT(10 10)', 'SPHEROID["WGS 84", 6378137, 298.257223563]').order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_distance_spheroid_desc
+    assert_equal([1, 3, 2], Foo.order_by_st_distance_spheroid('POINT(10 10)', 'SPHEROID["WGS 84", 6378137, 298.257223563]', :desc => true).order('id').all.collect(&:id))
+  end
+
+  def test_order_by_st_area_with_desc_symbol
+    assert_equal([3, 1, 2], Foo.order_by_st_area(:desc).order('id').all.collect(&:id))
+  end
+
+  def test_3dintersects
+    skip('ST_3dintersects is unavailable') unless Foo3d.respond_to?(:st_3dintersects)
+
+    ids_tester(:st_3dintersects, 'LINESTRING(-5 -5 -5, 10 10 10)', [ 1, 3 ], Foo3d)
+  end
+
+  def test_3ddistance
+    skip('ST_3ddistance is unavailable') unless Foo3d.respond_to?(:order_by_st_3ddistance)
+
+    assert_equal([3, 2, 1], Foo3d.order_by_st_3ddistance('POINT(10 10)').order('id').all.collect(&:id))
+  end
+
+  def test_3dmaxdistance
+    skip('ST_3dmaxdistance is unavailable') unless Foo3d.respond_to?(:order_by_st_3dmaxdistance)
+
+    assert_equal([2, 1, 3], Foo3d.order_by_st_3dmaxdistance('POINT(10 10)').order('id').all.collect(&:id))
+  end
+
+  def test_3ddwithin
+    skip('ST_3ddwithin is unavailable') unless Foo3d.respond_to?(:st_3ddwithin)
+
+    ids_tester(:st_3ddwithin, [ 'LINESTRING(-5 -5 -5, 10 10 10)', 10 ], [ 1, 2, 3 ], Foo3d)
+  end
+
+  def test_3ddfullywithin
+    skip('ST_3ddfullywithin is unavilable') unless Foo3d.respond_to?(:st_3ddfullywithin)
+
+    ids_tester(:st_3ddfullywithin, [ 'LINESTRING(-10 -10 -10, 10 10 10)', 100 ], [ 1, 2, 3 ], Foo3d)
+  end
+
+  def test_order_by_with_column_wrapper
+    values = nil
+
+    assert_sql(/ST_envelope\("foos"."the_geom"\)/) do
+      values = Foo.
+        order_by_st_perimeter(
+          :desc => true,
+          :column => {
+            :wrapper => :envelope
+          }
+        ).order('id').all.collect(&:id)
+    end
+
+    assert_equal([3, 1, 2], values)
+  end
+
+  def test_order_by_with_column_wrapper_and_an_option
+    values = nil
+
+    assert_sql(/ST_geometryn\("foos"."the_geom", 1\)/) do
+      values = Foo.
+        order_by_st_perimeter(
+          :desc => true,
+          :column => {
+            :wrapper => {
+              :geometryn => 1
+            }
+          }
+        ).order('id').all.collect(&:id)
+    end
+
+    assert_equal([3, 1, 2], values)
+  end
+
+  def test_order_by_with_column_wrapper_and_options
+    values = nil
+
+    assert_sql(/ST_snap\("foos"."the_geom", 'POINT \(0 0\)', 1.0\)/) do
+      values = Foo.
+        order_by_st_perimeter(
+          :desc => true,
+          :column => {
+            :wrapper => {
+              :snap => [
+                'POINT (0 0)',
+                1.0
+              ]
+            }
+          }
+        ).order('id').all.collect(&:id)
+    end
+
+    assert_equal([3, 1, 2], values)
+  end
+
+  def test_relationship_with_column_wrapper
+    values = nil
+
+    assert_sql(/ST_centroid\("foos"."the_geom"\)/) do
+      values = Foo.
+        st_within(
+          'POLYGON((-5 -5, 5 10, 20 20, 10 5, -5 -5))',
+          :column => {
+            :wrapper => :centroid
+          }
+        ).order('id').all.collect(&:id)
+    end
+
+    assert_equal([1, 2, 3], values)
+  end
+
+  def test_relationship_with_column_wrapper_and_option
+    values = nil
+
+    assert_sql(/ST_geometryn\("foos"."the_geom", 1\)/) do
+      values = Foo.
+        st_within(
+          'POLYGON((-5 -5, 5 10, 20 20, 10 5, -5 -5))',
+          :column => {
+            :wrapper => {
+              :geometryn => 1
+            }
+          }
+        ).order('id').all.collect(&:id)
+    end
+
+    assert_equal([1, 2], values)
+  end
+
+    def test_relationship_with_column_wrapper_and_options
+    values = nil
+
+    assert_sql(/ST_snap\("foos"."the_geom", 'POINT \(0 0\)', 1.0\)/) do
+      values = Foo.
+        st_within(
+          'POLYGON((-5 -5, 5 10, 20 20, 10 5, -5 -5))',
+          :column => {
+            :wrapper => {
+              :snap => [
+                'POINT (0 0)',
+                1.0
+              ]
+            }
+          }
+        ).order('id').all.collect(&:id)
+    end
+
+    assert_equal([1, 2], values)
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,272 @@
+
+require 'simplecov'
+
+SimpleCov.command_name('Unit Tests')
+SimpleCov.start do
+  add_filter '/test/'
+end
+
+require 'rubygems'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'active_support'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/dependencies'
+require 'active_record'
+require 'active_record/fixtures'
+require 'logger'
+
+require File.join(File.dirname(__FILE__), %w{ .. lib activerecord-spatial })
+
+POSTGIS_PATHS = [
+  ENV['POSTGIS_PATH'],
+  '/opt/local/share/postgresql*/contrib/postgis-*',
+  '/usr/share/postgresql*/contrib/postgis-*',
+  '/usr/pgsql-*/share/contrib/postgis-*',
+].compact
+
+puts "Testing against ActiveRecord #{Gem.loaded_specs['activerecord'].version.to_s}"
+puts "Ruby version #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
+puts "Geos library version #{Geos::VERSION}" if defined?(Geos::VERSION)
+puts "GEOS version #{Geos::GEOS_VERSION}"
+puts "GEOS extensions version #{Geos::GEOS_EXTENSIONS_VERSION}"
+if defined?(Geos::FFIGeos)
+  puts "Using #{Geos::FFIGeos.geos_library_paths.join(', ')}"
+end
+
+ActiveRecord::Base.logger = Logger.new("debug.log") if ENV['ENABLE_LOGGER']
+ActiveRecord::Base.configurations = {
+  'arunit' => {}
+}
+
+%w{
+  database.yml
+  local_database.yml
+}.each do |file|
+  file = File.join('test', file)
+
+  next unless File.exists?(file)
+
+  configuration = YAML.load(File.read(file))
+
+  if configuration['arunit']
+    ActiveRecord::Base.configurations['arunit'].merge!(configuration['arunit'])
+  end
+
+  if defined?(JRUBY_VERSION) && configuration['jdbc']
+    ActiveRecord::Base.configurations['arunit'].merge!(configuration['jdbc'])
+  end
+end
+
+ActiveRecord::Base.establish_connection 'arunit'
+ARBC = ActiveRecord::Base.connection
+
+if postgresql_version = ARBC.select_rows('SELECT version()').first.first
+  puts "PostgreSQL info from version(): #{postgresql_version}"
+end
+
+puts "Checking for PostGIS install"
+2.times do
+  begin
+    if postgis_version = ActiveRecordSpatial::POSTGIS[:lib]
+      puts "PostGIS info from postgis_full_version(): #{postgis_version}"
+      break
+    end
+  rescue ActiveRecord::StatementInvalid
+    puts "Trying to install PostGIS. If this doesn't work, you'll have to do this manually!"
+
+    plpgsql = ARBC.select_rows(%{SELECT count(*) FROM pg_language WHERE lanname = 'plpgsql'}).first.first.to_i
+    if plpgsql == 0
+      ARBC.execute(%{CREATE LANGUAGE plpgsql})
+    end
+
+    %w{
+      postgis.sql
+      spatial_ref_sys.sql
+    }.each do |file|
+      if !(found = Dir.glob(POSTGIS_PATHS).collect { |path|
+        File.join(path, file)
+      }.first)
+        puts "ERROR: Couldn't find #{file}. Try setting the POSTGIS_PATH to give us a hint!"
+        exit
+      else
+        ARBC.execute(File.read(found))
+      end
+    end
+  end
+end
+
+class ActiveRecordSpatialTestCase < ActiveRecord::TestCase
+  BASE_PATH = Pathname.new(File.dirname(__FILE__))
+
+  include ActiveRecord::TestFixtures
+  self.fixture_path = BASE_PATH.join('fixtures')
+
+  REGEXP_WKB_HEX = /[A-Fa-f0-9\s]+/
+
+  POINT_WKT = 'POINT(10 10.01)'
+  POINT_EWKT = 'SRID=4326; POINT(10 10.01)'
+  POINT_EWKT_WITH_DEFAULT = 'SRID=default; POINT(10 10.01)'
+  POINT_WKB = "0101000000000000000000244085EB51B81E052440"
+  POINT_WKB_BIN = "\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40"
+  POINT_EWKB = "0101000020E6100000000000000000244085EB51B81E052440"
+  POINT_EWKB_BIN = "\x01\x01\x00\x00\x20\xE6\x10\x00\x00\x00\x00\x00\x00\x00\x00\x24\x40\x85\xEB\x51\xB8\x1E\x05\x24\x40"
+  POINT_G_LAT_LNG = "(10.01, 10)"
+  POINT_G_LAT_LNG_URL_VALUE = "10.01,10"
+
+  POLYGON_WKT = 'POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
+  POLYGON_EWKT = 'SRID=4326; POLYGON((0 0, 1 1, 2.5 2.5, 5 5, 0 0))'
+  POLYGON_WKB = "
+    0103000000010000000500000000000000000000000000000000000000000000000000F
+    03F000000000000F03F0000000000000440000000000000044000000000000014400000
+    00000000144000000000000000000000000000000000
+  ".gsub(/\s/, '')
+  POLYGON_WKB_BIN = [
+    "\x01\x03\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xF0\x3F\x00",
+    "\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00",
+    "\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14",
+    "\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+  ].join
+  POLYGON_EWKB = "
+    0103000020E610000001000000050000000000000000000000000000000000000000000
+    0000000F03F000000000000F03F00000000000004400000000000000440000000000000
+    1440000000000000144000000000000000000000000000000000
+  ".gsub(/\s/, '')
+  POLYGON_EWKB_BIN = [
+    "\x01\x03\x00\x00\x20\xE6\x10\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\xF0\x3F\x00\x00\x00\x00\x00\x00\xF0\x3F\x00\x00",
+    "\x00\x00\x00\x00\x04\x40\x00\x00\x00\x00\x00\x00\x04\x40\x00\x00\x00",
+    "\x00\x00\x00\x14\x40\x00\x00\x00\x00\x00\x00\x14\x40\x00\x00\x00\x00",
+    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+  ].join
+
+  POLYGON_WITH_INTERIOR_RING = "POLYGON((0 0, 5 0, 5 5, 0 5, 0 0),(4 4, 4 1, 1 1, 1 4, 4 4))"
+
+  LINESTRING_WKT = "LINESTRING (0 0, 5 5, 5 10, 10 10)"
+
+  GEOMETRYCOLLECTION_WKT = 'GEOMETRYCOLLECTION (
+    MULTIPOLYGON (
+      ((0 0, 1 0, 1 1, 0 1, 0 0)),
+      (
+        (10 10, 10 14, 14 14, 14 10, 10 10),
+        (11 11, 11 12, 12 12, 12 11, 11 11)
+      )
+    ),
+    POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0)),
+    POLYGON ((0 0, 5 0, 5 5, 0 5, 0 0), (4 4, 4 1, 1 1, 1 4, 4 4)),
+    MULTILINESTRING ((0 0, 2 3), (10 10, 3 4)),
+    LINESTRING (0 0, 2 3),
+    MULTIPOINT ((0 0), (2 3)),
+    POINT (9 0)
+  )'
+
+  BOUNDS_G_LAT_LNG = "((0.1, 0.1), (5.2, 5.2))"
+  BOUNDS_G_LAT_LNG_URL_VALUE = '0.1,0.1,5.2,5.2'
+
+  class << self
+    def load_models(*args)
+      options = args.extract_options!
+
+      args.each do |model|
+        model = model.to_s
+        klass = model.classify
+
+        ActiveSupport::Dependencies.load_file(BASE_PATH.join("models/#{model}.rb"), [ klass ])
+
+        ActiveRecord::Base.silence do
+          fixtures model.pluralize
+        end
+      end
+    end
+
+    def load_default_models
+      load_models(:foo, :bar)
+
+      Foo.class_eval do
+        has_many_spatially :foos
+        has_many_spatially :bars
+      end
+
+      Bar.class_eval do
+        has_many_spatially :foos
+        has_many_spatially :bars
+      end
+    end
+
+    def after_suite
+      ActiveSupport::Dependencies.clear
+    end
+  end
+
+  def setup
+    if ActiveRecord::Base.logger
+      ActiveRecord::Base.logger.debug("Beginning tests for #{self.class.name}##{self.method_name}")
+    end
+  end
+
+  def assert_saneness_of_point(point)
+    assert_kind_of(Geos::Point, point)
+    assert_equal(10.01, point.lat)
+    assert_equal(10, point.lng)
+  end
+
+  def assert_saneness_of_polygon(polygon)
+    assert_kind_of(Geos::Polygon, polygon)
+    cs = polygon.exterior_ring.coord_seq
+    assert_equal([
+      [ 0, 0 ],
+      [ 1, 1 ],
+      [ 2.5, 2.5 ],
+      [ 5, 5 ],
+      [ 0, 0 ]
+    ], cs.to_a)
+  end
+end
+
+module ActiveRecord
+  class SQLCounter
+    cattr_accessor :ignored_sql
+    self.ignored_sql = [
+      /^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/,
+      /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/,
+      /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/, /^ROLLBACK/, /\WFROM pg_/
+    ]
+
+    cattr_accessor :log
+    self.log = []
+
+    attr_reader :ignore
+
+    def initialize(ignore = self.class.ignored_sql)
+      @ignore   = ignore
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      # FIXME: this seems bad. we should probably have a better way to indicate
+      # the query was cached
+      return if 'CACHE' == values[:name] || ignore.any? { |x| x =~ sql }
+      self.class.log << sql
+    end
+  end
+
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end
+
+class SpatialTestRunner < MiniTest::Reporters::SpecReporter
+  def before_suite(suite)
+    super(suite)
+    suite.before_suite if suite.respond_to?(:before_suite)
+  end
+
+  def after_suite(suite)
+    super(suite)
+    suite.after_suite if suite.respond_to?(:after_suite)
+  end
+end
+
+MiniTest::Reporters.use!(SpatialTestRunner.new)
+