activerecord-postgresql-extensions 0.2.2 → 0.3.0

data/test/{index_tests.rb → indexes_tests.rb}

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class IndexTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class IndexTests < PostgreSQLExtensionsTestCase
   def test_create_index
     Mig.create_index(:foo_names_idx, :foo, [ :first_name, :last_name ])
     Mig.create_index(:foo_bar_id_idx, :foo, :column => :bar_id)
@@ -43,13 +41,13 @@ class IndexTests < MiniTest::Unit::TestCase
     end
 
     assert_equal([
-      "CREATE INDEX \"foo_names_idx\" ON \"foo\"(\"first_name\", \"last_name\");",
-      "CREATE INDEX \"foo_bar_id_idx\" ON \"foo\"(\"bar_id\");",
-      "CREATE INDEX \"foo_coalesce_bar_id_idx\" ON \"foo\"((COALESCE(bar_id, 0)));",
-      "CREATE INDEX \"foo_search_idx\" ON \"foo\" USING \"gin\"(\"search\");",
-      "CREATE INDEX \"foo_names_idx\" ON \"foo\"(\"name\" \"text_pattern_ops\");",
-      "CREATE UNIQUE INDEX CONCURRENTLY \"foo_bar_id_idx\" ON \"foo\"(\"bar_id\" ASC NULLS LAST) WITH (FILLFACTOR = 10) TABLESPACE \"fubar\" WHERE (bar_id IS NOT NULL);",
-      "CREATE INDEX \"foo_bar_id_idx\" ON \"foo\"(\"bar_id\") WHERE (\"foos\".\"id\" IN #{escaped_array});",
+      %{CREATE INDEX "foo_names_idx" ON "foo"("first_name", "last_name");},
+      %{CREATE INDEX "foo_bar_id_idx" ON "foo"("bar_id");},
+      %{CREATE INDEX "foo_coalesce_bar_id_idx" ON "foo"((COALESCE(bar_id, 0)));},
+      %{CREATE INDEX "foo_search_idx" ON "foo" USING "gin"("search");},
+      %{CREATE INDEX "foo_names_idx" ON "foo"("name" "text_pattern_ops");},
+      %{CREATE UNIQUE INDEX CONCURRENTLY "foo_bar_id_idx" ON "foo"("bar_id" ASC NULLS LAST) WITH (FILLFACTOR = 10) TABLESPACE "fubar" WHERE (bar_id IS NOT NULL);},
+      %{CREATE INDEX "foo_bar_id_idx" ON "foo"("bar_id") WHERE ("foos"."id" IN #{escaped_array});}
     ], statements)
   end
 
@@ -58,12 +56,14 @@ class IndexTests < MiniTest::Unit::TestCase
     Mig.drop_index(:foo_names_idx, :if_exists => true)
     Mig.drop_index(:foo_names_idx, :cascade => true)
     Mig.drop_index(:foo_names_idx, :concurrently => true)
+    Mig.drop_index(:foo_names_idx, :bar_names_idx)
 
     assert_equal([
-      "DROP INDEX \"foo_names_idx\";",
-      "DROP INDEX IF EXISTS \"foo_names_idx\";",
-      "DROP INDEX \"foo_names_idx\" CASCADE;",
-      "DROP INDEX CONCURRENTLY \"foo_names_idx\";"
+      %{DROP INDEX "foo_names_idx";},
+      %{DROP INDEX IF EXISTS "foo_names_idx";},
+      %{DROP INDEX "foo_names_idx" CASCADE;},
+      %{DROP INDEX CONCURRENTLY "foo_names_idx";},
+      %{DROP INDEX "foo_names_idx", "bar_names_idx";}
     ], statements)
 
     assert_raises(ArgumentError) do
@@ -79,7 +79,7 @@ class IndexTests < MiniTest::Unit::TestCase
     Mig.rename_index(:foo_names_idx, :foo_renamed_idx)
 
     assert_equal([
-      "ALTER INDEX \"foo_names_idx\" RENAME TO \"foo_renamed_idx\";"
+      %{ALTER INDEX "foo_names_idx" RENAME TO "foo_renamed_idx";}
     ], statements)
   end
 
@@ -87,7 +87,7 @@ class IndexTests < MiniTest::Unit::TestCase
     Mig.alter_index_tablespace(:foo_names_idx, :fubar)
 
     assert_equal([
-      "ALTER INDEX \"foo_names_idx\" SET TABLESPACE \"fubar\";"
+      %{ALTER INDEX "foo_names_idx" SET TABLESPACE "fubar";}
     ], statements)
   end
 end

data/test/languages_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class LanguagesTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class LanguagesTests < PostgreSQLExtensionsTestCase
   def test_create_language
     ARBC.create_language(:foo)
     ARBC.create_language(
@@ -15,8 +13,8 @@ class LanguagesTests < MiniTest::Unit::TestCase
     )
 
     assert_equal([
-      "CREATE PROCEDURAL LANGUAGE \"foo\";",
-      "CREATE TRUSTED PROCEDURAL LANGUAGE \"foo\" HANDLER \"plpgsql\" VALIDATOR test();"
+      %{CREATE PROCEDURAL LANGUAGE "foo";},
+      %{CREATE TRUSTED PROCEDURAL LANGUAGE "foo" HANDLER "plpgsql" VALIDATOR test();}
     ], statements)
   end
 
@@ -25,8 +23,8 @@ class LanguagesTests < MiniTest::Unit::TestCase
     ARBC.drop_language(:foo, :if_exists => true, :cascade => true)
 
     assert_equal([
-      "DROP PROCEDURAL LANGUAGE \"foo\";",
-      "DROP PROCEDURAL LANGUAGE IF EXISTS \"foo\" CASCADE;"
+      %{DROP PROCEDURAL LANGUAGE "foo";},
+      %{DROP PROCEDURAL LANGUAGE IF EXISTS "foo" CASCADE;}
     ], statements)
   end
 
@@ -34,7 +32,7 @@ class LanguagesTests < MiniTest::Unit::TestCase
     ARBC.alter_language_name(:foo, :bar)
 
     assert_equal([
-      "ALTER PROCEDURAL LANGUAGE \"foo\" RENAME TO \"bar\";"
+      %{ALTER PROCEDURAL LANGUAGE "foo" RENAME TO "bar";}
     ], statements)
   end
 
@@ -42,7 +40,26 @@ class LanguagesTests < MiniTest::Unit::TestCase
     ARBC.alter_language_owner(:foo, :bar)
 
     assert_equal([
-      "ALTER PROCEDURAL LANGUAGE \"foo\" OWNER TO \"bar\";"
+      %{ALTER PROCEDURAL LANGUAGE "foo" OWNER TO "bar";}
     ], statements)
   end
+
+  def test_languages
+    ARBC.real_execute do
+      languages = ARBC.languages
+
+      assert_kind_of(Array, languages)
+      assert_includes(languages, "sql")
+      assert_includes(languages, "c")
+      assert_includes(languages, "internal")
+    end
+  end
+
+  def test_language_exists
+    ARBC.real_execute do
+      assert(ARBC.language_exists?("sql"))
+      assert(ARBC.language_exists?("c"))
+      assert(ARBC.language_exists?("internal"))
+    end
+  end
 end

data/test/materialized_views_tests.rb

@@ -0,0 +1,174 @@
+
+$: << File.dirname(__FILE__)
+require "test_helper"
+
+class MaterializedViewsTests < PostgreSQLExtensionsTestCase
+  def test_create_materialized_view
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.create_materialized_view("foos_view", "SELECT * FROM foos")
+    Mig.create_materialized_view("foos_view", "SELECT * FROM foos", :columns => %w{ hello world })
+    Mig.create_materialized_view("foos_view", "SELECT * FROM foos", :tablespace => "foo")
+    Mig.create_materialized_view("foos_view", "SELECT * FROM foos", :with_data => false)
+    Mig.create_materialized_view("foos_view", "SELECT * FROM foos", :with_data => true)
+    Mig.create_materialized_view("foos_view", "SELECT * FROM foos", :with_options => {
+      :fillfactor => 10
+    })
+    Mig.create_materialized_view("foos_view", "SELECT * FROM foos", :with_options => "FILLFACTOR=10")
+    ARBC.create_materialized_view(
+      { :baz => "foos_view" },
+      "SELECT * FROM foos"
+    )
+
+    assert_equal([
+      %{CREATE MATERIALIZED VIEW "foos_view" AS SELECT * FROM foos;},
+      %{CREATE MATERIALIZED VIEW "foos_view" ("hello", "world") AS SELECT * FROM foos;},
+      %{CREATE MATERIALIZED VIEW "foos_view" TABLESPACE "foo" AS SELECT * FROM foos;},
+      %{CREATE MATERIALIZED VIEW "foos_view" AS SELECT * FROM foos WITH NO DATA;},
+      %{CREATE MATERIALIZED VIEW "foos_view" AS SELECT * FROM foos;},
+      %{CREATE MATERIALIZED VIEW "foos_view" WITH ("fillfactor" = 10) AS SELECT * FROM foos;},
+      %{CREATE MATERIALIZED VIEW "foos_view" WITH (FILLFACTOR=10) AS SELECT * FROM foos;},
+      %{CREATE MATERIALIZED VIEW "baz"."foos_view" AS SELECT * FROM foos;}
+    ], statements)
+  end
+
+  def test_drop_materialized_view
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.drop_materialized_view(:foos_view)
+    Mig.drop_materialized_view(:foos_view, :bars_view)
+    Mig.drop_materialized_view(:foos_view, :if_exists => true)
+    Mig.drop_materialized_view(:foos_view, :cascade => true)
+
+    assert_equal([
+      %{DROP MATERIALIZED VIEW "foos_view";},
+      %{DROP MATERIALIZED VIEW "foos_view", "bars_view";},
+      %{DROP MATERIALIZED VIEW IF EXISTS "foos_view";},
+      %{DROP MATERIALIZED VIEW "foos_view" CASCADE;}
+    ], statements)
+  end
+
+  def test_rename_materialized_view
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.rename_materialized_view(:foos_view, :bars_view)
+    ARBC.rename_materialized_view({ :baz => :foos_view }, :bars_view)
+
+    ARBC.with_schema(:blort) do
+      Mig.rename_materialized_view(:foos_view, :bars_view)
+    end
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos_view" RENAME TO "bars_view";},
+      %{ALTER MATERIALIZED VIEW "baz"."foos_view" RENAME TO "bars_view";},
+      %{ALTER MATERIALIZED VIEW "blort"."foos_view" RENAME TO "bars_view";}
+    ], statements)
+  end
+
+  def test_alter_materialized_view_set_column_default
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.alter_materialized_view_set_column_default(:foos, :name, "hello world")
+    Mig.alter_materialized_view_set_column_default(:foos, :name, nil)
+    Mig.alter_materialized_view_set_column_default(:foos, :name, :expression => "1 + 2")
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos" ALTER COLUMN "name" SET DEFAULT 'hello world';},
+      %{ALTER MATERIALIZED VIEW "foos" ALTER COLUMN "name" SET DEFAULT NULL;},
+      %{ALTER MATERIALIZED VIEW "foos" ALTER COLUMN "name" SET DEFAULT 1 + 2;}
+    ], statements)
+  end
+
+  def test_alter_materialized_view_drop_column_default
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.alter_materialized_view_drop_column_default(:foos, :name)
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos" ALTER COLUMN "name" DROP DEFAULT;}
+    ], statements)
+  end
+
+  def test_alter_materialized_view_owner
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.alter_materialized_view_owner(:foos, :joe)
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos" OWNER TO "joe";}
+    ], statements)
+  end
+
+  def test_alter_materialized_view_schema
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.alter_materialized_view_schema(:foos, :bar)
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos" SET SCHEMA "bar";}
+    ], statements)
+  end
+
+  def test_alter_materialized_view_set_options
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.alter_materialized_view_set_options(
+      "foos_view",
+      "security_barrier = true"
+    )
+
+    Mig.alter_materialized_view_set_options(:foos_view,
+      :security_barrier => true
+    )
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos_view" SET (security_barrier = true);},
+      %{ALTER MATERIALIZED VIEW "foos_view" SET ("security_barrier" = 't');}
+    ], statements)
+  end
+
+  def test_alter_materialized_view_reset_options
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.alter_materialized_view_reset_options(:foos_view, :security_barrier)
+    Mig.alter_materialized_view_reset_options(:foos_view, :security_barrier, :foos)
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos_view" RESET ("security_barrier");},
+      %{ALTER MATERIALIZED VIEW "foos_view" RESET ("security_barrier", "foos");}
+    ], statements)
+  end
+
+  def test_cluster_materialized_view
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.cluster_materialized_view(:foos_view, :foo)
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos_view" CLUSTER ON "foo";}
+    ], statements)
+  end
+
+  def test_remove_cluster_from_materialized_view
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.remove_cluster_from_materialized_view(:foos_view)
+
+    assert_equal([
+      %{ALTER MATERIALIZED VIEW "foos_view" SET WITHOUT CLUSTER;}
+    ], statements)
+  end
+
+  def test_refresh_materialized_view
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.refresh_materialized_view(:foos_view)
+    Mig.refresh_materialized_view(:foos_view, :with_data => false)
+
+    assert_equal([
+      %{REFRESH MATERIALIZED VIEW "foos_view";},
+      %{REFRESH MATERIALIZED VIEW "foos_view" WITH NO DATA;}
+    ], statements)
+  end
+end
+

