lotus-model 0.0.0 → 0.1.0

data/lotus-model.gemspec

@@ -4,20 +4,24 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'lotus/model/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "lotus-model"
+  spec.name          = 'lotus-model'
   spec.version       = Lotus::Model::VERSION
-  spec.authors       = ["Luca Guidi"]
-  spec.email         = ["me@lucaguidi.com"]
-  spec.summary       = %q{Model layer for Lotus}
-  spec.description   = %q{Model layer for Lotus}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.authors       = ['Luca Guidi']
+  spec.email         = ['me@lucaguidi.com']
+  spec.summary       = %q{A persistence layer for Lotus}
+  spec.description   = %q{A persistence framework with entities, repositories, data mapper and query objects}
+  spec.homepage      = 'http://lotusrb.org'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.5"
-  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency 'lotus-utils', '~> 0.1', '> 0.1.0'
+  spec.add_runtime_dependency 'sequel',      '~> 4.9'
+
+  spec.add_development_dependency 'bundler',  '~> 1.5'
+  spec.add_development_dependency 'minitest', '~> 5'
+  spec.add_development_dependency 'rake',     '~> 10'
 end

data/test/entity_test.rb

@@ -0,0 +1,126 @@
+require 'test_helper'
+
+describe Lotus::Entity do
+  before do
+    class Car
+      include Lotus::Entity
+    end
+
+    class Book
+      include Lotus::Entity
+      self.attributes = :title, :author
+    end
+
+    class NonFinctionBook < Book
+    end
+
+    class Camera
+      include Lotus::Entity
+      attr_accessor :analog
+    end
+  end
+
+  after do
+    [:Car, :Book, :NonFinctionBook, :Camera].each do |const|
+      Object.send(:remove_const, const)
+    end
+  end
+
+  describe 'attributes' do
+    let(:attributes) { [:id, :model] }
+
+    it 'defines attributes' do
+      Car.send(:attributes=, attributes)
+      Car.send(:attributes).must_equal attributes
+    end
+  end
+
+  describe '#initialize' do
+    describe 'with defined attributes' do
+      it 'accepts given attributes' do
+        book = Book.new(title: "A Lover's Discourse: Fragments", author: 'Roland Barthes')
+
+        book.instance_variable_get(:@title).must_equal  "A Lover's Discourse: Fragments"
+        book.instance_variable_get(:@author).must_equal 'Roland Barthes'
+      end
+
+      it 'ignores unknown attributes' do
+        book = Book.new(unknown: 'x')
+
+        book.instance_variable_get(:@book).must_be_nil
+      end
+
+      it 'accepts given attributes for subclass' do
+        book = NonFinctionBook.new(title: 'Refactoring', author: 'Martin Fowler')
+
+        book.instance_variable_get(:@title).must_equal  'Refactoring'
+        book.instance_variable_get(:@author).must_equal 'Martin Fowler'
+      end
+    end
+
+    describe 'with undefined attributes' do
+      it 'is able to initialize an entity without given attributes' do
+        camera = Camera.new
+        camera.analog.must_be_nil
+      end
+
+      it 'is able to initialize an entity if it has the right accessors' do
+        camera = Camera.new(analog: true)
+        camera.analog.must_equal(true)
+      end
+
+      it "raises an error when the given attributes don't correspond to a known accessor" do
+        -> { Camera.new(digital: true) }.must_raise(NoMethodError)
+      end
+    end
+  end
+
+  describe 'accessors' do
+    it 'exposes getters for attributes' do
+      book = Book.new(title: 'High Fidelity')
+
+      book.title.must_equal 'High Fidelity'
+    end
+
+    it 'exposes setters for attributes' do
+      book = Book.new
+      book.title = 'A Man'
+
+      book.instance_variable_get(:@title).must_equal 'A Man'
+      book.title.must_equal 'A Man'
+    end
+
+    it 'exposes accessor for id' do
+      book = Book.new
+      book.id.must_be_nil
+
+      book.id = 23
+      book.id.must_equal 23
+    end
+  end
+
+  describe '#==' do
+    before do
+      @book1 = Book.new
+      @book1.id = 23
+
+      @book2 = Book.new
+      @book2.id = 23
+
+      @book3 = Book.new
+      @car   = Car.new
+    end
+
+    it 'returns true if they have the same class and id' do
+      @book1.must_equal @book2
+    end
+
+    it 'returns false if they have the same class but different id' do
+      @book1.wont_equal @book3
+    end
+
+    it 'returns false if they have different class' do
+      @book1.wont_equal @car
+    end
+  end
+end

