activerecord-postgresql-extensions 0.2.2 → 0.3.0

data/test/event_triggers_tests.rb

@@ -0,0 +1,109 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class EventTriggerTests < PostgreSQLExtensionsTestCase
+  def skip_unless_supported
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.event_triggers?
+  end
+
+  def test_create_event_trigger
+    skip_unless_supported
+
+    Mig.create_event_trigger(:foo_trg, :ddl_command_start, :foo_trg_function)
+
+    assert_equal([
+      %{CREATE EVENT TRIGGER "foo_trg" ON "ddl_command_start" EXECUTE PROCEDURE "foo_trg_function"();}
+    ], statements)
+  end
+
+  def test_create_event_trigger_bad_event
+    skip_unless_supported
+
+    assert_raises(ActiveRecord::InvalidEventTriggerEventType) do
+      Mig.create_event_trigger(:foo_trg, :blort, :foo_trg_function)
+    end
+  end
+
+  def test_create_event_trigger_with_when_option
+    skip_unless_supported
+
+    Mig.create_event_trigger(:foo_trg, :ddl_command_start, :foo_trg_function,
+      :when => {
+        :tag => 'CREATE TABLE',
+        :toplevel => 'FOOS'
+      }
+    )
+
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE EVENT TRIGGER "foo_trg" ON "ddl_command_start"
+        WHEN "tag" IN ('CREATE TABLE')
+        AND "toplevel" IN ('FOOS')
+        EXECUTE PROCEDURE "foo_trg_function"();
+    SQL
+  end
+
+  def test_drop_event_trigger
+    skip_unless_supported
+
+    ARBC.drop_event_trigger(:foo)
+    ARBC.drop_event_trigger(:foo, :if_exists => true, :cascade => true)
+
+    assert_equal([
+      %{DROP EVENT TRIGGER "foo";},
+      %{DROP EVENT TRIGGER IF EXISTS "foo" CASCADE;}
+    ], statements)
+  end
+
+  def test_rename_event_trigger
+    skip_unless_supported
+
+    ARBC.rename_event_trigger(:foo, :bar)
+
+    assert_equal([
+      %{ALTER EVENT TRIGGER "foo" RENAME TO "bar";}
+    ], statements)
+  end
+
+  def test_alter_event_trigger_owner
+    skip_unless_supported
+
+    ARBC.alter_event_trigger_owner(:foo, :bar)
+
+    assert_equal([
+      %{ALTER EVENT TRIGGER "foo" OWNER TO "bar";}
+    ], statements)
+  end
+
+  def test_enable_event_trigger
+    skip_unless_supported
+
+    ARBC.enable_event_trigger(:foo)
+    ARBC.enable_event_trigger(:foo, :always => true)
+    ARBC.enable_event_trigger(:foo, :replica => true)
+
+    assert_equal([
+      %{ALTER EVENT TRIGGER "foo" ENABLE;},
+      %{ALTER EVENT TRIGGER "foo" ENABLE ALWAYS;},
+      %{ALTER EVENT TRIGGER "foo" ENABLE REPLICA;}
+    ], statements)
+  end
+
+  def test_enable_event_trigger_with_replica_and_always
+    skip_unless_supported
+
+    assert_raises(ArgumentError) do
+      ARBC.enable_event_trigger(:foo, :always => true, :replica => true)
+    end
+  end
+
+  def test_disable_event_trigger
+    skip_unless_supported
+
+    ARBC.disable_event_trigger(:foo)
+
+    assert_equal([
+      %{ALTER EVENT TRIGGER "foo" DISABLE;}
+    ], statements)
+  end
+end

data/test/extensions_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class ExtensionsTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class ExtensionsTests < PostgreSQLExtensionsTestCase
   def test_create_extension
     skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
 
@@ -194,11 +192,11 @@ class ExtensionsTests < MiniTest::Unit::TestCase
       e.domain :bar
     end
 
