active_type 0.4.5 → 0.7.5

data/spec/active_type/util_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-
-module UtilSpec
-
-  class BaseRecord < ActiveRecord::Base
-    self.table_name = 'records'
-  end
-
-  class ExtendedRecord < ActiveType::Record[BaseRecord]
-
-    attribute :virtual_string
-    after_initialize :set_virtual_string
-
-    def set_virtual_string
-      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.virtual_string).to be_present
-      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
-
-    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

data/spec/integration/sign_in_spec.rb

@@ -1,101 +0,0 @@
-# Usecase: implement a sign in form
-# The sign in is not tied to a database record
-
-require 'spec_helper'
-
-module SignInSpec
-
-  class SignIn < ActiveType::Object
-    attribute :email, :string
-    attribute :password, :string
-
-    validates :email, :presence => true
-    validates :password, :presence => true
-
-    validate :if => :password do |sign_in|
-      errors.add(:password, 'is not correct') unless sign_in.password == "correct password"
-    end
-
-    after_save :set_session
-
-    def set_session
-    end
-  end
-
-end
-
-describe SignInSpec::SignIn do
-
-  describe 'with missing credentials' do
-
-    it 'is invalid' do
-      expect(subject).not_to be_valid
-    end
-
-    it 'has errors' do
-      subject.valid?
-      expect(subject.errors[:email]).to eq(["can't be blank"])
-      expect(subject.errors[:password]).to eq(["can't be blank"])
-    end
-
-    it 'does not save' do
-      expect(subject.save).to be_falsey
-    end
-
-    it 'does not set the session' do
-      expect(subject).not_to receive :set_session
-      subject.save
-    end
-
-  end
-
-  describe 'with invalid credentials' do
-
-    before do
-      subject.email = "email"
-      subject.password = "incorrect password"
-    end
-
-    it 'is invalid' do
-      expect(subject).not_to be_valid
-    end
-
-    it 'has errors' do
-      subject.valid?
-      expect(subject.errors[:password]).to eq(["is not correct"])
-    end
-
-    it 'does not save' do
-      expect(subject.save).to be_falsey
-    end
-
-    it 'does not set the session' do
-      expect(subject).not_to receive :set_session
-      subject.save
-    end
-
-  end
-
-  describe 'with valid credentials' do
-
-    before do
-      subject.email = "email"
-      subject.password = "correct password"
-    end
-
-    it 'is invalid' do
-      expect(subject).to be_valid
-    end
-
-    it 'does save' do
-      expect(subject.save).to eq(true)
-    end
-
-    it 'sets the session' do
-      expect(subject).to receive :set_session
-      subject.save
-    end
-
-  end
-
-end

data/spec/integration/sign_up_spec.rb

@@ -1,102 +0,0 @@
-# Usecase: implement a sign up form
-# The sign up is tied to a user model
-
-
-require 'spec_helper'
-
-ActiveRecord::Migration.class_eval do
-  create_table :users do |t|
-    t.string :email
-    t.string :password
-  end
-end
-
-
-module SignUpSpec
-
-  class User < ActiveType::Record
-    validates :email, :presence => true
-    validates :password, :presence => true
-  end
-
-
-  class SignUp < ActiveType::Record[User]
-    attribute :terms, :boolean
-
-    validates :terms, :acceptance => {:allow_nil => false, :accept => true}
-
-    after_create :send_welcome_email
-
-    def send_welcome_email
-    end
-  end
-
-end
-
-
-describe SignUpSpec::User do
-
-  it 'is valid without a password confirmation' do
-    subject.email = "email"
-    subject.password = "password"
-
-    expect(subject).to be_valid
-  end
-
-end
-
-
-describe SignUpSpec::SignUp do
-
-  it 'is invalid without an email' do
-    subject.password = "password"
-    subject.terms = true
-
-    expect(subject).not_to be_valid
-    expect(subject.errors['email']).to eq(["can't be blank"])
-  end
-
-  it 'is invalid without accepted terms' do
-    subject.email = "email"
-    subject.password = "password"
-
-    expect(subject).not_to be_valid
-    expect(subject.errors['terms']).to eq(["must be accepted"])
-  end
-
-  context 'with invalid data' do
-
-    it 'does not save' do
-      expect(subject.save).to be_falsey
-    end
-
-    it 'does not send an email' do
-      expect(subject).not_to receive :send_welcome_email
-      subject.save
-    end
-
-  end
-
-  context 'with valid data' do
-
-    before do
-      subject.email = "email"
-      subject.password = "password"
-      subject.terms = "1"
-    end
-
-    it 'does save' do
-      subject.valid?
-      expect(subject.save).to eq(true)
-    end
-
-    it 'sends the email' do
-      expect(subject).to receive :send_welcome_email
-
-      subject.save
-    end
-
-  end
-
-
-end

data/spec/shared_examples/accessors.rb

@@ -1,41 +0,0 @@
-class User < ::ActiveRecord::Base
-end
-
-class Foo < ::ActiveType::Record[User]
-  def new
-    allocate
-  end
-end
-
-
-shared_examples_for "ActiveRecord-like accessors" do |attributes|
-  it 'setup the virtual_attributes instance variable lazy' do
-    expect(Foo.new.virtual_attributes).to eq({})
-  end
-
-  it 'setup the virtual_attributes_cache instance variable lazy' do
-    expect(Foo.new.virtual_attributes_cache).to eq({})
-  end
-
-  it 'allows to read and write' do
-    attributes.each do |key, value|
-      subject.send("#{key}=", value)
-      expect(subject.send(key)).to eq(value)
-    end
-  end
-
-  it 'allows to read via []' do
-    attributes.each do |key, value|
-      subject.send("#{key}=", value)
-      expect(subject[key]).to eq(value)
-    end
-  end
-
-  it 'allows to write via []=' do
-    attributes.each do |key, value|
-      subject[key] = value
-      expect(subject.send(key)).to eq(value)
-    end
-  end
-
-end

data/spec/shared_examples/belongs_to.rb

@@ -1,17 +0,0 @@
-shared_examples_for 'a belongs_to association' do |association, klass|
-
-  let(:record) { klass.create }
-
-  it 'sets the id when assigning a record' do
-    subject.send("#{association}=", record)
-
-    expect(subject.send("#{association}_id")).to eq(record.id)
-  end
-
-  it 'sets the record when assigning an id' do
-    subject.send("#{association}_id=", record.id)
-
-    expect(subject.send("#{association}")).to eq(record)
-  end
-
-end