activerecord-postgresql-extensions 0.2.2 → 0.3.0

data/test/tablespace_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class TablespaceTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class TablespaceTests < PostgreSQLExtensionsTestCase
   def test_create_tablespace
     Mig.create_tablespace('foo', '/tmp/foo')
     Mig.create_tablespace('foo', '/tmp/foo', :owner => :bar)
@@ -41,23 +39,31 @@ class TablespaceTests < MiniTest::Unit::TestCase
     ], statements)
   end
 
-  def test_alter_tablespace_paramters
+  def test_alter_tablespace_parameters
     Mig.alter_tablespace_parameters('foo', :seq_page_cost => 2.0, :random_page_cost => 5.0)
 
-    assert_equal([
-      %{ALTER TABLESPACE "foo" SET (
-  "seq_page_cost" = 2.0,
-  "random_page_cost" = 5.0
-);} ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER TABLESPACE "foo" SET (
+        "seq_page_cost" = 2.0,
+        "random_page_cost" = 5.0
+      );
+    SQL
   end
 
-  def test_reset_tablespace_paramters
+  def test_reset_tablespace_parameters
     Mig.reset_tablespace_parameters('foo', :seq_page_cost, :random_page_cost)
 
-    assert_equal([
-      %{ALTER TABLESPACE "foo" RESET (
-  "seq_page_cost",
-  "random_page_cost"
-);} ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      ALTER TABLESPACE "foo" RESET (
+        "seq_page_cost",
+        "random_page_cost"
+      );
+    SQL
+  end
+
+  def test_invalid_tablespace_parameters
+    assert_raises(ActiveRecord::InvalidTablespaceParameter) do
+      Mig.alter_tablespace_parameters('foo', :blart => 2.0)
+    end
   end
 end

data/test/test_helper.rb

@@ -1,9 +1,15 @@
 
-ACTIVERECORD_GEM_VERSION = ENV['ACTIVERECORD_GEM_VERSION'] || '~> 3.2.0'
 
-require 'rubygems'
-gem 'activerecord', ACTIVERECORD_GEM_VERSION
+if RUBY_VERSION >= '1.9'
+  require 'simplecov'
+
+  SimpleCov.command_name('Unit Tests')
+  SimpleCov.start do
+    add_filter '/test/'
+  end
+end
 
+require 'rubygems'
 require 'active_record'
 require 'logger'
 require 'minitest/autorun'
@@ -41,6 +47,7 @@ end
 ActiveRecord::Base.establish_connection 'arunit'
 ARBC = ActiveRecord::Base.connection
 
+puts "Ruby version #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} - #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}"
 puts "Testing against ActiveRecord #{Gem.loaded_specs['activerecord'].version.to_s}"
 if postgresql_version = ActiveRecord::PostgreSQLExtensions.SERVER_VERSION
   puts "PostgreSQL info from pg_catalog.version(): #{postgresql_version}"
@@ -53,29 +60,45 @@ else
 end
 
 class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+  def real_execute
+    @real_execute = true
+    yield
+  ensure
+    @real_execute = false
+  end
+
   def execute_with_statement_capture(*args)
     PostgreSQLExtensionsTestHelper.add_statement(args.first)
 
-    if RUBY_PLATFORM == 'java'
-      if args.first =~ /pg_tables/
-        return execute_without_statement_capture(*args)
+    if @real_execute
+      execute_without_statement_capture(*args)
+    else
+      if RUBY_PLATFORM == 'java'
+        if args.first =~ /pg_tables/
+          return execute_without_statement_capture(*args)
+        end
       end
-    end
 
-    args.first
+      args.first
+    end
   end
   alias_method_chain :execute, :statement_capture
 
   unless RUBY_PLATFORM == 'java'
     def query_with_statement_capture(*args)
-      PostgreSQLExtensionsTestHelper.add_statement(args.first)
-      #query_without_statement_capture(*args)
+      if @real_execute
+        query_without_statement_capture(*args)
+      else
+        PostgreSQLExtensionsTestHelper.add_statement(args.first)
+      end
     end
     alias_method_chain :query, :statement_capture
   end
 end
 
 module PostgreSQLExtensionsTestHelper
+  include ActiveRecord::PostgreSQLExtensions::Utils
+
   class << self
     def statements
       @statements ||= []
@@ -123,6 +146,29 @@ end
 class Foo < ActiveRecord::Base
 end
 
+class PostgreSQLExtensionsTestCase < ActiveRecord::TestCase
+  include ActiveRecord::TestFixtures
+  include PostgreSQLExtensionsTestHelper
+
+  attr_writer :tagged_logger
+
+  def before_setup
+    if tagged_logger
+      heading = "#{self.class}: #{__name__}"
+      divider = '-' * heading.size
+      tagged_logger.info divider
+      tagged_logger.info heading
+      tagged_logger.info divider
+    end
+    super
+  end
+
+  private
+    def tagged_logger
+      @tagged_logger ||= (defined?(ActiveRecord::Base.logger) && ActiveRecord::Base.logger)
+    end
+end
+
 if RUBY_VERSION >= '1.9'
   MiniTest::Reporters.use!(MiniTest::Reporters::SpecReporter.new)
 end

data/test/text_search_tests.rb

@@ -2,18 +2,16 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class TextSearchTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class TextSearchTests < PostgreSQLExtensionsTestCase
   def test_create_text_search_configuration
     ARBC.create_text_search_configuration(:foo, :parser_name => 'bar')
     ARBC.create_text_search_configuration(:foo, :source_config => 'bar')
     ARBC.create_text_search_configuration(:foo, :source_config => { :pg_catalog => 'english' })
 
     assert_equal([
-      "CREATE TEXT SEARCH CONFIGURATION \"foo\" (PARSER = \"bar\");",
-      "CREATE TEXT SEARCH CONFIGURATION \"foo\" (COPY = \"bar\");",
-      "CREATE TEXT SEARCH CONFIGURATION \"foo\" (COPY = \"pg_catalog\".\"english\");"
+      %{CREATE TEXT SEARCH CONFIGURATION "foo" (PARSER = "bar");},
+      %{CREATE TEXT SEARCH CONFIGURATION "foo" (COPY = "bar");},
+      %{CREATE TEXT SEARCH CONFIGURATION "foo" (COPY = "pg_catalog"."english");}
     ], statements)
 
     assert_raises(ArgumentError) do
@@ -30,8 +28,8 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.add_text_search_configuration_mapping(:foo, [ :asciiword, :word ], [ :bar, :up ])
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" ADD MAPPING FOR \"asciiword\" WITH \"bar\";",
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" ADD MAPPING FOR \"asciiword\", \"word\" WITH \"bar\", \"up\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" ADD MAPPING FOR "asciiword" WITH "bar";},
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" ADD MAPPING FOR "asciiword", "word" WITH "bar", "up";}
     ], statements)
   end
 
@@ -40,8 +38,8 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_configuration_mapping(:foo, [ :asciiword, :word ], [ :bar, :up ])
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" ALTER MAPPING FOR \"asciiword\" WITH \"bar\";",
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" ALTER MAPPING FOR \"asciiword\", \"word\" WITH \"bar\", \"up\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" ALTER MAPPING FOR "asciiword" WITH "bar";},
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" ALTER MAPPING FOR "asciiword", "word" WITH "bar", "up";}
     ], statements)
   end
 
