activerecord-postgresql-extensions 0.2.2 → 0.3.0

data/test/roles_tests.rb

@@ -2,11 +2,19 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class RolesTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class RolesTests < PostgreSQLExtensionsTestCase
   def test_create_role
     ARBC.create_role('foo')
+
+    ARBC.create_role('foo', {
+      :password => 'testing',
+      :encrypted_password => false
+    })
+
+    ARBC.create_role('foo', {
+      :valid_until => 'foo'
+    })
+
     ARBC.create_role('foo', {
       :superuser => true,
       :create_db => true,
@@ -23,7 +31,9 @@ class RolesTests < MiniTest::Unit::TestCase
     })
 
     assert_equal([
-      'CREATE ROLE "foo";',
+      %{CREATE ROLE "foo";},
+      %{CREATE ROLE "foo" UNENCRYPTED PASSWORD 'testing';},
+      %{CREATE ROLE "foo" VALID UNTIL 'foo';},
       %{CREATE ROLE "foo" SUPERUSER CREATEDB CREATEROLE NOINHERIT LOGIN CONNECTION LIMIT 10 ENCRYPTED PASSWORD 'testing' VALID UNTIL '2011-10-12' IN ROLE "bar" ROLE "baz" ADMIN "blort";}
     ], statements)
   end
@@ -55,9 +65,9 @@ class RolesTests < MiniTest::Unit::TestCase
     ARBC.drop_role(%w{ foo bar baz }, :if_exists => true)
 
     assert_equal([
-      'DROP ROLE "foo";',
-      'DROP ROLE "foo", "bar", "baz";',
-      'DROP ROLE IF EXISTS "foo", "bar", "baz";',
+      %{DROP ROLE "foo";},
+      %{DROP ROLE "foo", "bar", "baz";},
+      %{DROP ROLE IF EXISTS "foo", "bar", "baz";}
     ], statements)
   end
 end

data/test/rules_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class RulesTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class RulesTests < PostgreSQLExtensionsTestCase
   def test_create_rule
     ARBC.create_rule(
       :ignore_root, :update, :foos, :instead, :nothing, :conditions => 'user_id = 0'
@@ -17,8 +15,8 @@ class RulesTests < MiniTest::Unit::TestCase
     )
 
     assert_equal([
-      "CREATE RULE \"ignore_root\" AS ON UPDATE TO \"foos\" WHERE user_id = 0 DO INSTEAD NOTHING;",
-      "CREATE  OR REPLACE RULE \"ignore_root\" AS ON UPDATE TO \"foos\" WHERE user_id > 0 DO INSTEAD SELECT * FROM non_admins;"
+      %{CREATE RULE "ignore_root" AS ON UPDATE TO "foos" WHERE user_id = 0 DO INSTEAD NOTHING;},
+      %{CREATE  OR REPLACE RULE "ignore_root" AS ON UPDATE TO "foos" WHERE user_id > 0 DO INSTEAD SELECT * FROM non_admins;}
     ], statements)
   end
 
@@ -26,7 +24,17 @@ class RulesTests < MiniTest::Unit::TestCase
     ARBC.drop_rule(:foo, :bar)
 
     assert_equal([
-      "DROP RULE \"foo\" ON \"bar\";",
+      %{DROP RULE "foo" ON "bar";}
+    ], statements)
+  end
+
+  def test_rename_rule
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.rename_rule?
+
+    Mig.rename_rule(:foo, :bar, :baz)
+
+    assert_equal([
+      %{ALTER RULE "foo" ON "bar" RENAME TO "baz";}
     ], statements)
   end
 end

data/test/schemas_tests.rb

@@ -2,16 +2,24 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class SchemasTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class SchemasTests < PostgreSQLExtensionsTestCase
   def test_create_schema
     Mig.create_schema(:foo)
     Mig.create_schema(:foo, :authorization => 'bar')
 
     assert_equal([
-      "CREATE SCHEMA \"foo\";",
-      "CREATE SCHEMA \"foo\" AUTHORIZATION \"bar\";"
+      %{CREATE SCHEMA "foo";},
+      %{CREATE SCHEMA "foo" AUTHORIZATION "bar";}
+    ], statements)
+  end
+
+  def test_create_schema_if_not_exists
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.create_schema_if_not_exists?
+
+    Mig.create_schema(:foo, :if_not_exists => true)
+
+    assert_equal([
+      %{CREATE SCHEMA IF NOT EXISTS "foo";}
     ], statements)
   end
 
@@ -20,8 +28,8 @@ class SchemasTests < MiniTest::Unit::TestCase
     Mig.drop_schema(:foo, :if_exists => true, :cascade => true)
 
     assert_equal([
-      "DROP SCHEMA \"foo\";",
-      "DROP SCHEMA IF EXISTS \"foo\" CASCADE;"
+      %{DROP SCHEMA "foo";},
+      %{DROP SCHEMA IF EXISTS "foo" CASCADE;}
     ], statements)
   end
 
