active_data 0.3.0 → 1.0.0

data/spec/lib/active_data/model/attributes/attribute_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Attribute do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Attribute, :field, {type: Object}.merge(options))
+    Dummy.new.attribute(:field)
+  end
+
+  describe '#read' do
+    let(:field) { attribute(type: String, normalizer: ->(v){ v ? v.strip : v }, default: :world, enum: ['hello', '42', 'world']) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read).to eq('world') }
+    specify { expect(field.tap { |r| r.write(:world) }.read).to eq('world') }
+    specify { expect(field.tap { |r| r.write('hello') }.read).to eq('hello') }
+    specify { expect(field.tap { |r| r.write(' hello ') }.read).to eq(nil) }
+    specify { expect(field.tap { |r| r.write(42) }.read).to eq('42') }
+    specify { expect(field.tap { |r| r.write(43) }.read).to eq(nil) }
+    specify { expect(field.tap { |r| r.write('') }.read).to eq(nil) }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true, default: :world).tap { |r| r.write('string') }.read).to eq(:world) }
+    end
+  end
+
+  describe '#read_before_type_cast' do
+    let(:field) { attribute(type: String, normalizer: ->(v){ v.strip }, default: :world, enum: ['hello', '42', 'world']) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(:world) }.read_before_type_cast).to eq(:world) }
+    specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq('hello') }
+    specify { expect(field.tap { |r| r.write(42) }.read_before_type_cast).to eq(42) }
+    specify { expect(field.tap { |r| r.write(43) }.read_before_type_cast).to eq(43) }
+    specify { expect(field.tap { |r| r.write('') }.read_before_type_cast).to eq('') }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true, default: :world).tap { |r| r.write('string') }.read_before_type_cast).to eq(:world) }
+    end
+  end
+
+  describe '#default' do
+    before { allow_any_instance_of(Dummy).to receive_messages(value: 42) }
+
+    specify { expect(attribute.default).to eq(nil) }
+    specify { expect(attribute(default: 'hello').default).to eq('hello') }
+    specify { expect(attribute(default: -> { value }).default).to eq(42) }
+    specify { expect(attribute(default: ->(object) { object.value }).default).to eq(42) }
+    specify { expect(attribute(default: ->(*args) { args.first.value }).default).to eq(42) }
+  end
+
+  describe '#defaultize' do
+    specify { expect(attribute.defaultize(nil)).to be_nil }
+    specify { expect(attribute(default: 'hello').defaultize(nil)).to eq('hello') }
+    specify { expect(attribute(default: 'hello').defaultize('world')).to eq('world') }
+  end
+
+  describe '#typecast' do
+    specify { expect(attribute.typecast(:hello)).to eq(:hello) }
+    specify { expect(attribute(type: Integer).typecast(42)).to eq(42) }
+    specify { expect(attribute(type: Integer).typecast('42')).to eq(42) }
+  end
+
+  describe '#enum' do
+    before { allow_any_instance_of(Dummy).to receive_messages(value: 1..5) }
+
+    specify { expect(attribute.enum).to eq([].to_set) }
+    specify { expect(attribute(enum: []).enum).to eq([].to_set) }
+    specify { expect(attribute(enum: 'hello').enum).to eq(['hello'].to_set) }
+    specify { expect(attribute(enum: ['hello', 'world']).enum).to eq(['hello', 'world'].to_set) }
+    specify { expect(attribute(enum: [1..5]).enum).to eq([1..5].to_set) }
+    specify { expect(attribute(enum: 1..5).enum).to eq((1..5).to_a.to_set) }
+    specify { expect(attribute(enum: -> { 1..5 }).enum).to eq((1..5).to_a.to_set) }
+    specify { expect(attribute(enum: -> { 'hello' }).enum).to eq(['hello'].to_set) }
+    specify { expect(attribute(enum: -> { ['hello', 42] }).enum).to eq(['hello', 42].to_set) }
+    specify { expect(attribute(enum: -> { value }).enum).to eq((1..5).to_a.to_set) }
+    specify { expect(attribute(enum: ->(object) { object.value }).enum).to eq((1..5).to_a.to_set) }
+  end
+
+  describe '#enumerize' do
+    specify { expect(attribute.enumerize('anything')).to eq('anything') }
+    specify { expect(attribute(enum: ['hello', 42]).enumerize('hello')).to eq('hello') }
+    specify { expect(attribute(enum: ['hello', 42]).enumerize('world')).to eq(nil) }
+    specify { expect(attribute(enum: -> { 'hello' }).enumerize('hello')).to eq('hello') }
+    specify { expect(attribute(enum: -> { 1..5 }).enumerize(2)).to eq(2) }
+    specify { expect(attribute(enum: -> { 1..5 }).enumerize(42)).to eq(nil) }
+  end
+
+  describe '#normalize' do
+    specify { expect(attribute.normalize(' hello ')).to eq(' hello ') }
+    specify { expect(attribute(normalizer: ->(v) { v.strip }).normalize(' hello ')).to eq('hello') }
+    specify { expect(attribute(normalizer: [->(v) { v.strip }, ->(v) { v.first(4) }]).normalize(' hello ')).to eq('hell') }
+    specify { expect(attribute(normalizer: [->(v) { v.first(4) }, ->(v) { v.strip }]).normalize(' hello ')).to eq('hel') }
+
+    context do
+      before { allow_any_instance_of(Dummy).to receive_messages(value: 'value') }
+      let(:other) { 'other' }
+
+      specify { expect(attribute(normalizer: ->(v) { value }).normalize(' hello ')).to eq('value') }
+      specify { expect(attribute(normalizer: ->(v, object) { object.value }).normalize(' hello ')).to eq('value') }
+      specify { expect(attribute(normalizer: ->(v, object) { other }).normalize(' hello ')).to eq('other') }
+    end
+
+    context 'integration' do
+      before do
+        allow(ActiveData).to receive_messages(config: ActiveData::Config.send(:new))
+        ActiveData.normalizer(:strip) do |value|
+          value.strip
+        end
+        ActiveData.normalizer(:trim) do |value, options, attribute|
+          value.first(length || options[:length] || 2)
+        end
+        ActiveData.normalizer(:reset) do |value, options, attribute|
+          empty = value.respond_to?(:empty?) ? value.empty? : value.nil?
+          empty ? attribute.default : value
+        end
+      end
+
+      let(:length) { nil }
+
+      specify { expect(attribute(normalizer: :strip).normalize(' hello ')).to eq('hello') }
+      specify { expect(attribute(normalizer: [:strip, :trim]).normalize(' hello ')).to eq('he') }
+      specify { expect(attribute(normalizer: [:trim, :strip]).normalize(' hello ')).to eq('h') }
+      specify { expect(attribute(normalizer: [:strip, { trim: { length: 4 } }]).normalize(' hello ')).to eq('hell') }
+      specify { expect(attribute(normalizer: {strip: { }, trim: { length: 4 } }).normalize(' hello ')).to eq('hell') }
+      specify { expect(attribute(normalizer: [:strip, { trim: { length: 4 } }, ->(v) { v.last(2) }])
+        .normalize(' hello ')).to eq('ll') }
+      specify { expect(attribute(normalizer: :reset).normalize('')).to eq(nil) }
+      specify { expect(attribute(normalizer: [:strip, :reset]).normalize('   ')).to eq(nil) }
+      specify { expect(attribute(normalizer: :reset, default: '!!!').normalize(nil)).to eq('!!!') }
+      specify { expect(attribute(normalizer: :reset, default: '!!!').normalize('')).to eq('!!!') }
+
+      context do
+        let(:length) { 3 }
+
+        specify { expect(attribute(normalizer: [:strip, { trim: { length: 4 } }]).normalize(' hello ')).to eq('hel') }
+        specify { expect(attribute(normalizer: {strip: { }, trim: { length: 4 } }).normalize(' hello ')).to eq('hel') }
+        specify { expect(attribute(normalizer: [:strip, { trim: { length: 4 } }, ->(v) { v.last(2) }])
+          .normalize(' hello ')).to eq('el') }
+      end
+    end
+  end
+end

