attributor 5.0.2 → 5.1.0

data/spec/types/polymorphic_spec.rb

@@ -0,0 +1,134 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+
+describe Attributor::Polymorphic do
+  subject(:type) do
+    Attributor::Polymorphic.on(:type)
+  end
+
+  before do
+    type.given :chicken, Chicken
+    type.given :duck, Duck
+    type.given :turkey, Turkey
+  end
+
+  its(:discriminator) { should be :type }
+  its(:types) { should eq(chicken: Chicken, duck: Duck, turkey: Turkey) }
+  its(:native_type) { should be type }
+
+  context '.load' do
+    let(:chicken) { Chicken.example }
+    let(:duck) { Duck.example }
+    let(:turkey) { Turkey.example }
+
+    it 'loads' do
+      expect(type.load(chicken.dump)).to be_kind_of(Chicken)
+      expect(type.load(duck.dump)).to be_kind_of(Duck)
+      expect(type.load(turkey.dump)).to be_kind_of(Turkey)
+    end
+
+    it 'loads a hash with string keys' do
+      data = { 'type' => :chicken }
+      expect(type.load(data)).to be_kind_of(Chicken)
+    end
+
+    it 'raises a LoadError if the discriminator value is unknown' do
+      data = { type: :turducken }
+      expect { type.load(data) }.to raise_error(Attributor::LoadError)
+    end
+
+    it 'raises a LoadError if the discriminator value is missing' do
+      data = { id: 1 }
+      expect { type.load(data) }.to raise_error(Attributor::LoadError)
+    end
+
+    context 'for a type with a string discriminator' do
+      subject(:string_type) do
+        Attributor::Polymorphic.on('type')
+      end
+      it 'loads a hash with symbol keys' do
+        data = { 'type' => :chicken }
+        expect(type.load(data)).to be_kind_of(Chicken)
+      end
+    end
+  end
+
+  context '.dump' do
+    context 'when used in a model' do
+      let(:example) { Sandwich.example }
+      subject(:dumped) { example.dump }
+
+      it 'properly dumps the attribute' do
+        expect(dumped[:meat]).to eq example.meat.dump
+      end
+    end
+  end
+
+  context '.valid_type?' do
+    it 'is true for instances of possible types' do
+      [Chicken, Duck, Turkey].each do |bird_type|
+        example = bird_type.example
+        expect(type.valid_type?(example)).to be_truthy
+      end
+    end
+    it 'is false for other model types' do
+      [Address, Person].each do |other_type|
+        example = other_type.example
+        expect(type.valid_type?(example)).to be_falsey
+      end
+    end
+  end
+
+  context '.example' do
+    subject(:example) { type.example }
+    it do
+      expect([Chicken, Duck, Turkey]).to include(type.example.class)
+    end
+  end
+
+  context '.describe' do
+    let(:example) { nil }
+    subject(:description) { type.describe(example: example) }
+
+    its([:discriminator]) { should eq :type }
+    context 'types' do
+      subject(:types) { description[:types] }
+      its(:keys) { should eq type.types.keys }
+      it do
+        expect(types[:chicken]).to eq(type: Chicken.describe(true))
+        expect(types[:turkey]).to eq(type: Turkey.describe(true))
+        expect(types[:duck]).to eq(type: Duck.describe(true))
+      end
+    end
+
+    context 'in a Model' do
+      subject(:description) { Sandwich.describe[:attributes][:meat][:type] }
+      its([:discriminator]) { should eq :type }
+      context 'types' do
+        subject(:types) { description[:types] }
+        its(:keys) { should match_array [:chicken, :turkey, :duck] }
+        it do
+          expect(types[:chicken]).to eq(type: Chicken.describe(true))
+          expect(types[:turkey]).to eq(type: Turkey.describe(true))
+          expect(types[:duck]).to eq(type: Duck.describe(true))
+        end
+      end
+    end
+  end
+
+  context 'as an attribute in a model' do
+    let(:model) { Sandwich }
+    subject(:example) { model.example }
+    it 'generates an example properly' do
+      expect([Chicken, Duck, Turkey]).to include(example.meat.class)
+    end
+
+    context 'loading' do
+      [Chicken, Duck, Turkey].each do |meat_class|
+        it "loads #{meat_class}" do
+          data = { meat: meat_class.example.dump }
+          expect(Sandwich.load(data).meat).to be_kind_of(meat_class)
+        end
+      end
+    end
+  end
+end

data/spec/types/regexp_spec.rb

@@ -1,32 +1,29 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Regexp do
-
   subject(:type) { Attributor::Regexp }
 
   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(::Regexp) }
   its(:example) { should be_a(::String) }
