active_type 0.6.0 → 0.6.1

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,24 +0,0 @@
-shared_examples_for "ActiveRecord-like accessors" do |attributes|
-
-  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

data/spec/shared_examples/coercible_columns.rb

@@ -1,248 +0,0 @@
-module TimeConversionSpec
-  class Record < ActiveRecord::Base
-  end
-end
-
-shared_examples_for 'a coercible string column' do |column|
-
-  it 'is nil by default' do
-    expect(subject.send(column)).to be_nil
-  end
-
-  it 'leaves strings alone' do
-    subject.send(:"#{column}=", "string")
-
-    expect(subject.send(column)).to eq("string")
-  end
-
-  it 'does not convert blank' do
-    subject.send(:"#{column}=", "")
-
-    expect(subject.send(column)).to eq("")
-  end
-
-end
-
-
-shared_examples_for 'a coercible integer column' do |column|
-
-  it 'is nil by default' do
-    expect(subject.send(column)).to be_nil
-  end
-
-  it 'leaves integers alone' do
-    subject.send(:"#{column}=", 10)
-
-    expect(subject.send(column)).to eq(10)
-  end
-
-  it 'converts strings to integers' do
-    subject.send(:"#{column}=", "10")
-
-    expect(subject.send(column)).to eq(10)
-  end
-
-  it 'converts blank to nil' do
-    subject.send(:"#{column}=", "")
-
-    expect(subject.send(column)).to be_nil
-  end
-
-end
-
-
-shared_examples_for 'a coercible date column' do |column|
-
-  it 'is nil by default' do
-    expect(subject.send(column)).to be_nil
-  end
-
-  it 'leaves dates alone' do
-    date = Date.today
-    subject.send(:"#{column}=", date)
-
-    expect(subject.send(column)).to eq(date)
-  end
-
-  it 'converts strings to dates' do
-    subject.send(:"#{column}=", "2010-10-01")
-
-    expect(subject.send(column)).to eq(Date.new(2010, 10, 1))
-  end
-
-  it 'converts blank to nil' do
-    subject.send(:"#{column}=", "")
-
-    expect(subject.send(column)).to be_nil
-  end
-
-end
-
-
-shared_examples_for 'a coercible time column' do |column|
-
-  around do |example|
-    begin
-      old_time_zone = Time.zone
-      old_time_zone_aware_attributes = ActiveRecord::Base.time_zone_aware_attributes
-      old_default_timezone = ActiveRecord::Base.default_timezone
-      example.run
-    ensure
-      Time.zone = old_time_zone
-      ActiveRecord::Base.time_zone_aware_attributes = old_time_zone_aware_attributes
-      ActiveRecord::Base.default_timezone = old_default_timezone
-      subject.class.reset_column_information
-    end
-  end
-
-  def it_should_convert_like_active_record(column)
-    time = "2010-10-01 12:15"
-    TimeConversionSpec::Record.reset_column_information
-    subject.class.reset_column_information
-
-    comparison = TimeConversionSpec::Record.new
-    subject.send(:"#{column}=", time)
-    comparison.persisted_time = time
-
-    result = subject.send(column)
-    expect(result).to eq(comparison.persisted_time)
-    expect(result.zone).to eq(comparison.persisted_time.zone)
-  end
-
-
-  it 'is nil by default' do
-    expect(subject.send(column)).to be_nil
-  end
-
-  it 'leaves times alone' do
-    time = Time.at(Time.now.to_i)
-    subject.send(:"#{column}=", time)
-
-    expect(subject.send(column)).to eq(time)
-  end
-
-  it 'converts strings to times' do
-    subject.send(:"#{column}=", "2010-10-01 12:15")
-
-    expect(subject.send(column)).to eq(Time.local(2010, 10, 1, 12, 15))
-  end
-
-  it 'behaves consistently with ActiveRecord' do
-    Time.zone = 'Hawaii'
-
-    it_should_convert_like_active_record(column)
-  end
-
-  it 'behaves consistently with ActiveRecord if time_zone_aware_attributes is set' do
-    Time.zone = 'Hawaii'
-    ActiveRecord::Base.time_zone_aware_attributes = true
-
-    it_should_convert_like_active_record(column)
-  end
-
-  it 'behaves consistently with ActiveRecord if default_timezone is :utc' do
-    Time.zone = 'Hawaii'
-    ActiveRecord::Base.default_timezone = :utc
-
-    it_should_convert_like_active_record(column)
-  end
-
-  it 'behaves consistently with ActiveRecord if time_zone_aware_attributes is set, default_timezone is :utc' do
-    Time.zone = 'Hawaii'
-    ActiveRecord::Base.default_timezone = :utc
-    ActiveRecord::Base.time_zone_aware_attributes = true
-
-    it_should_convert_like_active_record(column)
-  end
-
-end
-
-
-shared_examples_for 'a coercible boolean column' do |column|
-
-  it 'is nil by default' do
-    expect(subject.send(column)).to be_nil
-  end
-
-  it 'leaves booleans alone' do
-    subject.send(:"#{column}=", true)
-
-    expect(subject.send(column)).to eq(true)
-  end
-
-  it 'converts 1 to true' do
-    subject.send(:"#{column}=", "1")
-
-    expect(subject.send(column)).to eq(true)
-  end
-
-  it 'converts 0 to false' do
-    subject.send(:"#{column}=", "0")
-
-    expect(subject.send(column)).to eq(false)
-  end
-
-  it 'converts "" to nil' do
-    subject.send(:"#{column}=", "")
-
-    expect(subject.send(column)).to be_nil
-  end
-
-  it 'converts "true" to true' do
-    subject.send(:"#{column}=", "true")
-
-    expect(subject.send(column)).to eq(true)
-  end
-
-  it 'converts "false" to false' do
-    subject.send(:"#{column}=", "false")
-
-    expect(subject.send(column)).to eq(false)
-  end
-
-end
-
-shared_examples_for 'an untyped column' do |column|
-  it 'is nil by default' do
-    expect(subject.send(column)).to be_nil
-  end
-
-  it 'leaves strings alone' do
-    subject.send(:"#{column}=", "string")
-
-    expect(subject.send(column)).to eq("string")
-  end
-
-  it 'leaves integers alone' do
-    subject.send(:"#{column}=", 17)
-
-    expect(subject.send(column)).to eq(17)
-  end
-
-  it 'leaves objects alone' do
-    object = Object.new
-    subject.send(:"#{column}=", object)
-
-    expect(subject.send(column)).to eq(object)
-  end
-end
-
-
-shared_examples_for 'a coercible type column' do |column, type|
-
-  if type
-
-    it 'is nil by default' do
-      expect(subject.send(column)).to be_nil
-    end
-
-    it 'leaves strings alone' do
-      expect(type).to receive(:cast).with('input').and_return('output')
-      subject.send(:"#{column}=", 'input')
-
-      expect(subject.send(column)).to eq('output')
-    end
-
-  end
-
-end