data/test/permissions_tests.rb

@@ -2,24 +2,30 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class PermissionsTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class PermissionsTests < PostgreSQLExtensionsTestCase
   def test_grant_table_privileges
     Mig.grant_table_privileges(:foo, :select, :nobody)
     Mig.grant_table_privileges(:foo, [ :select, :update, :delete, :insert ], [ :nobody, :somebody ])
     Mig.grant_table_privileges(:foo, :select, :nobody, :with_grant_option => true)
     Mig.grant_table_privileges(:foo, :select, :nobody, :cascade => true)
     Mig.grant_table_privileges(:foo, :select, :public, :cascade => true)
+
+    assert_equal([
+      %{GRANT SELECT ON TABLE "foo" TO "nobody";},
+      %{GRANT SELECT, UPDATE, DELETE, INSERT ON TABLE "foo" TO "nobody", "somebody";},
+      %{GRANT SELECT ON TABLE "foo" TO "nobody" WITH GRANT OPTION;},
+      %{GRANT SELECT ON TABLE "foo" TO "nobody";},
+      %{GRANT SELECT ON TABLE "foo" TO PUBLIC;}
+    ], statements)
+  end
+
+  def test_grant_table_privileges_all
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+
     Mig.grant_table_privileges(:foo, :select, :nobody, :all => true)
 
     assert_equal([
-      "GRANT SELECT ON TABLE \"foo\" TO \"nobody\";",
-      "GRANT SELECT, UPDATE, DELETE, INSERT ON TABLE \"foo\" TO \"nobody\", \"somebody\";",
-      "GRANT SELECT ON TABLE \"foo\" TO \"nobody\" WITH GRANT OPTION;",
-      "GRANT SELECT ON TABLE \"foo\" TO \"nobody\";",
-      "GRANT SELECT ON TABLE \"foo\" TO PUBLIC;",
-      "GRANT SELECT ON ALL TABLES IN SCHEMA \"foo\" TO \"nobody\";"
+      %{GRANT SELECT ON ALL TABLES IN SCHEMA "foo" TO "nobody";}
     ], statements)
   end
 
