simple_mapper 0.0.1

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'simple_mapper'
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+

data/test/unit/attribute_collection_test.rb

@@ -0,0 +1,379 @@
+require 'test_helper'
+class AttributeCollectionTest < Test::Unit::TestCase
+  context 'A collection-type attribute' do
+    setup do
+      @class = Class.new(SimpleMapper::Attribute) do
+        include SimpleMapper::Attribute::Collection
+      end
+      @name = :me_collection_attribute
+      @instance = @class.new(@name)
+      @source = {}
+      @object = stub('object', :simple_mapper_source => @source)
+    end
+
+    context 'transforming a value from source' do
+      should 'prepare value marked for tracking changes' do
+        collection = @instance.transformed_source_value(@object)
+        assert_equal true, collection.change_tracking
+      end
+
+      should 'prepare value with no changes marked' do
+        @source.merge!({'a' => 'A', 'b' => 'B'})
+        collection = @instance.transformed_source_value(@object)
+        assert_equal [], collection.changed_members
+      end
+    end
+
+    context 'changed?' do
+      setup do
+        @collection = {}
+        @instance.stubs(:value).with(@object).returns(@collection)
+      end
+
+      context 'with empty changed_members' do
+        setup do
+          @collection.stubs(:changed_members).returns(SimpleMapper::ChangeHash.new)
+        end
+
+        should 'be false' do
+          assert_equal false, @instance.changed?(@object)
+        end
+
+        context 'and a mapper' do
+          setup do
+            @mapper = stub('mapper')
+            @instance.mapper = @mapper
+            @keys = [:a, :b, :c]
+            @keys.each do |key|
+              item = stub('item_' + key.to_s)
+              @collection[key] = item
+            end
+          end
+
+          should 'be false if no mapped values are changed' do
+            @collection.values.each {|item| item.stubs(:changed?).with.returns(false)}
+            assert_equal false, @instance.changed?(@object)
+          end
+
+          should 'be true if any mapped values are changed' do
+            item = @keys.pop
+            @collection[item].stubs(:changed?).with.returns(true)
+            @keys.each {|x| @collection[x].stubs(:changed?).with.returns(false)}
+            assert_equal true, @instance.changed?(@object)
+          end
+        end
+      end
+
+      should 'be true if changed_members is populated' do
+        hash = SimpleMapper::ChangeHash.new
+        hash[:foo] = true
+        @collection.stubs(:changed_members).returns(hash)
+        assert_equal true, @instance.changed?(@object)
+      end
+    end
+
+    should 'pass keys through unchanged for :to_simple_key' do
+      items = ['a string', :a_symbol, 666]
+      assert_equal(items, items.collect {|item| @instance.to_simple_key(item)})
+    end
+
+    should 'pass keys through unchanged for :from_simple_key' do
+      items = ['another string', :another_symbol, 444]
+      assert_equal(items, items.collect {|item| @instance.from_simple_key(item)})
+    end
+
+    context 'for source value' do
+      should 'get its container value from :new_collection' do
+        @instance.expects(:new_collection).returns(container = stub('container'))
+        assert_equal(container, @instance.source_value(@object))
+      end
+
+      should 'determine keys for the mapped structure via :from_simple_key' do
+        source_additional = {:a => 'A', :abc => 'ABC', :aarp => 'AARP'}
+        @instance.stubs(:member_key).returns(false)
+        expected = source_additional.inject({}) do |hash, keyval|
+          @instance.stubs(:member_key?).with(keyval[0]).returns(true)
+          key = keyval[0].to_s + ' transformed'
+          hash[key] = keyval[1]
+          @instance.expects(:from_simple_key).with(keyval[0]).returns(key)
+          hash
+        end
+        @source.merge! source_additional
+        result = @instance.source_value(@object)
+        assert_equal expected, result
+      end
+
+      should 'return empty hash if no keys in the source pass the member_key? test' do
+        # note that this depends on member_key? being a default-false method in the module
+        assert_equal({}, @instance.source_value(@object))
+      end
+
+      should 'return hash with key/value pairs for only the keys passing member_key? test' do
+        expected = {:a => 'A', :abc => 'ABC', :aarp => 'AARP'}
+        @source.merge! expected
+        @instance.stubs(:member_key).returns(false)
+        expected.keys.each do |key|
+          @instance.expects(:member_key?).with(key).returns(true)
+        end
+        assert_equal expected, @instance.source_value(@object)
+      end
+    end
+
+
+    context 'for transformed_source_value' do
+      setup do
+        @expected_source  = {:a => 'A', :aa => 'AA'}
+        @expected_default = {:a => 'Default A', :aa => 'Default AA'}
+        @instance.stubs(:default_value).with(@object).returns(@expected_default)
+      end
+
+      should 'return the source value if there is no type and source is non-empty' do
+        @instance.stubs(:source_value).with(@object).returns(@expected_source)
+        assert_equal @expected_source, @instance.transformed_source_value(@object)
+      end
+
+      should 'return the default value if there is no type and source is empty' do
+        @instance.stubs(:source_value).with(@object).returns(nil)
+        assert_equal @expected_default, @instance.transformed_source_value(@object)
+      end
+
+      context 'with a type' do
+        setup do
+          @instance.type = stub('type')
+        end
+
+        should 'return the result of apply type given the source value' do
+          @instance.expects(:apply_type).with(@expected_source).returns( expected = {:a => 'Foo'})
+          @instance.stubs(:source_value).with(@object).returns(@expected_source)
+          result = @instance.transformed_source_value(@object)
+          assert_equal expected, result
+        end
+
+        should 'return the result of the apply type given the default value and empty source' do
+          @instance.expects(:apply_type).with(@expected_default).returns( expected = {:a => 'Default'} )
+          @instance.stubs(:source_value).with(@object).returns(nil)
+          result = @instance.transformed_source_value(@object)
+          assert_equal expected, result
+        end
+      end
+    end
+
+    context 'for freeze_for' do
+      setup do
+        @collection = [:a, :b, :c].inject({}) {|hash, name| hash[name] = stub(name.to_s); hash}
+        @object = stub('object')
+        @instance.stubs(:value).with(@object).returns(@collection)
+      end
+
+      context 'with simple values' do
+        should 'freeze the collection and leave members alone' do
+          @collection.values.each {|member| member.expects(:freeze).never}
+          @collection.expects(:freeze).with.once
+          @instance.freeze_for(@object)
+        end
+      end
+
+      context 'with mapped values' do
+        setup do
+          @instance.mapper = stub('mapper', :encode => 'foo')
+          @instance.type = @instance.mapper
+        end
+
+        should 'freeze the collection and each collection member' do
+          @collection.values.each {|member| member.expects(:freeze).with.once}
+          @collection.expects(:freeze).with.once
+          @instance.freeze_for(@object)
+        end
+      end
+    end
+
+    context 'for to_simple' do
+      context 'with simple values' do
+        setup do
+          @container_extra = {:foo => 'foo', :bar => 'bar'}
+          @container_added = {:a => 'A', :ab => 'AB'}
+          @value = @container_added.clone
+          @changed_members = SimpleMapper::ChangeHash.new
+          @value.stubs(:simple_mapper_changes).returns(@changed_members)
+        end
+
+        should 'add keys and values to container' do
+          @instance.expects(:value).with(@object).returns(@value)
+          result = @instance.to_simple(@object, @container_extra.clone)
+          assert_equal @container_extra.merge(@container_added), result
+        end
+
+        should 'filters keys through :to_simple_key when adding to container' do
+          @instance.expects(:value).with(@object).returns(@value)
+          expectation = {}
+          @container_added.each do |k, v|
+            key = k.to_s + ' transformed'
+            expectation[key] = v
+            @instance.expects(:to_simple_key).with(k).returns(key)
+          end
+          result = @instance.to_simple(@object, @container_extra.clone)
+          assert_equal @container_extra.merge(expectation), result
+        end
+
+        should 'encode typed values' do
+          @instance.type = mock('type')
+          @instance.expects(:value).with(@object).returns(@value)
+          expectation = {}
+          @container_added.each do |k, v|
+            expectation[k] = v + ' encoded'
+            @instance.type.expects(:encode).with(v).returns(expectation[k])
+          end
+          result = @instance.to_simple(@object, @container_extra.clone)
+          assert_equal @container_extra.merge(expectation), result
+        end
+
+        context 'with changes' do
+          setup do
+            @instance.expects(:value).with(@object).returns(@value)
+            @value.instance_eval do
+              def is_member?(key)
+                key? key
+              end
+            end
+          end
+
+          context 'and :changed option' do
+            should 'not include any unchanged members' do
+              result = @instance.to_simple(@object, @container_extra.clone, :changed => true)
+              assert_equal @container_extra, result
+            end
+
+            should 'include members that are changed' do
+              key = @container_added.keys.first
+              @changed_members[key] = true
+              result = @instance.to_simple(@object, @container_extra.clone, :changed => true)
+              assert_equal @container_extra.merge(key => @container_added[key]), result
+            end
+
+            should 'include members that are deleted' do
+              @changed_members[:removed_a] = true
+              @changed_members[:removed_b] = true
+              result = @instance.to_simple(@object, @container_extra.clone, :changed => true)
+              deletes = @changed_members.keys.inject({}) {|m,k| m[k] = nil; m}
+              assert_equal @container_extra.merge(deletes), result
+            end
+          end
+
+          context 'and :all option' do
+            setup do
+              @changed_members[:removed_a] = true
+              @changed_members[:removed_b] = true
+            end
+
+            should 'include all members included deleted ones' do
+              result = @instance.to_simple(@object, @container_extra.clone, :all => true)
+              deletes = @changed_members.keys.inject({}) {|m,k| m[k] = nil; m}
+              assert_equal @container_extra.merge(@container_added).merge(deletes), result
+            end
+
+            should 'not included deleted members if :defined option present' do
+              result = @instance.to_simple(@object, @container_extra.clone, :all => true, :defined => true)
+              assert_equal @container_extra.merge(@container_added), result
+            end
+          end
+        end
+      end
+
+      context 'with mapped values' do
+        setup do
+          @instance.mapper = stub('mapper', :encode => 'foo')
+          @instance.type = @instance.mapper
+          @base_value = {}
+          @changed_members = SimpleMapper::ChangeHash.new
+          @base_value.stubs(:simple_mapper_changes).returns(@changed_members)
+          @expected_value = {}
+          @container = {}
+        end
+
+        should 'apply to_simple on values' do
+          [:a, :ab, :abc].each do |sym|
+            val = sym.to_s.upcase
+            expect = val + ' simplified'
+            @expected_value[sym] = {sym => expect}
+            @base_value[sym] = mock(val)
+            @base_value[sym].expects(:to_simple).with({}).returns(@expected_value[sym].clone)
+          end
+          @instance.expects(:value).with(@object).returns(@base_value)
+          result = @instance.to_simple(@object, @container) || {}
+          assert_equal @expected_value, result
+        end
+
+        should 'apply to_simple on values and use string keys on collection when requested' do
+          [:a, :ab, :abc].each do |sym|
+            val = sym.to_s.upcase
+            expect = val + ' simplified'
+            @expected_value[sym.to_s] = {sym.to_s => expect}
+            @base_value[sym] = mock(val)
+            @base_value[sym].expects(:to_simple).with({:string_keys => true}).returns(@expected_value[sym.to_s].clone)
+          end
+          @instance.expects(:value).with(@object).returns(@base_value)
+          result = @instance.to_simple(@object, @container, :string_keys => true) || {}
+          assert_equal @expected_value, result
+        end
+
+        context 'with :changed' do
+          should 'include members marked as changed in the collection and members that identify themselves as changed' do
+            [:collection_changed, :item_changed, :not_changed].each do |sym|
+              val = sym.to_s.upcase
+              expect = val + ' simplified'
+              @expected_value[sym] = {sym => expect}
+              @base_value[sym] = mock(val)
+              @base_value[sym].stubs(:to_simple).with({:changed => true}).returns(@expected_value[sym].clone)
+              @base_value.instance_eval do
+                def is_member?(key)
+                  key? key
+                end
+              end
+            end
+            @base_value[:item_changed].expects(:changed?).with.returns(true)
+            @base_value[:not_changed].expects(:changed?).with.returns(false)
+            @base_value[:collection_changed].expects(:changed?).never
+            @changed_members[:collection_changed] = true
+            @instance.expects(:value).with(@object).returns(@base_value)
+            result = @instance.to_simple(@object, @container, :changed => true)
+            @expected_value.delete(:not_changed)
+            assert_equal @expected_value, result
+          end
+        end
+      end
+    end
+
+    context 'when applying type to a source/default value' do
+      setup do
+        @input    = {:a => 'A', :abc => 'ABC', :aabb => 'AABB'}
+        @expected = @input.inject({}) {|h, kv| h[kv[0]] = kv[1] + ' encoded'; h}
+        @type     = stub('type')
+        @instance.stubs(:converter).returns(@type)
+      end
+
+      should 'decode all values in the input hash' do
+        @expected.each do |key, value|
+          @type.expects(:decode).with(@input[key]).returns(value)
+        end
+        @instance.apply_type(@input)
+      end
+
+      should 'return new collection hash of keys mapped to decoded values' do
+        @expected.each do |key, value|
+          @type.stubs(:decode).with(@input[key]).returns(value)
+        end
+        result = @instance.apply_type(@input)
+        assert_equal @expected, result
+        assert_equal SimpleMapper::Collection::Hash, result.class
+      end
+
+      should 'initialize collection hash with the attribute instance' do
+        @expected.each do |key, value|
+          @type.stubs(:decode).with(@input[key]).returns(value)
+        end
+        result = @instance.apply_type(@input)
+        assert_equal @instance, result.attribute
+      end
+    end
+  end
+end

