virtus 0.0.5 → 0.0.6

data/spec/unit/virtus/coercion/integer/class_methods/to_decimal_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Integer, '.to_decimal' do
+  subject { object.to_decimal(fixnum) }
+
+  let(:object) { described_class }
+  let(:fixnum) { 1               }
+
+  it { should be_instance_of(BigDecimal) }
+
+  it { should eql(BigDecimal('1.0')) }
+end

data/spec/unit/virtus/coercion/integer/class_methods/to_float_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Integer, '.to_float' do
+  subject { object.to_float(fixnum) }
+
+  let(:object) { described_class }
+  let(:fixnum) { 1               }
+
+  it { should be_instance_of(Float) }
+
+  it { should eql(1.0) }
+end

data/spec/unit/virtus/coercion/integer/class_methods/to_string_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Integer, '.to_string' do
+  subject { object.to_string(integer) }
+
+  let(:object)  { described_class }
+  let(:integer) { 1               }
+
+  it { should be_instance_of(String) }
+
+  it { should eql('1') }
+end

data/spec/unit/virtus/coercion/object/class_methods/method_missing_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Object, '.method_missing' do
+  subject { described_class.send(method_name, value) }
+
+  let(:value) { '1' }
+
+  shared_examples_for 'no method error' do
+    specify do
+      expect { subject }.to raise_error(NoMethodError)
+    end
+  end
+
+  context 'with a non-typecast method' do
+    let(:method_name) { 'not_here' }
+
+    it_behaves_like 'no method error'
+  end
+
+  Virtus::Attribute::Object.descendants.each do |attribute|
+    let(:method_name) { attribute.coercion_method }
+
+    context "with #{attribute.coercion_method.inspect} and an input value" do
+      it { should equal(value) }
+    end
+
+    context "with #{attribute.coercion_method.inspect} and without an input value" do
+      subject { described_class.send(method_name) }
+
+      it_behaves_like 'no method error'
+    end
+  end
+end

data/spec/unit/virtus/coercion/string/class_methods/to_boolean_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::String, '.to_boolean' do
+  subject { object.to_boolean(string) }
+
+  let(:object) { described_class }
+
+  %w[ 1 t true T TRUE ].each do |value|
+    context "with #{value.inspect}" do
+      let(:string) { value }
+
+      it { should be(true) }
+    end
+  end
+
+  %w[ 0 f false F FALSE ].each do |value|
+    context "with #{value.inspect}" do
+      let(:string) { value }
+
+      it { should be(false) }
+    end
+  end
+
+  context 'with an invalid boolean string' do
+    let(:string) { 'non-boolean' }
+
+    it { should equal(string) }
+  end
+end

data/spec/unit/virtus/coercion/string/class_methods/to_date_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::String, '.to_date' do
+  subject { object.to_date(string) }
+
+  let(:object) { described_class }
+
+  context 'with a valid date string' do
+    let(:string) { "July, 22th, 2011" }
+
+    it { should be_instance_of(Date) }
+
+    its(:year)  { should == 2011 }
+    its(:month) { should == 7    }
+    its(:day)   { should == 22   }
+  end
+
+  context 'with an invalid date string' do
+    let(:string) { 'non-date' }
+
+    it { should equal(string) }
+  end
+end

data/spec/unit/virtus/coercion/string/class_methods/to_datetime_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::String, '.to_datetime' do
+  subject { object.to_datetime(string) }
+
+  let(:object) { described_class }
+
+  shared_examples_for 'a correct datetime object' do
+    it { should be_instance_of(DateTime) }
+
+    its(:year)  { should == year  }
+    its(:month) { should == month }
+    its(:day)   { should == day   }
+    its(:hour)  { should == hour  }
+    its(:min)   { should == min   }
+    its(:sec)   { should == sec   }
+  end
+
+  context 'with a valid date string' do
+    let(:year)  { 2011 }
+    let(:month) { 7    }
+    let(:day)   { 22   }
+
+    context 'not including time part' do
+      let(:string) { "July, #{day}th, #{year}" }
+
+      let(:hour) { 0 }
+      let(:min)  { 0 }
+      let(:sec)  { 0 }
+
+      it_behaves_like 'a correct datetime object'
+    end
+
+    context 'including time part' do
+      let(:string) { "July, #{day}, #{year}, #{hour}:#{min}:#{sec}" }
+
+      let(:hour) { 13 }
+      let(:min)  { 44 }
+      let(:sec)  { 50 }
+
+      it_behaves_like 'a correct datetime object'
+    end
+  end
+
+  context 'with an invalid date time string' do
+    let(:string) { 'non-datetime' }
+
+    it { should equal(string) }
+  end
+end

