lotus-model 0.1.0 → 0.1.1

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

@@ -1,121 +0,0 @@
-require 'test_helper'
-
-describe Lotus::Model::Adapters::Sql::Query do
-  before do
-    @query = Lotus::Model::Adapters::Sql::Query.new(collection)
-  end
-
-  let(:collection) { [] }
-
-  describe '#negate!' do
-    describe 'where' do
-      before do
-        @query.where(id: 1)
-      end
-
-      it 'negates with exclude' do
-        @query.negate!
-        operator, condition = *@query.conditions.first
-
-        operator.must_equal :exclude
-        condition.must_equal({id: 1})
-      end
-    end
-
-    describe 'multipe where conditions' do
-      before do
-        @query.where(id: 1).and(name: 'L')
-      end
-
-      it 'negates with exclude' do
-        @query.negate!
-        operator, condition = *@query.conditions.last
-
-        operator.must_equal :exclude
-        condition.must_equal({name: 'L'})
-      end
-    end
-
-    describe 'exclude' do
-      before do
-        @query.exclude(published: false)
-      end
-
-      it 'negates with where' do
-        @query.negate!
-        operator, condition = *@query.conditions.first
-
-        operator.must_equal :where
-        condition.must_equal({published: false})
-      end
-    end
-
-    describe 'multiple exclude conditions' do
-      before do
-        @query.exclude(published: false).not(comments_count: 0)
-      end
-
-      it 'negates with where' do
-        @query.negate!
-        operator, condition = *@query.conditions.last
-
-        operator.must_equal :where
-        condition.must_equal({comments_count: 0})
-      end
-    end
-  end
-
-  describe '#to_s' do
-    let(:collection) { [1, 2, 3] }
-
-    it 'delegates to the wrapped collection' do
-      @query.to_s.must_equal collection.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(:collection) { [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(:collection) { [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/sql_adapter_test.rb

@@ -1,1078 +0,0 @@
-require 'test_helper'
-
-describe Lotus::Model::Adapters::SqlAdapter 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::SqlAdapter.new(@mapper, SQLITE_CONNECTION_STRING)
-  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 '#initialize' do
-    it 'raises an error when the given URI refers to a non registered database adapter' do
-      -> {
-        Lotus::Model::Adapters::SqlAdapter.new(@mapper, 'postgres://host')
-      }.must_raise(Lotus::Model::Adapters::DatabaseAdapterNotFound)
-    end
-
-    it 'raises an error when the given URI refers to an unknown database adapter' do
-      -> {
-        Lotus::Model::Adapters::SqlAdapter.new(@mapper, 'unknown://host')
-      }.must_raise(Lotus::Model::Adapters::DatabaseAdapterNotFound)
-    end
-
-    it 'raises an error when the given URI is malformed' do
-      -> {
-        Lotus::Model::Adapters::SqlAdapter.new(@mapper, 'unknown_db:host')
-      }.must_raise(URI::InvalidURIError)
-    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)
-    end
-
-    let(:entity) { TestUser.new }
-
-    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
-  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)
-          }
-
-          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
-      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
-
-        it 'returns sorted records, using multiple columns' do
-          query = Proc.new {
-            order(:age, :id)
-          }
-
-          result = @adapter.query(collection, &query).all
-          result.must_equal [user2, user1]
-        end
-
-        it 'returns sorted records, using multiple invokations' do
-          query = Proc.new {
-            order(:age).order(:id)
-          }
-
-          result = @adapter.query(collection, &query).all
-          result.must_equal [user2, user1]
-        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
-
-        it 'returns sorted records, using multiple columns' do
-          query = Proc.new {
-            desc(:age, :id)
-          }
-
-          result = @adapter.query(collection, &query).all
-          result.must_equal [user1, user2]
-        end
-
-        it 'returns sorted records, using multiple invokations' do
-          query = Proc.new {
-            desc(:age).desc(:id)
-          }
-
-          result = @adapter.query(collection, &query).all
-          result.must_equal [user1, user2]
-        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
-        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
-        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