mattly-exegesis 0.2.2 → 0.2.3

data/test/design_test.rb

@@ -21,7 +21,7 @@ class DesignTestDatabase
   end
 end
 
-class ExegesisDesignTest < Test::Unit::TestCase
+describe Exegesis::Design do
   
   def setup_db(with_doc=true)
     reset_db
@@ -38,19 +38,19 @@ class ExegesisDesignTest < Test::Unit::TestCase
     end
   end
   
-  context "design instances" do
+  describe "design instances" do
     before { setup_db }
-    expect { @db.things.database.will == @db }
+    expect { @db.things.database.must_equal @db }
   end
   
-  context "design declarations" do
+  describe "design declarations" do
     before { setup_db }
-    expect { @db.things.class.will == DesignTestDatabase::ThingsDesign }
-    expect { @db.things.is_a?(Exegesis::Design).will == true }
-    expect { @db.things.design_name.will == 'things' }
+    expect { @db.things.class.must_equal DesignTestDatabase::ThingsDesign }
+    expect { @db.things.must_be_kind_of Exegesis::Design }
+    expect { @db.things.design_name.must_equal 'things' }
   end
   
-  context "view declarations" do
+  describe "view declarations" do
     before do
       setup_db
       @docs = [
@@ -61,26 +61,26 @@ class ExegesisDesignTest < Test::Unit::TestCase
       @db.save(@docs)
     end
     
-    context "declared docs" do
+    describe "declared docs" do
       describe "with default key" do
         before { @response = @db.things.by_tag('foo') }
-        expect { @response.kind_of?(Exegesis::DocumentCollection).will == true }
-        expect { @response.size.will == @docs.select{|d| d['tags'].include?('foo')}.size }
-        expect { @response.documents.all? {|id,d| d.kind_of?(DesignTestDoc) }.will == true }
-        expect { @response.documents.all? {|id,d| d['tags'].include?('foo') }.will == true }
+        expect { @response.must_be_kind_of Exegesis::DocumentCollection }
+        expect { @response.size.must_equal @docs.select{|d| d['tags'].include?('foo')}.size }
+        expect { @response.documents.each {|id,d| d.must_be_kind_of DesignTestDoc } }
+        expect { @response.documents.each {|id,d| d['tags'].must_include 'foo' } }
       end
       
       describe "with multiple keys" do
         before { @response = @db.things.by_tag :keys => %w(bar bee) }
-        expect { @response.kind_of?(Exegesis::DocumentCollection).will == true }
-        expect { @response.size.will == @docs.inject(0){|sum,d| sum+=(d['tags'] & %w(bar bee)).size } }
-        expect { @response.documents.size.will == @docs.select{|d| (d['tags'] & %w(bar bee)).size > 0}.size }
-        expect { @response.documents.all? {|id,d| d.kind_of?(DesignTestDoc) }.will == true }
+        expect { @response.must_be_kind_of Exegesis::DocumentCollection }
+        expect { @response.size.must_equal @docs.inject(0){|sum,d| sum+=(d['tags'] & %w(bar bee)).size } }
+        expect { @response.documents.size.must_equal @docs.select{|d| (d['tags'] & %w(bar bee)).size > 0}.size }
+        expect { @response.documents.each {|id,d| d.must_be_kind_of DesignTestDoc } }
       end
       
     end
     
-    context "declared hashes" do
+    describe "declared hashes" do
       before do
         @counts = Hash.new(0)
         @docs.each do |doc|
@@ -94,111 +94,53 @@ class ExegesisDesignTest < Test::Unit::TestCase
           end
         end
       end
-      expect { @db.things.count.should == @counts }
-      expect { @db.things.count('foo').should == @counts['foo'] }
+      expect { @db.things.count.must_equal @counts }
+      expect { @db.things.count('foo').must_equal @counts['foo'] }
       
-      context "invalid options" do
-        expect { lambda{@db.things.count(:group=>false)}.will raise_error(ArgumentError) }
-        expect { lambda{@db.things.count(:include_docs=>true)}.will raise_error(ArgumentError) }
+      describe "invalid options" do
+        expect { lambda{@db.things.count(:group=>false)}.must_raise ArgumentError }
+        expect { lambda{@db.things.count(:include_docs=>true)}.must_raise ArgumentError }
       end
       
-      context "for views without reduce" do
+      describe "for views without reduce" do
         before { @klass = DesignTestDatabase::StuffDesign }
-        expect { lambda{@klass.class_eval{hash(:name_count, :view=>:by_name)}}.will raise_error }
+        expect { lambda{@klass.class_eval{hash(:name_count, :view=>:by_name)}}.must_raise(ArgumentError) }
       end
     end
   end
   
-  context "parsing query options" do
-    before { setup_db }
-    
-    context "with a key as an initial arguemnt" do
-      expect { @db.things.parse_opts('foo').will == {:key => 'foo'} }
-      expect { @db.things.parse_opts('foo', :include_docs => true).will == {:key => 'foo', :include_docs => true} }
-      expect { @db.things.parse_opts('foo', {:stale => 'ok'}, {:include_docs => true}).will == {:key => 'foo', :stale => 'ok', :include_docs => true }}
-    end
-    
-    context "without an implied key" do
-      expect { @db.things.parse_opts(:key => 'foo').will == {:key => 'foo'} }
-      expect { @db.things.parse_opts({:key => 'foo'}, nil, {:stale => 'ok'}).will == {:key => 'foo', :stale => 'ok'} }
-    end
-    
-    context "when a keys option is empty" do
-      expect { @db.things.parse_opts(:keys => []).will == {} }
-    end
-    
-    context "for ranges" do
-      context "when the key _is_ a range" do
-        before { @opts = @db.things.parse_opts(:key => 'bar'..'baz') }
-        expect { @opts.has_key?(:key).will == false }
-        expect { @opts[:startkey].will == 'bar' }
-        expect { @opts[:endkey].will == 'baz'}
-      end
-      
-      context "when the key is an array that includes a range" do
-        before { @opts = @db.things.parse_opts(:key => ['published', '2009'..'2009/04']) }
-        expect { @opts.has_key?(:key).will == false }
-        expect { @opts[:startkey].will == ['published', '2009'] }
-        expect { @opts[:endkey].will == ['published', '2009/04'] }
-      end
-      
-      context "for non inclusive ranges" do
-      end
-      context "when descending:true is an option" do
-        context "and first value is greater than the end value" do
-        end
-      end
-      context "when the first value is greater than the end value" do
-      end
-      
-      context "invalid option configurations" do
-        expect { lambda {@db.things.parse_opts(:startkey => 'foo')}.will raise_error(ArgumentError) }
-      end
-    end
-    
-    context "reducing" do
-      before { @parsing = lambda{|opts| @db.things.parse_opts(opts) } }
-      expect { @parsing.call(:group => 3).will == {:group_level => 3}}
-      expect { lambda{@parsing.call(:group => true, :reduce => false)}.will raise_error(ArgumentError) }
-      expect { lambda{@parsing.call(:group => true, :include_docs => true)}.will raise_error(ArgumentError) }
-      expect { lambda{@parsing.call(:group => 1, :reduce => false)}.will raise_error(ArgumentError) }
-      expect { lambda{@parsing.call(:group => 1, :include_docs => true)}.will raise_error(ArgumentError) }
-    end
+  describe "design doc meta declarations" do
+    expect { DesignTestDatabase::StuffDesign.design_name.must_equal "things" }
+    expect { DesignTestDatabase::StuffDesign.design_directory.must_equal Pathname.new("app/designs/stuff") }
   end
   
-  context "design doc meta declarations" do
-    expect { DesignTestDatabase::StuffDesign.design_name.will == "things" }
-    expect { DesignTestDatabase::StuffDesign.design_directory.will == Pathname.new("app/designs/stuff") }
-  end
-  
-  context "the design document" do
+  describe "the design document" do
     before do
       @canonical = DesignTestDatabase::ThingsDesign.canonical_design
     end
     
-    context "composing the canonical version" do
-      context "from files" do
-        expect { @canonical['views']['by_tag']['map'].will == File.read(fixtures_path('designs/things/views/by_tag/map.js')) }
-        expect { @canonical['views']['by_tag']['reduce'].will == File.read(fixtures_path('designs/things/views/by_tag/reduce.js')) }
+    describe "composing the canonical version" do
+      describe "from files" do
+        expect { @canonical['views']['by_tag']['map'].must_equal File.read(fixtures_path('designs/things/views/by_tag/map.js')) }
+        expect { @canonical['views']['by_tag']['reduce'].must_equal File.read(fixtures_path('designs/things/views/by_tag/reduce.js')) }
       end
       
-      context "from class declarations" do
+      describe "from class declarations" do
         # tk
       end
     end
     
-    context "syncronizing" do
-      context "when the design_doc doesn't exist in the db yet" do
+    describe "syncronizing" do
+      describe "when the design_doc doesn't exist in the db yet" do
         before do 
           setup_db(false)
-          @db.things
         end
-        expect { lambda{@db.get('_design/things')}.wont raise_error }
-        expect { @db.things['views'].will == @canonical['views'] }
-        expect { @db.things.rev.will =~ /\d-\d{6,12}/ }
+        expect { lambda{@db.get('_design/things')}.must_raise RestClient::ResourceNotFound }
+        expect { @db.things['views'].must_equal @canonical['views'] }
+        expect { @db.things.rev.must_match /\d-\d{6,12}/ }
       end
       
-      context "when the design_doc exists but is not canonical" do
+      describe "when the design_doc exists but is not canonical" do
         before do
           # there are no line breaks in the version that setup_db posts
           setup_db
@@ -206,10 +148,10 @@ class ExegesisDesignTest < Test::Unit::TestCase
           @db.things
         end
         
-        expect { @db.things.rev.wont == @old['_rev'] }
+        expect { @db.things.rev.wont_equal @old['_rev'] }
       end
       
-      context "when the design_doc exists and is canonical" do
+      describe "when the design_doc exists and is canonical" do
         before do
           setup_db(false)
           @db.put('_design/things', DesignTestDatabase::ThingsDesign.canonical_design)
@@ -217,18 +159,18 @@ class ExegesisDesignTest < Test::Unit::TestCase
           @db.things
         end
         
-        expect { @db.things.rev.will == @old['_rev'] }
+        expect { @db.things.rev.must_equal @old['_rev'] }
       end
     end
     
-    context "knowing the views" do
+    describe "knowing the views" do
       before do
         @klass = DesignTestDatabase::ThingsDesign
       end
       
-      expect { @klass.views.will == @canonical['views'].keys }
-      expect { @klass.reduceable?('by_tag').will be(true) }
-      expect { @klass.reduceable?('by_name').will be(false) }
+      expect { @klass.views.must_equal @canonical['views'].keys }
+      expect { assert @klass.reduceable?('by_tag') }
+      expect { refute @klass.reduceable?('by_name') }
     end
   end
   

data/test/document_collection_test.rb

@@ -4,9 +4,9 @@ class DocCollectionTestDoc
   include Exegesis::Document
 end
 
-class ExegesisDocumentCollectionTest < Test::Unit::TestCase
+describe Exegesis::DocumentCollection do
   
-  context "when dealing with view response rows" do
+  describe "when dealing with view response rows" do
     before do
       reset_db
       @docs = [{'_id' => 'foo'}, {'_id' => 'bar'}, {'_id' => 'bee'}].map {|d| d.update('class' => 'DocCollectionTestDoc') }
@@ -16,14 +16,14 @@ class ExegesisDocumentCollectionTest < Test::Unit::TestCase
       @collection = Exegesis::DocumentCollection.new(@response_rows, @db)
     end
     
-    expect { @collection.size.will == @rows.size }
-    expect { @collection.keys.will == @rows.map{|r| r.first}.uniq }
-    expect { @collection.values.will == @rows.map{|r| r[1]} }
-    expect { @collection.documents.size.will == @rows.map{|r| r[2]}.uniq.size }
-    expect { @collection.documents.all? {|id,d| d.kind_of?(DocCollectionTestDoc) }.will == true }
-    expect { @collection.documents['foo'].id.will == @docs.first['_id'] }
+    expect { @collection.size.must_equal @rows.size }
+    expect { @collection.keys.must_equal @rows.map{|r| r.first}.uniq }
+    expect { @collection.values.must_equal @rows.map{|r| r[1]} }
+    expect { @collection.documents.size.must_equal @rows.map{|r| r[2]}.uniq.size }
+    expect { @collection.documents.each {|id,d| d.must_be_kind_of DocCollectionTestDoc } }
+    expect { @collection.documents['foo'].id.must_equal @docs.first['_id'] }
     
-    context "when documents are already in the rows" do
+    describe "when documents are already in the rows" do
       before do
         # "thing":"foobar" is not in the docs that have been saved to the database
         @docs.each {|d| d.update('thing' => 'foobar') }
@@ -31,22 +31,22 @@ class ExegesisDocumentCollectionTest < Test::Unit::TestCase
         @collection = Exegesis::DocumentCollection.new(@response_rows, @db)
       end
       
-      expect { @collection.documents.all?{|id,d| d['thing'] == 'foobar' }.will == true }
+      expect { @collection.documents.each {|id,d| d['thing'].must_equal 'foobar' } }
     end
     
-    context "filtering to a specific key" do
+    describe "filtering to a specific key" do
       before do
         @rows = @rows.select {|r| r[0]=="foo" }
         @foos = @collection['foo']
       end
       
-      expect { @foos.size.will == @rows.size }
-      expect { @foos.values.will == @rows.map{|r| r[1]} }
-      expect { @foos.documents.size.will == @rows.map{|r| r[2]}.uniq.size }
-      expect { @foos.documents.all? {|id,d| d.kind_of?(DocCollectionTestDoc) }.will == true }
-      expect { @foos.documents['foo'].object_id.will == @collection.documents['foo'].object_id }
+      expect { @foos.size.must_equal @rows.size }
+      expect { @foos.values.must_equal @rows.map{|r| r[1]} }
+      expect { @foos.documents.size.must_equal @rows.map{|r| r[2]}.uniq.size }
+      expect { @foos.documents.each {|id,d| d.must_be_kind_of DocCollectionTestDoc } }
+      expect { @foos.documents['foo'].object_id.must_equal @collection.documents['foo'].object_id }
       
-      context "with array keys" do
+      describe "with array keys" do
         before do
           @rows = [ [%w(bar baz), 5, 'bar'], 
                     [%w(bar bee), 5, 'bee'], 
@@ -60,17 +60,17 @@ class ExegesisDocumentCollectionTest < Test::Unit::TestCase
           @collection = Exegesis::DocumentCollection.new(@response_rows, @db)
         end
 
-        expect { @collection['foo'].size.will == @rows.select{|r| r[0][0]=='foo'}.size }
-        expect { @collection['foo'].values.will == @rows.select{|r| r[0][0]=='foo' }.map{|r| r[1]} }
-        expect { @collection['foo']['bar'].size.will == @rows.select{|r| r[0][0]=='foo' && r[0][1]=='bar'}.size }
-        expect { @collection['foo']['bar'].values.will == @rows.select{|r| r[0][0]=='foo'&&r[0][1]=='bar'}.map{|r| r[1]} }
+        expect { @collection['foo'].size.must_equal @rows.select{|r| r[0][0]=='foo'}.size }
+        expect { @collection['foo'].values.must_equal @rows.select{|r| r[0][0]=='foo' }.map{|r| r[1]} }
+        expect { @collection['foo']['bar'].size.must_equal @rows.select{|r| r[0][0]=='foo' && r[0][1]=='bar'}.size }
+        expect { @collection['foo']['bar'].values.must_equal @rows.select{|r| r[0][0]=='foo'&&r[0][1]=='bar'}.map{|r| r[1]} }
       end
 
     end
     
   end
   
-  context "iterating" do
+  describe "iterating" do
     before do
       reset_db
       @docs = [%w(bar bee), %w(bee foo), %w(foo bar)].map {|k,t| {'_id'=>k, 'thing'=>t, 'class'=>'DocCollectionTestDoc'} }
@@ -79,7 +79,7 @@ class ExegesisDocumentCollectionTest < Test::Unit::TestCase
       @collection = Exegesis::DocumentCollection.new(@rows, @db)
     end
     
-    context "each" do
+    describe "each" do
       before do
         @counter = 0
         @bin = []
@@ -88,10 +88,10 @@ class ExegesisDocumentCollectionTest < Test::Unit::TestCase
         @valbinning = lambda{ @collection.each{|k,v,d| @bin << v }; @bin }
         @docbinning = lambda{ @collection.each{|k,v,d| @bin << d.id }; @bin }
       end
-      expect { @counting.call.will == 3 }
-      expect { @keybinning.call.will == @rows.map{|r| r['key']} }
-      expect { @valbinning.call.will == @rows.map{|r| r['value']} }
-      expect { @docbinning.call.will == @rows.map{|r| @db.get(r['id']).id} }
+      expect { @counting.call.must_equal 3 }
+      expect { @keybinning.call.must_equal @rows.map{|r| r['key']} }
+      expect { @valbinning.call.must_equal @rows.map{|r| r['value']} }
+      expect { @docbinning.call.must_equal @rows.map{|r| @db.get(r['id']).id} }
     end
   end
 end

data/test/document_test.rb

@@ -23,10 +23,10 @@ class UniqueIdBlockTestDocument
   unique_id {|doc, attempt| attempt.zero? ? doc['pk'] : "#{doc['pk']}-#{attempt}" }
 end
 
-class ExegesisDocumentClassDefinitionsTest < Test::Unit::TestCase
+describe Exegesis::Document do
   
-  context "class definitions" do
-    context "with timestamps" do
+  describe "class definitions" do
+    describe "with timestamps" do
       before do
         reset_db
         @obj = TimestampTestDocument.new({}, @db)
@@ -34,144 +34,143 @@ class ExegesisDocumentClassDefinitionsTest < Test::Unit::TestCase
         @obj = @db.get(@obj.id)
       end
     
-      context "initial save" do
-        expect { @obj.created_at.to_f.will be_close(Time.now.to_f, 2) }
-        expect { @obj.updated_at.to_f.will be_close(Time.now.to_f, 2) }
+      describe "initial save" do
+        expect { @obj.created_at.to_f.must_be_close_to Time.now.to_f, 2 }
+        expect { @obj.updated_at.to_f.must_be_close_to Time.now.to_f, 2 }
       end
     
-      context "when created_at already exists" do
+      describe "when created_at already exists" do
         before do
           @obj['created_at'] = Time.now - 3600
           @obj.save
           @obj = @db.get(@obj.id)
         end
       
-        expect { @obj.created_at.to_f.will be_close((Time.now - 3600).to_f, 2) }
-        expect { @obj.updated_at.to_f.will be_close(Time.now.to_f, 2) }
+        expect { @obj.created_at.to_f.must_be_close_to((Time.now - 3600).to_f, 2) }
+        expect { @obj.updated_at.to_f.must_be_close_to Time.now.to_f, 2 }
       end
     
     end
   
-    context "with a custom unique_id setter" do
-      context "as a method" do
+    describe "with a custom unique_id setter" do
+      describe "as a method" do
         before do
           reset_db
           @obj = UniqueIdTestDocument.new({}, @db)
         end
     
-        context "when the id isn't in place yet" do
+        describe "when the id isn't in place yet" do
           before do
             @obj.save
           end
       
-          expect { @obj.id.will == "snowflake" }
+          expect { @obj.id.must_equal "snowflake" }
         end
     
-        context "when there is an id in place already" do
+        describe "when there is an id in place already" do
           before do
             @obj['_id'] = 'foo'
             @obj.save
           end
       
-          expect { @obj.id.will == "foo" }
+          expect { @obj.id.must_equal "foo" }
         end
     
-        context "when the desired id is already in use" do
+        describe "when the desired id is already in use" do
           before do
             @db.put('snowflake', {'_id' => 'snowflake', 'foo' => 'bar'})
             @obj.save
           end
       
-          expect { @obj.id.will == 'snowflake-1' }
+          expect { @obj.id.must_equal 'snowflake-1' }
         end
       end
       
-      context "as a block" do
+      describe "as a block" do
         before do
           reset_db
           @obj = UniqueIdBlockTestDocument.new({'pk'=>'bar'}, @db)
         end
         
-        context "when the id doesn't yet exist and no id in place" do
+        describe "when the id doesn't yet exist and no id in place" do
           before { @obj.save }
-          expect { @obj.id.will == @obj['pk'] }
+          expect { @obj.id.must_equal @obj['pk'] }
         end
         
-        context "when the document has an id in place already" do
+        describe "when the document has an id in place already" do
           before do
             @obj['_id'] = 'foo'
             @obj.save
           end
-          expect { @obj.id.will == 'foo' }
+          expect { @obj.id.must_equal 'foo' }
         end
         
-        context "when the desired id is already in use" do
+        describe "when the desired id is already in use" do
           before do
             @db.put('bar', {'_id' => 'bar', 'pk' => 'bar'})
             @obj.save
           end
-          expect { @obj.id.will == 'bar-1'}
+          expect { @obj.id.must_equal 'bar-1'}
         end
       end
     end
   end
   
-  context "instance methods" do
+  describe "instance methods" do
     before do
       reset_db
     end
 
-    context "updating attributes" do
+    describe "updating attributes" do
     
-      context "an existing doc" do
+      describe "an existing doc" do
         before do
           @doc = TestDocument.new({'foo' => 'bar'}, @db)
           @doc.save
           @old_rev = @doc.rev
         end
       
-        context "without a matching rev" do
-          expect { lambda {@doc.update_attributes({'foo' => 'bee'})}.will raise_error(ArgumentError) }
-          expect { lambda {@doc.update_attributes({'foo' => 'bee', '_rev' => 'z'})}.will raise_error(ArgumentError) }
+        describe "without a matching rev" do
+          expect { lambda{@doc.update_attributes({'foo' => 'bee'})}.must_raise ArgumentError }
+          expect { lambda{@doc.update_attributes({'foo' => 'bee', '_rev' => 'z'})}.must_raise ArgumentError }
         end
       
-        context "with a matching rev" do
+        describe "with a matching rev" do
           before do
             @doc.update_attributes({'_rev' => @doc.rev, 'foo' => 'bee'})
           end
         
-          expect { @doc['foo'].will == 'bee' }
-          expect { @doc.rev.wont == @old_rev }
+          expect { @doc['foo'].must_equal 'bee' }
+          expect { @doc.rev.wont_equal @old_rev }
         end
         
-        context "when given keys without writers" do
+        describe "when given keys without writers" do
           before do
             @action = lambda {@doc.update_attributes({'_rev' => @doc.rev, 'bar' => 'boo'})}
           end
           
-          expect { @action.will raise_error(NoMethodError) }
+          expect { @action.must_raise NoMethodError }
         end
       end
       
-      context "a new doc" do
+      describe "a new doc" do
         before { @doc = TestDocument.new({'foo' => 'bar'}, @db) }
         
-        context "without a rev" do
+        describe "without a rev" do
           before { @doc.update_attributes({'foo' => 'baz'}) }
-          expect { @doc['foo'].will == 'baz' }
+          expect { @doc['foo'].must_equal 'baz' }
         end
 
-        context "with a blank rev" do
+        describe "with a blank rev" do
           before { @doc.update_attributes({'foo' => 'baz', '_rev' => ''}) }
-          expect { @doc['foo'].will == 'baz' }
+          expect { @doc['foo'].must_equal 'baz' }
         end
-        context "with a non blank rev" do
+        describe "with a non blank rev" do
           before { @action = lambda{@doc.update_attributes({'foo'=>'baz', '_rev'=>'1-3034523523'})} }
-          expect { @action.will raise_error(ArgumentError)}
+          expect { @action.must_raise ArgumentError }
         end
       end
       
-      
     end
   end
   

data/test/http_test.rb

@@ -2,20 +2,20 @@ require File.join(File.dirname(__FILE__), 'test_helper.rb')
 require 'restclient'
 require 'json'
 
-class HttpTest < Test::Unit::TestCase
+describe Exegesis::Http do
   
-  context "url formatting" do
-    context "with no params" do
+  describe "url formatting" do
+    describe "with no params" do
       before do
         @url = "/some_url"
         @action = lambda {|params| Exegesis::Http.format_url(@url, params) }
       end
       
-      expect { @action.call(nil).will == "/some_url" }
-      expect { @action.call({}).will == "/some_url" }
+      expect { @action.call(nil).must_equal "/some_url" }
+      expect { @action.call({}).must_equal "/some_url" }
     end
     
-    context "with normal params" do
+    describe "with normal params" do
       before do
         @url = "/some_url"
         @params = {
@@ -25,54 +25,52 @@ class HttpTest < Test::Unit::TestCase
         @expected = ["/some_url?one=1&two=2", "/some_url?two=2&one=1"]
       end
       
-      expect { @expected.will include(Exegesis::Http.format_url(@url, @params)) }
+      expect { @expected.must_include Exegesis::Http.format_url(@url, @params) }
     end
   end
   
-  context "making requests" do
-    before(:all) do
+  describe "making requests" do
+    before do
       @db = 'http://localhost:5984/exegesis-test'
       RestClient.delete(@db) rescue nil
       RestClient.put(@db, '')
     end
     
-    after(:all) do
+    after do
       RestClient.delete(@db) rescue nil
     end
     
-    context "get requests" do
+    describe "get requests" do
       before do
         @response = Exegesis::Http.get(@db)
       end
       
-      expect { @response['db_name'].will == 'exegesis-test' }
+      expect { @response['db_name'].must_equal 'exegesis-test' }
     end
     
-    context "post requests" do
+    describe "post requests" do
       before do
         @response = Exegesis::Http.post(@db, {'test' => 'value'}.to_json)
       end
       
-      expect { @response['ok'].will == true }
+      expect { @response['ok'].must_equal true }
     end
     
-    context "put requests" do
+    describe "put requests" do
       before do
         @response = Exegesis::Http.put("#{@db}/test-document", {'test' => 'value'}.to_json)
       end
       
-      expect { @response['ok'].will == true }
-
-      after { RestClient.delete("#{@db}/test-document?rev=#{@response['rev']}") }
+      expect { @response['ok'].must_equal true }
     end
     
-    context "delete requests" do
+    describe "delete requests" do
       before do
         @doc = JSON.parse RestClient.put("#{@db}/test-document", {'test' => 'value'}.to_json)
         @response = RestClient.delete("#{@db}/test-document?rev=#{@doc['rev']}")
       end
       
-      expect { @response['ok'].will == 'ok' }
+      expect { @response['ok'].must_equal 'ok' }
     end
   end