activerecord-postgis-array 0.3.4

data/spec/migrations/active_record_migration_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'ActiveRecord Migrations' do
+  let!(:connection) { ActiveRecord::Base.connection }
+  after { connection.drop_table :generic_data_types }
+  it 'creates non-activerecord-postgis-array columns' do
+    lambda do
+      connection.create_table :generic_data_types do |t|
+        t.integer :col_1
+        t.string :col_2
+        t.datetime :col_3
+      end
+      connection.add_column :generic_data_types, :col_4, :text
+    end.should_not raise_exception
+
+    columns = connection.columns(:generic_data_types)
+    col_1 = columns.detect { |c| c.name == 'col_1'}
+    col_2 = columns.detect { |c| c.name == 'col_2'}
+    col_3 = columns.detect { |c| c.name == 'col_3'}
+    col_4 = columns.detect { |c| c.name == 'col_4'}
+
+
+    col_1.sql_type.should eq 'integer'
+    col_2.sql_type.should eq 'character varying(255)'
+    col_3.sql_type.should eq 'timestamp without time zone'
+    col_4.sql_type.should eq 'text'
+  end
+end
+

data/spec/migrations/array_spec.rb

@@ -0,0 +1,136 @@
+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.integer :array_1, :array => true
+            t.integer :array_2, :array_3, :array => true
+            t.column :array_4, :integer, :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 'integer[]'
+        array_2.sql_type.should eq 'integer[]'
+        array_3.sql_type.should eq 'integer[]'
+        array_4.sql_type.should eq 'integer[]'
+      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, :integer, :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 'integer[]'
+        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, :integer, :array => true
+            t.integer :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 'integer[]'
+        array_7.sql_type.should eq 'integer[]'
+      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/index_spec.rb

