activerecord-postgis-adapter 2.2.2 → 3.0.0.beta1

data/test/nested_class_test.rb

@@ -1,32 +1,21 @@
 require 'test_helper'
 
 class NestedClassTest < ActiveSupport::TestCase  # :nodoc:
-  DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database.yml'
-  OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database_local.yml'
-
-  include RGeo::ActiveRecord::AdapterTestHelper
-
   module Foo
     def self.table_name_prefix
       'foo_'
     end
-    class Bar < ::ActiveRecord::Base
+    class Bar < ActiveRecord::Base
+      establish_connection YAML.load_file(ActiveSupport::TestCase::DATABASE_CONFIG_PATH)
     end
   end
 
-  define_test_methods do
-
-    def test_nested_model
-      Foo::Bar.class_eval do
-        establish_connection(DATABASE_CONFIG)
-      end
-      Foo::Bar.connection.create_table(:foo_bars) do |t|
-        t.column 'latlon', :point, :srid => 3785
-      end
-      Foo::Bar.all
-      Foo::Bar.connection.drop_table(:foo_bars)
+  def test_nested_model
+    Foo::Bar.connection.create_table(:foo_bars, force: true) do |t|
+      t.column 'latlon', :st_point, srid: 3785
     end
-
+    assert_empty Foo::Bar.all
+    assert_equal 1, Foo::Bar.connection.drop_table(:foo_bars).result_status
   end
 
 end

data/test/spatial_queries_test.rb

@@ -1,97 +1,79 @@
 require 'test_helper'
 
 class SpatialQueriesTest < ActiveSupport::TestCase  # :nodoc:
+  def test_query_point
+    create_model
+    obj = SpatialModel.new
+    obj.latlon = factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.where(latlon: factory.multi_point([factory.point(1.0, 2.0)])).first
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = SpatialModel.where(latlon: factory.point(2.0, 2.0)).first
+    assert_nil(obj3)
+  end
 
-  DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database.yml'
-  OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database_local.yml'
-
-  include RGeo::ActiveRecord::AdapterTestHelper
-
-  define_test_methods do
-
-    def populate_ar_class(content)
-      klass = create_ar_class
-      case content
-      when :mercator_point
-        klass.connection.create_table(:spatial_test) do |t|
-          t.column 'latlon', :point, :srid => 3785
-        end
-      when :latlon_point_geographic
-        klass.connection.create_table(:spatial_test) do |t|
-          t.column 'latlon', :point, :srid => 4326, :geographic => true
-        end
-      when :path_linestring
-        klass.connection.create_table(:spatial_test) do |t|
-          t.column 'path', :line_string, :srid => 3785
-        end
-      end
-      klass
-    end
+  def test_query_point_wkt
+    create_model
+    obj = SpatialModel.new
+    obj.latlon = factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.where(latlon: 'SRID=3785;POINT(1 2)').first
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = SpatialModel.where(latlon: 'SRID=3785;POINT(2 2)').first
+    assert_nil(obj3)
+  end
 
-    def test_query_point
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      obj.latlon = @factory.point(1.0, 2.0)
-      obj.save!
-      id = obj.id
-      obj2 = klass.where(:latlon => @factory.multi_point([@factory.point(1.0, 2.0)])).first
-      refute_nil(obj2)
-      assert_equal(id, obj2.id)
-      obj3 = klass.where(:latlon => @factory.point(2.0, 2.0)).first
-      assert_nil(obj3)
-    end
+  def test_query_st_distance
+    create_model
+    obj = SpatialModel.new
+    obj.latlon = factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.where(SpatialModel.arel_table[:latlon].st_distance('SRID=3785;POINT(2 3)').lt(2)).first
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = SpatialModel.where(SpatialModel.arel_table[:latlon].st_distance('SRID=3785;POINT(2 3)').gt(2)).first
+    assert_nil(obj3)
+  end
 