data/spec/lib/active_data/model/attributes/base_spec.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Base do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Base, :field, options)
+    Dummy.new.attribute(:field)
+  end
+
+  describe '#read' do
+    let(:field) { attribute(type: String, normalizer: ->(v){ v ? v.strip : v }, default: :world, enum: ['hello', '42', 'world']) }
+    let(:object) { Object.new }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read).to be_nil }
+    specify { expect(field.tap { |r| r.write('') }.read).to eq('') }
+    specify { expect(field.tap { |r| r.write(:world) }.read).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(object) }.read).to eq(object) }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read).to be_nil }
+    end
+  end
+
+  describe '#read_before_type_cast' do
+    let(:field) { attribute(type: String, normalizer: ->(v){ v.strip }, default: :world, enum: ['hello', '42', 'world']) }
+    let(:object) { Object.new }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to be_nil }
+    specify { expect(field.tap { |r| r.write('') }.read_before_type_cast).to eq('') }
+    specify { expect(field.tap { |r| r.write(:world) }.read_before_type_cast).to eq(:world) }
+    specify { expect(field.tap { |r| r.write(object) }.read_before_type_cast).to eq(object) }
+
+    context ':readonly' do
+      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read_before_type_cast).to be_nil }
+    end
+  end
+
+  describe '#value_present?' do
+    let(:field) { attribute }
+
+    specify { expect(field.tap { |r| r.write(0) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(42) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(true) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(false) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(nil) }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write('') }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write(:world) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write(Object.new) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write([]) }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write([42]) }).to be_value_present }
+    specify { expect(field.tap { |r| r.write({}) }).not_to be_value_present }
+    specify { expect(field.tap { |r| r.write({hello: 42}) }).to be_value_present }
+  end
+
+  describe '#query' do
+    let(:field) { attribute }
+
+    specify { expect(field.tap { |r| r.write(0) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write(42) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write(true) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write(false) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write(nil) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write('') }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write(:world) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write(Object.new) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write([]) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write([42]) }.query).to be(true) }
+    specify { expect(field.tap { |r| r.write({}) }.query).to be(false) }
+    specify { expect(field.tap { |r| r.write({hello: 42}) }.query).to be(true) }
+  end
+
+  describe '#readonly?' do
+    specify { expect(attribute).not_to be_readonly }
+    specify { expect(attribute(readonly: false)).not_to be_readonly }
+    specify { expect(attribute(readonly: true)).to be_readonly }
+    specify { expect(attribute(readonly: -> { false })).not_to be_readonly }
+    specify { expect(attribute(readonly: -> { true })).to be_readonly }
+  end
+end

