active_type 0.6.0 → 0.6.1

data/spec/active_type/record_spec.rb

@@ -1,274 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-module RecordSpec
-
-  def self.type
-    if ActiveRecord::VERSION::MAJOR >= 5
-      @type ||= ActiveModel::Type::Value.new
-    end
-  end
-
-  class Record < ActiveType::Record
-
-    attribute :virtual_string, :string
-    attribute :virtual_integer, :integer
-    attribute :virtual_time, :datetime
-    attribute :virtual_date, :date
-    attribute :virtual_boolean, :boolean
-    attribute :virtual_attribute
-    attribute :virtual_type_attribute, RecordSpec.type
-
-  end
-
-  class RecordWithValidations < Record
-
-    validates :persisted_string, :presence => true
-    validates :virtual_string, :presence => true
-
-  end
-
-
-  class RecordWithOverrides < Record
-
-    attribute :overridable_test, :string
-
-    def overridable_test
-      super + super
-    end
-
-  end
-
-  class RecordCopy < ActiveType::Record
-    self.table_name = 'records'
-
-    attribute :virtual_string, :string
-
-  end
-
-  class OtherRecord < ActiveType::Record
-  end
-
-  class Child < ActiveRecord::Base
-  end
-
-  class RecordWithBelongsTo < Record
-
-    attribute :child_id, :integer
-
-    belongs_to :child
-
-  end
-end
-
-
-describe ActiveType::Record do
-
-  subject { RecordSpec::Record.new }
-  t = Time.new(2016, 2, 1, 12)
-
-  it 'is a ActiveRecord::Base' do
-    expect(subject).to be_a(ActiveRecord::Base)
-  end
-
-  it 'is an abstract class' do
-    expect(ActiveType::Record).to be_abstract_class
-  end
-
-  describe 'constructors' do
-    subject { RecordSpec::Record }
-
-    it_should_behave_like 'ActiveRecord-like constructors', { :persisted_string => "string", :persisted_integer => 100, :persisted_time => t, :persisted_date => Date.today, :persisted_boolean => true }
-
-    it_should_behave_like 'ActiveRecord-like constructors', { :virtual_string => "string", :virtual_integer => 100, :virtual_time => t, :virtual_date => Date.today, :virtual_boolean => true }
-
-  end
-
-  describe 'mass assignment' do
-    it_should_behave_like 'ActiveRecord-like mass assignment', { :persisted_string => "string", :persisted_integer => 100, :persisted_time => t, :persisted_date => Date.today, :persisted_boolean => true }
-
-    it_should_behave_like 'ActiveRecord-like mass assignment', { :virtual_string => "string", :virtual_integer => 100, :virtual_time => t, :virtual_date => Date.today, :virtual_boolean => true }
-  end
-
-  describe 'accessors' do
-    it_should_behave_like 'ActiveRecord-like accessors', { :persisted_string => "string", :persisted_integer => 100, :persisted_time => t, :persisted_date => Date.today, :persisted_boolean => true }
-
-    it_should_behave_like 'ActiveRecord-like accessors', { :virtual_string => "string", :virtual_integer => 100, :virtual_time => t, :virtual_date => Date.today, :virtual_boolean => true }
-  end
-
-  describe 'overridable attributes' do
-
-    subject { RecordSpec::RecordWithOverrides.new }
-
-    it 'is possible to override attributes with super' do
-      subject.overridable_test = "test"
-
-      expect(subject.overridable_test).to eq("testtest")
-    end
-  end
-
-  describe 'attribute name validation' do
-    it 'crashes when trying to define an invalid attribute name' do
-      klass = Class.new(ActiveType::Record)
-      expect {
-        klass.class_eval do
-          attribute :"<attr>", :string
-        end
-      }.to raise_error(ActiveType::InvalidAttributeNameError)
-    end
-  end
-
-  describe '.reset_column_information' do
-    it 'does not affect virtual attributes' do
-      RecordSpec::RecordCopy.new.persisted_string = "string"
-      RecordSpec::RecordCopy.reset_column_information
-
-      expect do
-        RecordSpec::RecordCopy.new.virtual_string = "string"
-      end.to_not raise_error
-    end
-  end
-
-  context 'coercible' do
-    describe 'string columns' do
-      it_should_behave_like 'a coercible string column', :persisted_string
-      it_should_behave_like 'a coercible string column', :virtual_string
-    end
-
-    describe 'integer columns' do
-      it_should_behave_like 'a coercible integer column', :persisted_integer
-      it_should_behave_like 'a coercible integer column', :virtual_integer
-    end
-
-    describe 'date columns' do
-      it_should_behave_like 'a coercible date column', :persisted_date
-      it_should_behave_like 'a coercible date column', :virtual_date
-    end
-
-    describe 'time columns' do
-      it_should_behave_like 'a coercible time column', :persisted_time
-      it_should_behave_like 'a coercible time column', :virtual_time
-    end
-
-    describe 'boolean columns' do
-      it_should_behave_like 'a coercible boolean column', :persisted_boolean
-      it_should_behave_like 'a coercible boolean column', :virtual_boolean
-    end
-
-    describe 'untyped columns' do
-      it_should_behave_like 'an untyped column', :virtual_attribute
-    end
-
-    describe 'type columns' do
-      it_should_behave_like 'a coercible type column', :virtual_type_attribute, RecordSpec.type
-    end
-  end
-
-  describe '#inspect' do
-
-    it 'returns the contents of the object as a nicely formatted string' do
-      t = Time.now
-      subject.persisted_string = "persisted string"
-      subject.virtual_string = "string"
-      subject.persisted_integer = 20
-      subject.virtual_integer = 17
-      subject.virtual_time = t
-      subject.virtual_date = Date.today
-      subject.virtual_boolean = true
-      subject.virtual_attribute = OpenStruct.new({:test => "openstruct"})
-
-      expect(subject.inspect).to eq("#<RecordSpec::Record id: nil, persisted_boolean: nil, persisted_date: nil, persisted_integer: 20, persisted_string: \"persisted string\", persisted_time: nil, virtual_attribute: #<OpenStruct test=\"openstruct\">, virtual_boolean: true, virtual_date: \"#{Date.today}\", virtual_integer: 17, virtual_string: \"string\", virtual_time: \"#{t.to_s(:db)}\", virtual_type_attribute: nil>")
-    end
-
-  end
-
-  describe '#attributes' do
-
-    it 'returns a hash of virtual and persisted attributes' do
-      subject.persisted_string = "string"
-      subject.virtual_string = "string"
-      subject.virtual_integer = "17"
-
-      expect(subject.attributes).to eq({
-        "virtual_string" => "string",
-        "virtual_integer" => 17,
-        "virtual_time" => nil,
-        "virtual_date" => nil,
-        "virtual_boolean" => nil,
-        "virtual_attribute" => nil,
-        "virtual_type_attribute" => nil,
-        "id" => nil,
-        "persisted_string" => "string",
-        "persisted_integer" => nil,
-        "persisted_time" => nil,
-        "persisted_date" => nil,
-        "persisted_boolean" => nil,
-      })
-    end
-
-  end
-
-  describe 'validations' do
-    subject { RecordSpec::RecordWithValidations.new }
-
-    it 'has 1 error_on' do
-      expect(subject.error_on(:persisted_string).size).to eq(1)
-    end
-    it 'has 1 error_on' do
-      expect(subject.error_on(:virtual_string).size).to eq(1)
-    end
-  end
-
-  describe 'undefined columns' do
-    it 'raises an error when trying to access an undefined virtual attribute' do
-      expect do
-        subject.read_virtual_attribute('foo')
-      end.to raise_error(ActiveType::MissingAttributeError)
-    end
-  end
-
-  describe 'defaults' do
-    it_should_behave_like "a class accepting attribute defaults", RecordSpec::Record
-  end
-
-  describe 'duping' do
-    it_should_behave_like "a class supporting dup for attributes", RecordSpec::Record
-  end
-
-  describe 'dirty tracking' do
-    it_should_behave_like 'a class supporting dirty tracking for virtual attributes', RecordSpec::Record
-  end
-
-  describe 'persistence' do
-
-    it 'persists to the database' do
-      subject.persisted_string = "persisted string"
-      expect(subject.save).to eq(true)
-
-      expect(subject.class.find(subject.id).persisted_string).to eq("persisted string")
-    end
-  end
-
-  describe 'isolation' do
-    it 'does not let column information bleed into different models' do
-      record = RecordSpec::Record.new
-      other_record = RecordSpec::OtherRecord.new
-
-      expect(record).not_to respond_to(:other_string)
-      expect(other_record).not_to respond_to(:persisted_string)
-    end
-  end
-
-  describe '#belongs_to' do
-    subject { RecordSpec::RecordWithBelongsTo.new }
-
-    it_should_behave_like 'a belongs_to association', :child, RecordSpec::Child
-  end
-
-  it 'can access virtual attributes after .find' do
-    subject.save!
-    expect(subject.class.find(subject.id).virtual_string).to eq(nil)
-    expect(subject.class.find(subject.id).virtual_string).to eq(nil)
-  end
-
-end