@@ -49,7 +47,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.replace_text_search_configuration_dictionary(:foo, :bar, :ometer)
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" ALTER MAPPING REPLACE \"bar\" WITH \"ometer\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" ALTER MAPPING REPLACE "bar" WITH "ometer";}
     ], statements)
   end
 
@@ -58,8 +56,8 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_configuration_mapping_replace_dictionary(:foo, [ :hello, :world ], :old, :new)
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" ALTER MAPPING FOR \"bar\" REPLACE \"old\" WITH \"new\";",
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" ALTER MAPPING FOR \"hello\", \"world\" REPLACE \"old\" WITH \"new\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" ALTER MAPPING FOR "bar" REPLACE "old" WITH "new";},
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" ALTER MAPPING FOR "hello", "world" REPLACE "old" WITH "new";}
     ], statements)
   end
 
@@ -69,9 +67,9 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.drop_text_search_configuration_mapping(:foo, :bar, :if_exists => true)
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" DROP MAPPING FOR \"bar\";",
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" DROP MAPPING FOR \"bar\", \"blort\";",
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" DROP MAPPING IF EXISTS FOR \"bar\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" DROP MAPPING FOR "bar";},
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" DROP MAPPING FOR "bar", "blort";},
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" DROP MAPPING IF EXISTS FOR "bar";}
     ], statements)
 
     assert_raises(ArgumentError) do
