postgres_ext 1.0.0 → 2.0.0

data/spec/migrations/array_spec.rb

@@ -1,214 +0,0 @@
-require 'spec_helper'
-
-describe 'Array migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-
-  context 'New Table' do
-    after { connection.drop_table :data_types }
-    describe 'Create table methods' do
-      it 'creates an array column' do
-        lambda do
-          connection.create_table :data_types do |t|
-            t.cidr :array_1, :array => true
-            t.cidr :array_2, :array_3, :array => true
-            t.column :array_4, :cidr, :array => true
-          end
-        end.should_not raise_exception
-
-        columns = connection.columns(:data_types)
-
-        array_1 = columns.detect { |c| c.name == 'array_1'}
-        array_2 = columns.detect { |c| c.name == 'array_2'}
-        array_3 = columns.detect { |c| c.name == 'array_3'}
-        array_4 = columns.detect { |c| c.name == 'array_4'}
-
-        array_1.sql_type.should eq 'cidr[]'
-        array_2.sql_type.should eq 'cidr[]'
-        array_3.sql_type.should eq 'cidr[]'
-        array_4.sql_type.should eq 'cidr[]'
-      end
-    end
-  end
-
-  context 'Existing Table' do
-    before { connection.create_table :data_types }
-    after  { connection.drop_table   :data_types }
-    describe 'Add Column' do
-      context 'no default' do
-        it 'creates an array column' do
-          lambda do
-            connection.add_column :data_types, :array_5, :cidr, :array => true
-          end.should_not raise_exception
-
-          columns = connection.columns(:data_types)
-
-          array_5 = columns.detect { |c| c.name == 'array_5'}
-          array_5.sql_type.should eq 'cidr[]'
-        end
-      end
-
-      context 'with default' do
-        it 'creates an array column' do
-          lambda do
-            connection.add_column :data_types, :array_6, :integer, :array => true, :default => []
-          end.should_not raise_exception
-
-          columns = connection.columns(:data_types)
-
-          array_6 = columns.detect { |c| c.name == 'array_6'}
-          array_6.sql_type.should eq 'integer[]'
-        end
-      end
-
-    end
-
-    describe 'Change table methods' do
-      it 'creates an array column' do
-        lambda do
-          connection.change_table :data_types do |t|
-            t.column :array_6, :cidr, :array => true
-            t.cidr :array_7, :array => true
-          end
-        end.should_not raise_exception
-
-        columns = connection.columns(:data_types)
-
-        array_6 = columns.detect { |c| c.name == 'array_6'}
-        array_7 = columns.detect { |c| c.name == 'array_7'}
-
-        array_6.sql_type.should eq 'cidr[]'
-        array_7.sql_type.should eq 'cidr[]'
-      end
-    end
-  end
-
-  context 'Change Column' do
-    describe 'Change with column existing as array' do
-      after { connection.drop_table :data_types }
-      it 'updates the column definitions' do
-        lambda do
-          connection.create_table :data_types do |t|
-            t.integer :array_1, :array => true, :default => []
-          end
-
-          connection.change_column :data_types, :array_1, :integer, :array => true, :default => [], :null => false
-        end.should_not raise_exception
-
-        columns = connection.columns(:data_types)
-
-        array_1 = columns.detect { |c| c.name == 'array_1'}
-        array_1.sql_type.should eq 'integer[]'
-        array_1.default.should  eq []
-        array_1.null.should     be_false
-      end
-    end
-
-    describe 'Change string column to array' do
-      after { connection.drop_table :data_types }
-      it 'updates the column definitions' do
-        lambda do
-          connection.create_table :data_types do |t|
-            t.string :string_1
-          end
-
-          connection.exec_query "INSERT INTO data_types (string_1) VALUES ('some,values,here')"
-          connection.change_column :data_types, :string_1, :string, :array => true, :default => [], :null => false
-        end.should_not raise_exception
-
-        columns = connection.columns(:data_types)
-
-        string_1 = columns.detect { |c| c.name == 'string_1'}
-        string_1.sql_type.should eq 'character varying(255)[]'
-        string_1.default.should  eq []
-        string_1.null.should     be_false
-
-        new_string_value = connection.exec_query "SELECT array_length(string_1, 1) FROM data_types LIMIT 1"
-        if RUBY_PLATFORM =~ /java/
-          new_string_value.first['array_length'].should eq 3
-        else
-          new_string_value.rows.first.should == ['3']
-        end
-      end
-    end
-
-    describe 'Change text column to array' do
-      after { connection.drop_table :data_types }
-      it 'updates the column definitions' do
-        lambda do
-          connection.create_table :data_types do |t|
-            t.text :text_1
-          end
-
-          connection.exec_query "INSERT INTO data_types (text_1) VALUES ('some,values,here')"
-          connection.change_column :data_types, :text_1, :text, :array => true, :default => [], :null => false
-        end.should_not raise_exception
-
-        columns = connection.columns(:data_types)
-
-        text_1 = columns.detect { |c| c.name == 'text_1'}
-        text_1.sql_type.should eq 'text[]'
-        text_1.default.should  eq []
-        text_1.null.should     be_false
-
-        new_text_value = connection.exec_query "SELECT array_length(text_1, 1) FROM data_types LIMIT 1"
-        if RUBY_PLATFORM =~ /java/
-          new_text_value.first['array_length'].should eq 3
-        else
-          new_text_value.rows.first.should eq ['3']
-        end
-      end
-    end
-  end
-
-  context 'Default Values' do
-    describe 'String defaults' do
-      after { connection.drop_table :default_strings }
-      it 'creates array column with proper defaults' do
-        lambda do
-          connection.create_table :default_strings do |t|
-            t.string :names_1, :array => true, :default => []
-            t.string :names_2, :array => true, :default => '{}'
-            t.string :names_3, :array => true, :default => ['something']
-            t.string :names_4, :array => true, :default => '{something}'
-          end
-        end.should_not raise_exception
-        columns = connection.columns(:default_strings)
-
-        names_1 = columns.detect { |c| c.name == 'names_1' }
-        names_2 = columns.detect { |c| c.name == 'names_2' }
-        names_3 = columns.detect { |c| c.name == 'names_3' }
-        names_4 = columns.detect { |c| c.name == 'names_4' }
-
-        names_1.default.should eq []
-        names_2.default.should eq []
-        names_3.default.should eq ['something']
-        names_4.default.should eq ['something']
-      end
-    end
-
-    describe 'Integer defaults' do
-      after { connection.drop_table :default_integers }
-      it 'creates array column with proper defaults' do
-        lambda do
-          connection.create_table :default_integers do |t|
-            t.integer :numbers_1, :array => true, :default => []
-            t.integer :numbers_2, :array => true, :default => '{}'
-            t.integer :numbers_3, :array => true, :default => [3]
-            t.integer :numbers_4, :array => true, :default => '{4}'
-          end
-        end.should_not raise_exception
-        columns = connection.columns(:default_integers)
-
-        numbers_1 = columns.detect { |c| c.name == 'numbers_1' }
-        numbers_2 = columns.detect { |c| c.name == 'numbers_2' }
-        numbers_3 = columns.detect { |c| c.name == 'numbers_3' }
-        numbers_4 = columns.detect { |c| c.name == 'numbers_4' }
-
-        numbers_1.default.should eq []
-        numbers_2.default.should eq []
-        numbers_3.default.should eq [3]
-        numbers_4.default.should eq [4]
-      end
-    end
-  end
-end

