locomotivecms_models 0.0.1.pre.alpha

data/spec/fixtures/example_entities.rb

@@ -0,0 +1,23 @@
+module Locomotive
+  module Example
+    class Article
+      include Locomotive::Entity
+      attributes :title, :content, :author_id, :author, :comments
+    end
+
+    class Author
+      include Locomotive::Entity
+      attributes :name, :articles
+    end
+
+    class Comment
+      include Locomotive::Entity
+      attributes :title, :content, :article_id, :article
+    end
+
+    class Product
+      include Locomotive::Entity
+      attributes :title, :price
+    end
+  end
+end

data/spec/fixtures/example_mapper.rb

@@ -0,0 +1,40 @@
+collection :products do
+  entity Locomotive::Example::Product
+  repository Locomotive::Example::ProductsRepository
+
+  attribute :title, localized: true
+  attribute :price
+end
+
+collection :articles do
+  entity Locomotive::Example::Article
+  repository Locomotive::Example::ArticlesRepository
+
+  attribute :title, localized: true
+  attribute :content,  klass: String
+
+  attribute :author_id # Make reflection around keep this field or store id on author direclty
+  attribute :author,   association: { type: :belongs_to, key: :author_id, name: :authors }
+
+  attribute :comments, association: { type: :has_many, key: :article_id, name: :comments }
+end
+
+collection :authors do
+  entity Locomotive::Example::Author
+  repository Locomotive::Example::AuthorsRepository
+
+  attribute :name
+
+  attribute :articles, association: { type: :has_many, key: :author_id, name: :articles }
+end
+
+collection :comments do
+  entity Locomotive::Example::Comment
+  repository Locomotive::Example::CommentsRepository
+
+  attribute :title
+  attribute :content
+
+  attribute :article_id
+  attribute :article, association: { type: :belongs_to, key: :article_id, name: :articles }
+end

data/spec/fixtures/example_repositories.rb

@@ -0,0 +1,19 @@
+  module Locomotive
+  module Example
+    class ArticlesRepository
+      include Locomotive::Repository
+    end
+
+    class AuthorsRepository
+      include Locomotive::Repository
+    end
+
+    class ProductsRepository
+      include Locomotive::Repository
+    end
+
+    class CommentsRepository
+      include Locomotive::Repository
+    end
+  end
+end

data/spec/integration/criteria_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe 'query' do
+  include_context 'memory'
+
+  context 'with record', pending: true do
+
+    let(:entity)  { Example::Article.new(record) }
+    let(:records) do
+      [ { title: { en: 'Screen 1', fr: 'Ecran 1' }, content: 'content 1' },
+        { title: { en: 'Screen 2', fr: 'Ecran 2' }, content: 'content 2' } ]
+    end
+
+    before do fill_articles! end
+
+    specify do
+      expect(articles_repository.all.size).to eq(2)
+    end
+
+    context 'en' do
+      let(:locale)  { :en }
+
+      specify('can be chained') do
+        expect(
+          articles_repository.query(locale) do
+            where('content.eq' => 'content 1').
+            where('id.lt' => 2)
+          end.first.title[:en]
+        ).to eq('Screen 1')
+      end
+
+      specify('i18n field') do
+        expect(
+          articles_repository.query(locale) do
+            where('title.eq' => 'Screen 2')
+            where('id.gt' => 1)
+          end.first.title[:en]
+        ).to eq('Screen 2')
+      end
+
+    end
+
+    context 'fr' do
+      let(:locale)  { :fr }
+
+      specify('can be chained') do
+        expect(
+          articles_repository.query(locale) do
+            where('content.eq' => 'content 1').
+            where('id.lt' => 2)
+          end.first.title.fr
+        ).to eq('Ecran 1')
+      end
+
+      specify('i18n field') do
+        expect(
+          articles_repository.query(locale) do
+            where('title.eq' => 'Ecran 2')
+            where('content.matches' => /content/)
+            where('id.gt' => 1)
+          end.first.title.fr
+        ).to eq('Ecran 2')
+      end
+
+    end
+  end
+end

