activerecord-postgresql-extensions 0.0.7

data/test/functions_test.rb

@@ -0,0 +1,112 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class FunctionsTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def test_create_function
+    Mig.create_function(:test, :integer, :integer, :sql) do
+      "select 10;"
+    end
+
+    Mig.create_function(:test, :integer, :integer, :sql, {
+      :force => true,
+      :delimiter => '$__$',
+      :behavior => :immutable,
+      :on_null_input => :strict,
+      :cost => 1,
+      :rows => 10,
+      :set => {
+        'TIME ZONE' => 'America/Halifax'
+      }
+    }) do
+      "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)
+  end
+
+  def test_drop_function
+    Mig.drop_function(:test, :integer)
+    Mig.drop_function(:test, :integer, :if_exists => true, :cascade => true)
+
+    assert_equal([
+      "DROP FUNCTION \"test\"(integer)",
+      "DROP FUNCTION IF EXISTS \"test\"(integer) CASCADE"
+    ], statements)
+  end
+
+  def test_rename_function
+    Mig.rename_function(:test, 'integer, text', :foo)
+
+    assert_equal([
+      "ALTER FUNCTION \"test\"(integer, text) RENAME TO \"foo\""
+    ], statements)
+  end
+
+  def test_alter_function_owner
+    Mig.alter_function_owner(:test, 'integer, text', :admin)
+
+    assert_equal([
+      "ALTER FUNCTION \"test\"(integer, text) OWNER TO \"admin\""
+    ], statements)
+  end
+
+  def test_alter_function_schema
+    Mig.alter_function_schema(:test, 'integer, text', :geospatial)
+
+    assert_equal([
+      "ALTER FUNCTION \"test\"(integer, text) SET SCHEMA \"geospatial\""
+    ], statements)
+  end
+
+  def test_alter_function
+    Mig.alter_function('my_function', 'integer', :rename_to => 'another_function')
+    Mig.alter_function('another_function', 'integer', :owner_to => 'jdoe')
+    Mig.alter_function('my_function', 'integer') do |f|
+      f.rename_to 'another_function'
+      f.owner_to 'jdoe'
+      f.set_schema 'foo'
+      f.behavior 'immutable'
+      f.security 'invoker'
+      f.cost 10
+      f.rows 10
+      f.set({
+        :log_duration => 0.4
+      })
+      f.reset :all
+      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)
+  end
+end

data/test/geometry_test.rb

@@ -0,0 +1,43 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+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" (
+  "id" serial primary key,
+  "the_geom" geometry,
+  CONSTRAINT "enforce_srid_the_geom" CHECK (srid("the_geom") = (4326)),
+  CONSTRAINT "enforce_dims_the_geom" CHECK (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 "foo" USING "gist"("the_geom")}
+    ], statements)
+  end
+
+  def test_create_geometry_with_schema
+    Mig.create_table('public.foo') do |t|
+      t.geometry :the_geom, :srid => 4326
+    end
+
+    assert_equal([
+      %{CREATE TABLE "public"."foo" (
+  "id" serial primary key,
+  "the_geom" geometry,
+  CONSTRAINT "enforce_srid_the_geom" CHECK (srid("the_geom") = (4326)),
+  CONSTRAINT "enforce_dims_the_geom" CHECK (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 "foo" USING "gist"("the_geom")}
+    ], statements)
+  end
+end

data/test/index_test.rb

@@ -0,0 +1,68 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class IndexTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  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)
+    Mig.create_index(:foo_coalesce_bar_id_idx, :foo, :expression => 'COALESCE(bar_id, 0)')
+    Mig.create_index(:foo_search_idx, :foo, :search, :using => :gin)
+
+    Mig.create_index(:foo_names_idx, :foo, {
+      :column => :name,
+      :opclass => 'text_pattern_ops'
+    })
+
+    Mig.create_index(:foo_bar_id_idx, :foo, {
+      :column => :bar_id,
+      :order => :asc,
+      :nulls => :last
+    }, {
+      :fill_factor => 10,
+      :unique => true,
+      :concurrently => true,
+      :tablespace => 'fubar',
+      :conditions => 'bar_id IS NOT NULL'
+    })
+
+    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"
+    ], statements)
+  end
+
+  def test_drop_index
+    Mig.drop_index(:foo_names_idx)
+    Mig.drop_index(:foo_names_idx, :if_exists => true)
+    Mig.drop_index(:foo_names_idx, :cascade => true)
+
+    assert_equal([
+      "DROP INDEX \"foo_names_idx\"",
+      "DROP INDEX IF EXISTS \"foo_names_idx\"",
+      "DROP INDEX \"foo_names_idx\" CASCADE"
+    ], statements)
+  end
+
+  def test_rename_index
+    Mig.rename_index(:foo_names_idx, :foo_renamed_idx)
+
+    assert_equal([
+      "ALTER INDEX \"foo_names_idx\" RENAME TO \"foo_renamed_idx\""
+    ], statements)
+  end
+
+  def test_alter_index_tablespace
+    Mig.alter_index_tablespace(:foo_names_idx, :fubar)
+
+    assert_equal([
+      "ALTER INDEX \"foo_names_idx\" SET TABLESPACE \"fubar\""
+    ], statements)
+  end
+end

