locomotivecms_models 0.0.1.pre.alpha

data/spec/unit/adapters/memory/dataset_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Locomotive::Adapters::Memory::Dataset do
+
+  let(:john) do
+    {
+      firstname: 'John',
+      lastname: 'Doe',
+      email: 'john@example.com',
+      age: 24
+    }
+  end
+
+  let(:jane) do
+    {
+      firstname: 'Jane',
+      lastname: 'Doe',
+      email: 'jane@example.com',
+      age: 20
+    }
+  end
+
+  let(:alex) do
+    {
+      firstname: 'Alex',
+      lastname: 'Turam',
+      email: 'alex@example.com',
+      age: 26
+    }
+  end
+
+  subject { Locomotive::Adapters::Memory::Dataset.new(:foo) } #(loader) }
+
+  before do
+    [john.to_hash, jane.to_hash, alex.to_hash].each do |record|
+      subject.insert record
+    end
+  end
+
+  describe '#all' do
+    its(:all) { should eq [john.to_hash, jane.to_hash, alex.to_hash] }
+  end
+
+  describe '#find' do
+    specify do
+      expect(subject.find(john[:id])).to eq(john.to_hash)
+    end
+  end
+
+  describe '#update' do
+    before do
+      subject.update(jane.to_hash.merge(lastname: 'birkin'))
+    end
+
+    specify do
+      expect(subject.find(jane[:id]).fetch(:lastname)).to eq('birkin')
+    end
+  end
+
+  describe '#exists?' do
+    let(:dataset) { Locomotive::Adapters::Memory::Dataset.new(:dummy) }
+    before do
+      dataset.instance_variable_set('@records', { 1 => 'Record 1', 2 => 'Record 2' })
+    end
+
+    it { dataset.exists?(2).should   be_true  }
+    it { dataset.exists?(3).should   be_false }
+    it { dataset.exists?(nil).should be_false }
+
+  end
+end