data/test/unit/attribute_pattern_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class SimpleMapperAttributePatternTest < Test::Unit::TestCase
+  context 'A SimpleMapper::Attribute::Pattern instance' do
+    setup do
+      @class = SimpleMapper::Attribute::Pattern
+      @pattern = /^a+/
+      @instance = @class.new(@name = :pattern_collection, :pattern => @pattern)
+    end
+
+    should 'extend SimpleMapper::Attribute' do
+      assert_equal true, @instance.is_a?(SimpleMapper::Attribute)
+    end
+
+    should 'have a pattern attribute' do
+      assert_equal @pattern, @instance.pattern
+      new_pattern = /foo/
+      @instance.pattern = new_pattern
+      assert_equal new_pattern, @instance.pattern
+    end
+
+    should 'require a pattern value' do
+      # no problem if it has a :match method
+      item = stub('item', :match => true)
+      @instance.pattern = item
+      assert_equal item, @instance.pattern
+
+      # no rikey if no :match
+      item = stub('bad bad not-a-pattern')
+      assert_raise(SimpleMapper::InvalidPatternException) do
+        @instance.pattern = item
+      end
+    end
+
+    context 'with a SimpleMapper::Attributes-derived object' do
+      setup do
+        # initialize with non-matching keys
+        @source_values = {:b => 'Bad', :c => 'Cows', :d => 'Deathdog'}
+        @object = stub('object', :simple_mapper_source => @source_values)
+      end
+
+      context 'for source value' do
+        should 'return empty hash if no keys in the source match the pattern' do
+          assert_equal({}, @instance.source_value(@object))
+        end
+
+        should 'return hash with key/value pairs for only the keys matching pattern' do
+          expected = {:a => 'A', :abc => 'ABC', :aarp => 'AARP'}
+          @source_values.merge! expected
+          assert_equal expected, @instance.source_value(@object)
+        end
+      end
+    end
+  end
+end