@@ -29,63 +35,135 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.revoke_table_privileges(:foo, :select, :nobody, :with_grant_option => true)
     Mig.revoke_table_privileges(:foo, :select, :nobody, :cascade => true)
     Mig.revoke_table_privileges(:foo, :select, :public, :cascade => true)
+
+    assert_equal([
+      %{REVOKE SELECT ON TABLE "foo" FROM "nobody";},
+      %{REVOKE SELECT, UPDATE, DELETE, INSERT ON TABLE "foo" FROM "nobody", "somebody";},
+      %{REVOKE SELECT ON TABLE "foo" FROM "nobody";},
+      %{REVOKE SELECT ON TABLE "foo" FROM "nobody" CASCADE;},
+      %{REVOKE SELECT ON TABLE "foo" FROM PUBLIC CASCADE;}
+    ], statements)
+  end
+
+  def test_revoke_table_privileges_all
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+
     Mig.revoke_table_privileges(:foo, :select, :nobody, :all => true)
 
     assert_equal([
-      "REVOKE SELECT ON TABLE \"foo\" FROM \"nobody\";",
-      "REVOKE SELECT, UPDATE, DELETE, INSERT ON TABLE \"foo\" FROM \"nobody\", \"somebody\";",
-      "REVOKE SELECT ON TABLE \"foo\" FROM \"nobody\";",
-      "REVOKE SELECT ON TABLE \"foo\" FROM \"nobody\" CASCADE;",
-      "REVOKE SELECT ON TABLE \"foo\" FROM PUBLIC CASCADE;",
-      "REVOKE SELECT ON ALL TABLES IN SCHEMA \"foo\" FROM \"nobody\";"
+      %{REVOKE SELECT ON ALL TABLES IN SCHEMA "foo" FROM "nobody";}
+    ], statements)
+  end
+
+  def test_grant_view_privileges
+    Mig.grant_view_privileges(:foo, :select, :nobody)
+    Mig.grant_view_privileges(:foo, [ :select, :update, :delete, :insert ], [ :nobody, :somebody ])
+    Mig.grant_view_privileges(:foo, :select, :nobody, :with_grant_option => true)
+    Mig.grant_view_privileges(:foo, :select, :nobody, :cascade => true)
+    Mig.grant_view_privileges(:foo, :select, :public, :cascade => true)
+
+    assert_equal([
+      %{GRANT SELECT ON "foo" TO "nobody";},
+      %{GRANT SELECT, UPDATE, DELETE, INSERT ON "foo" TO "nobody", "somebody";},
+      %{GRANT SELECT ON "foo" TO "nobody" WITH GRANT OPTION;},
+      %{GRANT SELECT ON "foo" TO "nobody";},
+      %{GRANT SELECT ON "foo" TO PUBLIC;}
+    ], statements)
+  end
+
+  def test_revoke_view_privileges
+    Mig.revoke_view_privileges(:foo, :select, :nobody)
+    Mig.revoke_view_privileges(:foo, [ :select, :update, :delete, :insert ], [ :nobody, :somebody ])
+    Mig.revoke_view_privileges(:foo, :select, :nobody, :with_grant_option => true)
+    Mig.revoke_view_privileges(:foo, :select, :nobody, :cascade => true)
+    Mig.revoke_view_privileges(:foo, :select, :public, :cascade => true)
+
+    assert_equal([
+      %{REVOKE SELECT ON "foo" FROM "nobody";},
+      %{REVOKE SELECT, UPDATE, DELETE, INSERT ON "foo" FROM "nobody", "somebody";},
+      %{REVOKE SELECT ON "foo" FROM "nobody";},
+      %{REVOKE SELECT ON "foo" FROM "nobody" CASCADE;},
+      %{REVOKE SELECT ON "foo" FROM PUBLIC CASCADE;},
     ], statements)
   end
 
   def test_grant_sequence_privileges
     Mig.grant_sequence_privileges(:foo, :select, :nobody)
     Mig.grant_sequence_privileges(:foo, [ :select, :update ], [ :nobody, :somebody ])