@@ -29,7 +37,7 @@ class SchemasTests < MiniTest::Unit::TestCase
     Mig.alter_schema_name(:foo, :bar)
 
     assert_equal([
-      "ALTER SCHEMA \"foo\" RENAME TO \"bar\";"
+      %{ALTER SCHEMA "foo" RENAME TO "bar";}
     ], statements)
   end
 
@@ -37,7 +45,25 @@ class SchemasTests < MiniTest::Unit::TestCase
     Mig.alter_schema_owner(:foo, :bar)
 
     assert_equal([
-      "ALTER SCHEMA \"foo\" OWNER TO \"bar\";"
+      %{ALTER SCHEMA "foo" OWNER TO "bar";}
+    ], statements)
+  end
+
+  def test_create_schema_authorization
+    Mig.create_schema_authorization(:foo)
+
+    assert_equal([
+      %{CREATE SCHEMA AUTHORIZATION "foo";}
+    ], statements)
+  end
+
+  def test_create_schema_authorization_if_not_exists
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.create_schema_if_not_exists?
+
+    Mig.create_schema_authorization(:foo, :if_not_exists => true)
+
+    assert_equal([
+      %{CREATE SCHEMA IF NOT EXISTS AUTHORIZATION "foo";}
     ], statements)
   end
 end

data/test/sequences_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class SequenceTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class SequenceTests < PostgreSQLExtensionsTestCase
   def test_create_sequence
     Mig.create_sequence(
       'what_a_sequence_of_events',
@@ -21,8 +19,8 @@ class SequenceTests < MiniTest::Unit::TestCase
     )
 
     assert_equal([
-      "CREATE SEQUENCE \"what_a_sequence_of_events\" START WITH 10;",
-      "CREATE SEQUENCE \"what_a_sequence_of_events\" INCREMENT BY 2 NO MINVALUE MAXVALUE 10 CACHE 2 OWNED BY \"foo\".\"id\";"
+      %{CREATE SEQUENCE "what_a_sequence_of_events" START WITH 10;},
+      %{CREATE SEQUENCE "what_a_sequence_of_events" INCREMENT BY 2 NO MINVALUE MAXVALUE 10 CACHE 2 OWNED BY "foo"."id";}
     ], statements)
   end
 
@@ -34,7 +32,7 @@ class SequenceTests < MiniTest::Unit::TestCase
     )
 
     assert_equal([
-      "DROP SEQUENCE IF EXISTS \"foo_id_seq\" CASCADE;"
+      %{DROP SEQUENCE IF EXISTS "foo_id_seq" CASCADE;}
     ], statements)
   end
 
@@ -42,7 +40,7 @@ class SequenceTests < MiniTest::Unit::TestCase
     Mig.rename_sequence(:foo, :bar)
 
     assert_equal([
-      'ALTER SEQUENCE "foo" RENAME TO "bar";'
+      %{ALTER SEQUENCE "foo" RENAME TO "bar";}
     ], statements)
   end
 
@@ -51,8 +49,8 @@ class SequenceTests < MiniTest::Unit::TestCase
     Mig.alter_sequence_schema(:foo, :public)
 
     assert_equal([
-      'ALTER SEQUENCE "foo" SET SCHEMA "bar";',
-      'ALTER SEQUENCE "foo" SET SCHEMA PUBLIC;',
+      %{ALTER SEQUENCE "foo" SET SCHEMA "bar";},
+      %{ALTER SEQUENCE "foo" SET SCHEMA PUBLIC;}
     ], statements)
   end
 
@@ -61,8 +59,8 @@ class SequenceTests < MiniTest::Unit::TestCase
     Mig.set_sequence_value(:foo, 42, :is_called => false)
 
     assert_equal([
-      "SELECT setval('foo', 42, true);",
-      "SELECT setval('foo', 42, false);"
+      %{SELECT setval('foo', 42, true);},
+      %{SELECT setval('foo', 42, false);}
     ], statements)
   end
 end

data/test/tables_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class TablesTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class TablesTests < PostgreSQLExtensionsTestCase
   def test_default_with_expression
     Mig.create_table('foo') do |t|
       t.integer :foo_id, :default => { :expression => '10 + 20' }
@@ -12,19 +10,21 @@ class TablesTests < MiniTest::Unit::TestCase
     end
 
     if ActiveRecord::VERSION::STRING >= "3.2"
-      assert_equal([
-      %{CREATE TABLE "foo" (
-  "id" serial primary key,
-  "foo_id" integer DEFAULT 10 + 20,
-  "bar_id" integer DEFAULT 20
-);} ], statements)
+      assert_equal([ strip_heredoc(<<-SQL) ], statements)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "foo_id" integer DEFAULT 10 + 20,
+          "bar_id" integer DEFAULT 20
+        );
+      SQL
     else
-      assert_equal([
-      %{CREATE TABLE "foo" (
-  "id" serial primary key,
-  "foo_id" integer DEFAULT 10 + 20,
-  "bar_id" integer DEFAULT '20 + 10'
-);} ], statements)
+      assert_equal([ strip_heredoc(<<-SQL) ], statements)
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "foo_id" integer DEFAULT 10 + 20,
+          "bar_id" integer DEFAULT '20 + 10'
+        );
+      SQL
     end
   end
 