-  its(:family) { should == 'string' }
+  its(:family) { should eq 'string' }
 
   context '.load' do
     let(:value) { nil }
 
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'for incoming String values' do
-
       { 'foo' => /foo/, '^pattern$' => /^pattern$/ }.each do |value, expected|
         it "loads '#{value}' as #{expected.inspect}" do
-          type.load(value).should eq(expected)
+          expect(type.load(value)).to eq(expected)
         end
       end
-
     end
   end
 end

data/spec/types/string_spec.rb

@@ -1,61 +1,57 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::String do
-
   subject(:type) { Attributor::String }
 
   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 '.native_type' do
-    it "returns String" do
-      type.native_type.should be(::String)
+    it 'returns String' do
+      expect(type.native_type).to be(::String)
     end
   end
 
   context '.example' do
-    it "should return a valid String" do
-      type.example(options:{regexp: /\w\d{2,3}/}).should be_a(::String)
+    it 'should return a valid String' do
+      expect(type.example(options: { regexp: /\w\d{2,3}/ })).to be_a(::String)
     end
 
-    it "should return a valid String" do
-      type.example.should be_a(::String)
+    it 'should return a valid String' do
+      expect(type.example).to be_a(::String)
     end
 
     it 'handles regexps that Randexp can not (#72)' do
       regex = /\w+(,\w+)*/
-      expect {
-        val = Attributor::String.example(options:{regexp: regex})
-        val.should be_a(::String)
-        val.should =~ /Failed to generate.+is too vague/
-      }.to_not raise_error
+      expect do
+        val = Attributor::String.example(options: { regexp: regex })
+        expect(val).to be_a(::String)
+        expect(val).to match(/Failed to generate.+is too vague/)
+      end.to_not raise_error
     end
-
   end
 
   context '.load' do
     let(:value) { nil }
 
     it 'returns nil for nil' do
-      type.load(nil).should be(nil)
+      expect(type.load(nil)).to be(nil)
     end
 
     context 'for incoming String values' do
-
       it 'returns the incoming value' do
         ['', 'foo', '0.0', '-1.0', '1.0', '1e-10', 1].each do |value|
-          type.load(value).should eq(String(value))
+          expect(type.load(value)).to eq(String(value))
         end
       end
     end
-
   end
 
   context 'for incoming Symbol values' do
     let(:value) { :something }
     it 'returns the stringified-value' do
-      type.load(value).should == value.to_s
+      expect(type.load(value)).to eq value.to_s
     end
   end
 
@@ -63,9 +59,9 @@ describe Attributor::String do
     let(:value) { [1] }
 
     it 'raises IncompatibleTypeError' do
-      expect {
+      expect do
         type.load(value)
-      }.to raise_error(Attributor::IncompatibleTypeError)
+      end.to raise_error(Attributor::IncompatibleTypeError)
     end
   end
 end

data/spec/types/struct_spec.rb

@@ -1,36 +1,33 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
 
 describe Attributor::Struct do
-
   context '.definition for a Struct with no sub-attributes' do
     subject { Attributor::Struct }
     it 'raises an error' do
-      expect {
+      expect do
         subject.definition
-      }.to raise_error(Attributor::AttributorException,"Can not use a pure Struct without defining sub-attributes")
+      end.to raise_error(Attributor::AttributorException, 'Can not use a pure Struct without defining sub-attributes')
     end
-
   end
   context '.construct' do
-
     context 'empty struct' do
       let(:attribute_definition) do
-        Proc.new {}
+        proc {}
       end
 
       subject(:empty_struct) { Attributor::Struct.construct(attribute_definition) }
 
       it 'constructs a struct with no attributes' do
-        empty_struct.should < Attributor::Struct
+        expect(empty_struct).to be_subclass_of Attributor::Struct
 
         attributes = empty_struct.attributes
-        attributes.should be_empty
+        expect(attributes).to be_empty
       end
     end
 
     context 'simple struct' do
       let(:attribute_definition) do
-        Proc.new do
+        proc do
           attribute :age, Attributor::Integer
         end
       end
@@ -38,16 +35,16 @@ describe Attributor::Struct do
       subject(:simple_struct) { Attributor::Struct.construct(attribute_definition) }
 
       it 'constructs a struct with one attribute' do
-        simple_struct.should < Attributor::Struct
+        expect(simple_struct).to be_subclass_of Attributor::Struct
 
         attributes = simple_struct.attributes
-        attributes.should have_key :age
+        expect(attributes).to have_key :age
       end
     end
 
     context 'less simple struct' do
       let(:attribute_definition) do
-        Proc.new do
+        proc do
           attribute :age, Attributor::Integer
           attribute :name, Attributor::String
           attribute :employed?, Attributor::Boolean
@@ -59,20 +56,20 @@ describe Attributor::Struct do
       subject(:large_struct) { Attributor::Struct.construct(attribute_definition) }
 
       it 'constructs a struct with five attributes' do