+
+    assert_equal([
+      %{GRANT SELECT ON SEQUENCE "foo" TO "nobody";},
+      %{GRANT SELECT, UPDATE ON SEQUENCE "foo" TO "nobody", "somebody";}
+    ], statements)
+  end
+
+  def test_grant_sequence_privileges_all
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+
     Mig.grant_sequence_privileges(:foo, :select, :nobody, :all => true)
 
     assert_equal([
-      "GRANT SELECT ON SEQUENCE \"foo\" TO \"nobody\";",
-      "GRANT SELECT, UPDATE ON SEQUENCE \"foo\" TO \"nobody\", \"somebody\";",
-      "GRANT SELECT ON ALL SEQUENCES IN SCHEMA \"foo\" TO \"nobody\";"
+      %{GRANT SELECT ON ALL SEQUENCES IN SCHEMA "foo" TO "nobody";}
     ], statements)
   end
 
   def test_revoke_sequence_privileges
     Mig.revoke_sequence_privileges(:foo, :select, :nobody)
     Mig.revoke_sequence_privileges(:foo, [ :select, :update ], [ :nobody, :somebody ])
+
+    assert_equal([
+      %{REVOKE SELECT ON SEQUENCE "foo" FROM "nobody";},
+      %{REVOKE SELECT, UPDATE ON SEQUENCE "foo" FROM "nobody", "somebody";}
+    ], statements)
+  end
+
+  def test_revoke_sequence_privileges_all
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+
     Mig.revoke_sequence_privileges(:foo, :select, :nobody, :all => true)
 
     assert_equal([
-      "REVOKE SELECT ON SEQUENCE \"foo\" FROM \"nobody\";",
-      "REVOKE SELECT, UPDATE ON SEQUENCE \"foo\" FROM \"nobody\", \"somebody\";",
-      "REVOKE SELECT ON ALL SEQUENCES IN SCHEMA \"foo\" FROM \"nobody\";"
+      %{REVOKE SELECT ON ALL SEQUENCES IN SCHEMA "foo" FROM "nobody";}
     ], statements)
   end
 
   def test_grant_function_privileges
     Mig.grant_function_privileges('test(text, integer)', :execute, :nobody)
     Mig.grant_function_privileges('test(text, integer)', :all, [ :nobody, :somebody ])