data/test/unit/attribute_test.rb

@@ -0,0 +1,419 @@
+require 'test_helper'
+
+class AttributeTest < Test::Unit::TestCase
+  context 'A SimpleMapper::Attribute instance' do
+    setup do
+      @name = :some_name
+      @instance = SimpleMapper::Attribute.new(@name)
+    end
+
+    should 'have a name attribute' do
+      assert_equal @name, @instance.name
+      assert_equal :foo, @instance.name = :foo
+      assert_equal :foo, @instance.name
+    end
+
+    should 'have a key attribute that defaults to the name' do
+      assert_equal @name, @instance.key
+      assert_equal :some_key, @instance.key = :some_key
+      assert_equal :some_key, @instance.key
+    end
+
+    should 'have a type attribute' do
+      assert_equal nil, @instance.type
+      assert_equal :some_type, @instance.type = :some_type
+      assert_equal :some_type, @instance.type
+    end
+
+    should 'have a default attribute' do
+      assert_equal nil, @instance.default
+      assert_equal :some_default, @instance.default = :some_default
+      assert_equal :some_default, @instance.default
+    end
+
+    should 'have a mapper attribute' do
+      assert_equal nil, @instance.mapper
+      assert_equal :some_mapper, @instance.mapper = :some_mapper
+      assert_equal :some_mapper, @instance.mapper
+    end
+
+    should 'get value from instance argument' do
+      target = mock('target')
+      target.stubs(@name).with.returns(:foo)
+      assert_equal :foo, @instance.value(target)
+    end
+
+    context 'freeze_for' do
+      should 'do nothing for regular attributes' do
+        target = mock('target')
+        target.expects(:freeze).never
+        @instance.freeze_for(target)
+      end
+
+      should "invoke freeze on instance's nested mapper" do
+        target = mock('mapper target')
+        target.stubs(@instance.name).returns(mapped_obj = mock('mapped instance'))
+        mapped_obj.expects(:freeze).once.with
+        @instance.stubs(:mapper).returns(:some_mapper)
+        @instance.freeze_for(target)
+      end
+    end
+
+    should 'use target object :simple_mapper_changes as state hash of :change_tracking_for' do
+      changes = {}
+      object = mock('object', :simple_mapper_changes => changes)
+      result = @instance.change_tracking_for(object)
+      assert_equal result.object_id, changes.object_id
+    end
+
+    context 'change tracking' do
+      setup do
+        @changes = {}
+        @object = stub('object')
+        @instance.stubs(:change_tracking_for).with(@object).returns(@changes)
+      end
+
+      should 'mark the attribute as changed within an instance.simple_mapper_changes hash when instance given to :changed!' do
+        @instance.changed!(@object)
+        assert_equal({@name => true}, @changes)
+      end
+
+      should 'remove the attribute from changes hash when instance given to :changed! along with false' do
+        @changes[@name] = true
+        @instance.changed!(@object, false)
+        assert_equal({}, @changes)
+      end
+
+      should 'return truth of changed state for attribute on instance provided to :changed? based on instance.simple_mapper_changes' do
+        assert_equal false, @instance.changed?(@object)
+        @changes[@name] = true
+        assert_equal true, @instance.changed?(@object)
+      end
+
+      should 'delegate :changed? call to mapped object if attribute has a mapper' do
+        @instance.stubs(:mapper).returns(:foo)
+        seq = sequence('value calls')
+        true_mapper = stub('mapped object with true')
+        false_mapper = stub('mapped object with false')
+        # value must be checked to retrieve mapped object, so this is a reasonable expectation
+        @instance.expects(:value).with(@object).in_sequence(seq).returns(true_mapper)
+        true_mapper.expects(:changed?).with.in_sequence(seq).returns(true)
+        @instance.expects(:value).with(@object).in_sequence(seq).returns(false_mapper)
+        false_mapper.expects(:changed?).with.in_sequence(seq).returns(false)
+        result = [@instance.changed?(@object), @instance.changed?(@object)]
+        assert_equal [true, false], result
+      end
+
+      should 'return truth of changed state for attribute if attribute has a mapper and value is nil' do
+        @instance.stubs(:mapper).returns(:foo)
+        @instance.stubs(:value).with(@object).returns(nil)
+        assert_equal false, @instance.changed?(@object)
+        @changes[@name] = true
+        assert_equal true, @instance.changed?(@object)
+      end
+    end
+
+    context 'when encoding' do
+      should 'pass through the value when type is undefined' do
+        assert_equal :foo, @instance.encode(:foo)
+      end
+
+      should 'convert the value with type.encode if type is a convertor' do
+        type = stub('type')
+        type.expects(:encode).with(:foo).returns(:foo_too)
+        @instance.type = type
+        assert_equal :foo_too, @instance.encode(:foo)
+      end
+
+      should 'convert the value with type from registry if type is registered' do
+        type = stub('type')
+        type.expects(:encode).with(:foo).returns(:foo_too)
+        SimpleMapper::Attributes.expects(:type_for).with(:some_type).returns({:converter => type})
+        @instance.type = :some_type
+        assert_equal :foo_too, @instance.encode(:foo)
+      end
+
+      should 'throw an InvalidTypeException if type is specified but is not a convertor' do
+        @instance.type = stub('no type')
+        assert_raise(SimpleMapper::InvalidTypeException) { @instance.encode(:foo) }
+      end
+    end
+
+    context 'using its default_value method' do
+      setup do
+        @default_name = :default_method
+        @default_value = 'some default'
+        @object = stub('object', @default_name => @default_value)
+      end
+
+      should 'return nil if there is no default' do
+        assert_equal nil, @instance.default_value(@object)
+      end
+
+      should 'return the default value if there is one by invoking the default on the target object' do
+        @instance.default = @default_name
+        assert_equal @default_value, @instance.default_value(@object)
+      end
+
+      context 'with a default of :from_type' do
+        setup do
+          @expected_value = 'the default value'
+          @type = stub('type', :name => :some_type, :encode => :blah, :decode => :blah)
+          @type.expects(:default).once.with.returns(@expected_value)
+          @instance.default = :from_type
+        end
+
+        should 'invoke :default on type if it is able' do
+          @instance.type = @type
+          result = @instance.default_value(@object)
+          assert_equal @expected_value, result
+        end
+
+        should 'invoke :default on registered type if type is registered' do
+          @instance.type = @type.name
+          SimpleMapper::Attributes.stubs(:types).with.returns({@type.name => {
+            :name           => @type.name,
+            :expected_class => @type.class,
+            :converter      => @type,
+          }})
+          result = @instance.default_value(@object)
+          assert_equal @expected_value, result
+        end
+      end
+    end
+  end
+
+  context 'the SimpleMapper::Attribute constructor' do
+    setup do
+      @class = SimpleMapper::Attribute
+    end
+
+    should 'allow specification of key in constructor' do
+      instance = @class.new(:name, :key => :some_key)
+      assert_equal :some_key, instance.key
+    end
+
+    should 'allow specification of type in constructor' do
+      instance = @class.new(:name, :type => :some_type)
+      assert_equal :some_type, instance.type
+    end
+
+    should 'allow specification of default in constructor' do
+      instance = @class.new(:name, :default => :some_default)
+      assert_equal :some_default, instance.default
+    end
+
+    should 'allow specification of mapper in constructor' do
+      instance = @class.new(:name, :mapper => :some_mapper)
+      assert_equal :some_mapper, instance.mapper
+    end
+  end
+
+  context 'the SimpleMapper::Attribute :to_simple method' do
+    setup do
+      @name      = :some_attribute
+      @key       = :some_attribute_key
+      @class     = SimpleMapper::Attribute
+      @instance  = @class.new(@name, :key => @key)
+      @value     = 'some_attribute_value'
+
+      # the container is provided in each :to_simple call; it's where the
+      # simplified representation of the attribute/value should go.
+      # We want it to start as non-empty so the test can verify that the
+      # to_simple operation is additive rather than destructive
+      @container = {:preserve_me => :or_else}
+
+      @object    = stub('object')
+      @object.stubs(@name).returns(@value)
+    end
+
+    context 'for an untyped attribute' do
+      should 'assign the attribute value as key/pair to the provided container' do
+        result = @container.clone
+        result[@key] = @value
+        @instance.to_simple @object, @container
+        assert_equal result, @container
+      end
+
+      should 'not assign key/value if :defined is true and value is nil' do
+        @object.stubs(@name).returns(nil)
+        result = @container.clone
+        @instance.to_simple @object, @container, :defined => true
+        assert_equal result, @container
+      end
+
+      should 'assign attr value as key/val pair if :defined is true and value is !nil' do
+        result = @container.clone
+        result[@key] = @value
+        @instance.to_simple @object, @container, :defined => true
+        assert_equal result, @container
+      end
+
+      should 'use string keys instead of symbols if :string_keys option is true' do
+        result = @container.clone
+        result[@key.to_s] = @value
+        @instance.to_simple @object, @container, :string_keys => true
+        assert_equal result, @container
+      end
+
+      should 'invoke to_simple on value rather than encoding if mapper is set' do
+        @instance.mapper = mapper = mock('mapper')
+        options = {:some_useless_option => :me}
+        @value.expects(:to_simple).with(options).returns(:something_simple)
+        result = @container.clone
+        result[@key] = :something_simple
+        @instance.to_simple @object, @container, options
+        assert_equal result, @container
+      end
+
+      should 'assign key with nil value for mapper if :defined is false and value is nil' do
+        @instance.mapper = mapper = mock('mapper')
+        @object.stubs(@name).returns(nil)
+        result = @container.clone
+        @instance.to_simple @object, @container
+        assert_equal result.merge({@key => nil}), @container
+      end
+
+      should 'use the mapper as type if a mapper is set' do
+        @instance.mapper = mapper = mock('mapper')
+        assert_equal mapper, @instance.type
+      end
+    end
+
+    context 'for a typed attribute' do
+      setup do
+        @type = stub('type')
+        @type.stubs(:encode).with(@value).returns(@encoded_value = :some_encoded_value)
+        @instance.type = @type
+      end
+
+      should 'assign the encoded attribute value as key/pair to the provided container' do
+        result = @container.clone
+        result[@key] = @encoded_value
+        @instance.to_simple @object, @container
+        assert_equal result, @container
+      end
+
+      should 'not assign key/value if :defined is true and encoded value is nil' do
+        @type.stubs(:encode).with(@value).returns(nil)
+        result = @container.clone
+        @instance.to_simple @object, @container, :defined => true
+        assert_equal result, @container
+      end
+
+      should 'assign encoded attr value as key/val pair if :defined is true and value is !nil' do
+        result = @container.clone
+        result[@key] = @encoded_value
+        @instance.to_simple @object, @container, :defined => true
+        assert_equal result, @container
+      end
+
+      should 'use string keys instead of symbols if :string_keys option is true' do
+        result = @container.clone
+        result[@key.to_s] = @encoded_value
+        @instance.to_simple @object, @container, :string_keys => true
+        assert_equal result, @container
+      end
+
+      should 'use specified type when set rather than using the mapper' do
+        @instance.mapper = mapper = mock('mapper')
+        assert_equal @type, @instance.type
+      end
+    end
+  end
+
+  context 'A SimpleMapper::Attribute working with a SimpleMapper::Attributes-based object' do
+    setup do
+      @class = SimpleMapper::Attribute
+      @key      = :some_key
+      @value    = :some_value
+      @name     = :some_attribute
+      @instance = @class.new(@name, :key => @key)
+
+      @source = {}
+      @object.stubs(:simple_mapper_source).with.returns(@source)
+    end
+
+    context 'using the :source_value method' do
+      should 'return object source value by key symbol' do
+        @source[@key] = @value
+        assert_equal @value, @instance.source_value(@object)
+      end
+
+      should 'return object source value by key string if symbol does not exist' do
+        @source[@key.to_s] = @value
+        assert_equal @value, @instance.source_value(@object)
+      end
+    end
+
+    context 'using the :transformed_source_value method' do
+      should 'return the source value directly' do
+        @instance.expects(:source_value).with(@object).returns(@value)
+        assert_equal @value, @instance.transformed_source_value(@object)
+      end
+
+      should 'return the default value if the source value is undefined' do
+        @instance.stubs(:source_value).with(@object).returns(nil)
+        @instance.expects(:default_value).with(@object).returns(:my_default)
+        result = @instance.transformed_source_value(@object)
+        #assert_equal :my_default, result
+      end
+
+      context 'with a typed attribute' do
+        setup do
+          @type = stub('type', :name => :sooper_speshil_tipe)
+          @registry = {:name => @type.name, :converter => @type}
+          SimpleMapper::Attributes.stubs(:type_for).with(@type.name).returns(@registry)
+        end
+
+        context 'and a type that supports :decode' do
+          setup do
+            @instance.type = @type
+            @type.expects(:decode).with(@value).returns( @encoded = :encoded )
+          end
+
+          should 'return the decoded source value' do
+            @instance.stubs(:source_value).with(@object).returns(@value)
+            @instance.expects(:default_value).with(@object).never
+            assert_equal @encoded, @instance.transformed_source_value(@object)
+          end
+
+          should 'return the decoded default value if no source defined' do
+            @instance.stubs(:source_value).with(@object).returns(nil)
+            @instance.stubs(:default_value).with(@object).returns(@value)
+            result = @instance.transformed_source_value(@object)
+            # assert_equal @encoded, result
+          end
+        end
+
+        context 'and an expected type' do
+          setup do
+            @instance.type = @type.name
+            @registry[:expected_type] = @value.class
+            @type.expects(:decode).never
+          end
+
+          should 'return the source value if it matches' do
+            @instance.stubs(:source_value).with(@object).returns(@value)
+            assert_equal @value, @instance.transformed_source_value(@object)
+          end
+
+          should 'return the default value if no source defined and default matches' do
+            @instance.stubs(:source_value).with(@object).returns(nil)
+            @instance.expects(:default_value).with(@object).returns(@value)
+            result = @instance.transformed_source_value(@object)
+            # assert_equal @value, result
+          end
+        end
+
+        should 'return the decoded source value via the registered type' do
+          @instance.type = @type.name
+          @instance.stubs(:source_value).with(@object).returns(@value)
+          @type.expects(:decode).with(@value).returns( encoded = :encoded )
+          result = @instance.transformed_source_value(@object)
+          assert_equal encoded, result
+        end
+      end
+    end
+  end
+end