data/spec/unit/virtus/coercion/string/class_methods/to_decimal_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::String, '.to_decimal' do
+  subject { object.to_decimal(string) }
+
+  let(:object) { described_class }
+
+  { '1' => BigDecimal('1.0'), '1.0' => BigDecimal('1.0'), '.1' => BigDecimal('0.1') }.each do |value, expected|
+    context "with #{value.inspect}" do
+      let(:string) { value }
+
+      it { should be_instance_of(BigDecimal) }
+
+      it { should eql(expected) }
+    end
+  end
+
+  context 'with an invalid decimal string' do
+    let(:string) { 'non-decimal' }
+
+    it { should equal(string) }
+  end
+end

data/spec/unit/virtus/coercion/string/class_methods/to_float_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::String, '.to_float' do
+  subject { described_class.to_float(string) }
+
+  { '1' => 1.0, '1.0' => 1.0, '.1' => 0.1 }.each do |value, expected|
+    context "with #{value.inspect}" do
+      let(:string) { value }
+
+      it { should be_instance_of(Float) }
+
+      it { should eql(expected) }
+    end
+  end
+
+  context 'with an invalid float string' do
+    let(:string) { 'non-float' }
+
+    it { should equal(string) }
+  end
+end

data/spec/unit/virtus/coercion/string/class_methods/to_integer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::String, '.to_integer' do
+  subject { described_class.to_integer(string) }
+
+  { '1' => 1, '1.0' => 1, '.1' => 0 }.each do |value, expected|
+    context "with #{value.inspect}" do
+      let(:string) { value }
+
+      it { should be_kind_of(Integer) }
+
+      it { should eql(expected) }
+    end
+  end
+
+  context 'with an invalid integer string' do
+    let(:string) { 'non-integer' }
+
+    it { should equal(string) }
+  end
+end

data/spec/unit/virtus/coercion/string/class_methods/to_time_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::String, '.to_time' do
+  subject { object.to_time(string) }
+
+  let(:object) { described_class }
+
+  shared_examples_for 'a correct time object' do
+    it { should be_instance_of(Time) }
+
+    its(:year)  { should == year  }
+    its(:month) { should == month }
+    its(:day)   { should == day   }
+    its(:hour)  { should == hour  }
+    its(:min)   { should == min   }
+    its(:sec)   { should == sec   }
+  end
+
+  context 'with a valid time string' do
+    let(:year)  { 2011 }
+    let(:month) { 7    }
+    let(:day)   { 22   }
+
+    context 'not including time part' do
+      let(:string) { "July, #{day}th, #{year}" }
+
+      let(:hour) { 0 }
+      let(:min)  { 0 }
+      let(:sec)  { 0 }
+
+      it_behaves_like 'a correct time object'
+    end
+
+    context 'including time part' do
+      let(:string) { "July, #{day}, #{year}, #{hour}:#{min}:#{sec}" }
+
+      let(:hour) { 13 }
+      let(:min)  { 44 }
+      let(:sec)  { 50 }
+
+      it_behaves_like 'a correct time object'
+    end
+  end
+
+  context 'with an invalid date time string' do
+    let(:string) { '2999' }
+
+    it { should equal(string) }
+  end
+end

data/spec/unit/virtus/coercion/symbol/class_methods/to_string_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::Symbol, '.to_string' do
+  subject { object.to_string(symbol) }
+
+  let(:object) { described_class }
+  let(:symbol) { :piotr          }
+
+  it { should be_instance_of(String) }
+
+  it { should eql('piotr') }
+end