data/spec/integration/persistence_entity_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Locomotive
+
+  describe '', pending: true do
+    include_context 'memory'
+
+    let(:entity)  { Example::Article.new(record) }
+    let(:record)  {{ title: { en: 'new article' }, content: 'nothing has changed' }}
+    let(:records) {[ record ]}
+    let(:locale)  { :en }
+
+    describe '' do
+      let(:records) do
+        [ { title: { en: 'new article' }, content: 'nothing has changed' },
+          { title: { en: 'new article' }, content: 'nothing has changed' }]
+      end
+
+      before do fill_articles! end
+
+      specify do
+        expect(articles_repository.all.size).to eq(2)
+      end
+    end
+
+    describe 'write an entity' do
+      before do
+        articles_repository.create(entity)
+      end
+      specify do
+        expect(articles_repository.all.size).to eq(1)
+      end
+      it 'gives an ID to the entity' do
+        entity.id.should_not be_nil
+      end
+    end
+
+    describe 'finding an entity by its ID' do
+      context 'when entity exists' do
+        before  { articles_repository.create(entity) }
+        subject { articles_repository.find(entity.id) }
+
+        it { should be_kind_of Example::Article }
+        its(:id) { should_not be_nil }
+      end
+
+      context 'when entity could not be found' do
+        subject { articles_repository.find(1234) }
+        it 'raises an error' do
+          expect { subject }.to raise_error Repository::RecordNotFound, 'could not find articles with id = 1234'
+        end
+      end
+    end
+
+    describe 'update an entity' do
+      before do
+        articles_repository.create(entity)
+        entity.title << { en: 'Jane Doe' }
+        articles_repository.update(entity)
+      end
+
+      it 'does not create a new record' do
+        expect(articles_repository.all.size).to eq(1)
+      end
+    end
+
+    describe 'destroying an entity' do
+      before  { articles_repository.create(entity) }
+      it 'destroys an entry' do
+        articles_repository.destroy(entity)
+        expect(articles_repository.all.size).to eq(0)
+      end
+    end
+  end
+end

data/spec/integration/relations_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'fixtures/example_entities'
+
+module Locomotive
+  describe 'Handling relationships' do
+
+    include_context 'memory'
+
+    let(:article) do
+      Example::Article.new(title: { en:'My title' }, content: 'The article content', comments: [])
+    end
+    let(:author)  { Example::Author.new(name: 'John') }
+    let(:comment) do
+      Example::Comment.new(
+        { title: 'awesome comment', content: 'Lorem ipsum dolor sit amet, ...' }
+      )
+    end
+
+    # let(:locale)  { :en }
+
+    describe 'n-1 relationship' do
+
+      context 'set reference' do
+
+        it 'save and retrive article reference' do
+          articles_repository.create article
+          article.id.should_not be_nil
+          article.comments << comment
+          articles_repository.update article
+
+          comment.should respond_to :article_id
+          comment.article_id.should eq article.id
+
+          article_double = articles_repository.find(article.id)
+          comment = article_double.comments.first
+
+          comment.should respond_to :article_id
+          comment.article_id.should eq article.id
+        end
+      end
+
+      describe 'Saving and retreiving' do
+        before do
+          comments_repository.create comment
+          authors_repository .create author
+          articles_repository.create article
+        end
+
+        it 'allows to retreive associated record id', pending: true do
+          article_double = articles_repository.find(article.id)
+          article_double.author.id.should eql author.id
+        end
+
+        it 'Lazily loads the associated record', pending: true do
+          article_double = articles_repository.find(article.id)
+          article_double.author.name.should eq 'John'
+          article_double.author.should be_kind_of Example::Author
+          article_double.comments.first.should be_kind_of Example::Comment
+          article_double.comments.first.title.should eq 'awesome comment'
+        end
+      end
+
+      context 'when associated objects are non persisted', pending: true do
+
+        # context 'set reference' do
+        #   let(:article) do
+        #     Example::Article.new(title: { en:'My title' }, content: 'The article content', comments: [comment])
+        #   end
+        #
+        #   it '' do
+        #     comment.should_not respond_to :article_id
+        #     articles_repository.create article
+        #     comment.should respond_to :article_id
+        #     comment.article_id.should eq article.id
+        #   end
+        # end
+
+        context 'one to many' do
+          before do
+            articles_repository.create article
+            article.comments << comment
+            articles_repository.update article
+          end
+
+          it 'Lazily loads the associated record' do
+            article_double = articles_repository.find(article.id)
+
+            comment = article_double.comments.first
+            comment.should be_kind_of Example::Comment
+            comment.id.should eq 1
+            comment.title.should eq 'awesome'
+            # comment.article_id.should eq article.id
+          end
+        end
+
+        context 'belongs to' do
+          before do
+            articles_repository.create article
+            article.author = author
+            articles_repository.update article
+          end
+
+          it 'Lazily loads the associated record' do
+            article_double = articles_repository.find(article.id)
+            article_double.author.name.should eq 'John'
+            article_double.author.should be_kind_of Example::Author
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'common'
+
+begin
+  require 'pry'
+rescue LoadError
+end
+
+require_relative '../lib/locomotive/models'
+
+ENV['ADAPTER'] ||= 'memory'
+load File.dirname(__FILE__) + "/support/adapters/#{ENV['ADAPTER']}.rb"
+require_relative "../lib/locomotive/adapters/#{ENV['ADAPTER']}_adapter"
+
+RSpec.configure do |config|
+  config.filter_run focused: true
+  config.run_all_when_everything_filtered = true
+  # config.before { }
+  # config.after  { }
+end

data/spec/support/adapters/memory.rb