data/spec/active_type/util_spec.rb

@@ -1,142 +0,0 @@
-require 'spec_helper'
-
-module UtilSpec
-
-  class BaseRecord < ActiveRecord::Base
-    self.table_name = 'records'
-  end
-
-  class ExtendedRecord < ActiveType::Record[BaseRecord]
-
-    attribute :virtual_string
-    attribute :virtual_string_for_validation
-    after_initialize :set_virtual_string
-    attr_reader :after_initialize_called
-
-    def set_virtual_string
-      @after_initialize_called = true
-      self.virtual_string = "persisted_string is #{persisted_string}"
-    end
-
-  end
-
-  class Parent < ActiveRecord::Base
-    self.table_name = 'sti_records'
-  end
-
-  class Child < Parent
-  end
-
-  class ChildSibling < Parent
-  end
-
-  class ExtendedChild < ActiveType::Record[Child]
-  end
-
-end
-
-describe ActiveType::Util do
-  
-  describe '.cast' do
-
-    describe 'for a relation' do
-    
-      it 'casts a scope to a scope of another class' do
-        record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        base_scope = UtilSpec::BaseRecord.where(:persisted_string => 'foo')
-        casted_scope = ActiveType::Util.cast(base_scope, UtilSpec::ExtendedRecord)
-        expect(casted_scope.build).to be_a(UtilSpec::ExtendedRecord)
-        found_record = casted_scope.find(record.id)
-        expect(found_record.persisted_string).to eq('foo')
-        expect(found_record).to be_a(UtilSpec::ExtendedRecord)
-      end
-
-      it 'preserves existing scope conditions' do
-        match = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        no_match = UtilSpec::BaseRecord.create!(:persisted_string => 'bar')
-        base_scope = UtilSpec::BaseRecord.where(:persisted_string => 'foo')
-        casted_scope = ActiveType::Util.cast(base_scope, UtilSpec::ExtendedRecord)
-        casted_match = UtilSpec::ExtendedRecord.find(match.id)
-        expect(casted_scope.to_a).to eq([casted_match])
-      end
-
-    end
-
-    describe 'for a record type' do
-
-      it 'casts a base record to an extended record' do
-        base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        expect(extended_record).to be_a(UtilSpec::ExtendedRecord)
-        expect(extended_record).to be_persisted
-        expect(extended_record.id).to be_present
-        expect(extended_record.id).to eq(base_record.id)
-        expect(extended_record.persisted_string).to eq('foo')
-      end
-
-      it 'casts an extended record to a base record' do
-        extended_record = UtilSpec::ExtendedRecord.create!(:persisted_string => 'foo')
-        base_record = ActiveType::Util.cast(extended_record, UtilSpec::BaseRecord)
-        expect(base_record).to be_a(UtilSpec::BaseRecord)
-        expect(base_record).to be_persisted
-        expect(base_record.id).to be_present
-        expect(base_record.id).to eq(extended_record.id)
-        expect(base_record.persisted_string).to eq('foo')
-      end
-
-      it 'calls after_initialize callbacks of the cast target' do
-        base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        expect(extended_record.after_initialize_called).to eq true
-      end
-
-      it 'lets after_initialize callbacks access attributes (bug in ActiveRecord#becomes)' do
-        base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        expect(extended_record.virtual_string).to eq('persisted_string is foo')
-      end
-
-      it 'preserves the #type of an STI record that is casted to an ExtendedRecord' do
-        child_record = UtilSpec::Child.create!(:persisted_string => 'foo')
-        extended_child_record = ActiveType::Util.cast(child_record, UtilSpec::ExtendedChild)
-        expect(extended_child_record).to be_a(UtilSpec::ExtendedChild)
-        expect(extended_child_record.type).to eq('UtilSpec::Child')
-      end
-
-      it 'changes the #type of an STI record when casted to another type in the hierarchy' do
-        child_record = UtilSpec::Child.create!(:persisted_string => 'foo')
-        child_sibling_record = ActiveType::Util.cast(child_record, UtilSpec::ChildSibling)
-        expect(child_sibling_record).to be_a(UtilSpec::ChildSibling)
-        expect(child_sibling_record.type).to eq('UtilSpec::Child')
-      end
-
-      it 'preserves dirty tracking flags' do
-        base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        expect(base_record.changes).to eq({})
-        base_record.persisted_string = 'bar'
-        expect(base_record.changes).to eq({ 'persisted_string' => ['foo', 'bar'] })
-        extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        expect(extended_record).to be_a(UtilSpec::ExtendedRecord)
-        expect(extended_record.changes).to eq({ 'persisted_string' => ['foo', 'bar'] })
-      end
-
-      it 'associates the error object correctly with the new type (BUGFIX)' do
-        base_record = UtilSpec::BaseRecord.create!(:persisted_string => 'foo')
-        extended_record = ActiveType::Util.cast(base_record, UtilSpec::ExtendedRecord)
-        expect {
-          value = extended_record.virtual_string_for_validation
-          extended_record.errors.add(:virtual_string_for_validation, :empty) if value.nil? || value.empty?
-        }.not_to raise_error
-        expect(extended_record.errors.size).to eq 1
-        expect(base_record.errors.size).to eq 0
-      end
-
-    end
-
-  end
-
-  it "exposes all methods through ActiveType's root namespace" do
-    expect(ActiveType).to respond_to(:cast)
-  end
-
-end