-        large_struct.should < Attributor::Struct
+        expect(large_struct).to be_subclass_of Attributor::Struct
 
         attributes = large_struct.attributes
-        attributes.should have_key :age
-        attributes.should have_key :name
-        attributes.should have_key :employed?
-        attributes.should have_key :salary
-        attributes.should have_key :hired_at
+        expect(attributes).to have_key :age
+        expect(attributes).to have_key :name
+        expect(attributes).to have_key :employed?
+        expect(attributes).to have_key :salary
+        expect(attributes).to have_key :hired_at
       end
     end
 
     context 'complex struct containing model' do
       let(:attribute_definition) do
-        Proc.new do
+        proc do
           attribute :pet, ::Chicken
         end
       end
@@ -80,16 +77,16 @@ describe Attributor::Struct do
       subject(:struct_of_models) { Attributor::Struct.construct(attribute_definition) }
 
       it 'constructs a struct with a model attribute' do
-        struct_of_models.should < Attributor::Struct
+        expect(struct_of_models).to be_subclass_of Attributor::Struct
 
         attributes = struct_of_models.attributes
-        attributes.should have_key :pet
+        expect(attributes).to have_key :pet
       end
     end
 
     context 'complex struct containing named struct' do
       let(:attribute_definition) do
-        Proc.new do
+        proc do
           attribute :stats, Attributor::Struct do
             attribute :months, Attributor::Integer
             attribute :days, Attributor::Integer
@@ -100,20 +97,20 @@ describe Attributor::Struct do
       subject(:struct_of_structs) { Attributor::Struct.construct(attribute_definition) }
 
       it 'constructs a struct with a named struct attribute' do
-        struct_of_structs.should < Attributor::Struct
+        expect(struct_of_structs).to be_subclass_of Attributor::Struct
 
         attributes = struct_of_structs.attributes
-        attributes.should have_key :stats
+        expect(attributes).to have_key :stats
 
         stats = attributes[:stats].attributes
-        stats.should have_key :months
-        stats.should have_key :days
+        expect(stats).to have_key :months
+        expect(stats).to have_key :days
       end
     end
 
     context 'complex struct containing multi-level recursive structs' do
       let(:attribute_definition) do
-        Proc.new do
+        proc do
           attribute :arthropods, Attributor::Struct do
             attribute :insects, Attributor::Struct do
               attribute :ants, Attributor::Struct do
@@ -129,21 +126,21 @@ describe Attributor::Struct do
       subject(:multi_level_struct_of_structs) { Attributor::Struct.construct(attribute_definition) }
 
       it 'constructs a struct with multiple levels of named struct attributes' do
-        multi_level_struct_of_structs.should < Attributor::Struct
+        expect(multi_level_struct_of_structs).to be_subclass_of Attributor::Struct
 
         root = multi_level_struct_of_structs.attributes
-        root.should have_key :arthropods
+        expect(root).to have_key :arthropods
 
         arthropods = root[:arthropods].attributes
-        arthropods.should have_key :insects
+        expect(arthropods).to have_key :insects
 
         insects = arthropods[:insects].attributes
-        insects.should have_key :ants
+        expect(insects).to have_key :ants
 
         ants = insects[:ants].attributes
-        ants.should have_key :name
-        ants.should have_key :age
-        ants.should have_key :weight
+        expect(ants).to have_key :name
+        expect(ants).to have_key :age
+        expect(ants).to have_key :weight
       end
     end
 
@@ -153,37 +150,33 @@ describe Attributor::Struct do
         proc do
         end
       end
-      subject(:struct) { Attributor::Struct.construct(attribute_definition, options)}
+      subject(:struct) { Attributor::Struct.construct(attribute_definition, options) }
 
       context 'with new type-level options' do
-        let(:options) { {reference: reference} }
+        let(:options) { { reference: reference } }
         its(:options) { should have_key(:identity) }
         it 'inherits from the reference' do
-          struct.options[:identity].should eq(reference.options[:identity])
+          expect(struct.options[:identity]).to eq(reference.options[:identity])
         end
         it 'does not raise an error when used in an attribute' do
-          expect {
+          expect do
             Attributor::Attribute.new(struct)
-          }.to_not raise_error
+          end.to_not raise_error
         end
       end
 
       context 'with existing type-level options' do
-        let(:options) { {reference: reference, identity: :name} }
+        let(:options) { { reference: reference, identity: :name } }
         its(:options) { should have_key(:identity) }
         it 'does not override from the reference' do
-          struct.options[:identity].should eq(:name)
+          expect(struct.options[:identity]).to eq(:name)
         end
         it 'does not raise an error when used in an attribute' do
-          expect {
+          expect do
             Attributor::Attribute.new(struct)
-          }.to_not raise_error
+          end.to_not raise_error
         end
-
       end
     end
-
-
   end
-
 end