-    def test_query_point_wkt
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      obj.latlon = @factory.point(1.0, 2.0)
-      obj.save!
-      id = obj.id
-      obj2 = klass.where(:latlon => 'SRID=3785;POINT(1 2)').first
-      refute_nil(obj2)
-      assert_equal(id, obj2.id)
-      obj3 = klass.where(:latlon => 'SRID=3785;POINT(2 2)').first
-      assert_nil(obj3)
-    end
+  def test_query_st_distance_from_constant
+    create_model
+    obj = SpatialModel.new
+    obj.latlon = factory.point(1.0, 2.0)
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.where(::Arel.spatial('SRID=3785;POINT(2 3)').st_distance(SpatialModel.arel_table[:latlon]).lt(2)).first
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = SpatialModel.where(::Arel.spatial('SRID=3785;POINT(2 3)').st_distance(SpatialModel.arel_table[:latlon]).gt(2)).first
+    assert_nil(obj3)
+  end
 
-    def test_query_st_distance
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      obj.latlon = @factory.point(1.0, 2.0)
-      obj.save!
-      id = obj.id
-      obj2 = klass.where(klass.arel_table[:latlon].st_distance('SRID=3785;POINT(2 3)').lt(2)).first
-      refute_nil(obj2)
-      assert_equal(id, obj2.id)
-      obj3 = klass.where(klass.arel_table[:latlon].st_distance('SRID=3785;POINT(2 3)').gt(2)).first
-      assert_nil(obj3)
-    end
+  def test_query_st_length
+    create_model
+    obj = SpatialModel.new
+    obj.path = factory.line(factory.point(1.0, 2.0), factory.point(3.0, 2.0))
+    obj.save!
+    id = obj.id
+    obj2 = SpatialModel.where(SpatialModel.arel_table[:path].st_length.eq(2)).first
+    refute_nil(obj2)
+    assert_equal(id, obj2.id)
+    obj3 = SpatialModel.where(SpatialModel.arel_table[:path].st_length.gt(3)).first
+    assert_nil(obj3)
+  end
 
-    def test_query_st_distance_from_constant
-      klass = populate_ar_class(:mercator_point)
-      obj = klass.new
-      obj.latlon = @factory.point(1.0, 2.0)
-      obj.save!
-      id = obj.id
-      obj2 = klass.where(::Arel.spatial('SRID=3785;POINT(2 3)').st_distance(klass.arel_table[:latlon]).lt(2)).first
-      refute_nil(obj2)
-      assert_equal(id, obj2.id)
-      obj3 = klass.where(::Arel.spatial('SRID=3785;POINT(2 3)').st_distance(klass.arel_table[:latlon]).gt(2)).first
-      assert_nil(obj3)
-    end
+  private
 
-    def test_query_st_length
-      klass = populate_ar_class(:path_linestring)
-      obj = klass.new
-      obj.path = @factory.line(@factory.point(1.0, 2.0), @factory.point(3.0, 2.0))
-      obj.save!
-      id = obj.id
-      obj2 = klass.where(klass.arel_table[:path].st_length.eq(2)).first
-      refute_nil(obj2)
-      assert_equal(id, obj2.id)
-      obj3 = klass.where(klass.arel_table[:path].st_length.gt(3)).first
-      assert_nil(obj3)
+  def create_model
+    SpatialModel.connection.create_table(:spatial_models, force: true) do |t|
+      t.column 'latlon', :st_point, srid: 3785
+      t.column 'path', :line_string, srid: 3785
     end
-
+    SpatialModel.reset_column_information
   end
+
 end

data/test/tasks_test.rb

@@ -2,157 +2,156 @@ require 'test_helper'
 require 'active_record/schema_dumper'
 
 class TasksTest < ActiveSupport::TestCase  # :nodoc:
-  DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database.yml'
-  OVERRIDE_DATABASE_CONFIG_PATH = ::File.dirname(__FILE__) + '/database_local.yml'
-
-  class << self
-    def before_open_database(args)
-      @new_database_config = args[:config].merge('database' => 'postgis_adapter_test2')
-      @new_database_config.stringify_keys!
-    end
-    attr_reader :new_database_config
+  NEW_CONNECTION = {
+    "adapter"            => "postgis",
+    "host"               => "127.0.0.1",
+    "database"           => "postgis_tasks_test",
+    "username"           => "postgres",
+    "setup"              => "default",
+    "schema_search_path" => "public",
+  }
+
+  def test_create_database_from_extension_in_public_schema
+    drop_db_if_exists
+    ActiveRecord::Tasks::DatabaseTasks.create(NEW_CONNECTION)
+    refute_empty connection.select_values("SELECT * from public.spatial_ref_sys")
   end
 