data/test/fixtures.rb

@@ -0,0 +1,81 @@
+class User
+  include Lotus::Entity
+  self.attributes = :name, :age
+end
+
+class Article
+  include Lotus::Entity
+  self.attributes = :user_id, :unmapped_attribute, :title, :comments_count
+end
+
+class UserRepository
+  include Lotus::Repository
+end
+
+class ArticleRepository
+  include Lotus::Repository
+
+  def self.rank
+    query do
+      desc(:comments_count)
+    end
+  end
+
+  def self.by_user(user)
+    query do
+      where(user_id: user.id)
+    end
+  end
+
+  def self.not_by_user(user)
+    exclude by_user(user)
+  end
+
+  def self.rank_by_user(user)
+    rank.by_user(user)
+  end
+end
+
+DB = Sequel.connect(SQLITE_CONNECTION_STRING)
+
+DB.create_table :users do
+  primary_key :id
+  String  :name
+  Integer :age
+end
+
+DB.create_table :articles do
+  primary_key :_id
+  Integer :user_id
+  String  :s_title
+  String  :comments_count # Not an error: we're testing String => Integer coercion
+  String  :umapped_column
+end
+
+DB.create_table :devices do
+  primary_key :id
+end
+
+# DB.dataset_class = Class.new(Sequel::Dataset)
+
+#FIXME this should be passed by the framework internals.
+MAPPER = Lotus::Model::Mapper.new do
+  collection :users do
+    entity User
+
+    attribute :id,   Integer
+    attribute :name, String
+    attribute :age,  Integer
+  end
+
+  collection :articles do
+    entity Article
+
+    attribute :id,             Integer, as: :_id
+    attribute :user_id,        Integer
+    attribute :title,          String,  as: 's_title'
+    attribute :comments_count, Integer
+
+    identity :_id
+  end
+end.load!

