lotus-model 0.0.0 → 0.1.0

data/test/model/mapper_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+describe Lotus::Model::Mapper do
+  before do
+    @mapper = Lotus::Model::Mapper.new
+  end
+
+  describe '#initialize' do
+    before do
+      class FakeCoercer
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :FakeCoercer)
+    end
+
+    it 'uses the given coercer' do
+      mapper  = Lotus::Model::Mapper.new(FakeCoercer) do
+        collection :articles do
+        end
+      end
+
+      mapper.collection(:articles).coercer_class.must_equal(FakeCoercer)
+    end
+
+    it 'executes the given block' do
+      mapper = Lotus::Model::Mapper.new do
+        collection :articles do
+          entity Article
+        end
+      end.load!
+
+      mapper.collection(:articles).must_be_kind_of Lotus::Model::Mapping::Collection
+    end
+  end
+
+  describe '#collections' do
+    before do
+      @mapper = Lotus::Model::Mapper.new do
+        collection :teas do
+        end
+      end
+    end
+
+    it 'returns the mapped collections' do
+      name, collection = @mapper.collections.first
+
+      name.must_equal :teas
+      collection.must_be_kind_of Lotus::Model::Mapping::Collection
+    end
+  end
+
+  describe '#collection' do
+    describe 'when a block is given' do
+      it 'register a collection' do
+        @mapper.collection :users do
+          entity User
+        end
+
+        @mapper.load!
+
+        collection = @mapper.collection(:users)
+        collection.must_be_kind_of Lotus::Model::Mapping::Collection
+        collection.name.must_equal :users
+      end
+    end
+
+    describe 'when only the name is passed' do
+      describe 'and the collection is present' do
+        before do
+          @mapper.collection :users do
+            entity User
+          end
+
+          @mapper.load!
+        end
+
+        it 'returns the collection' do
+          collection = @mapper.collection(:users)
+
+          collection.must_be_kind_of(Lotus::Model::Mapping::Collection)
+          collection.name.must_equal :users
+        end
+      end
+
+      describe 'and the collection is missing' do
+        it 'raises an error' do
+          -> { @mapper.collection(:unknown) }.must_raise(Lotus::Model::Mapping::UnmappedCollectionError)
+        end
+      end
+    end
+  end
+end

data/test/model/mapping/coercer_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+describe Lotus::Model::Mapping::Coercer do
+  let(:entity) { User.new(name: 'Tyrion Lannister') }
+  let(:collection) { Lotus::Model::Mapping::Collection.new(:users, Lotus::Model::Mapping::Coercer) }
+  let(:coercer) { Lotus::Model::Mapping::Coercer.new(collection) }
+
+  before do
+    collection.entity(User)
+    collection.attribute :id,   Integer
+    collection.attribute :name, String
+  end
+
+  describe '#to_record' do
+    it 'should not return identity column' do
+      coercer.to_record(entity).must_equal(name: 'Tyrion Lannister')
+    end
+
+    describe 'when identity is set' do
+      let(:entity) { User.new(id: 3, name: 'Tyrion Lannister') }
+
+      it 'should return identity as well' do
+        coercer.to_record(entity).must_equal(id: 3, name: 'Tyrion Lannister')
+      end
+    end
+  end
+end

data/test/model/mapping/collection_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+describe Lotus::Model::Mapping::Collection do
+  before do
+    @collection = Lotus::Model::Mapping::Collection.new(:users, Lotus::Model::Mapping::Coercer)
+  end
+
+  describe '::Boolean' do
+    it 'defines top level constant' do
+      assert defined?(::Boolean)
+    end
+  end
+
+  describe '#initialize' do
+    it 'assigns the name' do
+      @collection.name.must_equal :users
+    end
+
+    it 'assigns the coercer class' do
+      @collection.coercer_class.must_equal Lotus::Model::Mapping::Coercer
+    end
+
+    it 'executes the given block' do
+      collection = Lotus::Model::Mapping::Collection.new(:users, Lotus::Model::Mapping::Coercer) do
+        entity User
+      end
+
+      collection.entity.must_equal User
+    end
+  end
+
+  describe '#entity' do
+    describe 'when a value is given' do
+      before do
+        @collection.entity(User)
+      end
+
+      it 'sets the value' do
+        @collection.entity.must_equal User
+      end
+    end
+
+    describe 'when a value is not given' do
+      it 'retuns the value' do
+        @collection.entity.must_be_nil
+      end
+    end
+  end
+
+  describe '#identity' do
+    describe 'when a value is given' do
+      before do
+        @collection.identity(:_id)
+      end
+
+      it 'sets the value' do
+        @collection.identity.must_equal :_id
+      end
+    end
+
+    describe 'when a value is not given' do
+      it 'retuns the value' do
+        @collection.identity.must_equal(:id)
+      end
+    end
+  end
+
+  describe '#attribute' do
+    before do
+      @collection.attribute :id,   Integer
+      @collection.attribute :name, String, as: 't_name'
+    end
+
+    it 'defines an attribute' do
+      @collection.attributes[:id].must_equal [Integer, :id]
+    end
+
+    it 'defines a mapped attribute' do
+      @collection.attributes[:name].must_equal [String, :t_name]
+    end
+  end
+end