data/spec/unit/adapters/memory/query_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Locomotive
+  module Adapters
+    module Memory
+
+      describe Query do
+        let(:entry_1) {{ name: 'foo',  id: 1 }}
+        let(:entry_2) {{ name: 'bar',  id: 2 }}
+        let(:entry_3) {{ name: 'zone', id: 3 }}
+        let(:records) do
+          { 1 => entry_1, 2 => entry_2, 3 => entry_3 }
+        end
+        let(:collection) { :foo }
+        let(:dataset) do
+          Dataset.new(collection).tap do |dataset|
+            dataset.stub records: records
+          end
+        end
+        let(:locale) { :en }
+
+        describe '#limited' do
+          specify do
+            expect(
+              Query.new(dataset, locale) do
+                limit(1)
+              end.all
+            ).to eq([entry_1])
+          end
+        end
+
+        describe '#order_by' do
+
+          context 'asc' do
+            specify do
+              expect(
+                Query.new(dataset, locale) do
+                  order_by('name asc')
+                end.all.map(&:id)
+              ).to eq([2, 1, 3])
+            end
+          end
+
+          context 'desc' do
+            specify do
+              expect(
+                Query.new(dataset, locale) do
+                  order_by('name desc')
+                end.all.map(&:id)
+              ).to eq([3, 1, 2])
+            end
+          end
+        end
+
+        describe '#where' do
+          specify do
+            expect(
+              Query.new(dataset, locale) do
+                where('name.eq' => 'foo').
+                where('id.lt' => 2)
+              end.all.map(&:id)
+            ).to eq([1])
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/decorators/i18n_decorator_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+require 'locomotive/decorators'
+
+describe Locomotive::Decorators::I18nDecorator do
+
+  class FakeEntity
+    include Locomotive::Entity
+    attributes :name, :description
+  end
+
+  describe 'initialization' do
+    context 'with instance' do
+      subject do
+        Locomotive::Decorators::I18nDecorator.new(FakeEntity.new)
+      end
+
+      it 'accepts an entity as parameter' do
+        subject.should be_kind_of Locomotive::Decorators::I18nDecorator
+      end
+
+      it 'responds to all entity attributes' do
+        subject.should respond_to :name
+        subject.should respond_to :description
+        subject.should respond_to :name=
+        subject.should respond_to :description=
+      end
+    end
+
+    context 'with resultset' do
+      let(:entities) {
+        [ FakeEntity.new, FakeEntity.new ]
+      }
+      it 'decorates each entity' do
+        Locomotive::Decorators::I18nDecorator.decorate(entities).each do |entity|
+          entity.should be_kind_of(Locomotive::Decorators::I18nDecorator)
+        end
+      end
+    end
+  end
+
+  describe 'fields on single instance' do
+
+    subject { decorator.name }
+    let(:decorator) { Locomotive::Decorators::I18nDecorator.new(entity) }
+    let(:entity) { FakeEntity.new(name: name) }
+
+    context 'when field is not an i18n field' do
+      let(:name) { 'blah' }
+      it { should eql 'blah' }
+    end
+
+    context 'when field is an i18n field' do
+      let(:name) { { en: 'blah', fr: 'bla' } }
+      context 'no current locale' do
+        it 'displays object for inspection' do
+          subject.should eql '#<I18nField: @i18n_values=>{:en=>blah,:fr=>bla}>'
+        end
+      end
+
+      context 'with current locale' do
+        before { decorator.current_locale = :fr }
+        it { should eql 'bla' }
+      end
+
+      context 'passing current locale in constructor' do
+        let(:decorator) { Locomotive::Decorators::I18nDecorator.new(entity, :fr) }
+        it { should eql 'bla' }
+      end
+    end
+  end
+
+  describe 'fields on resultset' do
+    subject { decorated_set.first.name }
+    let(:entities) {
+      [ FakeEntity.new(name: { en: 'blah', es: '', fr: 'bla'}),
+        FakeEntity.new
+      ]
+    }
+    context 'when no locale is passed in constructor' do
+      let(:decorated_set) do
+        Locomotive::Decorators::I18nDecorator.decorate(entities)
+      end
+      it 'displays object for inspection' do
+        subject.should eq '#<I18nField: @i18n_values=>{:en=>blah,:es=>,:fr=>bla}>'
+      end
+    end
+
+    context 'when locale is passed in the constructor' do
+      let(:decorated_set) do
+        Locomotive::Decorators::I18nDecorator.decorate(entities, :fr)
+      end
+      it { should eq 'bla' }
+    end
+  end
+
+  context 'Fallbacks' do
+    subject { decorator.name }
+    let(:decorator) { Locomotive::Decorators::I18nDecorator.new(entity, locale) }
+    let(:entity) { FakeEntity.new(name: name) }
+    let(:name) { { en: 'blah', fr: 'bla', es: '' } }
+
+    context 'when passed locale does not exist' do
+      let(:locale) { :wk }
+      context 'default fallback' do
+        it { should be_nil }
+      end
+      context 'custom fallback' do
+        before do
+          decorator.on_no_locale = Proc.new { |field, locale| "Translation #{locale} is not supported" }
+        end
+        it { should eq 'Translation wk is not supported' }
+      end
+    end
+
+    context 'when entity has empty locale value' do
+      let(:locale) { :es }
+
+      context 'default fallback' do
+        it 'returns the first locale in the field' do
+          subject.should eq 'blah'
+        end
+      end
+
+      context 'custom fallback' do
+        before do
+          decorator.on_empty_locale = Proc.new { |field, locale| "#{field[:en]} [untranslated #{locale}]" }
+        end
+        it { should eq 'blah [untranslated es]' }
+      end
+    end
+
+  end
+end

data/spec/unit/entity_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Locomotive::Entity do
+
+  class FakeEntity
+    include Locomotive::Entity
+    attributes :name, :description
+  end
+
+  context 'simplest instanciation' do
+    subject { FakeEntity.new }
+    it { should be_a FakeEntity }
+    it { should respond_to :name }
+    it { should respond_to :name= }
+  end
+
+  context 'with empty hash' do
+    subject { FakeEntity.new({}) }
+    it { should be_a FakeEntity }
+    its(:name) { should be_nil }
+  end
+
+  context 'with hash and data in it' do
+    subject { FakeEntity.new({name: 'John'}) }
+    it { should be_a FakeEntity }
+    its(:name) { should eq 'John' }
+    its(:description) { should be_nil }
+  end
+
+end