@@ -0,0 +1,67 @@
+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/models/array_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+
+describe 'Models with array columns' do
+  let!(:adapter) { ActiveRecord::Base.connection }
+
+  context 'no default value, string array' do
+    before do
+      adapter.create_table :users, :force => true do |t|
+        t.string :nick_names, :array => true
+        t.integer :favorite_numbers, :array => true
+
+        t.timestamps
+      end
+
+      class User < ActiveRecord::Base
+        attr_accessible :nick_names, :favorite_numbers
+      end
+    end
+
+    after do
+      adapter.drop_table :users
+      Object.send(:remove_const, :User)
+    end
+
+    context 'no default value, string array' do
+      describe '#create' do
+        it 'creates a user when there is no array assignment' do
+          u = User.create()
+          u.reload
+          u.nick_names.should eq nil
+        end
+
+        it 'creates a user with an empty array' do
+          u = User.create(:nick_names => [])
+          u.reload
+          u.nick_names.should eq []
+        end
+
+        it 'creates a user with an array of some values' do
+          u = User.create(:nick_names => ['some', 'things'])
+          u.reload
+          u.nick_names.should eq ['some', 'things']
+        end
+
+        it 'creates a user with an int array of some values' do
+          u = User.create(:favorite_numbers => [2,3,5])
+          u.reload
+          u.favorite_numbers.should eq [2,3,5]
+        end
+
+        it 'creates a user with an int array of string values' do
+          u = User.create(:favorite_numbers => ['2','3','5'])
+          u.reload
+          u.favorite_numbers.should eq [2,3,5]
+        end
+      end
+    end
+
+    context 'Setting values' do
+      it 'returns the value set when the record is retrieved' do
+        u = User.create(:nick_names => ['some', 'things'])
+        u.reload
+
+        u.nick_names = ['different', 'values']
+        u.save
+
+        u.reload
+        u.nick_names.should eq ['different', 'values']
+      end
+
+      it 'creates a user with an int array of some values' do
+        u = User.create(:favorite_numbers => [2,3,5])
+        u.reload
+
+        u.favorite_numbers = [1,2,3]
+        u.save
+
+        u.reload
+        u.favorite_numbers.should eq [1,2,3]
+      end
+    end
+
+    context '#update_attribute' do
+      describe 'setting a value via update_attribute' do
+        it 'returns the value set when the record is retrieved' do
+          user = User.create(:nick_names => [])
+          user.reload
+
+          user.update_attribute(:nick_names, ['some', 'values'])
+          user.save
+
+          user.reload
+          user.nick_names.should eq ['some', 'values']
+        end
+      end
+    end
+
+    context '#<column>? do' do
+      describe 'checking a value via <attribute_name>? 'do
+        it 'returns false if it\'s an empty array' do
+          user = User.create(:nick_names => [], :favorite_numbers => [])
+          user.reload
+
+          user.nick_names?.should be_false
+          user.favorite_numbers?.should be_false
+        end
+
+        it 'returns false if it\'s an empty array' do
+          user = User.create(:nick_names => ['bob'], :favorite_numbers => [0])
+          user.reload
+
+          user.nick_names?.should be_true
+          user.favorite_numbers?.should be_true
+        end
+      end
+    end
+
+    context '#update_column' do
+      describe 'setting a value via update_column' do
+        it 'returns the value set when the record is retrieved' do
+          user = User.create(:nick_names => [])
+          user.reload
+
+          user.update_column(:nick_names, ['some', 'values'])
+          user.save
+
+          user.reload
+          user.nick_names.should eq ['some', 'values']
+        end
+      end
+    end
+
+    context '#update_attributes' do
+      describe 'setting a value via update_attributes' do
+        it 'returns the value set when the record is retrieved' do
+          user = User.create(:nick_names => [])
+          user.reload
+
+          user.update_attributes(:nick_names => ['some', 'values'])
+          user.save
+
+          user.reload
+          user.nick_names.should eq ['some', 'values']
+        end
+      end
+    end
+
+    describe 'strings contain special characters' do
+      context '#save' do
+        it 'contains: \'' do
+          data = ['some\'thing']
+          u = User.create
+          u.nick_names = data
+          u.save!
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: {' do
+          data = ['some{thing']
+          u = User.create
+          u.nick_names = data
+          u.save!
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: }' do
+          data = ['some}thing']
+          u = User.create
+          u.nick_names = data
+          u.save!
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: backslash' do
+          data = ['some\\thing']
+          u = User.create
+          u.nick_names = data
+          u.save!
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: "' do
+          data = ['some"thing']
+          u = User.create
+          u.nick_names = data
+          u.save!
+          u.reload
+          u.nick_names.should eq data
+        end
+      end
+
+      context '#create' do
+        it 'contains: \'' do
+          data = ['some\'thing']
+          u = User.create(:nick_names => data)
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: {' do
+          data = ['some{thing']
+          u = User.create(:nick_names => data)
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: }' do
+          data = ['some}thing']
+          u = User.create(:nick_names => data)
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: backslash' do
+          data = ['some\\thing']
+          u = User.create(:nick_names => data)
+          u.reload
+          u.nick_names.should eq data
+        end
+
+        it 'contains: "' do
+          data = ['some"thing']
+          u = User.create(:nick_names => data)
+          u.reload
+          u.nick_names.should eq data
+        end
+      end
+    end
+
+    describe 'overlap' do
+      it "works" do
+        arel = User.arel_table
+        User.create(:nick_names => ['this'])
+        x = User.create
+        x.nick_names = ["s'o{m}e", 'thing']
+        x.save
+        u = User.where(arel[:nick_names].overlap(["s'o{m}e"]))
+        u.first.should_not be_nil
+        u.first.nick_names.should eq ["s'o{m}e", 'thing']
+      end
+    end
+  end
+
+  context 'default values' do
+    before do
+      adapter.create_table :defaulted_users, :force => true do |t|
+        t.string :nick_names, :array => true, :default => '{}'
+      end
+      class DefaultedUser < ActiveRecord::Base
+        attr_accessible :nick_names
+      end
+    end
+
+    after do
+      adapter.drop_table :defaulted_users
+      Object.send(:remove_const, :DefaultedUser)
+    end
+
+    context 'model creation' do
+      describe '#create' do
+        it 'creates a user when there is no array assignment' do
+          u = DefaultedUser.create()
+          u.reload
+          u.nick_names.should eq []
+        end
+
+        it 'creates a user with an nil' do
+          u = DefaultedUser.create(:nick_names => nil)
+          u.reload
+          u.nick_names.should eq nil
+        end
+
+        it 'creates a user with an array of some values' do
+          u = DefaultedUser.create(:nick_names => ['some', 'things'])
+          u.reload
+          u.nick_names.should eq ['some', 'things']
+        end
+      end
+    end
+  end
+end