data/test/repository_test.rb

@@ -0,0 +1,283 @@
+require 'test_helper'
+
+describe Lotus::Repository do
+  let(:user1) { User.new(name: 'L') }
+  let(:user2) { User.new(name: 'MG') }
+  let(:users) { [user1, user2] }
+
+  let(:article1) { Article.new(user_id: user1.id, title: 'Introducing Lotus::Model', comments_count: '23') }
+  let(:article2) { Article.new(user_id: user1.id, title: 'Thread safety',            comments_count: '42') }
+  let(:article3) { Article.new(user_id: user2.id, title: 'Love Relationships',       comments_count: '4') }
+
+  { memory: [Lotus::Model::Adapters::MemoryAdapter, nil, MAPPER],
+    sql:    [Lotus::Model::Adapters::SqlAdapter, SQLITE_CONNECTION_STRING, MAPPER] }.each do |adapter_name, (adapter,uri,mapper)|
+    describe "with #{ adapter_name } adapter" do
+      before do
+        UserRepository.adapter    = adapter.new(mapper, uri)
+        ArticleRepository.adapter = adapter.new(mapper, uri)
+
+        UserRepository.collection    = :users
+        ArticleRepository.collection = :articles
+
+        UserRepository.clear
+        ArticleRepository.clear
+      end
+
+      describe '.collection' do
+        it 'returns the collection name' do
+          UserRepository.collection.must_equal    :users
+          ArticleRepository.collection.must_equal :articles
+        end
+      end
+
+      describe '.persist' do
+        describe 'when non persisted' do
+          before do
+            UserRepository.persist(user)
+          end
+
+          let(:user) { User.new(name: 'S') }
+
+          it 'is created' do
+            id = UserRepository.last.id
+            UserRepository.find(id).must_equal(user)
+          end
+        end
+
+        describe 'when already persisted' do
+          before do
+            UserRepository.create(user1)
+
+            user1.name = 'Luke'
+            UserRepository.persist(user1)
+          end
+
+          let(:id) { user1.id }
+
+          it 'is updated' do
+            UserRepository.find(id).must_equal(user1)
+          end
+        end
+      end
+
+      describe '.create' do
+        before do
+          UserRepository.create(user1)
+          UserRepository.create(user2)
+        end
+
+        it 'persist entities' do
+          UserRepository.all.must_equal(users)
+        end
+
+        it 'creates different kind of entities' do
+          ArticleRepository.create(article1)
+          ArticleRepository.all.must_equal([article1])
+        end
+
+        it 'does nothing when already persisted' do
+          id = user1.id
+
+          UserRepository.create(user1)
+          user1.id.must_equal id
+        end
+      end
+
+      describe '.update' do
+        before do
+          UserRepository.create(user1)
+        end
+
+        let(:id) { user1.id }
+
+        it 'updates entities' do
+          user = User.new(name: 'Luca')
+          user.id = id
+
+          UserRepository.update(user)
+
+          u = UserRepository.find(id)
+          u.name.must_equal('Luca')
+        end
+
+        it 'raises an error when not persisted' do
+          -> { UserRepository.update(user2) }.must_raise(Lotus::Model::NonPersistedEntityError)
+        end
+      end
+
+      describe '.delete' do
+        before do
+          UserRepository.create(user)
+          UserRepository.delete(user)
+        end
+
+        let(:user) { User.new(name: 'D') }
+
+        it 'delete entity' do
+          UserRepository.all.wont_include(user)
+        end
+
+        it 'raises error when the given entity is not persisted' do
+          -> { UserRepository.delete(user2) }.must_raise(Lotus::Model::NonPersistedEntityError)
+        end
+      end
+
+      describe '.all' do
+        describe 'without data' do
+          it 'returns an empty collection' do
+            UserRepository.all.must_be_empty
+          end
+        end
+
+        describe 'with data' do
+          before do
+            UserRepository.create(user1)
+            UserRepository.create(user2)
+          end
+
+          it 'returns all the entities' do
+            UserRepository.all.must_equal(users)
+          end
+        end
+      end
+
+      describe '.find' do
+        describe 'without data' do
+          it 'raises error' do
+            -> { UserRepository.find(1) }.must_raise(Lotus::Model::EntityNotFound)
+          end
+        end
+
+        describe 'with data' do
+          before do
+            TestPrimaryKey = Struct.new(:id) do
+              def to_int
+                id
+              end
+            end
+
+            UserRepository.create(user1)
+            UserRepository.create(user2)
+
+            ArticleRepository.create(article1)
+          end
+
+          after do
+            Object.send(:remove_const, :TestPrimaryKey)
+          end
+
+          it 'returns the entity associated with the given id' do
+            UserRepository.find(user1.id).must_equal(user1)
+          end
+
+          it 'accepts a string as argument' do
+            UserRepository.find(user2.id.to_s).must_equal(user2)
+          end
+
+          it 'accepts an object that can be coerced to integer' do
+            id = TestPrimaryKey.new(user2.id)
+            UserRepository.find(id).must_equal(user2)
+          end
+
+          it 'coerces attributes as indicated by the mapper' do
+            result = ArticleRepository.find(article1.id)
+            result.comments_count.must_be_kind_of(Integer)
+          end
+
+          it "doesn't assign a value to unmapped attributes" do
+            ArticleRepository.find(article1.id).unmapped_attribute.must_be_nil
+          end
+
+          it "raises error when the given id isn't associated with any entity" do
+            -> { UserRepository.find(1_000_000) }.must_raise(Lotus::Model::EntityNotFound)
+          end
+        end
+      end
+
+      describe '.first' do
+        describe 'without data' do
+          it 'returns nil' do
+            UserRepository.first.must_be_nil
+          end
+        end
+
+        describe 'with data' do
+          before do
+            UserRepository.create(user1)
+            UserRepository.create(user2)
+          end
+
+          it 'returns first record' do
+            UserRepository.first.must_equal(user1)
+          end
+        end
+      end
+
+      describe '.last' do
+        describe 'without data' do
+          it 'returns nil' do
+            UserRepository.last.must_be_nil
+          end
+        end
+
+        describe 'with data' do
+          before do
+            UserRepository.create(user1)
+            UserRepository.create(user2)
+          end
+
+          it 'returns last record' do
+            UserRepository.last.must_equal(user2)
+          end
+        end
+      end
+
+      describe '.clear' do
+        describe 'without data' do
+          it 'removes all the records' do
+            UserRepository.clear
+            UserRepository.all.must_be_empty
+          end
+        end
+
+        describe 'with data' do
+          before do
+            UserRepository.create(user1)
+            UserRepository.create(user2)
+          end
+
+          it 'removes all the records' do
+            UserRepository.clear
+            UserRepository.all.must_be_empty
+          end
+        end
+      end
+
+      describe 'querying' do
+        before do
+          UserRepository.create(user1)
+          ArticleRepository.create(article1)
+          ArticleRepository.create(article2)
+          ArticleRepository.create(article3)
+        end
+
+        it 'defines custom finders' do
+          actual = ArticleRepository.by_user(user1)
+          actual.all.must_equal [article1, article2]
+        end
+
+        if adapter_name == :sql
+          it 'combines queries' do
+            actual = ArticleRepository.rank_by_user(user1)
+            actual.all.must_equal [article2, article1]
+          end
+
+          it 'negates a query' do
+            actual = ArticleRepository.not_by_user(user1)
+            actual.all.must_equal []
+          end
+        end
+      end
+    end
+  end
+end