data/spec/integration/holidays_spec.rb

@@ -1,102 +0,0 @@
-# Usecase: CRUD a number of records 
-
-require 'spec_helper'
-
-ActiveRecord::Migration.class_eval do
-  create_table :holidays do |t|
-    t.string :name
-    t.date :date
-  end
-end
-
-module HolidaySpec
-
-  class Holiday < ActiveRecord::Base
-    validates :name, :date, :presence => true
-  end
-
-  class HolidayForm < ActiveType::Object
-    nests_many :holidays, :scope => Holiday, :default => proc { Holiday.all }, :reject_if => :all_blank, :allow_destroy => true
-  end
-
-end
-
-
-describe HolidaySpec::HolidayForm do
-
-  let(:params) do
-    {
-      '1' => {
-        'name' => 'New Year',
-        'date' => '2014-01-01',
-      },
-      '2' => {
-        'name' => 'Epiphany',
-        'date' => '2014-01-06',
-      },
-    }
-  end
-
-  def update(params)
-    form = HolidaySpec::HolidayForm.new(:holidays_attributes => params)
-    if form.save
-      ids = form.holidays.collect(&:id)
-      params.each_with_index do |(key, attributes), index|
-        attributes['id'] = ids[index]
-      end
-      true
-    end
-  end
-
-  it 'will return holidays including updated ones' do
-    HolidaySpec::Holiday.create!(:name => 'New Year', :date => '2014-01-01')
-    form = HolidaySpec::HolidayForm.new(:holidays_attributes => params.slice('2'))
-    expect(form.holidays.collect(&:name)).to eq(["New Year", "Epiphany"])
-  end
-
-  it 'can create a list of holidays' do
-    expect(update(params)).to eq(true)
-
-    holidays = HolidaySpec::Holiday.order(:date)
-    expect(holidays.collect(&:name)).to eq(["New Year", "Epiphany"])
-    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)])
-  end
-
-  it 'can update holidays' do
-    update(params)
-
-    params['1']['name'] += ' 2014'
-    params['2']['name'] += ' 2014'
-    expect(update(params)).to eq(true)
-
-    holidays = HolidaySpec::Holiday.order(:date)
-    expect(holidays.collect(&:name)).to eq(["New Year 2014", "Epiphany 2014"])
-    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)])
-  end
-
-  it 'can destroy holidays' do
-    update(params)
-
-    params['1']['_destroy'] = '1'
-    expect(update(params)).to eq(true)
-
-    holidays = HolidaySpec::Holiday.order(:date)
-    expect(holidays.collect(&:name)).to eq(["Epiphany"])
-    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 6)])
-  end
-
-  it 'will not save if some fields are invalid' do
-    update(params)
-
-    params['1']['name'] = '-'
-    params['1']['_destroy'] = '1'
-    params['2']['name'] = ''  # invalid
-    expect(update(params)).to be_falsey
-
-    holidays = HolidaySpec::Holiday.order(:date)
-    expect(holidays.collect(&:name)).to eq(["New Year", "Epiphany"])
-    expect(holidays.collect(&:date)).to eq([Date.civil(2014, 1, 1), Date.civil(2014, 1, 6)])
-  end
-
-
-end