+
+    assert_equal([
+      %{GRANT EXECUTE ON FUNCTION test(text, integer) TO "nobody";},
+      %{GRANT ALL ON FUNCTION test(text, integer) TO "nobody", "somebody";}
+    ], statements)
+  end
+
+  def test_grant_function_privileges_all
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+
     Mig.grant_function_privileges(:foo, :execute, :nobody, :all => true)
 
     assert_equal([
-      "GRANT EXECUTE ON FUNCTION test(text, integer) TO \"nobody\";",
-      "GRANT ALL ON FUNCTION test(text, integer) TO \"nobody\", \"somebody\";",
-      "GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA \"foo\" TO \"nobody\";",
+      %{GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA "foo" TO "nobody";}
     ], statements)
   end
 
   def test_revoke_function_privileges
     Mig.revoke_function_privileges('test(text, integer)', :execute, :nobody)
     Mig.revoke_function_privileges('test(text, integer)', :all, [ :nobody, :somebody ])
+
+    assert_equal([
+      %{REVOKE EXECUTE ON FUNCTION test(text, integer) FROM "nobody";},
+      %{REVOKE ALL ON FUNCTION test(text, integer) FROM "nobody", "somebody";}
+    ], statements)
+  end
+
+  def test_revoke_function_privileges_all
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+
     Mig.revoke_function_privileges(:foo, :execute, :nobody, :all => true)
 
     assert_equal([
-      "REVOKE EXECUTE ON FUNCTION test(text, integer) FROM \"nobody\";",
-      "REVOKE ALL ON FUNCTION test(text, integer) FROM \"nobody\", \"somebody\";",
-      "REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA \"foo\" FROM \"nobody\";",
+      %{REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA "foo" FROM "nobody";}
     ], statements)
   end
 