@@ -87,7 +85,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.rename_text_search_configuration(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" RENAME TO \"bar\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" RENAME TO "bar";}
     ], statements)
   end
 
@@ -95,7 +93,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_configuration_owner(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" OWNER TO \"bar\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" OWNER TO "bar";}
     ], statements)
   end
 
@@ -103,7 +101,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_configuration_schema(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH CONFIGURATION \"foo\" SET SCHEMA \"bar\";"
+      %{ALTER TEXT SEARCH CONFIGURATION "foo" SET SCHEMA "bar";}
     ], statements)
   end
 
@@ -113,9 +111,9 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.drop_text_search_configuration(:foo, :if_exists => true, :cascade => true)
 
     assert_equal([
-      "DROP TEXT SEARCH CONFIGURATION \"foo\";",
-      "DROP TEXT SEARCH CONFIGURATION \"foo\".\"bar\";",
-      "DROP TEXT SEARCH CONFIGURATION IF EXISTS \"foo\" CASCADE;"
+      %{DROP TEXT SEARCH CONFIGURATION "foo";},
+      %{DROP TEXT SEARCH CONFIGURATION "foo"."bar";},
+      %{DROP TEXT SEARCH CONFIGURATION IF EXISTS "foo" CASCADE;}
     ], statements)
   end
 
@@ -124,8 +122,8 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.create_text_search_dictionary(:foo, { :pg_catalog => :snowball }, { :language => 'english' })
 
     assert_equal([
-      "CREATE TEXT SEARCH DICTIONARY \"foo\" (TEMPLATE = \"bar\", \"language\" = 'english');",
-      "CREATE TEXT SEARCH DICTIONARY \"foo\" (TEMPLATE = \"pg_catalog\".\"snowball\", \"language\" = 'english');"
+      %{CREATE TEXT SEARCH DICTIONARY "foo" (TEMPLATE = "bar", "language" = 'english');},
+      %{CREATE TEXT SEARCH DICTIONARY "foo" (TEMPLATE = "pg_catalog"."snowball", "language" = 'english');}
     ], statements)
   end
 
@@ -135,9 +133,9 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.drop_text_search_dictionary(:foo, :if_exists => true, :cascade => true)
 
     assert_equal([
-      "DROP TEXT SEARCH DICTIONARY \"foo\";",
-      "DROP TEXT SEARCH DICTIONARY \"foo\".\"bar\";",
-      "DROP TEXT SEARCH DICTIONARY IF EXISTS \"foo\" CASCADE;"
+      %{DROP TEXT SEARCH DICTIONARY "foo";},
+      %{DROP TEXT SEARCH DICTIONARY "foo"."bar";},
+      %{DROP TEXT SEARCH DICTIONARY IF EXISTS "foo" CASCADE;}
     ], statements)
   end
 
@@ -145,7 +143,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.rename_text_search_dictionary(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH DICTIONARY \"foo\" RENAME TO \"bar\";"
+      %{ALTER TEXT SEARCH DICTIONARY "foo" RENAME TO "bar";}
     ], statements)
   end
 
@@ -153,7 +151,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_dictionary_owner(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH DICTIONARY \"foo\" OWNER TO \"bar\";"
+      %{ALTER TEXT SEARCH DICTIONARY "foo" OWNER TO "bar";}
     ], statements)
   end
 