-  include RGeo::ActiveRecord::AdapterTestHelper
+  def test_create_database_from_extension_in_separate_schema
+    drop_db_if_exists
+    configuration = NEW_CONNECTION.merge("postgis_schema" => "postgis")
+    ActiveRecord::Tasks::DatabaseTasks.create(configuration)
+    refute_empty connection.select_values("SELECT * from postgis.spatial_ref_sys")
+  end
 
-  def cleanup_tables
-    ::ActiveRecord::Base.remove_connection
-    ::ActiveRecord::Base.clear_active_connections!
-    TasksTest::DEFAULT_AR_CLASS.connection.execute("DROP DATABASE IF EXISTS \"postgis_adapter_test2\"")
+  def test_empty_sql_dump
+    setup_database_tasks
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump(NEW_CONNECTION, tmp_sql_filename)
+    sql = File.read(tmp_sql_filename)
+    assert(sql !~ /CREATE TABLE/)
   end
 
-  define_test_methods do
-    def test_create_database_from_extension_in_public_schema
-      ::ActiveRecord::Tasks::DatabaseTasks.create(TasksTest.new_database_config)
-      refute_empty connection.select_values("SELECT * from public.spatial_ref_sys")
+  def test_basic_geography_sql_dump
+    setup_database_tasks
+    connection.create_table(:spatial_test, force: true) do |t|
+      t.st_point "latlon", geographic: true
     end
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump(NEW_CONNECTION, tmp_sql_filename)
+    data = File.read(tmp_sql_filename)
+    assert(data.index('latlon geography(Point,4326)'))
+  end
 
-    def test_create_database_from_extension_in_separate_schema
-      configuration = TasksTest.new_database_config.merge('postgis_schema' => 'postgis')
-      ::ActiveRecord::Tasks::DatabaseTasks.create(configuration)
-      refute_empty connection.select_values("SELECT * from postgis.spatial_ref_sys")
+  def test_index_sql_dump
+    setup_database_tasks
+    connection.create_table(:spatial_test, force: true) do |t|
+      t.st_point "latlon", geographic: true
+      t.string "name"
     end
+    connection.add_index :spatial_test, :latlon, using: :gist
+    connection.add_index :spatial_test, :name, using: :btree
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump(NEW_CONNECTION, tmp_sql_filename)
+    data = File.read(tmp_sql_filename)
+    assert(data.index('latlon geography(Point,4326)'))
+    assert data.index('CREATE INDEX index_spatial_test_on_latlon ON spatial_test USING gist (latlon);')
+    assert data.index('CREATE INDEX index_spatial_test_on_name ON spatial_test USING btree (name);')
+  end
 
-    def test_empty_sql_dump
-      setup_database_tasks
-      ::ActiveRecord::Tasks::DatabaseTasks.structure_dump(TasksTest.new_database_config, tmp_sql_filename)
-      sql = ::File.read(tmp_sql_filename)
-      assert(sql !~ /CREATE TABLE/)
+  def test_empty_schema_dump
+    setup_database_tasks
+    File.open(tmp_sql_filename, "w:utf-8") do |file|
+      ActiveRecord::SchemaDumper.dump(::ActiveRecord::Base.connection, file)
     end
+    data = File.read(tmp_sql_filename)
+    assert(data.index('ActiveRecord::Schema'))
+  end
 
-    def test_basic_geography_sql_dump
-      setup_database_tasks
-      connection.create_table(:spatial_test) do |t|
-        t.point "latlon", geographic: true
-      end
-      ::ActiveRecord::Tasks::DatabaseTasks.structure_dump(TasksTest.new_database_config, tmp_sql_filename)
-      data = ::File.read(tmp_sql_filename)
-      assert(data.index('latlon geography(Point,4326)'))
+  def test_basic_geometry_schema_dump
+    setup_database_tasks
+    connection.create_table(:spatial_test, force: true) do |t|
+      t.geometry 'object1'
+      t.spatial "object2", srid: connection.default_srid, type: "geometry"
     end