data/spec/shared_examples/constructor.rb

@@ -1,30 +0,0 @@
-shared_examples_for 'ActiveRecord-like constructors' do |attributes|
-
-  it 'return a new record' do
-    expect(subject.new).to be_new_record
-  end
-
-  it 'assigns given attributes' do
-    record = subject.new(attributes)
-
-    attributes.each do |key, value|
-      expect(record.send(key)).to eq(value)
-    end
-  end
-
-  if ActiveRecord::VERSION::MAJOR >= 4
-
-    it 'raises on unpermitted parameters' do
-      params = ProtectedParams.new(attributes)
-      expect { subject.new(params) }.to raise_error(ActiveModel::ForbiddenAttributesError)
-    end
-
-    it 'accepts permitted parameters' do
-      params = ProtectedParams.new(attributes)
-      params.permit!
-      expect { subject.new(params) }.to_not raise_error
-    end
-
-  end
-
-end

data/spec/shared_examples/defaults.rb

@@ -1,60 +0,0 @@
-shared_examples_for "a class accepting attribute defaults" do |klass|
-
-  subject do
-    Class.new(klass) do
-      attribute :static_string, :string, :default => "static string"
-      attribute :dynamic_string, :string, :default => proc { "dynamic string" }
-      attribute :referential_string, :string, :default => proc { value }
-      attribute :number, :integer, :default => "10"
-      attribute :computed, :default => proc { compute }
-
-      def value
-        "value"
-      end
-
-    end.new
-  end
-
-  it 'can have static defaults' do
-    expect(subject.static_string).to eq("static string")
-  end
-
-  it 'can have dynamic defaults' do
-    expect(subject.dynamic_string).to eq("dynamic string")
-  end
-
-  it 'can have defaults refering to instance methods' do
-    expect(subject.referential_string).to eq("value")
-  end
-
-  it 'typecasts defaults' do
-    expect(subject.number).to eq(10)
-  end
-
-  it 'computes defaults lazily' do
-    expect(subject).to receive(:compute).and_return("computed")
-    expect(subject.computed).to eq("computed")
-  end
-
-  it 'does not compute defaults more than once' do
-    expect(subject).to receive(:compute).exactly(:once).and_return(nil)
-    subject.computed
-    subject.computed
-  end
-
-  it 'does not compute defaults when overriden' do
-    subject.computed = 'not computed'
-    expect(subject.computed).to eq('not computed')
-  end
-
-  it 'does not use defaults when overriden' do
-    subject.static_string = "my string"
-    expect(subject.static_string).to eq("my string")
-  end
-
-  it 'does not use defaults when overriden with nil' do
-    subject.static_string = nil
-    expect(subject.static_string).to eq(nil)
-  end
-
-end