@@ -161,7 +159,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_dictionary_schema(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH DICTIONARY \"foo\" SET SCHEMA \"bar\";"
+      %{ALTER TEXT SEARCH DICTIONARY "foo" SET SCHEMA "bar";}
     ], statements)
   end
 
@@ -170,8 +168,8 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.create_text_search_template(:foo, :lexize => 'bar', :init => 'lol')
 
     assert_equal([
-      "CREATE TEXT SEARCH TEMPLATE \"foo\" (LEXIZE = \"bar\");",
-      "CREATE TEXT SEARCH TEMPLATE \"foo\" (INIT = \"lol\", LEXIZE = \"bar\");"
+      %{CREATE TEXT SEARCH TEMPLATE "foo" (LEXIZE = "bar");},
+      %{CREATE TEXT SEARCH TEMPLATE "foo" (INIT = "lol", LEXIZE = "bar");}
     ], statements)
 
     assert_raises(ArgumentError) do
@@ -185,9 +183,9 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.drop_text_search_template(:foo, :if_exists => true, :cascade => true)
 
     assert_equal([
-      "DROP TEXT SEARCH TEMPLATE \"foo\";",
-      "DROP TEXT SEARCH TEMPLATE \"foo\".\"bar\";",
-      "DROP TEXT SEARCH TEMPLATE IF EXISTS \"foo\" CASCADE;"
+      %{DROP TEXT SEARCH TEMPLATE "foo";},
+      %{DROP TEXT SEARCH TEMPLATE "foo"."bar";},
+      %{DROP TEXT SEARCH TEMPLATE IF EXISTS "foo" CASCADE;}
     ], statements)
   end
 
@@ -195,7 +193,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.rename_text_search_template(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH TEMPLATE \"foo\" RENAME TO \"bar\";"
+      %{ALTER TEXT SEARCH TEMPLATE "foo" RENAME TO "bar";}
     ], statements)
   end
 
@@ -203,7 +201,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_template_schema(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH TEMPLATE \"foo\" SET SCHEMA \"bar\";"
+      %{ALTER TEXT SEARCH TEMPLATE "foo" SET SCHEMA "bar";}
     ], statements)
   end
 
@@ -224,8 +222,8 @@ class TextSearchTests < MiniTest::Unit::TestCase
     })
 
     assert_equal([
-      "CREATE TEXT SEARCH PARSER \"foo\" (START = \"start\", GETTOKEN = \"gettoken\", END = \"end\", LEXTYPES = \"lextypes\");",
-      "CREATE TEXT SEARCH PARSER \"foo\" (START = \"start\", GETTOKEN = \"gettoken\", END = \"end\", LEXTYPES = \"lextypes\", HEADLINE = \"headline\");"
+      %{CREATE TEXT SEARCH PARSER "foo" (START = "start", GETTOKEN = "gettoken", END = "end", LEXTYPES = "lextypes");},
+      %{CREATE TEXT SEARCH PARSER "foo" (START = "start", GETTOKEN = "gettoken", END = "end", LEXTYPES = "lextypes", HEADLINE = "headline");}
     ], statements)
 
     assert_raises(ArgumentError) do
@@ -239,9 +237,9 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.drop_text_search_parser(:foo, :if_exists => true, :cascade => true)
 
     assert_equal([
-      "DROP TEXT SEARCH PARSER \"foo\";",
-      "DROP TEXT SEARCH PARSER \"foo\".\"bar\";",
-      "DROP TEXT SEARCH PARSER IF EXISTS \"foo\" CASCADE;"
+      %{DROP TEXT SEARCH PARSER "foo";},
+      %{DROP TEXT SEARCH PARSER "foo"."bar";},
+      %{DROP TEXT SEARCH PARSER IF EXISTS "foo" CASCADE;}
     ], statements)
   end
 
@@ -249,7 +247,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.rename_text_search_parser(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH PARSER \"foo\" RENAME TO \"bar\";"
+      %{ALTER TEXT SEARCH PARSER "foo" RENAME TO "bar";}
     ], statements)
   end
 
