attributor 5.0.2 → 5.1.0

data/spec/types/boolean_spec.rb

@@ -1,93 +1,66 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Boolean do
-
   subject(:type) { Attributor::Boolean }
 
   it 'it is not Dumpable' do
-    type.new.is_a?(Attributor::Dumpable).should_not be(true)
+    expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
   context '.valid_type?' do
-
     context 'for incoming Boolean values' do
-
       [false, true].each do |value|
-
         it "returns true for #{value.inspect}" do
-          type.valid_type?(value).should be_true
+          expect(type.valid_type?(value)).to be_truthy
         end
-
       end
-
     end
 
     context 'for incoming non-Boolean values' do
-
       ['false', 2, 1.0, Class, Object.new].each do |value|
-
         it "returns false for #{value.inspect}" do
-          type.valid_type?(value).should be_false
+          expect(type.valid_type?(value)).to be_falsey
         end
-
       end
-
     end
-
   end
 
   context '.example' do
-    it "should return a valid Boolean" do
-      [true, false].should include type.example
+    it 'should return a valid Boolean' do
+      expect([true, false]).to include type.example
     end
   end
 
   context '.load' do
-
     context 'for incoming Boolean false values' do
-
       [false, 'false', 'FALSE', '0', 0, 'f', 'F'].each do |value|
-
         it "returns false for #{value.inspect}" do
-          type.load(value).should be(false)
+          expect(type.load(value)).to be(false)
         end
-
       end
-
     end
 
     context 'for incoming Boolean false values' do
-
       [true, 'true', 'TRUE', '1', 1, 't', 'T'].each do |value|
-
         it "returns true for #{value.inspect}" do
-          type.load(value).should be(true)
+          expect(type.load(value)).to be(true)
         end
-
       end
-
     end
 
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'that are not valid Booleans' do
-      let(:context){ ['root','subattr'] }
+      let(:context) { %w(root subattr) }
       ['string', 2, 1.0, Class, Object.new].each do |value|
-
         it "raises Attributor::CoercionError for #{value.inspect}" do
-          expect {
-            type.load(value,context)
-          }.to raise_error(Attributor::CoercionError, /Error coercing from .+ to Attributor::Boolean.* #{context.join('.')}/)
+          expect do
+            type.load(value, context)
+          end.to raise_error(Attributor::CoercionError, /Error coercing from .+ to Attributor::Boolean.* #{context.join('.')}/)
         end
-
       end
-
     end
-
   end
-
 end
-
-

data/spec/types/class_spec.rb

@@ -2,15 +2,14 @@ require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 require 'backports'
 
 describe Attributor::Class do
-
   subject(:type) { Attributor::Class }
 
   it 'it is not Dumpable' do
-    type.new.is_a?(Attributor::Dumpable).should_not be(true)
+    expect(type.new.is_a?(Attributor::Dumpable)).not_to be(true)
   end
 
   its(:native_type) { should be(::Class) }
-  its(:family) { should == 'string' }
+  its(:family) { should eq 'string' }
 
   context '.example' do
     its(:example) { should be_a(::String) }
@@ -28,8 +27,8 @@ describe Attributor::Class do
 
     context 'for incoming String values' do
       ['Object', '::Object', '::Hash', 'Attributor::Struct'].each do |value|
-        it "loads '#{value}' as #{eval(value)}" do
-          type.load(value).should eq(value.constantize)
+        it "loads #{value.inspect}" do
+          expect(type.load(value)).to eq(value.constantize)
         end
       end
     end
@@ -37,7 +36,7 @@ describe Attributor::Class do
     context 'for incoming Class values' do
       [Object, ::Object, ::Hash, Attributor::Struct].each do |value|
         it "loads '#{value}' as #{value}" do
-          type.load(value).should eq(value)
+          expect(type.load(value)).to eq(value)
         end
       end
     end
@@ -47,11 +46,11 @@ describe Attributor::Class do
       subject(:type) { Attributor::Class.of(klass) }
 
       it "loads 'Integer' as Integer" do
-        type.load('Integer').should eq(Integer)
+        expect(type.load('Integer')).to eq(Integer)
       end
 
-      it "returns specified class for nil" do
-        type.load(nil).should be(klass)
+      it 'returns specified class for nil' do
+        expect(type.load(nil)).to be(klass)
       end
 
       it "raises when given a class that doesn't match specified class" do
@@ -60,11 +59,11 @@ describe Attributor::Class do
     end
 
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     it 'raises when given a non-String' do
-      expect {type.load(1)}.to raise_exception(Attributor::IncompatibleTypeError)
+      expect { type.load(1) }.to raise_exception(Attributor::IncompatibleTypeError)
     end
   end
 end

data/spec/types/collection_spec.rb

@@ -1,16 +1,14 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Collection do
-
   subject(:type) { Attributor::Collection }
 
   context '.of' do
-
     [Attributor::Integer, Attributor::Struct].each do |member_type|
       it "returns an anonymous class with correct member_attribute of type #{member_type}" do
         klass = type.of(member_type)
-        klass.should be_a(::Class)
-        klass.member_type.should == member_type
+        expect(klass).to be_a(::Class)
+        expect(klass.member_type).to eq member_type
       end
     end
 
@@ -21,13 +19,12 @@ describe Attributor::Collection do
       #::Object
     ].each do |member_type|
       it "raises when given invalid element type #{member_type}" do
-        expect { klass = type.of(member_type) }.to raise_error(Attributor::AttributorException)
+        expect { type.of(member_type) }.to raise_error(Attributor::AttributorException)
       end
     end
   end
 
   context '.construct' do
-
     # context 'with a Model (or Struct) member_type' do
     #   let(:member_type) { Attributor::Struct }
 
@@ -52,14 +49,13 @@ describe Attributor::Collection do
     # end
 
     context 'with :member_options option' do
-      let(:element_options) { {:identity => 'name'} }
+      let(:element_options) { { identity: 'name' } }
     end
-
   end
 
   context '.native_type' do
-    it "returns Array" do
-      type.native_type.should be(type)
+    it 'returns Array' do
+      expect(type.native_type).to be(type)
     end
   end
 
@@ -72,7 +68,7 @@ describe Attributor::Collection do
         '["alpha", 2, 3.0]'
       ].each do |value|
         it "parses JSON string as array when incoming value is #{value.inspect}" do