-
-    def test_index_sql_dump
-      setup_database_tasks
-      connection.create_table(:spatial_test) do |t|
-        t.point "latlon", geographic: true
-        t.string "name"
-      end
-      connection.add_index :spatial_test, :latlon, spatial: true
-      connection.add_index :spatial_test, :name, using: :btree
-      ::ActiveRecord::Tasks::DatabaseTasks.structure_dump(TasksTest.new_database_config, tmp_sql_filename)
-      data = ::File.read(tmp_sql_filename)
-      assert(data.index('latlon geography(Point,4326)'))
-      assert data.index('CREATE INDEX index_spatial_test_on_latlon ON spatial_test USING gist (latlon);')
-      assert data.index('CREATE INDEX index_spatial_test_on_name ON spatial_test USING btree (name);')
+    File.open(tmp_sql_filename, "w:utf-8") do |file|
+      ActiveRecord::SchemaDumper.dump(connection, file)
     end
+    data = File.read(tmp_sql_filename)
+    assert data.index("t.geometry \"object1\", limit: {:srid=>#{connection.default_srid}, :type=>\"geometry\"")
+    assert data.index("t.geometry \"object2\", limit: {:srid=>#{connection.default_srid}, :type=>\"geometry\"")
+  end
 
-    def test_empty_schema_dump
-      setup_database_tasks
-      ::File.open(tmp_sql_filename, "w:utf-8") do |file|
-        ::ActiveRecord::SchemaDumper.dump(::ActiveRecord::Base.connection, file)
-      end
-      data = ::File.read(tmp_sql_filename)
-      assert(data.index('ActiveRecord::Schema'))
+  def test_basic_geography_schema_dump
+    setup_database_tasks
+    connection.create_table(:spatial_test, force: true) do |t|
+      t.st_point "latlon1", geographic: true
+      t.spatial "latlon2", srid: 4326, type: "st_point", geographic: true
     end
-
-    def test_basic_geometry_schema_dump
-      setup_database_tasks
-      connection.create_table(:spatial_test) do |t|
-        t.geometry 'object1'
-        t.spatial "object2", limit: { srid: connection.default_srid, type: "geometry" }
-      end
-      ::File.open(tmp_sql_filename, "w:utf-8") do |file|
-        ::ActiveRecord::SchemaDumper.dump(connection, file)
-      end
-      data = ::File.read(tmp_sql_filename)
-      assert(data.index("t.spatial \"object1\", limit: {:srid=>#{connection.default_srid}, :type=>\"geometry\"}"))
-      assert(data.index("t.spatial \"object2\", limit: {:srid=>#{connection.default_srid}, :type=>\"geometry\"}"))
+    File.open(tmp_sql_filename, "w:utf-8") do |file|
+      ActiveRecord::SchemaDumper.dump(connection, file)
     end
+    data = File.read(tmp_sql_filename)
+    assert data.index(%(t.geography "latlon1", limit: {:srid=>4326, :type=>"point", :geographic=>true}))
+    assert data.index(%(t.geography "latlon2", limit: {:srid=>4326, :type=>"point", :geographic=>true}))
+  end
 
-    def test_basic_geography_schema_dump
-      setup_database_tasks
-      connection.create_table(:spatial_test) do |t|
-        t.point "latlon1", geographic: true
-        t.spatial "latlon2", limit: { srid: 4326, type: "point", geographic: true }
-      end
-      ::File.open(tmp_sql_filename, "w:utf-8") do |file|
-        ::ActiveRecord::SchemaDumper.dump(connection, file)
-      end
-      data = ::File.read(tmp_sql_filename)
-      assert(data.index('t.spatial "latlon1", limit: {:srid=>4326, :type=>"point", :geographic=>true}'))
-      assert(data.index('t.spatial "latlon2", limit: {:srid=>4326, :type=>"point", :geographic=>true}'))
+  def test_index_schema_dump
+    setup_database_tasks
+    connection.create_table(:spatial_test, force: true) do |t|
+      t.st_point "latlon", geographic: true
     end