@@ -257,7 +255,7 @@ class TextSearchTests < MiniTest::Unit::TestCase
     ARBC.alter_text_search_parser_schema(:foo, :bar)
 
     assert_equal([
-      "ALTER TEXT SEARCH PARSER \"foo\" SET SCHEMA \"bar\";"
+      %{ALTER TEXT SEARCH PARSER "foo" SET SCHEMA "bar";}
     ], statements)
   end
 end

data/test/trigger_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class TriggerTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class TriggerTests < PostgreSQLExtensionsTestCase
   def test_enable_triggers
     Foo.enable_triggers
     Foo.enable_triggers(:bar)

data/test/types_tests.rb

@@ -0,0 +1,95 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class TypesTests < PostgreSQLExtensionsTestCase
+  def test_types
+    types = ARBC.real_execute do
+      ARBC.types
+    end
+
+    assert_kind_of(Array, types)
+    assert_includes(types, 'oid')
+  end
+
+  def test_type_exists
+    ARBC.real_execute do
+      assert(ARBC.type_exists?(:oid))
+      assert(ARBC.type_exists?('oid'))
+    end
+  end
+
+  class EnumTests < PostgreSQLExtensionsTestCase
+    def setup
+      ARBC.real_execute do
+        Mig.drop_type(:foo_enum, :if_exists => true)
+      end
+
+      super
+    end
+
+    def test_create_enum
+      Mig.create_enum(:foo_enum)
+      Mig.create_enum(:foo_enum, %w{ one two three })
+      Mig.create_enum(:foo_enum, :one, :two, :three)
+
+      assert_equal([
+        %{CREATE TYPE "foo_enum" AS ENUM ();},
+        %{CREATE TYPE "foo_enum" AS ENUM ('one', 'two', 'three');},
+        %{CREATE TYPE "foo_enum" AS ENUM ('one', 'two', 'three');}
+      ], statements)
+    end
+
+    def test_add_enum_value
+      Mig.create_enum(:foo_enum)
+      Mig.add_enum_value(:foo_enum, :foo)
+      Mig.add_enum_value(:foo_enum, :bar, :before => :foo)
+      Mig.add_enum_value(:foo_enum, :blort, :after => :foo)
+
+      assert_equal([
+        %{CREATE TYPE "foo_enum" AS ENUM ();},
+        %{ALTER TYPE "foo_enum" ADD VALUE 'foo';},
+        %{ALTER TYPE "foo_enum" ADD VALUE 'bar' BEFORE 'foo';},
+        %{ALTER TYPE "foo_enum" ADD VALUE 'blort' AFTER 'foo';}
+      ], statements)
+    end
+
+    def test_add_enum_value_if_not_exists
+      skip unless ActiveRecord::PostgreSQLExtensions.SERVER_VERSION >= '9.3'
+
+      Mig.add_enum_value(:foo_enum, :baz, :if_not_exists => true)
+
+      assert_equal([
+        %{ALTER TYPE "foo_enum" ADD VALUE IF NOT EXISTS 'baz';}
+      ], statements)
+    end
+
+    def test_drop_type
+      Mig.drop_type(:foo_enum)
+      Mig.drop_type(:foo_enum, :if_exists => true)
+      Mig.drop_type(:foo_enum, :cascade => true)
+      Mig.drop_type(:foo_enum, :bar_enum)
+
+      assert_equal([
+        %{DROP TYPE "foo_enum";},
+        %{DROP TYPE IF EXISTS "foo_enum";},
+        %{DROP TYPE "foo_enum" CASCADE;},
+        %{DROP TYPE "foo_enum", "bar_enum";}
+      ], statements)
+    end
+
+    def test_enum_values
+      ARBC.real_execute do
+        Mig.create_enum(:foo_enum, :one, :two, :three)
+
+        assert_equal(%w{ one two three }, ARBC.enum_values(:foo_enum))
+      end
+    end
+
+    def test_both_before_and_after_add_enum_value
+      assert_raises(ActiveRecord::InvalidAddEnumValueOptions) do
+        Mig.add_enum_value(:foo_enum, :blort, :after => :foo, :before => :bar)
+      end
+    end
+  end
+end