activerecord-postgresql-extensions 0.1.0 → 0.2.0

data/test/constraints_tests.rb

@@ -2,7 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class ConstraintTests < Test::Unit::TestCase
+class ConstraintTests < MiniTest::Unit::TestCase
   include PostgreSQLExtensionsTestHelper
 
   def setup
@@ -250,4 +250,110 @@ EOF
       %{ALTER TABLE "foo" ADD EXCLUDE (length(name) WITH =) WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";}
     ], statements)
   end
+
+  def test_primary_key_in_column_definition
+    Mig.create_table('foo', :id => false) do |t|
+      t.integer :foo_id, :primary_key => true
+    end
+
+    Mig.create_table('foo', :id => false) do |t|
+      t.integer :foo_id, :primary_key => {
+        :tablespace => 'fubar',
+        :index_parameters => 'FILLFACTOR=10'
+      }
+    end
+
+    assert_equal([
+      %{CREATE TABLE "foo" (
+  "foo_id" integer,
+  PRIMARY KEY ("foo_id")
+);},
+
+      %{CREATE TABLE "foo" (
+  "foo_id" integer,
+  PRIMARY KEY ("foo_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
+);}], statements)
+  end
+
+
+  def test_primary_key_in_table_definition
+    Mig.create_table('foo', :id => false) do |t|
+      t.integer :foo_id
+      t.primary_key_constraint :foo_id
+    end
+
+    Mig.create_table('foo', :id => false) do |t|
+      t.integer :foo_id
+      t.primary_key_constraint :foo_id, {
+        :tablespace => 'fubar',
+        :index_parameters => 'FILLFACTOR=10'
+      }
+    end
+
+    Mig.create_table('foo', :id => false) do |t|
+      t.integer :foo_id
+      t.integer :bar_id
+      t.primary_key_constraint [ :foo_id, :bar_id ], {
+        :tablespace => 'fubar',
+        :index_parameters => 'FILLFACTOR=10'
+      }
+    end
+
+    assert_equal([
+      %{CREATE TABLE "foo" (
+  "foo_id" integer,
+  PRIMARY KEY ("foo_id")
+);},
+
+      %{CREATE TABLE "foo" (
+  "foo_id" integer,
+  PRIMARY KEY ("foo_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
+);},
+
+      %{CREATE TABLE "foo" (
+  "foo_id" integer,
+  "bar_id" integer,
+  PRIMARY KEY ("foo_id", "bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
+);}], statements)
+  end
+
+  def test_add_primary_key
+    Mig.add_primary_key(:foo, :bar_id)
+    Mig.add_primary_key(:foo, [ :bar_id, :baz_id ])
+    Mig.add_primary_key(:foo, :bar_id, :name => 'foo_pk')
+    Mig.add_primary_key(:foo, :bar_id, :tablespace => 'fubar', :index_parameters => 'FILLFACTOR=10')
+
+    assert_equal([
+      %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id");},
+      %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id", "baz_id");},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "foo_pk" PRIMARY KEY ("bar_id");},
+      %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";}
+    ], statements)
+  end
+
+  def test_not_valid
+    Mig.add_check_constraint(:foo, 'length(name) < 100', :not_valid => true)
+    Mig.add_foreign_key(:foo, :bar_id, :bar, :not_valid => true)
+
+    assert_equal([
+      "ALTER TABLE \"foo\" ADD CHECK (length(name) < 100) NOT VALID;",
+      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" NOT VALID;"
+    ], statements)
+  end
+
+  def test_validate_constraint
+    Mig.validate_constraint(:foo, :foo_constraint)
+
+    assert_equal([
+      "ALTER TABLE \"foo\" VALIDATE CONSTRAINT \"foo_constraint\";"
+    ], statements)
+  end
+
+  def test_no_inherit
+    Mig.add_check_constraint(:foo, 'length(name) < 100', :no_inherit => true)
+
+    assert_equal([
+      "ALTER TABLE \"foo\" ADD CHECK (length(name) < 100) NO INHERIT;",
+    ], statements)
+  end
 end

data/test/extensions_tests.rb

@@ -2,10 +2,12 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class ExtensionsTests < Test::Unit::TestCase
+class ExtensionsTests < MiniTest::Unit::TestCase
   include PostgreSQLExtensionsTestHelper
 
   def test_create_extension
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.create_extension(:foo)
     ARBC.create_extension(:foo, :if_not_exists => true)
     ARBC.create_extension(:foo, :schema => :bar)
@@ -22,6 +24,8 @@ class ExtensionsTests < Test::Unit::TestCase
   end
 
   def test_drop_extension
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.drop_extension(:foo)
     ARBC.drop_extension(:foo, :if_exists => true)
     ARBC.drop_extension(:foo, :cascade => true)
@@ -36,6 +40,8 @@ class ExtensionsTests < Test::Unit::TestCase
   end
 
   def test_update_extension
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.update_extension(:foo)
     ARBC.update_extension(:foo, '2.0.0')
 
@@ -46,6 +52,8 @@ class ExtensionsTests < Test::Unit::TestCase
   end
 
   def test_update_schema
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension_schema(:foo, :bar)
 
     assert_equal([
@@ -54,12 +62,16 @@ class ExtensionsTests < Test::Unit::TestCase
   end
 
   def test_alter_extension_empty
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo)
 
     assert_equal([], statements)
   end
 
   def test_alter_extension_regular_options_with_hashes
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo, {
       :collation => :bar,
       :conversion => :bar,
@@ -174,6 +186,8 @@ class ExtensionsTests < Test::Unit::TestCase
   end
 
   def test_alter_extension_regular_options_with_block
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo) do |e|
       e.drop_collation :bar
       e.add_conversion :bar
@@ -188,6 +202,8 @@ ALTER EXTENSION "foo" ADD DOMAIN "bar";}
   end
 
   def test_alter_extension_cast_option
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo) do |e|
       e.cast :hello => :world
       e.cast [ :hello, :world ]
@@ -202,6 +218,8 @@ ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");}
   end
 
   def test_alter_extension_aggregate_option
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo) do |e|
       e.aggregate :name => :bar, :types => %w{ type_a type_b type_c }
       e.aggregate :bar, :type_a, :type_b, :type_c
@@ -214,6 +232,8 @@ ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");}
   end
 
   def test_alter_extension_operator_option
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo) do |e|
       e.operator :bar, :hello, :world
       e.operator [ :bar, :hello, :world ]