data/spec/lib/active_data/model/attributes/collection_spec.rb

@@ -0,0 +1,73 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Collection do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Collection, :field, options)
+    Dummy.new.attribute(:field)
+  end
+
+  describe '#read' do
+    let(:field) { attribute(type: String, normalizer: ->(v){ v.uniq }, default: :world, enum: ['hello', '42']) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
+    specify { expect(field.tap { |r| r.write([nil]) }.read).to eq([nil]) }
+    specify { expect(field.tap { |r| r.write('hello') }.read).to eq(['hello']) }
+    specify { expect(field.tap { |r| r.write([42]) }.read).to eq(['42']) }
+    specify { expect(field.tap { |r| r.write([43]) }.read).to eq([nil]) }
+    specify { expect(field.tap { |r| r.write([43, 44]) }.read).to eq([nil]) }
+    specify { expect(field.tap { |r| r.write(['']) }.read).to eq([nil]) }
+    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read).to eq(['hello', '42']) }
+    specify { expect(field.tap { |r| r.write(['hello', false]) }.read).to eq(['hello', nil]) }
+
+    context do
+      let(:field) { attribute(type: String, normalizer: ->(v){ v.uniq }, default: :world) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read).to eq([]) }
+      specify { expect(field.tap { |r| r.write([nil, nil]) }.read).to eq(['world']) }
+      specify { expect(field.tap { |r| r.write('hello') }.read).to eq(['hello']) }
+      specify { expect(field.tap { |r| r.write([42]) }.read).to eq(['42']) }
+      specify { expect(field.tap { |r| r.write(['']) }.read).to eq(['']) }
+    end
+  end
+
+  describe '#read_before_type_cast' do
+    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
+    specify { expect(field.tap { |r| r.write([nil]) }.read_before_type_cast).to eq([:world]) }
+    specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq(['hello']) }
+    specify { expect(field.tap { |r| r.write([42]) }.read_before_type_cast).to eq([42]) }
+    specify { expect(field.tap { |r| r.write([43]) }.read_before_type_cast).to eq([43]) }
+    specify { expect(field.tap { |r| r.write([43, 44]) }.read_before_type_cast).to eq([43, 44]) }
+    specify { expect(field.tap { |r| r.write(['']) }.read_before_type_cast).to eq(['']) }
+    specify { expect(field.tap { |r| r.write(['hello', 42]) }.read_before_type_cast).to eq(['hello', 42]) }
+    specify { expect(field.tap { |r| r.write(['hello', false]) }.read_before_type_cast).to eq(['hello', false]) }
+
+    context do
+      let(:field) { attribute(type: String, default: :world) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq([]) }
+      specify { expect(field.tap { |r| r.write([nil, nil]) }.read_before_type_cast).to eq([:world, :world]) }
+      specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq(['hello']) }
+      specify { expect(field.tap { |r| r.write([42]) }.read_before_type_cast).to eq([42]) }
+      specify { expect(field.tap { |r| r.write(['']) }.read_before_type_cast).to eq(['']) }
+    end
+  end
+
+  context 'integration' do
+    before do
+      stub_model(:post) do
+        collection :tags, String
+      end
+    end
+
+    specify { expect(Post.new(tags: ['hello', 42]).tags).to eq(['hello', '42']) }
+    specify { expect(Post.new(tags: ['hello', 42]).tags_before_type_cast).to eq(['hello', 42]) }
+    specify { expect(Post.new.tags?).to eq(false) }
+    specify { expect(Post.new(tags: ['hello', 42]).tags?).to eq(true) }
+  end
+end