data/spec/migrations/cidr_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe 'CIDR migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-  it 'creates an cidr column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.cidr :cidr_1
-        t.cidr :cidr_2, :cidr_3
-        t.column :cidr_4, :cidr
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    cidr_1 = columns.detect { |c| c.name == 'cidr_1'}
-    cidr_2 = columns.detect { |c| c.name == 'cidr_2'}
-    cidr_3 = columns.detect { |c| c.name == 'cidr_3'}
-    cidr_4 = columns.detect { |c| c.name == 'cidr_4'}
-
-    cidr_1.sql_type.should eq 'cidr'
-    cidr_2.sql_type.should eq 'cidr'
-    cidr_3.sql_type.should eq 'cidr'
-    cidr_4.sql_type.should eq 'cidr'
-  end
-end

data/spec/migrations/citext_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe 'CITEXT migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  before(:all) { ActiveRecord::Base.connection.add_extension('citext') if ActiveRecord::Base.connection.supports_extensions? }
-  after { connection.drop_table :data_types }
-  it 'creates an citext column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.citext :citext_1
-        t.citext :citext_2, :citext_3
-        t.column :citext_4, :citext
-        t.text   :citext_5
-      end
-
-      connection.change_column :data_types, :citext_5, :citext
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    citext_1 = columns.detect { |c| c.name == 'citext_1'}
-    citext_2 = columns.detect { |c| c.name == 'citext_2'}
-    citext_3 = columns.detect { |c| c.name == 'citext_3'}
-    citext_4 = columns.detect { |c| c.name == 'citext_4'}
-    citext_5 = columns.detect { |c| c.name == 'citext_5'}
-
-    citext_1.sql_type.should eq 'citext'
-    citext_2.sql_type.should eq 'citext'
-    citext_3.sql_type.should eq 'citext'
-    citext_4.sql_type.should eq 'citext'
-    citext_5.sql_type.should eq 'citext'
-  end
-end