@@ -228,6 +248,8 @@ ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");}
   end
 
   def test_alter_extension_operator_class_option
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo) do |e|
       e.operator_class :hello => :world
       e.operator_class :hello, :world
@@ -244,6 +266,8 @@ ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");}
   end
 
   def test_alter_extension_operator_family_option
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo) do |e|
       e.operator_family :hello => :world
       e.operator_family :hello, :world
@@ -260,6 +284,8 @@ ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");}
   end
 
   def test_alter_extension_function_option
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
     ARBC.alter_extension(:foo) do |e|
       e.function :bar, "VARIADIC hello world"
       e.function [ :bar, "VARIADIC hello world" ]

data/test/functions_tests.rb

@@ -2,7 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class FunctionsTests < Test::Unit::TestCase
+class FunctionsTests < MiniTest::Unit::TestCase
   include PostgreSQLExtensionsTestHelper
 
   def test_create_function

data/test/geometry_tests.rb

@@ -2,251 +2,277 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-if ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION
-  if ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] >= '2.0'
-    class GeometryTests < Test::Unit::TestCase
-      include PostgreSQLExtensionsTestHelper
-
-      def test_create_geometry
-        Mig.create_table(:foo) do |t|
-          t.geometry :the_geom, :srid => 4326
-        end
-
-        assert_equal([
-          %{CREATE TABLE "foo" (
+if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0'
+  class GeometryTests < MiniTest::Unit::TestCase
+    include PostgreSQLExtensionsTestHelper
+
+    def test_create_geometry
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
+
+      Mig.create_table(:foo) do |t|
+        t.geometry :the_geom, :srid => 4326
+      end
+
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry(GEOMETRY, 4326)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_spatial
-        Mig.create_table(:foo) do |t|
-          t.spatial :the_geom, :srid => 4326
-        end
+    def test_create_geometry_with_spatial
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
+
+      Mig.create_table(:foo) do |t|
+        t.spatial :the_geom, :srid => 4326
+      end
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry(GEOMETRY, 4326)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_spatial_and_spatial_column_type
-        Mig.create_table(:foo) do |t|
-          t.spatial :the_geom, :srid => 4326, :spatial_column_type => :geography
-        end
+    def test_create_geometry_with_spatial_and_spatial_column_type
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
+
+      Mig.create_table(:foo) do |t|
+        t.spatial :the_geom, :srid => 4326, :spatial_column_type => :geography
+      end
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geography(GEOMETRY, 4326)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
+
+    def test_create_geography
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-      def test_create_geography
-        Mig.create_table(:foo) do |t|
-          t.geography :the_geom, :srid => 4326
-        end
+      Mig.create_table(:foo) do |t|
+        t.geography :the_geom, :srid => 4326
+      end
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geography(GEOMETRY, 4326)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
+
+    def test_create_geometry_with_force_constraints
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-      def test_create_geometry_with_force_constraints
-        Mig.create_table(:foo) do |t|
-          t.geometry :the_geom, :srid => 4326, :force_constraints => true
-        end
+      Mig.create_table(:foo) do |t|
+        t.geometry :the_geom, :srid => 4326, :force_constraints => true
+      end
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry(GEOMETRY, 4326),
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_schema
-        Mig.create_table('shabba.foo') do |t|
-          t.geometry :the_geom, :srid => 4326
-        end
+    def test_create_geometry_with_schema
+      Mig.create_table('shabba.foo') do |t|
+        t.geometry :the_geom, :srid => 4326
+      end
 
-        assert_equal([
-          %{CREATE TABLE "shabba"."foo" (
+      assert_equal([
+        %{CREATE TABLE "shabba"."foo" (
   "id" serial primary key,
   "the_geom" geometry(GEOMETRY, 4326)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_not_null
-        Mig.create_table(:foo) do |t|
-          t.geometry :the_geom, :srid => 4326, :null => false
-        end
+    def test_create_geometry_with_not_null
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
+
+      Mig.create_table(:foo) do |t|
+        t.geometry :the_geom, :srid => 4326, :null => false
+      end
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry(GEOMETRY, 4326) NOT NULL
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
+
+    def test_create_geometry_with_null_and_type
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-      def test_create_geometry_with_null_and_type
-        Mig.create_table(:foo) do |t|
-          t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
-        end
+      Mig.create_table(:foo) do |t|
+        t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
+      end
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry(POLYGON, 4326)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
     end
-  else
-    class GeometryTests < Test::Unit::TestCase
-      include PostgreSQLExtensionsTestHelper
+  end
+else
+  class GeometryTests < Test::Unit::TestCase
+    include PostgreSQLExtensionsTestHelper
+
+    def test_create_geometry
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-      def test_create_geometry
-        Mig.create_table(:foo) do |t|
-          t.geometry :the_geom, :srid => 4326
-        end
+      Mig.create_table(:foo) do |t|
+        t.geometry :the_geom, :srid => 4326
+      end
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry,
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+        %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_spatial
-        Mig.create_table(:foo) do |t|
-          t.spatial :the_geom, :srid => 4326
-        end
+    def test_create_geometry_with_spatial
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      Mig.create_table(:foo) do |t|
+        t.spatial :the_geom, :srid => 4326
+      end
+
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry,
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+        %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_spatial_and_spatial_column_type
-        Mig.create_table(:foo) do |t|
-          t.spatial :the_geom, :srid => 4326, :spatial_column_type => :geography
-        end
+    def test_create_geometry_with_spatial_and_spatial_column_type
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      Mig.create_table(:foo) do |t|
+        t.spatial :the_geom, :srid => 4326, :spatial_column_type => :geography
+      end
+
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geography,
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geography
-        Mig.create_table(:foo) do |t|
-          t.geography :the_geom, :srid => 4326
-        end
+    def test_create_geography
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      Mig.create_table(:foo) do |t|
+        t.geography :the_geom, :srid => 4326
+      end
+
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geography,
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_schema
-        Mig.create_table('shabba.foo') do |t|
-          t.geometry :the_geom, :srid => 4326
-        end
+    def test_create_geometry_with_schema
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-        assert_equal([
-          %{CREATE TABLE "shabba"."foo" (
+      Mig.create_table('shabba.foo') do |t|
+        t.geometry :the_geom, :srid => 4326
+      end
+
+      assert_equal([
+        %{CREATE TABLE "shabba"."foo" (
   "id" serial primary key,
   "the_geom" geometry,
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'shabba' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-          %{INSERT INTO "geometry_columns" VALUES ('', 'shabba', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'shabba' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+        %{INSERT INTO "geometry_columns" VALUES ('', 'shabba', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+        %{CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_not_null
-        Mig.create_table(:foo) do |t|
-          t.geometry :the_geom, :srid => 4326, :null => false
-        end
+    def test_create_geometry_with_not_null
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      Mig.create_table(:foo) do |t|
+        t.geometry :the_geom, :srid => 4326, :null => false
+      end
+
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry NOT NULL,
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+        %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
+    end
 
-      def test_create_geometry_with_null_and_type
-        Mig.create_table(:foo) do |t|
-          t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
-        end
+    def test_create_geometry_with_null_and_type
+      skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
-        assert_equal([
-          %{CREATE TABLE "foo" (
+      Mig.create_table(:foo) do |t|
+        t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
+      end
+
+      assert_equal([
+        %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry,
   CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
   CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2),
   CONSTRAINT "enforce_geotype_the_geom" CHECK (geometrytype("the_geom") = 'POLYGON'::text OR "the_geom" IS NULL)
 );},
-          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'POLYGON');},
-          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
-        ], statements)
-      end
+        %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+        %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'POLYGON');},
+        %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+      ], statements)
     end
   end
 end