data/spec/lib/active_data/model/attributes/dictionary_spec.rb

@@ -0,0 +1,93 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Attributes::Dictionary do
+  before { stub_model(:dummy) }
+
+  def attribute(*args)
+    options = args.extract_options!
+    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Dictionary, :field, options)
+    Dummy.new.attribute(:field)
+  end
+
+  describe '#read' do
+    let(:field) { attribute(type: String, normalizer: ->(v){ v.delete_if { |_, v| v == nil } },
+      default: :world, enum: ['hello', '42']) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write({a: nil}) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write({a: ''}) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write({a: 1}) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write({a: 42}) }.read).to eq({'a' => '42'}) }
+    specify { expect(field.tap { |r| r.write({a: 'hello', b: '42'}) }.read).to eq({'a' => 'hello', 'b' => '42'}) }
+    specify { expect(field.tap { |r| r.write({a: 'hello', b: '1'}) }.read).to eq({'a' => 'hello'}) }
+    specify { expect(field.tap { |r| r.write({a: 'hello', x: '42'}) }.read).to eq({'a' => 'hello', 'x' => '42'}) }
+
+    context do
+      let(:field) { attribute(type: String, normalizer: ->(v){ v.delete_if { |_, v| v == nil } },
+        default: :world) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
+      specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
+      specify { expect(field.tap { |r| r.write({a: 1}) }.read).to eq({'a' => '1'}) }
+      specify { expect(field.tap { |r| r.write({a: nil, b: nil}) }.read).to eq({'a' => 'world', 'b' => 'world'}) }
+      specify { expect(field.tap { |r| r.write({a: ''}) }.read).to eq({'a' => ''}) }
+    end
+
+    context 'with :keys' do
+      let(:field) { attribute(type: String, keys: ['a', :b]) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
+      specify { expect(field.tap { |r| r.write({}) }.read).to eq({}) }
+      specify { expect(field.tap { |r| r.write({a: 1, 'b' => 2, c: 3, 'd' => 4}) }.read).to eq({'a' => '1', 'b' => '2'}) }
+      specify { expect(field.tap { |r| r.write({a: 1, c: 3, 'd' => 4}) }.read).to eq({'a' => '1'}) }
+    end
+  end
+
+  describe '#read_before_type_cast' do
+    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
+    specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
+    specify { expect(field.tap { |r| r.write({a: 1}) }.read_before_type_cast).to eq({'a' => 1}) }
+    specify { expect(field.tap { |r| r.write({a: nil}) }.read_before_type_cast).to eq({'a' => :world}) }
+    specify { expect(field.tap { |r| r.write({a: ''}) }.read_before_type_cast).to eq({'a' => ''}) }
+    specify { expect(field.tap { |r| r.write({a: 42}) }.read_before_type_cast).to eq({'a' => 42}) }
+    specify { expect(field.tap { |r| r.write({a: 'hello', b: '42'}) }.read_before_type_cast).to eq({'a' => 'hello', 'b' => '42'}) }
+    specify { expect(field.tap { |r| r.write({a: 'hello', b: '1'}) }.read_before_type_cast).to eq({'a' => 'hello', 'b' => '1'}) }
+    specify { expect(field.tap { |r| r.write({a: 'hello', x: '42'}) }.read_before_type_cast).to eq({'a' => 'hello', 'x' => '42'}) }
+
+    context do
+      let(:field) { attribute(type: String, default: :world) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
+      specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
+      specify { expect(field.tap { |r| r.write({a: 1}) }.read_before_type_cast).to eq({'a' => 1}) }
+      specify { expect(field.tap { |r| r.write({a: nil, b: nil}) }.read_before_type_cast).to eq({'a' => :world, 'b' => :world}) }
+      specify { expect(field.tap { |r| r.write({a: ''}) }.read_before_type_cast).to eq({'a' => ''}) }
+    end
+
+    context 'with :keys' do
+      let(:field) { attribute(type: String, keys: ['a', :b]) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
+      specify { expect(field.tap { |r| r.write({}) }.read_before_type_cast).to eq({}) }
+      specify { expect(field.tap { |r| r.write({a: 1, 'b' => 2, c: 3, 'd' => 4}) }.read_before_type_cast)
+        .to eq({'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4}) }
+    end
+  end
+
+  context 'integration' do
+    before do
+      stub_model(:post) do
+        dictionary :options, type: String
+      end
+    end
+
+    specify { expect(Post.new(options: {a: 'hello', b: 42}).options).to eq({'a' => 'hello', 'b' => '42'}) }
+    specify { expect(Post.new(options: {a: 'hello', b: 42}).options_before_type_cast).to eq({'a' => 'hello', 'b' => 42}) }
+    specify { expect(Post.new.options?).to eq(false) }
+    specify { expect(Post.new(options: {a: 'hello', b: 42}).options?).to eq(true) }
+  end
+end

data/spec/lib/active_data/model/attributes/localized_spec.rb

@@ -1,49 +1,104 @@
 # encoding: UTF-8
 require 'spec_helper'
 
-describe Localized do
-  let(:klass) do
-    Class.new do
-      include ActiveData::Model
+describe ActiveData::Model::Attributes::Localized do
+  before { stub_model(:dummy) }
 
-      attribute :name, type: Localized
-    end
+  def attribute(*args)
+    options = args.extract_options!
+    reflection = Dummy.add_attribute(ActiveData::Model::Attributes::Reflections::Localized, :field, options)
+    described_class.new('field', Dummy.new)
   end
-  let(:translations) { { en: 'Hello', ru: 'Привет' } }
-  before { I18n.locale = :en }
 
-  describe '#name_translations' do
-    subject { klass.new name_translations: translations }
-    its(:name_translations) { should == translations.stringify_keys }
-    its(:name) { should == translations[:en] }
-  end
+  describe '#read' do
+    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
 
-  describe '#name' do
-    subject { klass.new name: 'Hello' }
-    its(:name_translations) { should == { 'en' => 'Hello' } }
-    its(:name) { should == 'Hello' }
-  end
+    specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
+    specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read).to eq({ 'en' => 'hello' }) }
+    specify { expect(field.tap { |r| r.write({ en: 42 }) }.read).to eq({ 'en' => '42' }) }
+    specify { expect(field.tap { |r| r.write({ en: 43 }) }.read).to eq({ 'en' => nil }) }
+    specify { expect(field.tap { |r| r.write({ en: '' }) }.read).to eq({ 'en' => nil }) }
+    specify { expect(field.tap { |r| r.write({ en: nil }) }.read).to eq({ 'en' => nil }) }
+    specify { expect(field.tap { |r| r.write({ en: 'hello', ru: 42 }) }.read).to eq({ 'en' => 'hello', 'ru' => '42' }) }
 
-  describe '#name_before_type_cast' do
-    let(:object) { Object.new }
-    subject { klass.new name: object }
-    its(:name_before_type_cast) { should == object }
+    context do
+      let(:field) { attribute(type: String, default: :world) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read).to eq({}) }
+      specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read).to eq({ 'en' => 'hello' }) }
+      specify { expect(field.tap { |r| r.write({ en: 42 }) }.read).to eq({ 'en' => '42' }) }
+      specify { expect(field.tap { |r| r.write({ en: '' }) }.read).to eq({ 'en' => '' }) }
+      specify { expect(field.tap { |r| r.write({ en: nil }) }.read).to eq({ 'en' => 'world' }) }
+    end
   end
 
-  context 'fallbacks' do
-    subject { klass.new name_translations: { ru: 'Привет' } }
+  describe '#read_before_type_cast' do
+    let(:field) { attribute(type: String, default: :world, enum: ['hello', '42']) }
+
+    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
+    specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read_before_type_cast).to eq({ 'en' => 'hello' }) }
+    specify { expect(field.tap { |r| r.write({ en: 42 }) }.read_before_type_cast).to eq({ 'en' => 42 }) }
+    specify { expect(field.tap { |r| r.write({ en: 43 }) }.read_before_type_cast).to eq({ 'en' => 43 }) }
+    specify { expect(field.tap { |r| r.write({ en: '' }) }.read_before_type_cast).to eq({ 'en' => '' }) }
+    specify { expect(field.tap { |r| r.write({ en: nil }) }.read_before_type_cast).to eq({ 'en' => :world }) }
+    specify { expect(field.tap { |r| r.write({ en: 'hello', ru: 42 }) }.read_before_type_cast).to eq({ 'en' => 'hello', 'ru' => 42 }) }
+
     context do