-          type.decode_json(value).should == JSON.parse(value)
+          expect(type.decode_json(value)).to eq JSON.parse(value)
         end
       end
     end
@@ -86,50 +82,47 @@ describe Attributor::Collection do
         nil
       ].each do |value|
         it "parses JSON string as array when incoming value is #{value.inspect}" do
-          expect {
+          expect do
             type.decode_json(value)
-          }.to raise_error(Attributor::AttributorException)
+          end.to raise_error(Attributor::AttributorException)
         end
       end
     end
-
   end
 
   context '.load' do
     context 'from a Set' do
-      let(:values) { [1,2,3]}
+      let(:values) { [1, 2, 3] }
       let(:value) { Set.new(values) }
       it 'loads properly' do
-        type.load(value).should =~ values
+        expect(type.load(value)).to match_array values
       end
-
     end
 
     context 'with unspecified element type' do
       context 'for nil values' do
         it 'returns nil' do
-          type.load(nil).should be nil
+          expect(type.load(nil)).to be nil
         end
       end
 
       context 'for valid values' do
         [
           [],
-          [1,2,3],
-          [Object.new, [1,2], nil, true]
+          [1, 2, 3],
+          [Object.new, [1, 2], nil, true]
         ].each do |value|
           it "returns value when incoming value is #{value.inspect}" do
-
-            type.load(value).should =~ value
+            expect(type.load(value)).to match_array value
           end
         end
       end
 
       context 'for invalid values' do
-        let(:context){ ['root','subattr'] }
+        let(:context) { %w(root subattr) }
         [1, Object.new, false, true, 3.0].each do |value|
           it "raises error when incoming value is #{value.inspect} (propagating the context)" do