data/spec/unit/virtus/coercion/true_class/class_methods/to_string_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Virtus::Coercion::TrueClass, '.to_string' do
+  subject { object.to_string(true_class) }
+
+  let(:object)     { described_class }
+  let(:true_class) { true           }
+
+  it { should be_instance_of(String) }
+
+  it { should eql('true') }
+end

data/spec/unit/virtus/instance_methods/attributes_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 
+# TODO: split this into separate files - solnic
 describe Virtus do
   let(:model) do
     Class.new do
@@ -25,6 +26,12 @@ describe Virtus do
     end
   end
 
+  describe '#to_hash' do
+    it 'returns attributes' do
+      object.to_hash.should == object.attributes
+    end
+  end
+
   describe "#attributes=" do
     before do
       object.attributes = attributes

data/spec/unit/virtus/options/accept_options_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Virtus::Options, '.accept_options' do
+  let(:object) do
+    Class.new do
+      extend Virtus::DescendantsTracker
+      extend Virtus::Options
+    end
+  end
+
+  let(:descendant) { Class.new(object) }
+  let(:new_option) { :width }
+
+  specify { object.should     respond_to(:accept_options) }
+  specify { descendant.should respond_to(:accept_options) }
+
+  before :all do
+    object.accepted_options.should_not include(new_option)
+    descendant.accepted_options.should_not include(new_option)
+    object.accept_options(new_option)
+  end
+
+  it "sets new accepted options on itself" do
+    object.accepted_options.should include(new_option)
+  end
+
+  it "sets new accepted option on its descendants" do
+    descendant.accepted_options.should include(new_option)
+  end
+
+  it "creates option accessors" do
+    object.should respond_to(new_option)
+  end
+
+  it "creates option accessors on descendant" do
+    descendant.should respond_to(new_option)
+  end
+end

data/spec/unit/virtus/options/accepted_options_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Virtus::Options, '.accepted_options' do
+  subject { object.accepted_options }
+
+  specify { object.should respond_to(:accepted_options) }
+
+  let(:object) do
+    Class.new do
+      extend Virtus::DescendantsTracker
+      extend Virtus::Options
+    end
+  end
+
+  let(:options) { [ :width, :height ] }
+
+  before { object.accept_options(*options) }
+
+  it { should be_instance_of(Array) }
+  it { should include(*options)     }
+end

data/spec/unit/virtus/options/options_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Virtus::Options, '.options' do
+  subject { object.options }
+
+  specify { object.should respond_to(:options) }
+
+  let(:object) { Class.new { extend Virtus::Options } }
+
+  it { should be_instance_of(Hash) }
+end

data/spec/unit/virtus/type_lookup/determine_type_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Virtus::TypeLookup, '#determine_type' do
+  subject { object.determine_type(class_or_name) }
+
+  let(:object) do
+    Class.new do
+      extend Virtus::DescendantsTracker
+      extend Virtus::TypeLookup
+    end
+  end
+
+  let(:descendant) do
+    object.const_set :String, Class.new(object) {
+      def self.primitive
+        ::String
+      end
+    }
+  end
+
+  context 'with a TypeLookup class' do
+    context 'when the argument is a descendant of the object' do
+      let(:class_or_name) { descendant }
+
+      it { should equal(descendant) }
+    end
+
+    context 'when the argument is the same object' do
+      let(:class_or_name) { object }
+
+      it { should be_nil }
+    end
+  end
+
+  context 'with a class' do
+    context 'when the argument is a known primitive' do
+      let(:class_or_name) { ::String }
+
+      it { should equal(descendant) }
+    end
+
+    context 'when the argument is an unknown class' do
+      let(:class_or_name) { Class.new }
+
+      it { should be_nil }
+    end
+  end
+
+  context 'with an instance' do
+    context 'when the argument is the name of a known constant' do
+      let(:class_or_name) { 'String' }
+
+      it { should equal(descendant) }
+    end
+
+    context 'when the argument does not stringify to a valid constant name' do
+      let(:class_or_name) { Object.new }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is not the name of a known constant' do
+      let(:class_or_name) { 'Unknown' }
+
+      it { should be_nil }
+    end
+  end
+end