attrocity 0.0.1 → 0.1.0

data/spec/attrocity/attributes/attribute_methods_builder_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Attrocity
+  describe AttributeMethodsBuilder do
+    let(:object) { Object.new }
+    let(:attr_name) { :a_string }
+    let(:attribute) { Attribute.new(attr_name, 'hello') }
+    subject { described_class.new(object, Array(attribute)) }
+
+    describe '#define_reader' do
+      it 'defines a reader method for the attribute' do
+        expect {
+          subject.define_reader(attribute)
+        }.to change { object.respond_to?(attr_name) }.from(false).to(true)
+      end
+
+      it 'returns the attribute value from the defined reader method' do
+        subject.define_reader(attribute)
+        expect(object.send(attr_name)).to eq('hello')
+      end
+    end
+
+    describe '#define_writer' do
+      it 'defines a writer method for the attribute' do
+        expect {
+          subject.define_writer(attribute)
+        }.to change { object.respond_to?("#{attr_name}=") }.from(false).to(true)
+      end
+
+      it 'sets the attribute value' do
+        subject.define_writer(attribute)
+        object.send("#{attr_name}=", 'foobar')
+        expect(attribute.value).to eq('foobar')
+      end
+    end
+
+    describe '#define_predicate' do
+      it 'defines a predicate method for the attribute' do
+        expect {
+          subject.define_predicate(attribute)
+        }.to change { object.respond_to?("#{attr_name}?") }.from(false).to(true)
+      end
+
+      it 'returns true if the attribute has a truthy value' do
+        subject.define_predicate(attribute)
+        attribute.value = 'xyz'
+        expect(object.send("#{attr_name}?")).to be true
+      end
+
+      it 'returns false if the attribute has a falsy value' do
+        subject.define_predicate(attribute)
+        expect(attribute).to receive(:value).and_return(nil)
+        expect(object.send("#{attr_name}?")).to be false
+      end
+    end
+  end
+end

data/spec/attrocity/attributes/attribute_set_spec.rb

@@ -0,0 +1,24 @@
+module Attrocity
+  RSpec.describe AttributeSet do
+    let(:attrs) { [Attribute.new(:foo, 1), Attribute.new(:bar, 2) ] }
+
+    subject(:attribute_set) { described_class.new }
+
+    describe '#<<' do
+      it 'adds an attribute' do
+        attr = attrs.first
+        subject << attr
+        expect(attribute_set.attributes).to include(attr)
+      end
+
+      it 'raises error when non-attribute is added'
+    end
+
+    describe '#to_h' do
+      it 'returns hash of instance attribute names and values' do
+        attrs.each { |attr| attribute_set << attr }
+        expect(attribute_set.to_h).to eq({ foo: 1, bar: 2 })
+      end
+    end
+  end
+end

data/spec/attrocity/attributes/attribute_spec.rb

@@ -0,0 +1,4 @@
+module Attrocity
+  RSpec.describe Attribute do
+  end
+end

data/spec/attrocity/attributes/attribute_template_set_spec.rb

@@ -0,0 +1,6 @@
+require 'attrocity/attributes/attribute_template_set'
+
+module Attrocity
+  RSpec.describe AttributeTemplateSet do
+  end
+end

data/spec/attrocity/attributes/attribute_template_spec.rb

@@ -0,0 +1,25 @@
+require 'attrocity/attributes/attribute_template'
+
+module Attrocity
+  RSpec.describe AttributeTemplate do
+    describe '#mapper_key_for' do
+      it "returns mapper key when attribute name matches" do
+        attribute = AttributeTemplate.new(
+          :street, Coercers::String.new, KeyMapper.new(:addressline1))
+        expect(attribute.mapper_key_for(:street)).to eq(:addressline1)
+      end
+
+      it "returns mapper key when mapper matches" do
+        attribute = AttributeTemplate.new(
+          :zip, Coercers::String.new, KeyMapper.new(:zipcode))
+        expect(attribute.mapper_key_for(:zipcode)).to eq(:zipcode)
+      end
+
+      it 'returns nil when no match' do
+        attribute = AttributeTemplate.new(
+          :street, Coercers::String.new, KeyMapper.new(:addressline1))
+        expect(attribute.mapper_key_for(:nomatch)).to be_nil
+      end
+    end
+  end
+end

data/spec/attrocity/attributes/model_attribute_spec.rb