data/spec/unit/fields/i18n_field_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Locomotive::Fields::I18nField do
+
+  subject { Locomotive::Fields::I18nField.new(values) }
+  let(:values) { { wk: '', en: 'My value', es: 'Mi valor' } }
+  describe '#to_s' do
+    context 'no params' do
+      it 'displays object inspection' do
+        subject.to_s.should eql '#<I18nField: @i18n_values=>{:wk=>,:en=>My value,:es=>Mi valor}>'
+      end
+    end
+    context 'locale as param' do
+      it { subject.to_s(:en).should eq 'My value' }
+    end
+    context 'non existing locale as param' do
+      it 'raises an error' do
+        expect{ subject.to_s(:kz) }.to raise_error(Locomotive::Fields::I18nField::NoLocaleError)
+      end
+    end
+    context 'empty translation' do
+      it 'raises an error' do
+        expect{ subject.to_s(:wk) }.to raise_error(Locomotive::Fields::I18nField::EmptyLocaleError)
+      end
+    end
+  end
+
+  describe 'alternative access' do
+    it { subject.en.should eq 'My value' }
+    it { subject[:en].should eq 'My value' }
+  end
+
+  describe 'adding values' do
+    subject { Locomotive::Fields::I18nField.new(values) }
+    let(:values) { { en: 'My value' } }
+    before { subject << new_values }
+
+    context 'hash with string keys' do
+      let(:new_values) { {'fr' => 'Valeur'} }
+      it { subject.fr.should eq 'Valeur' }
+    end
+
+    context 'hash with symbol keys' do
+      let(:new_values) { {fr: 'Valeur'} }
+      it { subject.fr.should eq 'Valeur' }
+    end
+  end
+
+  describe 'iterating over values' do
+    subject { Locomotive::Fields::I18nField.new(values) }
+    let(:values) { { en: 'My value', fr: 'Valeur' } }
+    it 'allow to iterate over strings' do
+      test_val = []
+      subject.each do |locale, value|
+        test_val << subject[locale]
+      end
+      test_val.join.should eq 'My valueValeur'
+    end
+  end
+end

data/spec/unit/mapper_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+# require 'fixtures/example_entities'
+
+module Locomotive
+
+  describe Mapper do
+
+    class Dummy
+      include Entity
+      attributes :foo
+    end
+
+    class DummiesRepository
+      include Repository
+    end
+
+    let(:adapter) do
+      Locomotive::Adapters::MemoryAdapter
+    end
+
+    let!(:mapper) do
+      Mapper.new(adapter) do
+        collection :dummies do
+          entity Dummy
+          repository DummiesRepository
+
+          attribute :foo
+        end
+      end
+    end
+
+    describe '' do
+      before do mapper end
+      specify do
+        expect(Models.mapper).to be_a Mapper
+      end
+      specify do
+        expect(Models.mapper.collection(:dummies)).to be_a Mapping::Collection
+      end
+      specify do
+        expect(Models.mapper.collection(:dummies).repository).to be_a Locomotive::DummiesRepository
+      end
+
+      context '' do
+        let(:dummy_entity) do
+          Dummy.new({ foo: 'bar' })
+        end
+        let(:repository) do
+          Models.mapper.collection(:dummies).repository
+        end
+        before do
+          repository.create dummy_entity
+        end
+        specify do
+          expect(repository.find(dummy_entity.id).foo).to eq('bar')
+        end
+      end
+    end
+  end
+end

data/spec/unit/mapping/coercer_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Locomotive
+  describe Mapping::Coercer do
+    include_context 'memory'
+
+    let(:coercer) { Mapping::Coercer.new(mapper.collection(:products)) }
+
+    describe '#to_record' do
+      let(:entity) { Example::Product.new entity_hash }
+
+      context 'with locale' do
+        subject { coercer.to_record(entity)[:title] }
+
+        context 'when i18n field is localized' do
+          let(:entity_hash) {{ title: { en: 'magic vacuum', fr: 'aspirateur magique' }}}
+
+          it { should eq en: 'magic vacuum' , fr: 'aspirateur magique' }
+        end
+
+      end
+
+      context 'nil value' do
+        subject { coercer.to_record(entity)[:title] }
+        let(:entity_hash) { { title: nil } }
+        it { should eq({}) }
+      end
+    end
+  end
+end