@@ -35,36 +35,46 @@ class TablesTests < MiniTest::Unit::TestCase
         :excluding => %w{ storage comments }
     end
 
-    assert_equal([
-       %{CREATE TABLE "foo" (
-  "id" serial primary key,
-  LIKE "bar" INCLUDING CONSTRAINTS INCLUDING INDEXES EXCLUDING STORAGE EXCLUDING COMMENTS
-);}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+       CREATE TABLE "foo" (
+        "id" serial primary key,
+        LIKE "bar" INCLUDING CONSTRAINTS INCLUDING INDEXES EXCLUDING STORAGE EXCLUDING COMMENTS
+      );
+    SQL
   end
 
   def test_option_unlogged
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.create_table_unlogged?
+
     Mig.create_table('foo', :unlogged => true)
 
-    assert_equal([
-      %{CREATE UNLOGGED TABLE "foo" (\n  "id" serial primary key\n);}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE UNLOGGED TABLE "foo" (
+        "id" serial primary key
+      );
+    SQL
   end
 
   def test_option_temporary
     Mig.create_table('foo', :temporary => true)
 
-    assert_equal([
-      %{CREATE TEMPORARY TABLE "foo" (\n  "id" serial primary key\n);}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TEMPORARY TABLE "foo" (
+        "id" serial primary key
+      );
+    SQL
   end
 
   def test_option_if_not_exists
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.create_table_if_not_exists?
+
     Mig.create_table('foo', :if_not_exists => true)
 
-    assert_equal([
-      %{CREATE TABLE IF NOT EXISTS "foo" (\n  "id" serial primary key\n);}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TABLE IF NOT EXISTS "foo" (
+        "id" serial primary key
+      );
+    SQL
   end
 
   def test_option_on_commit
@@ -72,27 +82,52 @@ class TablesTests < MiniTest::Unit::TestCase
     Mig.create_table('foo', :on_commit => :delete_rows)
     Mig.create_table('foo', :on_commit => :drop)
 
-    assert_equal([
-      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nON COMMIT PRESERVE ROWS;},
-      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nON COMMIT DELETE ROWS;},
-      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nON COMMIT DROP;}
-    ], statements)
+    expected = []
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "id" serial primary key
+      )
+      ON COMMIT PRESERVE ROWS;
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "id" serial primary key
+      )
+      ON COMMIT DELETE ROWS;
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "id" serial primary key
+      )
+      ON COMMIT DROP;
+    SQL
+
+    assert_equal(expected, statements)
   end
 
   def test_option_inherits
     Mig.create_table('foo', :inherits => 'bar')
 
-    assert_equal([
-      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nINHERITS ("bar");}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TABLE "foo" (
+        "id" serial primary key
+      )
+      INHERITS ("bar");
+    SQL
   end
 
   def test_option_tablespace
     Mig.create_table('foo', :tablespace => 'bar')
 
-    assert_equal([
-      %{CREATE TABLE "foo" (\n  "id" serial primary key\n)\nTABLESPACE "bar";}
-    ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TABLE "foo" (
+        "id" serial primary key
+      )
+      TABLESPACE "bar";
+    SQL
   end
 
   def test_option_of_type
@@ -128,8 +163,63 @@ class TablesTests < MiniTest::Unit::TestCase
       })
     end
 
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TABLE "foo" (
+        "id" serial primary key,
+        "blort" text,
+        CONSTRAINT "exclude_blort_length" EXCLUDE (length(blort) WITH =)
+      );
+    SQL
+  end
+
+  def test_index
+    Mig.create_table('foo') do |t|
+      t.text :blort
+      t.index :foo_blort_idx, :blort, :using => :gist
+      t.index :foo_blort_idx, :blort, :index_parameters => {
+        :fillfactor => 10
+      }
+    end
+
     assert_equal([
-      %{CREATE TABLE "foo" (\n  "id" serial primary key,\n  "blort" text,\n  CONSTRAINT "exclude_blort_length" EXCLUDE (length(blort) WITH =)\n);}
+      strip_heredoc(%{
+        CREATE TABLE "foo" (
+          "id" serial primary key,
+          "blort" text
+        );
+      }),
+
+      strip_heredoc(%{
+        CREATE INDEX "foo_blort_idx" ON "foo" USING "gist"("blort");
+      }),
+
+      strip_heredoc(%{
+        CREATE INDEX "foo_blort_idx" ON "foo"("blort") WITH ("fillfactor" = 10);
+      })
+    ], statements)
+  end
+
+  def test_storage_parameters
+    Mig.create_table('foo', :storage_parameters => {
+      :fillfactor => 10
+    })
+
+    Mig.create_table('foo', :storage_parameters => "FILLFACTOR=10")
+
+    assert_equal([
+      strip_heredoc(%{
+        CREATE TABLE "foo" (
+          "id" serial primary key
+        )
+        WITH ("fillfactor" = 10);
+      }),
+
+      strip_heredoc(%{
+        CREATE TABLE "foo" (
+          "id" serial primary key
+        )
+        WITH (FILLFACTOR=10);
+      })
     ], statements)
   end
 end