@@ -0,0 +1,26 @@
+module Attrocity
+  RSpec.describe ModelAttribute do
+
+      let(:listing) {
+        Examples::Listing.new({ 'listingid' => '1234',
+                                'addressline1' => '100 Elm Street',
+                                'zip' => '27571' })
+      }
+      let(:address) { listing.address }
+
+      it 'instantiates composed model object' do
+        expect(address.street).to eq('100 Elm Street')
+        expect(address.zip).to eq('27571')
+      end
+
+      it 'provides model object' do
+        model_attr = ModelAttribute.new(:address, Examples::Address)
+        address = model_attr.model(
+          { 'addressline1' => '100 Elm Street',
+            'zip' => '27571' })
+        expect(address.street).to eq('100 Elm Street')
+        expect(address.zip).to eq('27571')
+      end
+
+  end
+end

data/spec/attrocity/attrocity_spec.rb

@@ -0,0 +1,83 @@
+require 'attrocity'
+require 'support/examples'
+
+module Attrocity
+  RSpec.describe 'Attrocity module' do
+
+    describe '.initialize' do
+      it 'accepts a hash' do
+        expect {
+          Examples::Person.new(age: 29)
+        }.not_to raise_error
+      end
+
+      let(:person) { Examples::Person.new(age: 29) }
+
+      it 'creates a reader for instance-scope attribute set' do
+        expect { person.attribute_set }.not_to raise_error
+      end
+
+      it 'creates a reader for attribute' do
+        expect(person.respond_to?(:age)).to be true
+      end
+
+      # TODO: Move this spec to another unit?
+      it 'returns correct value for reader method' do
+        expect(person.age).to eq(29)
+      end
+    end
+
+    describe '.attribute' do
+      it 'does not raise error with declarative attribute method' do
+        expect {
+          module Examples
+            class SpecialPerson
+              include Attrocity.model
+              attribute :foo, coercer: :integer
+            end
+          end
+        }.not_to raise_error
+      end
+
+      it 'raises error when missing coercer keyword argument' do
+        expect {
+          module Examples
+            class SpecialDog
+              include Attrocity.model
+              attribute :name
+            end
+          end
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'raises error when using coercer name that is not on the registry' do
+        expect {
+          module Examples
+            class Person
+              include Attrocity.model
+              attribute :foo, coercer: :xyz
+            end
+          end
+        }.to raise_error(UnknownCoercerError)
+      end
+    end
+
+    describe '#attribute_set' do
+      it 'contains expected attributes' do
+        pending
+        obj = Examples::Person.new(age: 29)
+        attribute_names = obj.attribute_set.map(&:name)
+        expect(attribute_names).to include(:age)
+      end
+    end
+
+    describe '.model_from_mapped_data' do
+      it 'returns an instantiated model' do
+        data = { street: '1234 Elm', zip: '27517' }
+        address = Examples::Address.model_from_mapped_data(data)
+        expect(address.street).to eq('1234 Elm')
+        expect(address.zip).to eq('27517')
+      end
+    end
+  end
+end

data/spec/attrocity/coercer_registry_spec.rb

@@ -0,0 +1,14 @@
+require 'attrocity/coercer_registry'
+require 'support/examples'
+
+module Attrocity
+  RSpec.describe CoercerRegistry do
+    it 'adds to the registry' do
+      CoercerRegistry.register do
+        add :example, Examples::ExampleCoercer
+      end
+      expect(CoercerRegistry.coercer_for(:example)).
+        to eq(Examples::ExampleCoercer)
+    end
+  end
+end

data/spec/attrocity/coercers/boolean_spec.rb

@@ -0,0 +1,32 @@
+require 'attrocity/coercers/boolean'
+
+module Attrocity
+  RSpec.describe Coercers::Boolean do
+
+    subject(:coercer) { Coercers::Boolean.new }
+
+    describe '#coerce' do
+      it 'coerces nil to false' do
+        expect(coercer.coerce(nil)).to be false
+      end
+
+      it 'coerces false to false' do
+        expect(coercer.coerce(false)).to be false
+      end
+
+      it 'coerces true to true' do
+        expect(coercer.coerce(true)).to be true
+      end
+
+      it 'coerces 0 to true' do
+        expect(coercer.coerce(0)).to be true
+      end
+
+      it 'coerces an object to true' do
+        expect(coercer.coerce(Object.new)).to be true
+      end
+    end
+
+  end
+end
+

data/spec/attrocity/coercers/coercer_with_args_spec.rb

@@ -0,0 +1,9 @@
+module Attrocity
+  RSpec.describe 'coercer with args' do
+    it 'coerces correctly' do
+      model = Examples::DepositRange.new({ depositlow: '0', deposithigh: '999999' })
+      expect(model.low).to be_nil
+      expect(model.high).to be_nil
+    end
+  end
+end

data/spec/attrocity/coercers/integer_spec.rb

@@ -0,0 +1,25 @@
+require 'attrocity/coercers/integer'
+
+module Attrocity
+  RSpec.describe Coercers::Integer do
+    subject(:coercer) { Coercers::Integer.new }
+
+    describe '#coerce' do
+      it 'coerces to an integer' do
+        expect(coercer.coerce('1')).to eq(1)
+      end
+
+      describe 'given nil' do
+        it 'returns nil' do
+          expect(coercer.coerce(nil)).to be_nil
+        end
+      end
+
+      describe 'given an empty string' do
+        it 'returns nil' do
+          expect(coercer.coerce('')).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/attrocity/coercers/string_spec.rb

@@ -0,0 +1,13 @@
+require 'attrocity/coercers/string'
+
+module Attrocity
+  RSpec.describe Coercers::String do
+    describe '#coerce' do
+      it 'coerces to a string' do
+        coercer = Coercers::String.new
+        expect(coercer.coerce(1)).to eq('1')
+      end
+    end
+  end
+end
+

data/spec/attrocity/default_value_spec.rb

@@ -0,0 +1,22 @@
+module Attrocity
+  RSpec.describe 'Default value' do
+    before do
+      module Examples
+        class DefaultValueExample
+          include Attrocity.model
+          attribute :bool, coercer: :boolean, default: true
+        end
+      end
+    end
+
+    it 'defaults to default value' do
+      example = Examples::DefaultValueExample.new
+      expect(example.bool).to be true
+    end
+
+    it 'overrides default value' do
+      example = Examples::DefaultValueExample.new(bool: false)
+      expect(example.bool).to be false
+    end
+  end
+end

data/spec/attrocity/mappers/key_mapper_spec.rb

@@ -0,0 +1,22 @@
+module Attrocity
+  RSpec.describe KeyMapper do
+    let(:default_value) { nil }
+    subject(:mapper) { KeyMapper.new(:foo, default_value) }
+
+    it 'extracts data via hash key' do
+      expect(mapper.call(double, { foo: 'bar' })).to eq('bar')
+    end
+
+    it 'returns default value when key absent' do
+      expect(mapper.call(double, { biz: 'baz' })).to eq(default_value)
+    end
+
+    describe 'override default value' do
+      let(:default_value) { true }
+
+      it 'returns overridden value when key is absent' do
+        expect(mapper.call(double, { biz: 'baz' })).to eq(default_value)
+      end
+    end
+  end
+end

data/spec/attrocity/mapping_spec.rb

@@ -0,0 +1,47 @@
+require 'support/examples'
+require 'attrocity'
+
+module Attrocity
+  RSpec.describe "Mapping" do
+
+    describe 'with default key mapper' do
+      let(:data) { { 'listingid' => '1234' } }
+      let(:listing) { Examples::Listing.new(data) }
+
+      it 'maps attribute data to attribute name' do
+        expect(listing.id).to eq('1234')
+      end
+
+      it 'does not respond to mapped name' do
+        expect { listing.listingid }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe 'with proc mapper' do
+      before do
+        module Examples
+          class WithProcMapper
+            include Attrocity.model
+            attribute :age,
+              coercer: :integer,
+              from: lambda { |obj, attrs_data| attrs_data['properties']['age'] }
+          end
+        end
+      end
+
+      it 'maps attribute data to attribute name' do
+        object = Examples::WithProcMapper.new({'properties' => { 'age' => 27 } })
+        expect(object.age).to eq(27)
+      end
+
+    end
+
+    describe 'without explicit mapper' do
+      it 'maps attribute data to attribute name' do
+        person = Examples::Person.new(age: 44)
+        expect(person.age).to eq(44)
+      end
+    end
+
+  end
+end

data/spec/attrocity/model_spec.rb

@@ -0,0 +1,34 @@
+module Attrocity
+  RSpec.describe 'Attrocity.model' do
+    describe '#model' do
+      let(:person) { Examples::Person.new(age: 50) }
+      let(:model) { person.model }
+
+      it 'responds to a reader' do
+        expect(model.respond_to?(:age)).to be true
+      end
+
+      it 'does not respond to a writer' do
+        expect(model.respond_to?(:age=)).to be false
+      end
+
+      it 'responds to predicate'do
+        expect(model.respond_to?(:age?)).to be true
+      end
+
+      it 'has correct value for attribute' do
+        expect(model.age).to eq(50)
+      end
+
+      it 'has correct value for predicate' do
+        expect(model.age?).to be true
+      end
+
+      it 'includes model attributes' do
+        listing = Examples::Listing.new({ id: '1234', zip: '10101' })
+        model = listing.model
+        expect(model.address).not_to be_nil
+      end
+    end
+  end
+end