-    assert_equal([
-      %{ALTER EXTENSION "foo" DROP COLLATION "bar";
-ALTER EXTENSION "foo" ADD CONVERSION "bar";
-ALTER EXTENSION "foo" ADD DOMAIN "bar";}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER EXTENSION "foo" DROP COLLATION "bar";
+      ALTER EXTENSION "foo" ADD CONVERSION "bar";
+      ALTER EXTENSION "foo" ADD DOMAIN "bar";
+    SQL
   end
 
   def test_alter_extension_cast_option
@@ -210,11 +208,11 @@ ALTER EXTENSION "foo" ADD DOMAIN "bar";}
       e.cast :source => :hello, :target => :world
     end
 
-    assert_equal([
-      %{ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");
-ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");
-ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");
+      ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");
+      ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");
+    SQL
   end
 
   def test_alter_extension_aggregate_option
@@ -225,10 +223,10 @@ ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");}
       e.aggregate :bar, :type_a, :type_b, :type_c
     end
 
-    assert_equal([
-      %{ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");
-ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");
+      ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");
+    SQL
   end
 
   def test_alter_extension_operator_option
@@ -240,11 +238,11 @@ ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");}
       e.operator :name => :bar, :left_type => :hello, :right_type => :world
     end
 
-    assert_equal([
-      %{ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");
-ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");
-ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");
+      ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");
+      ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");
+    SQL
   end
 
   def test_alter_extension_operator_class_option
@@ -257,12 +255,12 @@ ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");}
       e.operator_class :name => :hello, :indexing_method => :world
     end
 
-    assert_equal([
-      %{ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
-ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
-ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
-ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
+      ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
+      ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
+      ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
+    SQL
   end
 
   def test_alter_extension_operator_family_option
@@ -275,12 +273,12 @@ ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");}
       e.operator_family :name => :hello, :indexing_method => :world
     end
 
-    assert_equal([
-      %{ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
-ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
-ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
-ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
+      ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
+      ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
+      ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
+    SQL
   end
 
   def test_alter_extension_function_option
@@ -292,10 +290,20 @@ ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");}
       e.function :name => :bar, :arguments => "VARIADIC hello world"
     end
 
-    assert_equal([
-      %{ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);
-ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);
-ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);
+      ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);
+      ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);
+    SQL
+  end
+
+  def test_alter_extension_bad_action
+    skip if !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+
+    assert_raises(ArgumentError) do
+      ARBC.alter_extension(:foo, {
+        :blort_collation => :bar
+      })
+    end
   end
 end

data/test/functions_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class FunctionsTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class FunctionsTests < PostgreSQLExtensionsTestCase
   def test_create_function
     ARBC.create_function(:test, :integer, :integer, :sql) do
       "select 10;"
@@ -24,22 +22,28 @@ class FunctionsTests < MiniTest::Unit::TestCase
       "return 10;"
     end
 
-    assert_equal([
-%{CREATE FUNCTION "test"(integer) RETURNS integer AS $$
-select 10;
-$$
-LANGUAGE "sql";},
-
-%{CREATE OR REPLACE FUNCTION "test"(integer) RETURNS integer AS $__$
-return 10;
-$__$
-LANGUAGE "sql"
-    IMMUTABLE
-    STRICT
-    COST 1
-    ROWS 10
-    SET TIME ZONE "America/Halifax";}
-    ], statements)
+    expected = []
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE FUNCTION "test"(integer) RETURNS integer AS $$
+      select 10;
+      $$
+      LANGUAGE "sql";
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE OR REPLACE FUNCTION "test"(integer) RETURNS integer AS $__$
+      return 10;
+      $__$
+      LANGUAGE "sql"
+          IMMUTABLE
+          STRICT
+          COST 1
+          ROWS 10
+          SET TIME ZONE "America/Halifax";
+    SQL
+
+    assert_equal(expected, statements)
   end
 
   def test_drop_function
@@ -47,8 +51,8 @@ LANGUAGE "sql"
     ARBC.drop_function(:test, :integer, :if_exists => true, :cascade => true)
 
     assert_equal([
-      "DROP FUNCTION \"test\"(integer);",
-      "DROP FUNCTION IF EXISTS \"test\"(integer) CASCADE;"
+      %{DROP FUNCTION "test"(integer);},
+      %{DROP FUNCTION IF EXISTS "test"(integer) CASCADE;}
     ], statements)
   end
 
@@ -56,7 +60,7 @@ LANGUAGE "sql"
     ARBC.rename_function(:test, 'integer, text', :foo)
 
     assert_equal([
-      "ALTER FUNCTION \"test\"(integer, text) RENAME TO \"foo\";"
+      %{ALTER FUNCTION "test"(integer, text) RENAME TO "foo";}
     ], statements)
   end
 
@@ -64,7 +68,7 @@ LANGUAGE "sql"
     ARBC.alter_function_owner(:test, 'integer, text', :admin)
 
     assert_equal([
-      "ALTER FUNCTION \"test\"(integer, text) OWNER TO \"admin\";"
+      %{ALTER FUNCTION "test"(integer, text) OWNER TO "admin";}
     ], statements)
   end
 
@@ -72,7 +76,7 @@ LANGUAGE "sql"
     ARBC.alter_function_schema(:test, 'integer, text', :geospatial)
 
     assert_equal([
-      "ALTER FUNCTION \"test\"(integer, text) SET SCHEMA \"geospatial\";"
+      %{ALTER FUNCTION "test"(integer, text) SET SCHEMA "geospatial";}
     ], statements)
   end
 
@@ -94,19 +98,24 @@ LANGUAGE "sql"
       f.reset %w{ debug_assertions trace_notify }
     end
 
-    assert_equal([
-%{ALTER FUNCTION "my_function"(integer) RENAME TO "another_function";},
-%{ALTER FUNCTION "another_function"(integer) OWNER TO "jdoe";},
-%{ALTER FUNCTION "my_function"(integer) RENAME TO "another_function";
-ALTER FUNCTION "another_function"(integer) OWNER TO "jdoe";
-ALTER FUNCTION "another_function"(integer) SET SCHEMA "foo";
-ALTER FUNCTION "another_function"(integer) IMMUTABLE;
-ALTER FUNCTION "another_function"(integer) SECURITY INVOKER;
-ALTER FUNCTION "another_function"(integer) COST 10;
-ALTER FUNCTION "another_function"(integer) ROWS 10;
-ALTER FUNCTION "another_function"(integer) SET "log_duration" TO "0.4";
-ALTER FUNCTION "another_function"(integer) RESET ALL;
-ALTER FUNCTION "another_function"(integer) RESET "debug_assertions" RESET "trace_notify";}
-    ], statements)
+    expected = [
+      %{ALTER FUNCTION "my_function"(integer) RENAME TO "another_function";},
+      %{ALTER FUNCTION "another_function"(integer) OWNER TO "jdoe";}
+    ]
+
+    expected << strip_heredoc(<<-SQL)
+      ALTER FUNCTION "my_function"(integer) RENAME TO "another_function";
+      ALTER FUNCTION "another_function"(integer) OWNER TO "jdoe";
+      ALTER FUNCTION "another_function"(integer) SET SCHEMA "foo";
+      ALTER FUNCTION "another_function"(integer) IMMUTABLE;
+      ALTER FUNCTION "another_function"(integer) SECURITY INVOKER;
+      ALTER FUNCTION "another_function"(integer) COST 10;
+      ALTER FUNCTION "another_function"(integer) ROWS 10;
+      ALTER FUNCTION "another_function"(integer) SET "log_duration" TO "0.4";
+      ALTER FUNCTION "another_function"(integer) RESET ALL;
+      ALTER FUNCTION "another_function"(integer) RESET "debug_assertions" RESET "trace_notify";
+    SQL
+
+    assert_equal(expected, statements)
   end
 end

data/test/geometry_tests.rb

@@ -3,9 +3,7 @@ $: << File.dirname(__FILE__)
 require 'test_helper'
 
 if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0'
-  class GeometryTests < MiniTest::Unit::TestCase
-    include PostgreSQLExtensionsTestHelper
-
+  class GeometryTests < PostgreSQLExtensionsTestCase
     def test_create_geometry
       skip if !ActiveRecord::PostgreSQLExtensions::Features.postgis?
 
@@ -13,13 +11,20 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "the_geom" geometry(GEOMETRY, 4326)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_spatial
@@ -29,13 +34,20 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         t.spatial :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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "the_geom" geometry(GEOMETRY, 4326)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_spatial_and_spatial_column_type
@@ -45,13 +57,20 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         t.spatial :the_geom, :srid => 4326, :spatial_column_type => :geography
       end
 
-      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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "the_geom" geography(GEOMETRY, 4326)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geography
@@ -61,13 +80,20 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         t.geography :the_geom, :srid => 4326
       end
 
-      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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "the_geom" geography(GEOMETRY, 4326)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_force_constraints
@@ -77,15 +103,22 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         t.geometry :the_geom, :srid => 4326, :force_constraints => true
       end
 
-      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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_schema
@@ -93,13 +126,20 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         t.geometry :the_geom, :srid => 4326
       end
 
-      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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE TABLE "shabba"."foo" (
+          "id" serial primary key,
+          "the_geom" geometry(GEOMETRY, 4326)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_not_null
@@ -109,13 +149,20 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         t.geometry :the_geom, :srid => 4326, :null => false
       end
 
-      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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "the_geom" geometry(GEOMETRY, 4326) NOT NULL
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_null_and_type
@@ -125,13 +172,20 @@ if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0
         t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
       end
 
-      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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "the_geom" geometry(POLYGON, 4326)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
   end
 else
@@ -145,17 +199,30 @@ else
         t.geometry :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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_spatial
@@ -165,17 +232,30 @@ else
         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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_spatial_and_spatial_column_type
@@ -185,15 +265,22 @@ else
         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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geography
@@ -203,15 +290,22 @@ else
         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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_schema
@@ -221,17 +315,30 @@ else
         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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'shabba' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        INSERT INTO "geometry_columns" VALUES ('', 'shabba', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_not_null
@@ -241,17 +348,30 @@ else
         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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
 
     def test_create_geometry_with_null_and_type
@@ -261,18 +381,31 @@ else
         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)
+      expected = []
+
+      expected << strip_heredoc(<<-SQL)
+        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)
+        );
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'POLYGON');
+      SQL
+
+      expected << strip_heredoc(<<-SQL)
+        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
+      SQL
+
+      assert_equal(expected, statements)
     end
   end
 end