-      its(:name) { should be_nil }
+      let(:field) { attribute(type: String, default: :world) }
+
+      specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq({}) }
+      specify { expect(field.tap { |r| r.write({ en: 'hello' }) }.read_before_type_cast).to eq({ 'en' => 'hello' }) }
+      specify { expect(field.tap { |r| r.write({ en: 42 }) }.read_before_type_cast).to eq({ 'en' => 42 }) }
+      specify { expect(field.tap { |r| r.write({ en: '' }) }.read_before_type_cast).to eq({ 'en' => '' }) }
+      specify { expect(field.tap { |r| r.write({ en: nil }) }.read_before_type_cast).to eq({ 'en' => :world }) }
     end
+  end
 
-    context do
-      before do
-        require "i18n/backend/fallbacks"
-        I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-        I18n.fallbacks.map(en: :ru)
+  context 'integration' do
+    let(:klass) do
+      Class.new do
+        include ActiveData::Model
+        include ActiveData::Model::Localization
+
+        localized :name, type: String
+      end
+    end
+    let(:translations) { { en: 'Hello', ru: 'Привет' } }
+    before { I18n.locale = :en }
+
+    describe '#name_translations' do
+      subject { klass.new name_translations: translations }
+      its(:name_translations) { should == translations.stringify_keys }
+      its(:name) { should == translations[:en] }
+    end
+
+    describe '#name' do
+      subject { klass.new name: 'Hello' }
+      its(:name_translations) { should == { 'en' => 'Hello' } }
+      its(:name) { should == 'Hello' }
+    end
+
+    describe '#name_before_type_cast' do
+      let(:object) { Object.new }
+      subject { klass.new name: object }
+      its(:name_before_type_cast) { should == object }
+    end
+
+    context 'fallbacks' do
+      subject { klass.new name_translations: { ru: 'Привет' } }
+      context do
+        its(:name) { should be_nil }
+      end
+
+      context do
+        before do
+          require "i18n/backend/fallbacks"
+          I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+          I18n.fallbacks.map(en: :ru)
+        end
+        after { I18n.fallbacks = false }
+        its(:name) { should == 'Привет' }
       end
-      after { I18n.fallbacks = false }
-      its(:name) { should == 'Привет' }
     end
   end
-end
+end