@@ -0,0 +1,39 @@
+require 'fixtures/example_entities'
+require 'fixtures/example_repositories'
+
+RSpec.shared_context 'memory' do
+
+  let(:mapper_file) do
+    File.expand_path('../../../fixtures/example_mapper.rb', __FILE__)
+  end
+
+  let(:adapter) do
+    Locomotive::Adapters::MemoryAdapter
+  end
+
+  let!(:mapper) do
+    Locomotive::Mapper.load_from_file! adapter, mapper_file
+  end
+
+  let(:articles_repository) do
+    Locomotive::Example::ArticlesRepository.new(mapper)
+  end
+
+  let(:authors_repository) do
+    Locomotive::Example::AuthorsRepository.new(mapper)
+  end
+
+  let(:comments_repository) do
+    Locomotive::Example::CommentsRepository.new(mapper)
+  end
+
+  let(:records) do
+    [{ title: { en: 'new article' }, content: 'nothing has changed' }]
+  end
+
+  def fill_articles!
+    records.each do |record|
+      articles_repository.create(Locomotive::Example::Article.new(record))
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Locomotive::Adapters::Memory::Condition do
+  let(:entry)    {{ title: { en: 'Awesome Site' }, content: 'foo' }}
+  let(:locale)   { :en }
+  let(:field)    { :title }
+  let(:operator) { :eq }
+  let(:name)     { "#{field}.#{operator}"}
+  let(:value)    { 'Awesome Site' }
+
+  subject { Locomotive::Adapters::Memory::Condition.new(name, value, locale) }
+
+  describe '#entry_value' do
+    context 'i18n' do
+      let(:name)  { 'title.eq' }
+      let(:value) { 'Awesome Site' }
+
+      context 'single entry' do
+        specify('should be match') do
+          expect(subject.matches?(entry)).to be_true
+        end
+
+        specify('return value') do
+          expect(subject.send(:entry_value, entry)).to eq(value)
+        end
+      end
+    end
+    context 'regular way' do
+      let(:name)  { 'content.eq' }
+      let(:value) { 'foo' }
+
+      context 'single entry' do
+        specify('should be match') do
+          expect(subject.matches?(entry)).to be_true
+        end
+
+        specify('return value') do
+          expect(subject.send(:entry_value, entry)).to eq(value)
+        end
+      end
+    end
+  end
+
+  describe '#decode_operator_and_field!' do
+    before { subject.send(:decode_operator_and_field!) }
+
+    context 'with normal value' do
+      specify('name should be left part of dot') { expect(subject.field).to eq(field) }
+      specify('operator should be right part of dot') { expect(subject.operator).to eq(operator) }
+      specify('right_operand should be value') { expect(subject.value).to eq(value) }
+    end
+
+    context 'with regex value' do
+      let(:value) { /^[a-z]$/ }
+      specify('operator should be matchtes') { expect(subject.operator).to eq(:matches) }
+    end
+  end
+
+  describe '#decode_operator_and_field!' do
+    context 'with unsupported operator' do
+      let(:name) { 'domains.unsupported' }
+      specify('should be throw Exception') do
+        expect do
+          subject.send(:decode_operator_and_field!)
+        end.to raise_error Locomotive::Adapters::Memory::Condition::UnsupportedOperator
+      end
+    end
+  end
+
+  describe '#adapt_operator!' do
+    let(:name) { 'domains.==' }
+    before do
+      subject.send(:decode_operator_and_field!)
+      subject.send(:adapt_operator!, value)
+    end
+    context 'with single value' do
+      let(:value) { 'sample.example.com' }
+      specify('operator should be :==') { expect(subject.operator).to eq(:==) }
+    end
+    context 'with array of values' do
+      let(:value) { ['sample.example.com'] }
+      specify('operator should be :in') { expect(subject.operator).to eq(:in) }
+    end
+  end
+
+  describe '#array_contains?' do
+    let(:source) { [1, 2, 3, 4] }
+    let(:target) { [1, 2, 3] }
+    context 'with target contains in source' do
+      specify('should be true') do
+        expect(subject.send(:array_contains?, source, target)).to be_true
+      end
+    end
+  end
+
+  describe '#value_in_right_operand?' do
+    context 'value contains in right operand' do
+      let(:value) { [1, 2, 3, 4] }
+      let(:right_operand) { [1, 2, 3] }
+
+      before do
+        subject.stub(operator: operator, right_operand: right_operand)
+      end
+
+      context 'with operator :in' do
+        let(:operator) { :in }
+        specify('should return true') do
+          expect(subject.send(:value_is_in_entry_value?, value)).to be_true
+        end
+      end
+
+      context 'with other operator' do
+        let(:operator) { :nin }
+        specify('should not return true') do
+          expect(subject.send(:value_is_in_entry_value?, value)).to be_false
+        end
+      end
+    end
+  end
+end