data/spec/integration/shape_spec.rb

@@ -1,110 +0,0 @@
-# Usecase: Create a STI record, form model decides which type
-
-require 'spec_helper'
-
-ActiveRecord::Migration.class_eval do
-  create_table :shapes do |t|
-    t.string :type
-    t.integer :radius
-    t.integer :length
-    t.integer :width
-  end
-end
-
-module ShapeSpec
-
-  class Shape < ActiveType::Record
-  end
-
-  class Circle < Shape
-    validates :radius, :presence => true
-  end
-
-  class Rectangle < Shape
-    validates :length, :width, :presence => true
-  end
-
-  class ShapeForm < ActiveType::Object
-    nests_one :child
-
-    def child_type=(type)
-      case type
-      when 'circle'
-        if child
-          self.child = self.child.becomes(Circle)
-        else
-          self.child = Circle.new
-        end
-      when 'rectangle'
-        if child
-          self.child = self.child.becomes(Rectangle)
-        else
-          self.child = Rectangle.new
-        end
-      end
-    end
-  end
-
-end
-
-
-describe ShapeSpec::ShapeForm do
-
-  let(:form) { ShapeSpec::ShapeForm.new }
-
-  def update(params)
-    form.child_type = params[:type]
-    form.child_attributes = params.except(:type)
-    form.save
-  end
-
-  it 'can create a circle' do
-    params = {
-      'type' => 'circle',
-      'radius' => '20'
-    }.with_indifferent_access
-
-    expect(update(params)).to eq(true)
-
-    expect(ShapeSpec::Circle.all.collect(&:radius)).to eq([20])
-    expect(ShapeSpec::Rectangle.count).to eq(0)
-  end
-
-  it 'can create a rectangle' do
-    params = {
-      'type' => 'rectangle',
-      'length' => '100',
-      'width' => '30'
-    }.with_indifferent_access
-
-    expect(update(params)).to eq(true)
-
-    expect(ShapeSpec::Circle.count).to eq(0)
-    expect(ShapeSpec::Rectangle.all.collect(&:length)).to eq([100])
-    expect(ShapeSpec::Rectangle.all.collect(&:width)).to eq([30])
-  end
-
-  it 'can update' do
-    params = {
-      'type' => 'circle',
-      'radius' => '20'
-    }.with_indifferent_access
-    update(params)
-
-    params['radius'] = '30'
-    expect(update(params)).to eq(true)
-
-    expect(ShapeSpec::Circle.all.collect(&:radius)).to eq([30])
-  end
-
-  it 'has validations' do
-    params = {
-      'type' => 'circle'
-    }.with_indifferent_access
-
-    expect(update(params)).to be_falsey
-
-    expect(form.child.errors['radius']).to eq(["can't be blank"])
-  end
-
-end