-            expect { type.load(value,context).should == value }.to raise_error(Attributor::IncompatibleTypeError,/#{context.join('.')}/)
+            expect { expect(type.load(value, context)).to eq value }.to raise_error(Attributor::IncompatibleTypeError, /#{context.join('.')}/)
           end
         end
       end
@@ -138,15 +131,15 @@ describe Attributor::Collection do
     context 'with Attributor::Type element type' do
       context 'for valid values' do
         {
-          Attributor::String   => ["foo", "bar"],
-          Attributor::Integer  => [1, "2", 3],
-          Attributor::Float    => [1.0, "2.0", Math::PI, Math::E],
-          Attributor::DateTime => ["2001-02-03T04:05:06+07:00", "Sat, 3 Feb 2001 04:05:06 +0700"],
+          Attributor::String   => %w(foo bar),
+          Attributor::Integer  => [1, '2', 3],
+          Attributor::Float    => [1.0, '2.0', Math::PI, Math::E],
+          Attributor::DateTime => ['2001-02-03T04:05:06+07:00', 'Sat, 3 Feb 2001 04:05:06 +0700'],
           ::Chicken            => [::Chicken.new, ::Chicken.new]
         }.each do |member_type, value|
           it "returns loaded value when member_type is #{member_type} and value is #{value.inspect}" do
-            expected_result = value.map {|v| member_type.load(v)}
-            type.of(member_type).load(value).should =~ expected_result
+            expected_result = value.map { |v| member_type.load(v) }
+            expect(type.of(member_type).load(value)).to match_array expected_result
           end
         end
       end
@@ -154,17 +147,15 @@ describe Attributor::Collection do
       context 'for invalid values' do
         let(:member_type) { ::Chicken }
         let(:value) { [::Turducken.example] }
-        it "raises error when incoming value is not of member_type" do
-          expect {
-            val = type.of(member_type).load(value)
-          }.to raise_error(Attributor::AttributorException,/Unknown key received/)
+        it 'raises error when incoming value is not of member_type' do
+          expect do
+            type.of(member_type).load(value)
+          end.to raise_error(Attributor::AttributorException, /Unknown key received/)
         end
-
       end
     end
 
     context 'with Attributor::Struct element type' do
-
       # FIXME: Raise in all cases of empty Structs
       # context 'for empty structs' do
       #   let(:attribute_definition) do
@@ -188,7 +179,7 @@ describe Attributor::Collection do
       #       it "returns value when incoming value is #{value.inspect}" do
       #         #pending
       #         expected_value = value.map {|v| empty_struct.load(v)}
-      #         type.of(Struct).load(value).should == expected_value
+      #         type.of(Struct).load(value).should eq expected_value
       #       end
       #     end
       #   end
@@ -206,13 +197,11 @@ describe Attributor::Collection do
       #     end
       #   end
 
-
       # end
 
-
       context 'for simple structs' do
         let(:attribute_definition) do
-          Proc.new do
+          proc do
             attribute :name, Attributor::String
           end
         end
@@ -221,26 +210,26 @@ describe Attributor::Collection do
 
         context 'for valid struct values' do
           [
-            [{"name" => "value"}, {"name" => "another_value"}], # Ruby hash
+            [{ 'name' => 'value' }, { 'name' => 'another_value' }], # Ruby hash
             ['{"name":"value"}'], # JSON hash
           ].each do |value|
             it "returns value when incoming value is #{value.inspect}" do
-              expected_value = value.map {|v| simple_struct.load(v.clone)}
-              type.of(simple_struct).load(value).should =~ expected_value
+              expected_value = value.map { |v| simple_struct.load(v.clone) }
+              expect(type.of(simple_struct).load(value)).to match_array expected_value
             end
           end
         end
 
         context 'for invalid struct values' do
           [
-            [{"name" => "value"}, {"foo" => "another_value"}], # Ruby hash
+            [{ 'name' => 'value' }, { 'foo' => 'another_value' }], # Ruby hash
             ['{"bar":"value"}'], # JSON hash
-            [1,2],
+            [1, 2]
           ].each do |value|
             it "raises when incoming value is #{value.inspect}" do
-              expect {
+              expect do
                 type.of(simple_struct).load(value)
-              }.to raise_error(Attributor::AttributorException)
+              end.to raise_error(Attributor::AttributorException)
             end
           end
         end
@@ -251,37 +240,36 @@ describe Attributor::Collection do
   context '.validate' do
     context 'compatible type values' do
       let(:collection_members) { [1, 2, 'three'] }
-      let(:expected_errors) { ["error 1", "error 2", "error 3"]}
+      let(:expected_errors) { ['error 1', 'error 2', 'error 3'] }
 
       let(:value) { type.load(collection_members) }
 
       before do
         collection_members.zip(expected_errors).each do |member, expected_error|
-          type.member_attribute.should_receive(:validate).
-            with(member,an_instance_of(Array)). # we don't care about the exact context here
-            and_return([expected_error])
+          expect(type.member_attribute).to receive(:validate)
+            .with(member, an_instance_of(Array)) # we don't care about the exact context here
+            .and_return([expected_error])
         end
       end
 
       it 'validates members' do
-        type.validate(value).should =~ expected_errors
+        expect(type.validate(value)).to match_array expected_errors
       end
     end
     context 'invalid incoming types' do
       subject(:type) { Attributor::Collection.of(Integer) }
       it 'raise an exception' do
-        expect {
+        expect do
           type.validate('invalid_value')
-        }.to raise_error(ArgumentError, /can not validate object of type String/)
+        end.to raise_error(ArgumentError, /can not validate object of type String/)
       end
     end
   end
 
-
   context '.example' do
-    it "returns an instance of the type" do
+    it 'returns an instance of the type' do
       value = type.example
-      value.should be_a(type)
+      expect(value).to be_a(type)
     end
 
     [
@@ -294,46 +282,50 @@ describe Attributor::Collection do
     ].each do |member_type|
       it "returns an Array of native types of #{member_type}" do
         value = Attributor::Collection.of(member_type).example
-        value.should_not be_empty
-        value.all? { |element| member_type.valid_type?(element) }.should be_true
+        expect(value).not_to be_empty
+        expect(value.all? { |element| member_type.valid_type?(element) }).to be_truthy
       end
     end
 
-    it "returns an Array with size specified" do
-      type.example(options: {size: 5}).size.should eq(5)
+    it 'returns an Array with size specified' do
+      expect(type.example(options: { size: 5 }).size).to eq(5)
     end
 
-    it "returns an Array with size within a range" do
+    it 'returns an Array with size within a range' do
       5.times do
-        type.example(options: {size: (2..4)}).size.should be_within(1).of(3)
+        expect(type.example(options: { size: (2..4) }).size).to be_within(1).of(3)
       end
     end
 
-    context "passing a non array context" do
+    context 'passing a non array context' do
       it 'still is handled correctly ' do
-        expect{
-          type.example("SimpleString")
-        }.to_not raise_error
+        expect do
+          type.example('SimpleString')
+        end.to_not raise_error
       end
     end
-
   end
 
   context '.describe' do
-    let(:type){ Attributor::Collection.of(Attributor::String)}
-    let(:example){ nil }
-    subject(:described){ type.describe(example: example)}
+    let(:type) { Attributor::Collection.of(Attributor::String) }
+    let(:example) { nil }
+    subject(:described) { type.describe(example: example) }
     it 'includes the member_attribute' do
-      described.should have_key(:member_attribute)
-      described[:member_attribute].should_not have_key(:example)
+      expect(described).to have_key(:member_attribute)
+      expect(described).not_to have_key(:example)
+      expect(described[:member_attribute]).not_to have_key(:example)
     end
 
     context 'with an example' do
-      let(:example){ type.example }
+      let(:example) { type.example }
       it 'includes the member_attribute with an example from the first member' do
-        described.should have_key(:member_attribute)
-        described[:member_attribute].should have_key(:example)
-        described[:member_attribute].should eq( type.member_attribute.describe(example: example.first ) )
+        expect(described).to have_key(:member_attribute)
+        expect(described[:member_attribute]).to have_key(:example)
+        expect(described[:member_attribute]).to eq(type.member_attribute.describe(example: example.first))
+      end
+      it 'includes the incoming example for the whole collection as well' do
+        expect(described).to have_key(:example)
+        expect(described[:example]).to eq(example)
       end
     end
   end
@@ -342,15 +334,14 @@ describe Attributor::Collection do
     let(:type) { Attributor::Collection.of(Cormorant) }
 
     it 'it is Dumpable' do
-      type.new.is_a?(Attributor::Dumpable).should be(true)
+      expect(type.new.is_a?(Attributor::Dumpable)).to be(true)
     end
 
     subject(:example) { type.example }
     it 'dumps' do
-      expect {
+      expect do
         example.dump
-      }.to_not raise_error
+      end.to_not raise_error
     end
   end
-
 end