data/test/model/adapters/abstract_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+describe Lotus::Model::Adapters::Abstract do
+  let(:adapter)    { Lotus::Model::Adapters::Abstract.new(mapper) }
+  let(:mapper)     { Object.new }
+  let(:entity)     { Object.new }
+  let(:query)      { Object.new }
+  let(:collection) { :collection }
+
+  describe '#persist' do
+    it 'raises error' do
+      ->{ adapter.persist(collection, entity) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#create' do
+    it 'raises error' do
+      ->{ adapter.create(collection, entity) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#update' do
+    it 'raises error' do
+      ->{ adapter.update(collection, entity) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#delete' do
+    it 'raises error' do
+      ->{ adapter.delete(collection, entity) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#all' do
+    it 'raises error' do
+      ->{ adapter.all(collection) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#find' do
+    it 'raises error' do
+      ->{ adapter.find(collection, 1) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#first' do
+    it 'raises error' do
+      ->{ adapter.first(collection) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#last' do
+    it 'raises error' do
+      ->{ adapter.last(collection) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#clear' do
+    it 'raises error' do
+      ->{ adapter.clear(collection) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#command' do
+    it 'raises error' do
+      ->{ adapter.command(query) }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#query' do
+    it 'raises error' do
+      ->{ adapter.query(collection) }.must_raise NotImplementedError
+    end
+  end
+end

data/test/model/adapters/implementation_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+describe Lotus::Model::Adapters::Implementation do
+  before do
+    TestAdapter = Class.new(Lotus::Model::Adapters::Abstract) do
+      include Lotus::Model::Adapters::Implementation
+    end
+
+    mapper   = Object.new
+    @adapter = TestAdapter.new(mapper)
+  end
+
+  after do
+    Object.send(:remove_const, :TestAdapter)
+  end
+
+  it 'must implement #_collection' do
+    -> {
+      @adapter.send(:_collection, :x)
+    }.must_raise NotImplementedError
+  end
+end

data/test/model/adapters/memory/query_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+describe Lotus::Model::Adapters::Memory::Query do
+  before do
+    MockDataset = Struct.new(:records) do
+      def all
+        records
+      end
+
+      def to_s
+        records.to_s
+      end
+    end
+
+    class MockCollection
+      def deserialize(array)
+        array
+      end
+    end
+
+    collection = MockCollection.new
+    @query     = Lotus::Model::Adapters::Memory::Query.new(dataset, collection)
+  end
+
+  after do
+    Object.send(:remove_const, :MockDataset)
+    Object.send(:remove_const, :MockCollection)
+  end
+
+  let(:dataset) { MockDataset.new([]) }
+
+  describe '#negate!' do
+    it 'raises an error' do
+      -> { @query.negate! }.must_raise NotImplementedError
+    end
+  end
+
+  describe '#to_s' do
+    let(:dataset) { MockDataset.new([1, 2, 3]) }
+
+    it 'delegates to the wrapped dataset' do
+      @query.to_s.must_equal dataset.to_s
+    end
+  end
+
+  describe '#empty?' do
+    describe "when it's empty" do
+      it 'returns true' do
+        @query.must_be_empty
+      end
+    end
+
+    describe "when it's filled with elements" do
+      let(:dataset) { MockDataset.new([1, 2, 3]) }
+
+      it 'returns false' do
+        @query.wont_be_empty
+      end
+    end
+  end
+
+  describe '#any?' do
+    describe "when it's empty" do
+      it 'returns false' do
+        assert !@query.any?
+      end
+    end
+
+    describe "when it's filled with elements" do
+      let(:dataset) { MockDataset.new([1, 2, 3]) }
+
+      it 'returns true' do
+        assert @query.any?
+      end
+
+      describe "when a block is passed" do
+        describe "and it doesn't match elements" do
+          it 'returns false' do
+            assert !@query.any? {|e| e > 100 }
+          end
+        end
+
+        describe "and it matches elements" do
+          it 'returns true' do
+            assert @query.any? {|e| e % 2 == 0 }
+          end
+        end
+      end
+    end
+  end
+end

data/test/model/adapters/memory_adapter_test.rb

@@ -0,0 +1,1044 @@
+require 'test_helper'
+
+describe Lotus::Model::Adapters::MemoryAdapter do
+  before do
+    TestUser = Struct.new(:id, :name, :age) do
+      include Lotus::Entity
+    end
+
+    TestDevice = Struct.new(:id) do
+      include Lotus::Entity
+    end
+
+    @mapper = Lotus::Model::Mapper.new do
+      collection :users do
+        entity TestUser
+
+        attribute :id,   Integer
+        attribute :name, String
+        attribute :age,  Integer
+      end
+
+      collection :devices do
+        entity TestDevice
+
+        attribute :id, Integer
+      end
+    end.load!
+
+    @adapter = Lotus::Model::Adapters::MemoryAdapter.new(@mapper)
+  end
+
+  after do
+    Object.send(:remove_const, :TestUser)
+    Object.send(:remove_const, :TestDevice)
+  end
+
+  let(:collection) { :users }
+
+  describe 'multiple collections' do
+    it 'create records' do
+      user   = TestUser.new
+      device = TestDevice.new
+
+      @adapter.create(:users, user)
+      @adapter.create(:devices, device)
+
+      @adapter.all(:users).must_equal   [user]
+      @adapter.all(:devices).must_equal [device]
+    end
+  end
+
+  describe '#persist' do
+    describe 'when the given entity is not persisted' do
+      let(:entity) { TestUser.new }
+
+      it 'stores the record and assigns an id' do
+        @adapter.persist(collection, entity)
+
+        entity.id.wont_be_nil
+        @adapter.find(collection, entity.id).must_equal entity
+      end
+    end
+
+    describe 'when the given entity is persisted' do
+      before do
+        @adapter.create(collection, entity)
+      end
+
+      let(:entity) { TestUser.new }
+
+      it 'updates the record and leaves untouched the id' do
+        id = entity.id
+        id.wont_be_nil
+
+        entity.name = 'L'
+        @adapter.persist(collection, entity)
+
+        entity.id.must_equal(id)
+        @adapter.find(collection, entity.id).must_equal entity
+      end
+    end
+  end
+
+  describe '#create' do
+    let(:entity) { TestUser.new }
+
+    it 'stores the record and assigns an id' do
+      @adapter.create(collection, entity)
+
+      entity.id.wont_be_nil
+      @adapter.find(collection, entity.id).must_equal entity
+    end
+  end
+
+  describe '#update' do
+    before do
+      @adapter.create(collection, entity)
+    end
+
+    let(:entity) { TestUser.new(id: nil, name: 'L') }
+
+    it 'stores the changes and leave the id untouched' do
+      id = entity.id
+
+      entity.name = 'MG'
+      @adapter.update(collection, entity)
+
+      entity.id.must_equal id
+      @adapter.find(collection, entity.id).must_equal entity
+    end
+  end
+
+  describe '#delete' do
+    before do
+      @adapter.create(collection, entity)
+    end
+
+    let(:entity) { TestUser.new }
+
+    it 'removes the given identity' do
+      @adapter.delete(collection, entity)
+      @adapter.find(collection, entity.id).must_be_nil
+    end
+  end
+
+  describe '#all' do
+    describe 'when no records are persisted' do
+      before do
+        @adapter.clear(collection)
+      end
+
+      it 'returns an empty collection' do
+        @adapter.all(collection).must_be_empty
+      end
+    end
+
+    describe 'when some records are persisted' do
+      before do
+        @adapter.create(collection, entity)
+      end
+
+      let(:entity) { TestUser.new }
+
+      it 'returns all of them' do
+        @adapter.all(collection).must_equal [entity]
+      end
+    end
+  end
+
+  describe '#find' do
+    before do
+      @adapter.create(collection, entity)
+      @adapter.instance_variable_get(:@collections).fetch(collection).records.store(nil, nil_entity)
+    end
+
+    let(:entity)      { TestUser.new }
+    let(:nil_entity)  { {id: 0} }
+
+    it 'returns the record by id' do
+      @adapter.find(collection, entity.id).must_equal entity
+    end
+
+    it 'returns nil when the record cannot be found' do
+      @adapter.find(collection, 1_000_000).must_be_nil
+    end
+
+    it 'returns nil when the given id is nil' do
+      @adapter.find(collection, nil).must_be_nil
+    end
+  end
+
+  describe '#first' do
+    describe 'when no records are peristed' do
+      before do
+        @adapter.clear(collection)
+      end
+
+      it 'returns nil' do
+        @adapter.first(collection).must_be_nil
+      end
+    end
+
+    describe 'when some records are persisted' do
+      before do
+        @adapter.create(collection, entity1)
+        @adapter.create(collection, entity2)
+      end
+
+      let(:entity1) { TestUser.new }
+      let(:entity2) { TestUser.new }
+
+      it 'returns the first record' do
+        @adapter.first(collection).must_equal entity1
+      end
+    end
+  end
+
+  describe '#last' do
+    describe 'when no records are peristed' do
+      before do
+        @adapter.clear(collection)
+      end
+
+      it 'returns nil' do
+        @adapter.last(collection).must_be_nil
+      end
+    end
+
+    describe 'when some records are persisted' do
+      before do
+        @adapter.create(collection, entity1)
+        @adapter.create(collection, entity2)
+      end
+
+      let(:entity1) { TestUser.new }
+      let(:entity2) { TestUser.new }
+
+      it 'returns the last record' do
+        @adapter.last(collection).must_equal entity2
+      end
+    end
+  end
+
+  describe '#clear' do
+    before do
+      @adapter.create(collection, entity)
+    end
+
+    let(:entity) { TestUser.new }
+
+    it 'removes all the records' do
+      @adapter.clear(collection)
+      @adapter.all(collection).must_be_empty
+    end
+
+    it 'resets the id counter' do
+      @adapter.clear(collection)
+
+      @adapter.create(collection, entity)
+      entity.id.must_equal 1
+    end
+  end
+
+  describe '#query' do
+    before do
+      @adapter.clear(collection)
+    end
+
+    let(:user1) { TestUser.new(name: 'L',  age: '32') }
+    let(:user2) { TestUser.new(name: 'MG', age: 31) }
+
+    describe 'where' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            where(id: 23)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+        end
+
+        it 'returns selected records' do
+          id = user1.id
+
+          query = Proc.new {
+            where(id: id)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user1]
+        end
+
+        it 'can use multiple where conditions' do
+          id   = user1.id
+          name = user1.name
+
+          query = Proc.new {
+            where(id: id).where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user1]
+        end
+
+        it 'can use multiple where conditions with "and" alias' do
+          id   = user1.id
+          name = user1.name
+
+          query = Proc.new {
+            where(id: id).and(name: name)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user1]
+        end
+      end
+    end
+
+    describe 'exclude' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            exclude(id: 23)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, user3)
+        end
+
+        let(:user3) { TestUser.new(name: 'S', age: 2) }
+
+        it 'returns selected records' do
+          id = user1.id
+
+          query = Proc.new {
+            exclude(id: id)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user2, user3]
+        end
+
+        it 'can use multiple exclude conditions' do
+          id   = user1.id
+          name = user2.name
+
+          query = Proc.new {
+            exclude(id: id).exclude(name: name)
+          }
+
+          $debug = true
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user3]
+        end
+
+        it 'can use multiple exclude conditions with "not" alias' do
+          id   = user1.id
+          name = user2.name
+
+          query = Proc.new {
+            self.not(id: id).not(name: name)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user3]
+        end
+      end
+    end
+
+    describe 'or' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            where(name: 'L').or(name: 'MG')
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+        end
+
+        it 'returns selected records' do
+          name1 = user1.name
+          name2 = user2.name
+
+          query = Proc.new {
+            where(name: name1).or(name: name2)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user1, user2]
+        end
+
+        it 'returns selected records only from the "or" condition' do
+          name2 = user2.name
+
+          query = Proc.new {
+            where(name: 'unknown').or(name: name2)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user2]
+        end
+      end
+    end
+
+    describe 'select' do
+      describe 'with an empty collection' do
+        it 'returns an empty result' do
+          result = @adapter.query(collection) do
+            select(:age)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, user3)
+        end
+
+        let(:user1) { TestUser.new(name: 'L', age: 32) }
+        let(:user3) { TestUser.new(name: 'S') }
+        let(:users) { [user1, user2, user3] }
+
+        it 'returns the selected columnts from all the records' do
+          query = Proc.new {
+            select(:age)
+          }
+
+          result = @adapter.query(collection, &query).all
+
+          users.each do |user|
+            record = result.find {|r| r.age == user.age }
+            record.wont_be_nil
+            record.name.must_be_nil
+          end
+        end
+
+        it 'returns only the select of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name).select(:age)
+          }
+
+          result = @adapter.query(collection, &query).all
+
+          record = result.first
+          record.age.must_equal(user2.age)
+          record.name.must_be_nil
+        end
+
+        it 'returns only the multiple select of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name).select(:name, :age)
+          }
+
+          result = @adapter.query(collection, &query).all
+
+          record = result.first
+          record.name.must_equal(user2.name)
+          record.age.must_equal(user2.age)
+          record.id.must_be_nil
+        end
+      end
+    end
+
+    describe 'order' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            order(:id)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+        end
+
+        it 'returns sorted records' do
+          query = Proc.new {
+            order(:id)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user1, user2]
+        end
+      end
+    end
+
+    describe 'asc' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            asc(:id)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+        end
+
+        it 'returns sorted records' do
+          query = Proc.new {
+            asc(:id)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user1, user2]
+        end
+      end
+    end
+
+    describe 'desc' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            desc(:id)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+        end
+
+        it 'returns reverse sorted records' do
+          query = Proc.new {
+            desc(:id)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user2, user1]
+        end
+      end
+    end
+
+    describe 'limit' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            limit(1)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: user2.name))
+        end
+
+        it 'returns only the number of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name).limit(1)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user2]
+        end
+      end
+    end
+
+    describe 'offset' do
+      describe 'with an empty collection' do
+        it 'returns an empty result set' do
+          result = @adapter.query(collection) do
+            limit(1).offset(1)
+          end.all
+
+          result.must_be_empty
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, user3)
+        end
+
+        let(:user3) { TestUser.new(name: user2.name) }
+
+        it 'returns only the number of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name).limit(1).offset(1)
+          }
+
+          result = @adapter.query(collection, &query).all
+          result.must_equal [user3]
+        end
+      end
+    end
+
+    describe 'exist?' do
+      describe 'with an empty collection' do
+        it 'returns false' do
+          result = @adapter.query(collection) do
+            where(id: 23)
+          end.exist?
+
+          result.must_equal false
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+        end
+
+        it 'returns true when there are matched records' do
+          id = user1.id
+
+          query = Proc.new {
+            where(id: id)
+          }
+
+          result = @adapter.query(collection, &query).exist?
+          result.must_equal true
+        end
+
+        it 'returns false when there are matched records' do
+          query = Proc.new {
+            where(id: 'unknown')
+          }
+
+          result = @adapter.query(collection, &query).exist?
+          result.must_equal false
+        end
+      end
+    end
+
+
+    describe 'count' do
+      describe 'with an empty collection' do
+        it 'returns 0' do
+          result = @adapter.query(collection) do
+            all
+          end.count
+
+          result.must_equal 0
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+        end
+
+        it 'returns the count of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).count
+          result.must_equal 2
+        end
+
+        it 'returns the count from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).count
+          result.must_equal 2
+        end
+
+        it 'returns only the count of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).count
+          result.must_equal 1
+        end
+      end
+    end
+
+    describe 'sum' do
+      describe 'with an empty collection' do
+        it 'returns nil' do
+          result = @adapter.query(collection) do
+            all
+          end.sum(:age)
+
+          result.must_be_nil
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: 'S'))
+        end
+
+        it 'returns the sum of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).sum(:age)
+          result.must_equal 63
+        end
+
+        it 'returns the sum from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).sum(:age)
+          result.must_equal 63
+        end
+
+        it 'returns only the sum of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).sum(:age)
+          result.must_equal 31
+        end
+      end
+    end
+
+    describe 'average' do
+      describe 'with an empty collection' do
+        it 'returns nil' do
+          result = @adapter.query(collection) do
+            all
+          end.average(:age)
+
+          result.must_be_nil
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: 'S'))
+        end
+
+        it 'returns the average of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).average(:age)
+          result.must_equal 31.5
+        end
+
+        it 'returns the average from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).average(:age)
+          result.must_equal 31.5
+        end
+
+        it 'returns only the average of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).average(:age)
+          result.must_equal 31.0
+        end
+      end
+    end
+
+    describe 'avg' do
+      describe 'with an empty collection' do
+        it 'returns nil' do
+          result = @adapter.query(collection) do
+            all
+          end.avg(:age)
+
+          result.must_be_nil
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: 'S'))
+        end
+
+        it 'returns the average of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).avg(:age)
+          result.must_equal 31.5
+        end
+
+        it 'returns the average from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).avg(:age)
+          result.must_equal 31.5
+        end
+
+        it 'returns only the average of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).avg(:age)
+          result.must_equal 31.0
+        end
+      end
+    end
+
+    describe 'max' do
+      describe 'with an empty collection' do
+        it 'returns nil' do
+          result = @adapter.query(collection) do
+            all
+          end.max(:age)
+
+          result.must_be_nil
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: 'S'))
+        end
+
+        it 'returns the maximum of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).max(:age)
+          result.must_equal 32
+        end
+
+        it 'returns the maximum from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).max(:age)
+          result.must_equal 32
+        end
+
+        it 'returns only the maximum of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).max(:age)
+          result.must_equal 31
+        end
+      end
+    end
+
+    describe 'min' do
+      describe 'with an empty collection' do
+        it 'returns nil' do
+          result = @adapter.query(collection) do
+            all
+          end.min(:age)
+
+          result.must_be_nil
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: 'S'))
+        end
+
+        it 'returns the minimum of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).min(:age)
+          result.must_equal 31
+        end
+
+        it 'returns the minimum from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).min(:age)
+          result.must_equal 31
+        end
+
+        it 'returns only the minimum of requested records' do
+          name = user1.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).min(:age)
+          result.must_equal 32
+        end
+      end
+    end
+
+    describe 'interval' do
+      describe 'with an empty collection' do
+        it 'returns nil' do
+          result = @adapter.query(collection) do
+            all
+          end.interval(:age)
+
+          result.must_be_nil
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: 'S'))
+        end
+
+        it 'returns the interval of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).interval(:age)
+          result.must_equal 1
+        end
+
+        it 'returns the interval from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).interval(:age)
+          result.must_equal 1
+        end
+
+        it 'returns only the interval of requested records' do
+          name = user1.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).interval(:age)
+          result.must_equal 0
+        end
+      end
+    end
+
+    describe 'range' do
+      describe 'with an empty collection' do
+        it 'returns nil' do
+          result = @adapter.query(collection) do
+            all
+          end.range(:age)
+
+          result.must_equal nil..nil
+        end
+      end
+
+      describe 'with a filled collection' do
+        before do
+          @adapter.create(collection, user1)
+          @adapter.create(collection, user2)
+          @adapter.create(collection, TestUser.new(name: 'S'))
+        end
+
+        it 'returns the range of all the records' do
+          query = Proc.new {
+            all
+          }
+
+          result = @adapter.query(collection, &query).range(:age)
+          result.must_equal 31..32
+        end
+
+        it 'returns the range from an empty query block' do
+          query = Proc.new {
+          }
+
+          result = @adapter.query(collection, &query).range(:age)
+          result.must_equal 31..32
+        end
+
+        it 'returns only the range of requested records' do
+          name = user2.name
+
+          query = Proc.new {
+            where(name: name)
+          }
+
+          result = @adapter.query(collection, &query).range(:age)
+          result.must_equal 31..31
+        end
+      end
+    end
+  end
+end