@@ -94,8 +172,8 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.grant_language_privileges('plpgsql', :all, [ :nobody, :somebody ])
 
     assert_equal([
-      "GRANT USAGE ON LANGUAGE \"plpgsql\" TO \"nobody\";",
-      "GRANT ALL ON LANGUAGE \"plpgsql\" TO \"nobody\", \"somebody\";"
+      %{GRANT USAGE ON LANGUAGE "plpgsql" TO "nobody";},
+      %{GRANT ALL ON LANGUAGE "plpgsql" TO "nobody", "somebody";}
     ], statements)
   end
 
@@ -104,8 +182,8 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.revoke_language_privileges('plpgsql', :all, [ :nobody, :somebody ])
 
     assert_equal([
-      "REVOKE USAGE ON LANGUAGE \"plpgsql\" FROM \"nobody\";",
-      "REVOKE ALL ON LANGUAGE \"plpgsql\" FROM \"nobody\", \"somebody\";"
+      %{REVOKE USAGE ON LANGUAGE "plpgsql" FROM "nobody";},
+      %{REVOKE ALL ON LANGUAGE "plpgsql" FROM "nobody", "somebody";}
     ], statements)
   end
 
@@ -114,8 +192,8 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.grant_schema_privileges(:foo, :all, [ :nobody, :somebody ])
 
     assert_equal([
-      "GRANT USAGE ON SCHEMA \"foo\" TO \"nobody\";",
-      "GRANT ALL ON SCHEMA \"foo\" TO \"nobody\", \"somebody\";"
+      %{GRANT USAGE ON SCHEMA "foo" TO "nobody";},
+      %{GRANT ALL ON SCHEMA "foo" TO "nobody", "somebody";}
     ], statements)
   end
 
@@ -124,8 +202,8 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.revoke_schema_privileges(:foo, :all, [ :nobody, :somebody ])
 
     assert_equal([
-      "REVOKE USAGE ON SCHEMA \"foo\" FROM \"nobody\";",
-      "REVOKE ALL ON SCHEMA \"foo\" FROM \"nobody\", \"somebody\";"
+      %{REVOKE USAGE ON SCHEMA "foo" FROM "nobody";},
+      %{REVOKE ALL ON SCHEMA "foo" FROM "nobody", "somebody";}
     ], statements)
   end
 