data/spec/migrations/ean13_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'ean13 migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  before(:all) { ActiveRecord::Base.connection.add_extension('isn') if ActiveRecord::Base.connection.supports_extensions? }
-  after { connection.drop_table :data_types }
-  it 'creates an ean13 column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.ean13 :ean13_1
-        t.ean13 :ean13_2, :ean13_3
-        t.column :ean13_4, :ean13
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    ean13_1 = columns.detect { |c| c.name == 'ean13_1'}
-    ean13_2 = columns.detect { |c| c.name == 'ean13_2'}
-    ean13_3 = columns.detect { |c| c.name == 'ean13_3'}
-    ean13_4 = columns.detect { |c| c.name == 'ean13_4'}
-
-    ean13_1.sql_type.should eq 'ean13'
-    ean13_2.sql_type.should eq 'ean13'
-    ean13_3.sql_type.should eq 'ean13'
-    ean13_4.sql_type.should eq 'ean13'
-  end
-end

data/spec/migrations/index_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe 'Index migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  let!(:stream) { StringIO.new }
-  before do
-    ActiveRecord::Base.logger = ActiveSupport::TaggedLogging.new(Logger.new stream)
-  end
-
-  after do
-    [:tag_ids, :lucky_number, :biography].each do |column|
-      begin
-        connection.remove_index :people, column
-      rescue ArgumentError
-      end
-    end
-  end
-
-  it 'creates special index' do
-    lambda do
-      connection.add_index(:people, :tag_ids, :using => :gin)
-    end.should_not raise_exception
-
-    indexes = connection.indexes(:people)
-    index_1 = indexes.detect { |c| c.columns.map(&:to_s) == ['tag_ids']}
-
-    index_1.using.should eq :gin
-  end
-
-  it 'creates indexes with where clauses' do
-    lambda do
-      connection.add_index(:people, :lucky_number, :where => '(lucky_number > 50)')
-    end.should_not raise_exception
-
-    indexes = connection.indexes(:people)
-    index_2 = indexes.detect { |c| c.columns.map(&:to_s) == ['lucky_number']}
-
-    index_2.where.should match /lucky_number > 50/
-  end
-
-  it 'creates index concurrently' do
-    lambda do
-      connection.add_index(:people, :lucky_number, :algorithm => :concurrently)
-    end.should_not raise_exception
-
-    output = stream.string
-    output.should match /CREATE INDEX CONCURRENTLY "index_people_on_lucky_number" ON "people"\(\"lucky_number\" \)/
-  end
-
-  it 'rejects bad algorithm arguments' do
-    lambda do
-      connection.add_index(:people, :lucky_number, :algorithm => :conurrently)
-    end.should raise_exception
-  end
-
-  it 'creates indexes with operator classes', :if => ActiveRecord::Base.connection.supports_extensions? do
-    lambda do
-      connection.add_index(:people, :biography, :using => :gin, :index_opclass => :gin_trgm_ops)
-    end.should_not raise_exception
-
-    indexes = connection.indexes(:people)
-    index_3 = indexes.detect { |c| c.columns.map(&:to_s) == ['biography']}
-
-    index_3.using.should         eq    :gin
-    index_3.index_opclass.should eq    :gin_trgm_ops
-  end
-end

data/spec/migrations/inet_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe 'INET migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-  it 'creates an inet column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.inet :ip_1
-        t.inet :ip_2, :ip_3
-        t.column :ip_4, :inet
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    ip_1 = columns.detect { |c| c.name == 'ip_1'}
-    ip_2 = columns.detect { |c| c.name == 'ip_2'}
-    ip_3 = columns.detect { |c| c.name == 'ip_3'}
-    ip_4 = columns.detect { |c| c.name == 'ip_4'}
-
-    ip_1.sql_type.should eq 'inet'
-    ip_2.sql_type.should eq 'inet'
-    ip_3.sql_type.should eq 'inet'
-    ip_4.sql_type.should eq 'inet'
-  end
-end

data/spec/migrations/macaddr_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe 'MACADDR migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-  it 'creates an macaddr column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.macaddr :macaddr_1
-        t.macaddr :macaddr_2, :macaddr_3
-        t.column :macaddr_4, :macaddr
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    macaddr_1 = columns.detect { |c| c.name == 'macaddr_1'}
-    macaddr_2 = columns.detect { |c| c.name == 'macaddr_2'}
-    macaddr_3 = columns.detect { |c| c.name == 'macaddr_3'}
-    macaddr_4 = columns.detect { |c| c.name == 'macaddr_4'}
-
-    macaddr_1.sql_type.should eq 'macaddr'
-    macaddr_2.sql_type.should eq 'macaddr'
-    macaddr_3.sql_type.should eq 'macaddr'
-    macaddr_4.sql_type.should eq 'macaddr'
-  end
-end

data/spec/migrations/ranges/daterange_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'daterange migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-
-  it 'creates an daterange column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.daterange :date_range_1
-        t.daterange :date_range_2, :date_range_3
-        t.column :date_range_4, :daterange
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    date_range_1 = columns.detect { |c| c.name == 'date_range_1'}
-    date_range_2 = columns.detect { |c| c.name == 'date_range_2'}
-    date_range_3 = columns.detect { |c| c.name == 'date_range_3'}
-    date_range_4 = columns.detect { |c| c.name == 'date_range_4'}
-
-    date_range_1.sql_type.should eq 'daterange'
-    date_range_2.sql_type.should eq 'daterange'
-    date_range_3.sql_type.should eq 'daterange'
-    date_range_4.sql_type.should eq 'daterange'
-  end
-end

data/spec/migrations/ranges/int4range_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'int4range migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-
-  it 'creates an numrange column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.int4range :range_1
-        t.int4range :range_2, :range_3
-        t.column :range_4, :int4range
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    range_1 = columns.detect { |c| c.name == 'range_1'}
-    range_2 = columns.detect { |c| c.name == 'range_2'}
-    range_3 = columns.detect { |c| c.name == 'range_3'}
-    range_4 = columns.detect { |c| c.name == 'range_4'}
-
-    range_1.sql_type.should eq 'int4range'
-    range_2.sql_type.should eq 'int4range'
-    range_3.sql_type.should eq 'int4range'
-    range_4.sql_type.should eq 'int4range'
-  end
-end

data/spec/migrations/ranges/int8range_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'int8range migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-
-  it 'creates an numrange column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.int8range :range_1
-        t.int8range :range_2, :range_3
-        t.column :range_4, :int8range
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    range_1 = columns.detect { |c| c.name == 'range_1'}
-    range_2 = columns.detect { |c| c.name == 'range_2'}
-    range_3 = columns.detect { |c| c.name == 'range_3'}
-    range_4 = columns.detect { |c| c.name == 'range_4'}
-
-    range_1.sql_type.should eq 'int8range'
-    range_2.sql_type.should eq 'int8range'
-    range_3.sql_type.should eq 'int8range'
-    range_4.sql_type.should eq 'int8range'
-  end
-end

data/spec/migrations/ranges/numrange_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'numrange migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-
-  it 'creates an numrange column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.numrange :num_range_1
-        t.numrange :num_range_2, :num_range_3
-        t.column :num_range_4, :numrange
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    num_range_1 = columns.detect { |c| c.name == 'num_range_1'}
-    num_range_2 = columns.detect { |c| c.name == 'num_range_2'}
-    num_range_3 = columns.detect { |c| c.name == 'num_range_3'}
-    num_range_4 = columns.detect { |c| c.name == 'num_range_4'}
-
-    num_range_1.sql_type.should eq 'numrange'
-    num_range_2.sql_type.should eq 'numrange'
-    num_range_3.sql_type.should eq 'numrange'
-    num_range_4.sql_type.should eq 'numrange'
-  end
-end

data/spec/migrations/ranges/tsrange_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'tsrange migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-
-  it 'creates an tsrange column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.tsrange :ts_range_1
-        t.tsrange :ts_range_2, :ts_range_3
-        t.column :ts_range_4, :tsrange
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    ts_range_1 = columns.detect { |c| c.name == 'ts_range_1'}
-    ts_range_2 = columns.detect { |c| c.name == 'ts_range_2'}
-    ts_range_3 = columns.detect { |c| c.name == 'ts_range_3'}
-    ts_range_4 = columns.detect { |c| c.name == 'ts_range_4'}
-
-    ts_range_1.sql_type.should eq 'tsrange'
-    ts_range_2.sql_type.should eq 'tsrange'
-    ts_range_3.sql_type.should eq 'tsrange'
-    ts_range_4.sql_type.should eq 'tsrange'
-  end
-end

data/spec/migrations/ranges/tstzrange_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe 'tstzrange migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-
-  it 'creates an tstzrange column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.tstzrange :tstz_range_1
-        t.tstzrange :tstz_range_2, :tstz_range_3
-        t.column :tstz_range_4, :tstzrange
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    tstz_range_1 = columns.detect { |c| c.name == 'tstz_range_1'}
-    tstz_range_2 = columns.detect { |c| c.name == 'tstz_range_2'}
-    tstz_range_3 = columns.detect { |c| c.name == 'tstz_range_3'}
-    tstz_range_4 = columns.detect { |c| c.name == 'tstz_range_4'}
-
-    tstz_range_1.sql_type.should eq 'tstzrange'
-    tstz_range_2.sql_type.should eq 'tstzrange'
-    tstz_range_3.sql_type.should eq 'tstzrange'
-    tstz_range_4.sql_type.should eq 'tstzrange'
-  end
-end

data/spec/migrations/uuid_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe 'UUID migrations' do
-  let!(:connection) { ActiveRecord::Base.connection }
-  after { connection.drop_table :data_types }
-  it 'creates an uuid column' do
-    lambda do
-      connection.create_table :data_types do |t|
-        t.uuid :uuid_1
-        t.uuid :uuid_2, :uuid_3
-        t.column :uuid_4, :uuid
-      end
-    end.should_not raise_exception
-
-    columns = connection.columns(:data_types)
-    uuid_1 = columns.detect { |c| c.name == 'uuid_1'}
-    uuid_2 = columns.detect { |c| c.name == 'uuid_2'}
-    uuid_3 = columns.detect { |c| c.name == 'uuid_3'}
-    uuid_4 = columns.detect { |c| c.name == 'uuid_4'}
-
-    uuid_1.sql_type.should eq 'uuid'
-    uuid_2.sql_type.should eq 'uuid'
-    uuid_3.sql_type.should eq 'uuid'
-    uuid_4.sql_type.should eq 'uuid'
-  end
-end