activerecord-spatial 0.0.1

data/lib/activerecord-spatial/version.rb

@@ -0,0 +1,5 @@
+
+module ActiveRecordSpatial
+  VERSION = '0.0.1'
+end
+

data/lib/tasks/test.rake

@@ -0,0 +1,45 @@
+
+namespace :test do
+  desc "Dumps data from the geometry_columns and spatial_ref_sys tables."
+  task :postgis_dump => :environment do
+    abcs = ActiveRecord::Base.configurations
+    ENV['PGHOST']     = abcs[Rails.env]["host"] if abcs[Rails.env]["host"]
+    ENV['PGPORT']     = abcs[Rails.env]["port"].to_s if abcs[Rails.env]["port"]
+    ENV['PGPASSWORD'] = abcs[Rails.env]["password"].to_s if abcs[Rails.env]["password"]
+    search_path = abcs[Rails.env]["schema_search_path"]
+    unless search_path.blank?
+      search_path = search_path.split(",").map{|search_path| "--schema=#{search_path.strip}" }.join(" ")
+    end
+
+    tables = %w{ geometry_columns spatial_ref_sys }.select do |table|
+      ActiveRecord::Base.connection.table_exists?(table) &&
+        !ActiveRecord::Base.connection.view_exists?(table)
+    end
+
+    pp tables
+
+    unless tables.empty?
+      `pg_dump -i -U "#{abcs[Rails.env]["username"]}" --data-only -t #{tables.join(' -t ')} -x -O -f db/#{Rails.env}_postgis_tables.sql #{search_path} #{abcs[Rails.env]["database"]}`
+    else
+      File.open("db/#{Rails.env}_postgis_tables.sql", 'w') do |fp|
+        fp.puts "-- empty, do geometry_columns and spatial_ref_sys tables exist?"
+      end
+    end
+  end
+
+  desc "Loads the geometry_columns and spatial_ref_sys tables."
+  task :postgis_load => :environment do
+    abcs = ActiveRecord::Base.configurations
+    ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+    ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+    ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+
+    `psql -U "#{abcs["test"]["username"]}" -f #{Rails.root}/db/#{Rails.env}_postgis_tables.sql #{abcs["test"]["database"]}`
+  end
+
+  desc "Dumps and loads the geometry_columns and spatial_ref_sys tables."
+  task :postgis_clone => [ :postgis_dump, :postgis_load ]
+end
+
+Rake::Task['test:prepare'].enhance(['test:postgis_clone'])
+

data/test/accessors_geographies_tests.rb