@@ -134,8 +212,8 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.grant_tablespace_privileges(:foo, :all, [ :nobody, :somebody ])
 
     assert_equal([
-      "GRANT CREATE ON TABLESPACE \"foo\" TO \"nobody\";",
-      "GRANT ALL ON TABLESPACE \"foo\" TO \"nobody\", \"somebody\";"
+      %{GRANT CREATE ON TABLESPACE "foo" TO "nobody";},
+      %{GRANT ALL ON TABLESPACE "foo" TO "nobody", "somebody";}
     ], statements)
   end
 
@@ -144,8 +222,44 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.revoke_tablespace_privileges(:foo, :all, [ :nobody, :somebody ])
 
     assert_equal([
-      "REVOKE CREATE ON TABLESPACE \"foo\" FROM \"nobody\";",
-      "REVOKE ALL ON TABLESPACE \"foo\" FROM \"nobody\", \"somebody\";"
+      %{REVOKE CREATE ON TABLESPACE "foo" FROM "nobody";},
+      %{REVOKE ALL ON TABLESPACE "foo" FROM "nobody", "somebody";}
+    ], statements)
+  end
+
+  def test_grant_materialized_view_privileges
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.grant_materialized_view_privileges(:foo, :select, :nobody)
+    Mig.grant_materialized_view_privileges(:foo, [ :select, :update, :delete, :insert ], [ :nobody, :somebody ])
+    Mig.grant_materialized_view_privileges(:foo, :select, :nobody, :with_grant_option => true)
+    Mig.grant_materialized_view_privileges(:foo, :select, :nobody, :cascade => true)
+    Mig.grant_materialized_view_privileges(:foo, :select, :public, :cascade => true)
+
+    assert_equal([
+      %{GRANT SELECT ON "foo" TO "nobody";},
+      %{GRANT SELECT, UPDATE, DELETE, INSERT ON "foo" TO "nobody", "somebody";},
+      %{GRANT SELECT ON "foo" TO "nobody" WITH GRANT OPTION;},
+      %{GRANT SELECT ON "foo" TO "nobody";},
+      %{GRANT SELECT ON "foo" TO PUBLIC;}
+    ], statements)
+  end
+
+  def test_revoke_materialized_view_privileges
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.materialized_views?
+
+    Mig.revoke_materialized_view_privileges(:foo, :select, :nobody)
+    Mig.revoke_materialized_view_privileges(:foo, [ :select, :update, :delete, :insert ], [ :nobody, :somebody ])
+    Mig.revoke_materialized_view_privileges(:foo, :select, :nobody, :with_grant_option => true)
+    Mig.revoke_materialized_view_privileges(:foo, :select, :nobody, :cascade => true)
+    Mig.revoke_materialized_view_privileges(:foo, :select, :public, :cascade => true)
+
+    assert_equal([
+      %{REVOKE SELECT ON "foo" FROM "nobody";},
+      %{REVOKE SELECT, UPDATE, DELETE, INSERT ON "foo" FROM "nobody", "somebody";},
+      %{REVOKE SELECT ON "foo" FROM "nobody";},
+      %{REVOKE SELECT ON "foo" FROM "nobody" CASCADE;},
+      %{REVOKE SELECT ON "foo" FROM PUBLIC CASCADE;}
     ], statements)
   end
 
@@ -155,9 +269,9 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.grant_role_membership(:foo, [ :nobody, :somebody ], :with_admin_option => true)
 
     assert_equal([
-      "GRANT \"foo\" TO \"nobody\";",
-      "GRANT \"foo\" TO \"nobody\", \"somebody\";",
-      "GRANT \"foo\" TO \"nobody\", \"somebody\" WITH ADMIN OPTION;"
+      %{GRANT "foo" TO "nobody";},
+      %{GRANT "foo" TO "nobody", "somebody";},
+      %{GRANT "foo" TO "nobody", "somebody" WITH ADMIN OPTION;}
     ], statements)
   end
 
@@ -167,9 +281,9 @@ class PermissionsTests < MiniTest::Unit::TestCase
     Mig.revoke_role_membership(:foo, [ :nobody, :somebody ], :with_admin_option => true)
 
     assert_equal([
-      "REVOKE \"foo\" FROM \"nobody\";",
-      "REVOKE \"foo\" FROM \"nobody\", \"somebody\";",
-      "REVOKE \"foo\" FROM \"nobody\", \"somebody\";"
+      %{REVOKE "foo" FROM "nobody";},
+      %{REVOKE "foo" FROM "nobody", "somebody";},
+      %{REVOKE "foo" FROM "nobody", "somebody";}
     ], statements)
   end
 end