-
-    def test_index_schema_dump
-      setup_database_tasks
-      connection.create_table(:spatial_test) do |t|
-        t.point "latlon", geographic: true
-      end
-      connection.add_index :spatial_test, :latlon, spatial: true
-      ::File.open(tmp_sql_filename, "w:utf-8") do |file|
-        ::ActiveRecord::SchemaDumper.dump(connection, file)
-      end
-      data = ::File.read(tmp_sql_filename)
-      assert data.index('t.spatial "latlon", limit: {:srid=>4326, :type=>"point", :geographic=>true}')
-      assert data.index('add_index "spatial_test", ["latlon"], :name => "index_spatial_test_on_latlon", :spatial => true')
+    connection.add_index :spatial_test, :latlon, using: :gist
+    File.open(tmp_sql_filename, "w:utf-8") do |file|
+      ActiveRecord::SchemaDumper.dump(connection, file)
     end
+    data = File.read(tmp_sql_filename)
+    assert data.index(%(t.geography "latlon", limit: {:srid=>4326, :type=>"point", :geographic=>true}))
+    assert data.index(%(add_index "spatial_test", ["latlon"], name: "index_spatial_test_on_latlon", using: :gist))
+  end
 
-    def test_add_index_with_nil_options
-      setup_database_tasks
-      connection.create_table(:test) do |t|
-        t.string "name"
-      end
-      connection.add_index :test, :name, nil
-      ::ActiveRecord::Tasks::DatabaseTasks.structure_dump(TasksTest.new_database_config, tmp_sql_filename)
-      data = ::File.read(tmp_sql_filename)
-      assert data.index('CREATE INDEX index_test_on_name ON test USING btree (name);')
+  def test_add_index_with_no_options
+    setup_database_tasks
+    connection.create_table(:test, force: true) do |t|
+      t.string "name"
     end
+    connection.add_index :test, :name
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump(NEW_CONNECTION, tmp_sql_filename)
+    data = File.read(tmp_sql_filename)
+    assert data.index('CREATE INDEX index_test_on_name ON test USING btree (name);')
+  end
 
-    def test_add_index_via_references
-      setup_database_tasks
-      connection.create_table(:cats)
-      connection.create_table(:dogs) do |t|
-        t.references :cats, index: true
-      end
-      ::ActiveRecord::Tasks::DatabaseTasks.structure_dump(TasksTest.new_database_config, tmp_sql_filename)
-      data = ::File.read(tmp_sql_filename)
-      assert data.index('CREATE INDEX index_dogs_on_cats_id ON dogs USING btree (cats_id);')
+  def test_add_index_via_references
+    setup_database_tasks
+    connection.create_table(:cats, force: true)
+    connection.create_table(:dogs, force: true) do |t|
+      t.references :cats, index: true
     end
+    ActiveRecord::Tasks::DatabaseTasks.structure_dump(NEW_CONNECTION, tmp_sql_filename)
+    data = File.read(tmp_sql_filename)
+    assert data.index('CREATE INDEX index_dogs_on_cats_id ON dogs USING btree (cats_id);')
   end
 
   private
 
   def connection
-    ::ActiveRecord::Base.connection
+    ActiveRecord::Base.connection
   end
 
   def tmp_sql_filename
-    ::File.expand_path('../tmp/tmp.sql', ::File.dirname(__FILE__))
+    File.expand_path('../tmp/tmp.sql', ::File.dirname(__FILE__))
   end
 
   def setup_database_tasks
-    ::FileUtils.rm_f(tmp_sql_filename)
-    ::FileUtils.mkdir_p(::File.dirname(tmp_sql_filename))
-    ::ActiveRecord::Tasks::DatabaseTasks.create(TasksTest.new_database_config)
+    FileUtils.rm_f(tmp_sql_filename)
+    FileUtils.mkdir_p(::File.dirname(tmp_sql_filename))
+    drop_db_if_exists
+    ActiveRecord::ConnectionAdapters::PostGISAdapter::PostGISDatabaseTasks.new(NEW_CONNECTION).create
+  rescue ActiveRecord::Tasks::DatabaseAlreadyExists
+    # ignore
+  end
+
+  def drop_db_if_exists
+    ActiveRecord::ConnectionAdapters::PostGISAdapter::PostGISDatabaseTasks.new(NEW_CONNECTION).drop
+  rescue ActiveRecord::Tasks::DatabaseAlreadyExists
+    # ignore
   end
 
 end