data/test/languages_test.rb

@@ -0,0 +1,48 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class LanguagesTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def test_create_language
+    Mig.create_language(:foo)
+    Mig.create_language(
+      :foo,
+      :trusted => true,
+      :call_handler => 'plpgsql',
+      :validator => 'test()'
+    )
+
+    assert_equal([
+      "CREATE PROCEDURAL LANGUAGE \"foo\"",
+      "CREATE TRUSTED PROCEDURAL LANGUAGE \"foo\" HANDLER \"plpgsql\" VALIDATOR test()"
+    ], statements)
+  end
+
+  def test_drop_language
+    Mig.drop_language(:foo)
+    Mig.drop_language(:foo, :if_exists => true, :cascade => true)
+
+    assert_equal([
+      "DROP PROCEDURAL LANGUAGE \"foo\"",
+      "DROP PROCEDURAL LANGUAGE IF EXISTS \"foo\" CASCADE"
+    ], statements)
+  end
+
+  def test_alter_language_name
+    Mig.alter_language_name(:foo, :bar)
+
+    assert_equal([
+      "ALTER PROCEDURAL LANGUAGE \"foo\" RENAME TO \"bar\""
+    ], statements)
+  end
+
+  def test_alter_language_owner
+    Mig.alter_language_owner(:foo, :bar)
+
+    assert_equal([
+      "ALTER PROCEDURAL LANGUAGE \"foo\" OWNER TO \"bar\""
+    ], statements)
+  end
+end

data/test/permissions_test.rb

@@ -0,0 +1,163 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class PermissionsTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  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_revoke_table_privileges
+    Mig.revoke_table_privileges(:foo, :select, :nobody)
+    Mig.revoke_table_privileges(:foo, [ :select, :update, :delete, :insert ], [ :nobody, :somebody ])
+    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_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_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_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_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_grant_language_privileges
+    Mig.grant_language_privileges('plpgsql', :usage, :nobody)
+    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\""
+    ], statements)
+  end
+
+  def test_revoke_language_privileges
+    Mig.revoke_language_privileges('plpgsql', :usage, :nobody)
+    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\""
+    ], statements)
+  end
+
+  def test_grant_schema_privileges
+    Mig.grant_schema_privileges(:foo, :usage, :nobody)
+    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\""
+    ], statements)
+  end
+
+  def test_revoke_schema_privileges
+    Mig.revoke_schema_privileges(:foo, :usage, :nobody)
+    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\""
+    ], statements)
+  end
+
+  def test_grant_tablespace_privileges
+    Mig.grant_tablespace_privileges(:foo, :create, :nobody)
+    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\""
+    ], statements)
+  end
+
+  def test_revoke_tablespace_privileges
+    Mig.revoke_tablespace_privileges(:foo, :create, :nobody)
+    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\""
+    ], statements)
+  end
+
+  def test_grant_role_membership
+    Mig.grant_role_membership(:foo, :nobody)
+    Mig.grant_role_membership(:foo, [ :nobody, :somebody ])
+    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"
+    ], statements)
+  end
+
+  def test_revoke_role_membership
+    Mig.revoke_role_membership(:foo, :nobody)
+    Mig.revoke_role_membership(:foo, [ :nobody, :somebody ])
+    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\""
+    ], statements)
+  end
+end

data/test/rules_test.rb

@@ -0,0 +1,32 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class RulesTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def test_create_rule
+    Mig.create_rule(
+      :ignore_root, :update, :users, :instead, :nothing, :conditions => 'user_id = 0'
+    )
+    Mig.create_rule(
+      :ignore_root, :update, :users, :instead, 'SELECT * FROM non_admins', {
+        :force => true,
+        :conditions => 'user_id > 0'
+      }
+    )
+
+    assert_equal([
+      "CREATE RULE \"ignore_root\" AS ON UPDATE TO \"users\" WHERE user_id = 0 DO INSTEAD NOTHING",
+      "CREATE  OR REPLACE RULE \"ignore_root\" AS ON UPDATE TO \"users\" WHERE user_id > 0 DO INSTEAD SELECT * FROM non_admins"
+    ], statements)
+  end
+
+  def test_drop_rule
+    Mig.drop_rule(:foo, :bar)
+
+    assert_equal([
+      "DROP RULE \"foo\" ON \"bar\"",
+    ], statements)
+  end
+end