@@ -0,0 +1,149 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class AccessorsGeographiesTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo_geography)
+  end
+
+  def test_accessors
+    foo = FooGeography.find(1)
+
+    ActiveRecordSpatial::SpatialColumns::SPATIAL_COLUMN_OUTPUT_FORMATS.each do |format|
+      assert(foo.respond_to?("the_geom_#{format}"))
+      assert(foo.respond_to?("the_other_geom_#{format}"))
+    end
+  end
+
+  def test_without_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(String, foo.the_geom)
+  end
+
+  def test_geos_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(Geos::Point, foo.the_geom_geos)
+  end
+
+  def test_wkt_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(String, foo.the_geom_wkt)
+    assert_match(/^POINT\s*\(0\.0+\s+0\.0+\)$/, foo.the_geom_wkt)
+  end
+
+  def test_wkb_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(String, foo.the_geom_wkb)
+    assert_match(/^[A-F0-9]+$/, foo.the_geom_wkb)
+  end
+
+  def test_ewkt_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(String, foo.the_geom_ewkt)
+    assert_match(/^SRID=\d+;POINT\s*\(0\.0+\s+0\.0+\)$/, foo.the_geom_ewkt)
+  end
+
+  def test_ewkb_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(String, foo.the_geom_ewkb)
+    assert(/^[A-F0-9]+$/, foo.the_geom_wkb)
+  end
+
+  def test_wkb_bin_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(String, foo.the_geom_wkb_bin)
+  end
+
+  def test_ewkb_bin_accessor
+    foo = FooGeography.find(1)
+    assert_kind_of(String, foo.the_geom_ewkb_bin)
+  end
+
+  def test_geos_create
+    foo = FooGeography.create!(
+      :name => 'test_geos_create',
+      :the_geom => Geos.read(POINT_WKT)
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_wkt_create
+    foo = FooGeography.create!(
+      :name => 'test_wkt_create',
+      :the_geom => POINT_WKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_wkb_create
+    foo = FooGeography.create!(
+      :name => 'test_wkb_create',
+      :the_geom => POINT_WKB
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_ewkt_create_with_srid_4326
+    foo = FooGeography.create!(
+      :name => 'test_ewkt_create_with_srid_4326',
+      :the_other_geom => POINT_EWKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+
+  def test_create_with_no_srid_converting_to_4326
+    foo = FooGeography.create!(
+      :name => 'test_ewkt_create_with_no_srid_converting_to_4326',
+      :the_other_geom => POINT_WKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+
+  def test_create_with_no_srid_converting_to_minus_1
+    foo = FooGeography.create!(
+      :name => 'test_ewkt_create_with_no_srid_converting_to_minus_1',
+      :the_geom => POINT_EWKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_create_with_converting_from_900913_to_4326
+    FooGeography.create!(
+      :name => 'test_create_with_converting_from_900913_to_4326',
+      :the_other_geom => "SRID=900913; #{POINT_WKT}"
+    )
+  end
+
+  def test_ewkt_create_with_srid_default
+    foo = FooGeography.create!(
+      :name => 'test_ewkt_create_with_srid_default',
+      :the_other_geom => POINT_EWKT_WITH_DEFAULT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+
+  def test_ewkb_create
+    foo = FooGeography.create!(
+      :name => 'test_ewkb_create',
+      :the_other_geom => POINT_EWKB
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+end

data/test/accessors_geometries_tests.rb

@@ -0,0 +1,151 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class AccessorsGeometriesTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo)
+  end
+
+  def test_accessors
+    foo = Foo.find(1)
+
+    ActiveRecordSpatial::SpatialColumns::SPATIAL_COLUMN_OUTPUT_FORMATS.each do |format|
+      assert(foo.respond_to?("the_geom_#{format}"))
+      assert(foo.respond_to?("the_other_geom_#{format}"))
+    end
+  end
+
+  def test_without_accessor
+    foo = Foo.find(1)
+    assert_kind_of(String, foo.the_geom)
+  end
+
+  def test_geos_accessor
+    foo = Foo.find(1)
+    assert_kind_of(Geos::Point, foo.the_geom_geos)
+  end
+
+  def test_wkt_accessor
+    foo = Foo.find(1)
+    assert_kind_of(String, foo.the_geom_wkt)
+    assert_match(/^POINT\s*\(0\.0+\s+0\.0+\)$/, foo.the_geom_wkt)
+  end
+
+  def test_wkb_accessor
+    foo = Foo.find(1)
+    assert_kind_of(String, foo.the_geom_wkb)
+    assert_match(/^[A-F0-9]+$/, foo.the_geom_wkb)
+  end
+
+  def test_ewkt_accessor
+    foo = Foo.find(1)
+    assert_kind_of(String, foo.the_geom_ewkt)
+    assert_match(/^SRID=\d+;POINT\s*\(0\.0+\s+0\.0+\)$/, foo.the_geom_ewkt)
+  end
+
+  def test_ewkb_accessor
+    foo = Foo.find(1)
+    assert_kind_of(String, foo.the_geom_ewkb)
+    assert(/^[A-F0-9]+$/, foo.the_geom_wkb)
+  end
+
+  def test_wkb_bin_accessor
+    foo = Foo.find(1)
+    assert_kind_of(String, foo.the_geom_wkb_bin)
+  end
+
+  def test_ewkb_bin_accessor
+    foo = Foo.find(1)
+    assert_kind_of(String, foo.the_geom_ewkb_bin)
+  end
+
+  def test_geos_create
+    foo = Foo.create!(
+      :name => 'test_geos_create',
+      :the_geom => Geos.read(POINT_WKT)
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_wkt_create
+    foo = Foo.create!(
+      :name => 'test_wkt_create',
+      :the_geom => POINT_WKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_wkb_create
+    foo = Foo.create!(
+      :name => 'test_wkb_create',
+      :the_geom => POINT_WKB
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_ewkt_create_with_srid_4326
+    foo = Foo.create!(
+      :name => 'test_ewkt_create_with_srid_4326',
+      :the_other_geom => POINT_EWKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+
+  def test_create_with_no_srid_converting_to_4326
+    foo = Foo.create!(
+      :name => 'test_ewkt_create_with_no_srid_converting_to_4326',
+      :the_other_geom => POINT_WKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+
+  def test_create_with_no_srid_converting_to_minus_1
+    foo = Foo.create!(
+      :name => 'test_ewkt_create_with_no_srid_converting_to_minus_1',
+      :the_geom => POINT_EWKT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_geom_geos)
+  end
+
+  def test_create_with_converting_from_900913_to_4326
+    assert_raise(ActiveRecordSpatial::GeometryColumns::CantConvertSRID) do
+      Foo.create!(
+        :name => 'test_create_with_converting_from_900913_to_4326',
+        :the_other_geom => "SRID=900913; #{POINT_WKT}"
+      )
+    end
+  end
+
+  def test_ewkt_create_with_srid_default
+    foo = Foo.create!(
+      :name => 'test_ewkt_create_with_srid_default',
+      :the_other_geom => POINT_EWKT_WITH_DEFAULT
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+
+  def test_ewkb_create
+    foo = Foo.create!(
+      :name => 'test_ewkb_create',
+      :the_other_geom => POINT_EWKB
+    )
+
+    foo.reload
+    assert_saneness_of_point(foo.the_other_geom_geos)
+  end
+end

data/test/adapter_tests.rb

@@ -0,0 +1,44 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class AdapterTests < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo)
+  end
+
+  def test_simplified_type
+    geometry_columns = Foo.columns.select do |c|
+      c.type == :geometry
+    end
+
+    other_columns = Foo.columns.select do |c|
+      c.type != :geometry
+    end
+
+    assert_equal(2, geometry_columns.length)
+    assert_equal(2, other_columns.length)
+  end
+end
+
+if ActiveRecordSpatial.geography_columns?
+  class AdapterWithGeographyTests < ActiveRecordSpatialTestCase
+    def self.before_suite
+      load_models(:foo_geography)
+    end
+
+    def test_simplified_type_geography
+      geography_columns = FooGeography.columns.select do |c|
+        c.type == :geography
+      end
+
+      other_columns = FooGeography.columns.select do |c|
+        c.type != :geography
+      end
+
+      assert_equal(2, geography_columns.length)
+      assert_equal(2, other_columns.length)
+    end
+  end
+end
+

data/test/associations_tests.rb

@@ -0,0 +1,656 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class DefaultIntersectsRelationshipTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars
+    end
+  end
+
+  def test_reflection
+    assert_equal(:has_many, Foo.reflections[:bars].macro)
+    assert_equal(:intersects, Foo.reflections[:bars].options[:relationship])
+  end
+
+  def test_association
+    assert_equal([ 3 ], Foo.first.bars.collect(&:id).sort)
+  end
+end
+
+class RelationshipsTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+  end
+
+  {
+    :contains => [],
+    :containsproperly => [],
+    :covers => [],
+    :coveredby => [ 3 ],
+    :crosses => [],
+    :disjoint => [ 1, 2 ],
+    :equals => [],
+    :intersects => [ 3 ],
+    :orderingequals => [],
+    :overlaps => [],
+    :touches => [],
+    :within => [ 3 ],
+    :'3dintersects' => [ 3 ]
+  }.each do |relationship, ids|
+    define_method("test_#{relationship}") do
+      skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
+
+      Foo.reflections.delete(:bars)
+
+      Foo.class_eval do
+        has_many_spatially :bars, :relationship => relationship
+      end
+
+      assert_equal(:has_many, Foo.reflections[:bars].macro)
+      assert_equal(relationship, Foo.reflections[:bars].options[:relationship])
+      assert_equal(ids, Foo.first.bars.collect(&:id).sort)
+    end
+  end
+end
+
+class RelationshipsWithSelfTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+  end
+
+  {
+    :contains => [ 1 ],
+    :containsproperly => [ 1 ],
+    :covers => [ 1 ],
+    :coveredby => [ 1, 3 ],
+    :crosses => [],
+    :disjoint => [ 2 ],
+    :equals => [ 1 ],
+    :intersects => [ 1, 3 ],
+    :orderingequals => [ 1 ],
+    :overlaps => [],
+    :touches => [],
+    :within => [ 1, 3 ],
+    :'3dintersects' => [ 1, 3 ]
+  }.each do |relationship, ids|
+    define_method("test_#{relationship}") do
+      skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
+
+      Foo.reflections.delete(:foos)
+
+      Foo.class_eval do
+        has_many_spatially :foos, :relationship => relationship
+      end
+
+      assert_equal(:has_many, Foo.reflections[:foos].macro)
+      assert_equal(relationship, Foo.reflections[:foos].options[:relationship])
+      assert_equal(ids, Foo.first.foos.collect(&:id).sort)
+    end
+  end
+end
+
+class RelationshipsWithForeignGeomTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+  end
+
+  {
+    :contains => [],
+    :containsproperly => [],
+    :covers => [],
+    :coveredby => [ 3 ],
+    :crosses => [],
+    :disjoint => [ 1, 2 ],
+    :equals => [],
+    :intersects => [ 3 ],
+    :orderingequals => [],
+    :overlaps => [],
+    :touches => [],
+    :within => [ 3 ],
+    :'3dintersects' => [ 3 ]
+  }.each do |relationship, ids|
+    define_method("test_#{relationship}") do
+      skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
+
+      Foo.reflections.delete(:bars)
+
+      Foo.class_eval do
+        has_many_spatially :bars,
+          :relationship => relationship,
+          :foreign_geom => :the_other_geom
+      end
+
+      assert_equal(:has_many, Foo.reflections[:bars].macro)
+      assert_equal(relationship, Foo.reflections[:bars].options[:relationship])
+      assert_equal(:the_geom, Foo.reflections[:bars].options[:geom])
+      assert_equal(:the_other_geom, Foo.reflections[:bars].options[:foreign_geom])
+      assert_equal(ids, Foo.first.bars.collect(&:id).sort)
+    end
+  end
+end
+
+class RelationshipsWithGeomTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+  end
+
+  {
+    :contains => [],
+    :containsproperly => [],
+    :covers => [],
+    :coveredby => [ 3 ],
+    :crosses => [],
+    :disjoint => [ 1, 2 ],
+    :equals => [],
+    :intersects => [ 3 ],
+    :orderingequals => [],
+    :overlaps => [],
+    :touches => [ 3 ],
+    :within => [],
+    :'3dintersects' => [ 3 ]
+  }.each do |relationship, ids|
+    define_method("test_#{relationship}") do
+      skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
+
+      Foo.reflections.delete(:bars)
+
+      Foo.class_eval do
+        has_many_spatially :bars,
+          :relationship => relationship,
+          :geom => :the_other_geom
+      end
+
+      assert_equal(:has_many, Foo.reflections[:bars].macro)
+      assert_equal(relationship, Foo.reflections[:bars].options[:relationship])
+      assert_equal(:the_other_geom, Foo.reflections[:bars].options[:geom])
+      assert_equal(:the_geom, Foo.reflections[:bars].options[:foreign_geom])
+      assert_equal(ids, Foo.first.bars.collect(&:id).sort)
+    end
+  end
+end
+
+class CountsTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_default_models
+  end
+
+  def test_count
+    assert_equal(2, Foo.last.bars.count)
+    assert_equal(2, Foo.last.foos.count)
+  end
+end
+
+class WithCounterSqlTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+  end
+
+  def test_should_fail
+    assert_raise(ArgumentError) do
+      Foo.class_eval do
+        has_many_spatially :bars,
+          :class_name => 'Bar',
+          :counter_sql => "SELECT COUNT(*) bars.* FROM bars"
+      end
+    end
+  end
+end
+
+class ScopeOptionsTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :class_name => 'Bar',
+        :scope_options => {
+          :use_index => false
+        }
+    end
+  end
+
+  def test_use_index_false
+    assert_sql(/_ST_intersects\(/) do
+      Foo.first.bars.length
+    end
+  end
+end
+
+class PreloadTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_default_models
+  end
+
+  def test_without_eager_loading
+    values = nil
+    assert_queries(4) do
+      assert_sql(/ST_intersects\('#{REGEXP_WKB_HEX}'::geometry, "bars"\."the_geom"/) do
+        values = Foo.all.collect do |foo|
+          foo.bars.length
+        end
+      end
+    end
+
+    assert_equal([ 1, 1, 2], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+    assert_queries(2) do
+      assert_sql(/SELECT "bars"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "bars" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_intersects\("__spatial_ids_join__"."the_geom", "bars"."the_geom"\)\) WHERE "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "bars"\."id"/) do
+        values = Foo.includes(:bars).all.collect do |foo|
+          foo.bars.length
+        end
+      end
+    end
+
+    assert_equal([ 1, 1, 2 ], values)
+  end
+end
+
+class PreloadWithOtherGeomTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :class_name => 'Bar',
+        :geom => :the_other_geom
+    end
+  end
+
+  def test_without_eager_loading
+    values = nil
+    assert_queries(4) do
+      assert_sql(/ST_intersects\(ST_SetSRID\('#{REGEXP_WKB_HEX}'::geometry, #{ActiveRecordSpatial::UNKNOWN_SRID}\), "bars"\."the_geom"/) do
+        values = Foo.order('id').all.collect do |foo|
+          foo.bars.length
+        end
+      end
+    end
+
+    assert_equal([ 1, 0, 2 ], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+    assert_queries(2) do
+      assert_sql(/SELECT "bars"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "bars" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_intersects\(ST_SetSRID\("__spatial_ids_join__"."the_other_geom", #{ActiveRecordSpatial::UNKNOWN_SRID}\), "bars"."the_geom"\)\) WHERE "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "bars"\."id"/) do
+        values = Foo.order('id').includes(:bars).all.collect do |foo|
+          foo.bars.length
+        end
+      end
+    end
+
+    assert_equal([ 1, 0, 2 ], values)
+  end
+end
+
+class OrderingTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :relationship => :disjoint,
+        :order => 'ST_area(the_geom)'
+    end
+  end
+
+  def test_ordering
+    assert_equal([ 1, 2 ], Foo.first.bars.collect(&:id))
+  end
+
+  def test_reordering
+    assert_equal([ 2, 1 ], Foo.first.bars.reorder('bars.id DESC').collect(&:id))
+  end
+end
+
+class PolymorphicAssociationsTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar, :zortable)
+
+    Foo.class_eval do
+      has_many_spatially :zortables,
+        :as => :zortable
+    end
+
+    Bar.class_eval do
+      has_many_spatially :zortables,
+        :as => :zortable,
+        :geom => :the_other_geom
+    end
+  end
+
+  def test_without_eager_loading
+    values = nil
+    assert_queries(2) do
+      assert_sql(/ST_intersects\('#{REGEXP_WKB_HEX}'::geometry, "zortables"\."zortable_geom"/) do
+        values = Foo.first.zortables.collect(&:id).sort
+      end
+    end
+
+    assert_equal([ 1, 7 ], values)
+  end
+
+  def test_without_eager_loading_and_geom
+    values = nil
+    assert_queries(2) do
+      assert_sql(/ST_intersects\(ST_SetSRID\('#{REGEXP_WKB_HEX}'::geometry, #{ActiveRecordSpatial::UNKNOWN_SRID}\), "zortables"\."zortable_geom"/) do
+        values = Bar.first.zortables.collect(&:id).sort
+      end
+    end
+
+    assert_equal([ 6 ], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+    assert_queries(2) do
+      assert_sql(/SELECT "zortables"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "zortables" INNER JOIN "foos" AS "__spatial_ids_join__" ON \(ST_intersects\("__spatial_ids_join__"."the_geom", "zortables"."zortable_geom"\)\) WHERE "zortables"."zortable_type" = 'Foo' AND "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "zortables"\."id"/) do
+        values = Foo.includes(:zortables).first.zortables.collect(&:id).sort
+      end
+    end
+
+    assert_equal([ 1, 7 ], values)
+  end
+
+  def test_with_eager_loading_and_geom
+    values = nil
+    assert_queries(2) do
+      assert_sql(/SELECT "zortables"\.\*, array_to_string\(array_agg\("__spatial_ids_join__"."id"\), ','\) AS "__spatial_ids__" FROM "zortables" INNER JOIN "bars" AS "__spatial_ids_join__" ON \(ST_intersects\(ST_SetSRID\("__spatial_ids_join__"."the_other_geom", #{ActiveRecordSpatial::UNKNOWN_SRID}\), "zortables"."zortable_geom"\)\) WHERE "zortables"."zortable_type" = 'Bar' AND "__spatial_ids_join__"\."id" IN \(.+\) GROUP BY "zortables"\."id"/) do
+        values = Bar.includes(:zortables).first.zortables.collect(&:id).sort
+      end
+    end
+
+    assert_equal([ 6 ], values)
+  end
+end
+
+class PolymorphicAssociationsWithRelationshipsTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar, :zortable)
+  end
+
+  {
+    :contains => [ 1 ],
+    :containsproperly => [ 1 ],
+    :covers => [ 1 ],
+    :coveredby => [ 1, 7 ],
+    :crosses => [],
+    :disjoint => [ 2, 3 ],
+    :equals => [ 1 ],
+    :intersects => [ 1, 7 ],
+    :orderingequals => [ 1 ],
+    :overlaps => [],
+    :touches => [],
+    :within => [ 1, 7 ],
+    :'3dintersects' => [ 1, 7 ]
+  }.each do |relationship, ids|
+    define_method("test_#{relationship}") do
+      skip("ST_#{relationship} is unavailable") unless Foo.respond_to?("st_#{relationship}")
+
+      Foo.reflections.delete(:zortables)
+
+      Foo.class_eval do
+        has_many_spatially :zortables,
+          :as => :zortable,
+          :relationship => relationship
+      end
+
+      assert_equal(ids, Foo.first.zortables.collect(&:id).sort)
+      assert_equal(ids, Foo.includes(:zortables).first.zortables.collect(&:id).sort)
+    end
+  end
+end
+
+class ClassNameOptionTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :blops,
+        :class_name => 'Bar'
+    end
+  end
+
+  def test_class_name
+    assert_equal([ 3 ], Foo.first.blops.collect(&:id))
+    assert_equal([ 3 ], Foo.includes(:blops).first.blops.collect(&:id))
+  end
+end
+
+class ConditionsOptionTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :relationship => :disjoint,
+        :conditions => {
+          :bars => {
+            :id => 3
+          }
+        }
+    end
+  end
+
+  def test_conditions
+    assert_equal([], Foo.first.bars.collect(&:id))
+    assert_equal([], Foo.includes(:bars).first.bars.collect(&:id))
+  end
+end
+
+class IncludeOptionTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:blort, :foo, :bar)
+
+    Foo.class_eval do
+      has_many :blorts
+    end
+
+    Bar.class_eval do
+      has_many_spatially :foos,
+        :include => :blorts
+    end
+  end
+
+  def test_includes
+    values = nil
+    assert_queries(3) do
+      assert_sql(/SELECT\s+"blorts"\.\*\s+FROM\s+"blorts"\s+WHERE\s+"blorts"\."foo_id"\s+IN\s+\(.+\)/) do
+        values = Bar.first.foos.collect(&:id)
+      end
+    end
+
+    assert_equal([ 3 ], values)
+  end
+end
+
+class GeomWrapperTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :class_name => 'Bar',
+        :geom => {
+          :wrapper => :envelope
+        }
+    end
+  end
+
+  def test_without_eager_loading
+    values = nil
+
+    assert_sql(/ST_intersects\(ST_envelope\('#{REGEXP_WKB_HEX}'::geometry\), "bars"."the_geom"\)/) do
+      values = Foo.first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+
+    assert_sql(/ST_intersects\(ST_envelope\("__spatial_ids_join__"."the_geom"\), "bars"."the_geom"\)/) do
+      values = Foo.includes(:bars).first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+end
+
+class ForeignGeomWrapperTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :class_name => 'Bar',
+        :foreign_geom => {
+          :wrapper => :envelope
+        }
+    end
+  end
+
+  def test_without_eager_loading
+    values = nil
+
+    assert_sql(/ST_envelope\("bars"."the_geom"\)/) do
+      values = Foo.first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+
+    assert_sql(/ST_intersects\("__spatial_ids_join__"."the_geom", ST_envelope\("bars"."the_geom"\)\)/) do
+      values = Foo.includes(:bars).first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+end
+
+class BothGeomWrapperTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :class_name => 'Bar',
+        :geom => {
+          :wrapper => :convexhull
+        },
+        :foreign_geom => {
+          :wrapper => :envelope
+        }
+    end
+  end
+
+  def test_without_eager_loading
+    values = nil
+
+    assert_sql(/ST_convexhull\('#{REGEXP_WKB_HEX}'::geometry\), ST_envelope\("bars"."the_geom"\)/) do
+      values = Foo.first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+
+    assert_sql(/ST_intersects\(ST_convexhull\("__spatial_ids_join__"."the_geom"\), ST_envelope\("bars"."the_geom"\)\)/) do
+      values = Foo.includes(:bars).first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+end
+
+class BothGeomWrapperWithMixedSRIDsTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :class_name => 'Bar',
+        :geom => {
+          :wrapper => :convexhull
+        },
+        :foreign_geom => {
+          :wrapper => :centroid,
+          :name => :the_other_geom
+        }
+    end
+  end
+
+  def test_without_eager_loading
+    values = nil
+
+    assert_sql(/ST_convexhull\(ST_SetSRID\('#{REGEXP_WKB_HEX}'::geometry, 4326\)\), ST_centroid\("bars"."the_other_geom"\)/) do
+      values = Foo.first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+
+    assert_sql(/ST_intersects\(ST_convexhull\(ST_SetSRID\("__spatial_ids_join__"."the_geom", 4326\)\), ST_centroid\("bars"."the_other_geom"\)\)/) do
+      values = Foo.includes(:bars).first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 3 ], values)
+  end
+end
+
+class BothGeomWrapperAndOptionsWithMixedSRIDsTest < ActiveRecordSpatialTestCase
+  def self.before_suite
+    load_models(:foo, :bar)
+
+    Foo.class_eval do
+      has_many_spatially :bars,
+        :class_name => 'Bar',
+        :geom => {
+          :wrapper => :convexhull
+        },
+        :foreign_geom => {
+          :wrapper => {
+            :buffer => 100
+          },
+          :name => :the_other_geom
+        }
+    end
+  end
+
+  def test_without_eager_loading
+    values = nil
+
+    assert_sql(/ST_convexhull\(ST_SetSRID\('#{REGEXP_WKB_HEX}'::geometry, 4326\)\), ST_buffer\("bars"."the_other_geom", 100\)/) do
+      values = Foo.first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 1, 2, 3 ], values)
+  end
+
+  def test_with_eager_loading
+    values = nil
+
+    assert_sql(/ST_intersects\(ST_convexhull\(ST_SetSRID\("__spatial_ids_join__"."the_geom", 4326\)\), ST_buffer\("bars"."the_other_geom", 100\)\)/) do
+      values = Foo.includes(:bars).first.bars.collect(&:id).sort
+    end
+
+    assert_equal([ 1, 2, 3 ], values)
+  end
+end
+