lotus-model 0.1.0 → 0.1.1

data/test/model/mapper_test.rb

@@ -1,94 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,283 +0,0 @@
-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