data/spec/shared_examples/dirty_tracking.rb

@@ -1,40 +0,0 @@
-shared_examples_for "a class supporting dirty tracking for virtual attributes" do |klass|
-
-  subject do
-    Class.new(klass) do
-      attribute :virtual_attribute
-    end.new
-  end
-
-  describe '#virtual_attribute_was' do
-
-    it 'always returns nil, since there can be no previously saved value' do
-      expect(subject.virtual_attribute_was).to be_nil
-    end
-
-  end
-
-  describe '#virtual_attribute_changed?' do
-
-    it 'returns true if the attribute is not nil' do
-      subject.virtual_attribute = 'foo'
-      expect(subject.virtual_attribute_changed?).to eq(true)
-    end
-
-    it 'returns false if the attribute is nil' do
-      subject.virtual_attribute = nil
-      expect(subject.virtual_attribute_changed?).to be_falsey
-    end
-
-  end
-
-  describe '#virtual_attribute_will_change!' do
-
-    it 'is implemented for compatibility with ActiveModel::Dirty, but does nothing' do
-      expect(subject).to respond_to(:virtual_attribute_will_change!)
-      expect { subject.virtual_attribute_will_change! }.to_not raise_error
-    end
-
-  end
-
-end

data/spec/shared_examples/dupable.rb

@@ -1,31 +0,0 @@
-shared_examples_for "a class supporting dup for attributes" do |klass|
-
-  subject do
-    Class.new(klass) do
-      attribute :attribute
-    end.new
-  end
-
-  describe '#dup' do
-
-    it 'returns an object with independent attributes' do
-      subject.attribute = "foo"
-      duped = subject.dup
-      duped.attribute = "bar"
-
-      expect(subject.attribute).to eq("foo")
-      expect(duped.attribute).to eq("bar")
-    end
-
-    it 'does a deep copy' do
-      subject.attribute = { :foo => "bar" }
-      duped = subject.dup
-      duped.attribute.merge!(:foo => "baz")
-
-      expect(subject.attribute).to eq({ :foo => "bar" })
-      expect(duped.attribute).to eq({ :foo => "baz" })
-    end
-
-  end
-
-end

data/spec/shared_examples/mass_assignment.rb

@@ -1,26 +0,0 @@
-shared_examples_for 'ActiveRecord-like mass assignment' do |attributes|
-
-  it 'assigns all given attributes' do
-    subject.attributes = attributes
-
-    attributes.each do |key, value|
-      expect(subject.send(key)).to eq(value)
-    end
-  end
-
-  if ActiveRecord::VERSION::MAJOR >= 4
-
-    it 'raises on unpermitted parameters' do
-      params = ProtectedParams.new(attributes)
-      expect { subject.attributes = params }.to raise_error(ActiveModel::ForbiddenAttributesError)
-    end
-
-    it 'accepts permitted parameters' do
-      params = ProtectedParams.new(attributes)
-      params.permit!
-      expect { subject.attributes = params }.to_not raise_error
-    end
-
-  end
-
-end