mattly-exegesis 0.2.2 → 0.2.3

data/README.rdoc

@@ -51,13 +51,18 @@ CouchDB is table-less, and Exegesis's design reflects this. In CouchDB, Document
 
 == Requirements:
 
-* RestClient
+* RestClient 0.9 or later.
 
 For running the tests:
 
-* Test::Unit (you got it)
-* Context (http://github.com/jeremymcanally/context, can install from github gems)
-* Matchy (http://github.com/jeremymcanally/matchy, github gem version out of date; clone, build & install for now)
-* Zebra (http://github.com/giraffesoft/zerba, depends on jeremymcanally-matchy, which is out of date; clone, build & install for now)
+* MiniTest
+  MiniTest is the default testing framework for Ruby 1.9
+  However, these tests require the trunk version, and my patches against the trunk version.
+  The trunk version is here: http://github.com/seattlerb/minitest
+  My patches are in my fork: http://github.com/mattly/minitest
+  You will need to clone my repo and from its directory, do the following:
+    `rake gem`
+    `sudo gem install pkg/minitest-1.3.1`
+  Once MiniTest 1.3.2 is released you should be able to use the standard gem.
 
-The test suite creates and destroys a database for each test that requires access to the database. This is slow, and the test suite may take some time to run. However, I would rather the test suite be slow and accurate than quick and full of mocking.
+The test suite creates and destroys a database for each test that requires access to the database. This is slow, and the test suite may take some time to run. However, I would rather the test suite be slow and accurate than quick and full of mocking or possibly error-prone deleting.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 2
-:patch: 2
+:patch: 4

data/lib/exegesis/design.rb

@@ -21,7 +21,7 @@ module Exegesis
     end
     
     def self.compose_canonical
-      Dir[design_directory + 'views' + '**/*.js'].each do |view_func|
+      Dir[(design_directory + 'views' + '**/*.js').to_s].each do |view_func|
         path = view_func.split('/')
         func = path.pop.sub(/\.js$/,'')
         name = path.pop

data/test/attachments_test.rb

@@ -4,18 +4,18 @@ class AttachmentsDocumentTest
   include Exegesis::Document
 end
 
-class ExegesisAttachmentsTest < Test::Unit::TestCase
+describe Exegesis::Document::Attachments do
   before do
     reset_db
     @doc = AttachmentsDocumentTest.new({}, @db)
   end
   
-  context "document methods" do
-    expect { @doc.attachments.kind_of?(Exegesis::Document::Attachments).will == true }
-    expect { @doc.attachments.size.will == 0 }
+  describe "document methods" do
+    expect { @doc.attachments.must_be_kind_of Exegesis::Document::Attachments }
+    expect { @doc.attachments.size.must_equal 0 }
   end
   
-  context "reading existing attachments" do
+  describe "reading existing attachments" do
     before do
       @doc.save
       @text = "this is a file"
@@ -23,20 +23,20 @@ class ExegesisAttachmentsTest < Test::Unit::TestCase
       @doc = @db.get(@doc['_id'])
     end
     
-    expect { @doc.attachments.size.will == 1 }
-    expect { @doc.attachments.keys.will == %w(file.txt) }
-    expect { @doc.attachments['file.txt'].content_type.will == 'text/plain' }
-    expect { @doc.attachments['file.txt'].length.will == @text.length }
-    expect { @doc.attachments['file.txt'].stub?.will == true }
-    expect { @doc.attachments['file.txt'].file.will == @text }
+    expect { @doc.attachments.size.must_equal 1 }
+    expect { @doc.attachments.keys.must_equal %w(file.txt) }
+    expect { @doc.attachments['file.txt'].content_type.must_equal 'text/plain' }
+    expect { @doc.attachments['file.txt'].length.must_equal @text.length }
+    expect { assert @doc.attachments['file.txt'].stub? }
+    expect { @doc.attachments['file.txt'].file.must_equal @text }
   end
   
-  context "writing attachments" do
+  describe "writing attachments" do
     before do
       @doc.save
     end
-    context "directly using attachments put" do
-      context "with the file's contents as a string" do
+    describe "directly using attachments put" do
+      describe "with the file's contents as a string" do
         before do
           @contents = "this is the contents of a text file"
           @type = 'text/plain'
@@ -44,62 +44,62 @@ class ExegesisAttachmentsTest < Test::Unit::TestCase
           @putting.call 'f.txt', @contents, @type
         end
 
-        context "when they don't exist yet" do
-          expect { RestClient.get("#{@doc.uri}/f.txt").will == @contents }
-          expect { @doc.attachments['f.txt'].file.will == @contents }
-          expect { @doc.rev.will == @db.raw_get(@doc.id)['_rev'] }
+        describe "when they don't exist yet" do
+          expect { RestClient.get("#{@doc.uri}/f.txt").must_equal @contents }
+          expect { @doc.attachments['f.txt'].file.must_equal @contents }
+          expect { @doc.rev.must_equal @db.raw_get(@doc.id)['_rev'] }
         end
       
-        context "when they do exist" do
+        describe "when they do exist" do
           before do
             @putting.call 'f.txt', "foo", @type
           end
-          expect { @doc.attachments['f.txt'].file.will == "foo" }
+          expect { @doc.attachments['f.txt'].file.must_equal "foo" }
         end
       end
       
       # it turns out rest-client doesn't actually support streaming uploads/downloads yet
-      # context "streaming the file as a block given" do
+      # describe "streaming the file as a block given" do
       #   before do
       #     @file = File.open(fixtures_path('attachments/flavakitten.jpg'))
       #     @type = 'image/jpeg'
       #     @doc.attachments.put('kitten.jpg', @type) { @file.read }
       #   end
       #   
-      #   expect { @doc.will satisfy(lambda{|e| e.attachments['kitten.jpg'].file == @file.read })}
+      #   expect { lambda{|e| e.attachments['kitten.jpg'].file == @file.read }.must_be true }
       # end
     end
     
-    context "indirectly, saved with the document" do
+    describe "indirectly, saved with the document" do
       before do
         @content = "this is an example file"
         @doc.attachments['file.txt'] = @content, 'text/plain'
       end
       
-      expect { @doc.attachments['file.txt'].content_type.will == 'text/plain' }
-      expect { @doc.attachments['file.txt'].metadata['data'].will == Base64.encode64(@content).gsub(/\s/,'') }
-      expect { @doc.attachments['file.txt'].length.will == @content.length }
-      expect { @doc.attachments.dirty?.will == true }
+      expect { @doc.attachments['file.txt'].content_type.must_equal 'text/plain' }
+      expect { @doc.attachments['file.txt'].metadata['data'].must_equal Base64.encode64(@content).strip }
+      expect { @doc.attachments['file.txt'].length.must_equal @content.length }
+      expect { assert @doc.attachments.dirty? }
       
-      context "when saving" do
+      describe "when saving" do
         before do
           @doc.save
         end
         
-        expect { @doc.attachments['file.txt'].file.will == @content }
-        expect { @doc.attachments['file.txt'].stub?.will == true }
-        expect { @doc.attachments['file.txt'].metadata.has_key?('data').will == false }
-        expect { @doc.attachments.dirty?.will == false }
+        expect { @doc.attachments['file.txt'].file.must_equal @content }
+        expect { assert @doc.attachments['file.txt'].stub? }
+        expect { refute @doc.attachments['file.txt'].metadata.has_key?('data') }
+        expect { refute @doc.attachments.dirty? }
       end
     end
   end
   
-  context "removing attachments" do
-    context "from the document" do
+  describe "removing attachments" do
+    describe "from the document" do
       
     end
     
-    context "directly from the database" do
+    describe "directly from the database" do
       
     end
   end

data/test/database_test.rb

@@ -21,52 +21,52 @@ class DatabaseTestDocument
   include Exegesis::Document
 end
 
-class ExegesisDatabaseTest < Test::Unit::TestCase
-  before(:all) do
+describe Exegesis::Database do
+  before do
     @server = Exegesis::Server.new('http://localhost:5984')
     RestClient.delete("#{@server.uri}/exegesis-test") rescue nil
     RestClient.delete("#{@server.uri}/exegesis-test-nonexistent") rescue nil
     RestClient.put("#{@server.uri}/exegesis-test", '')
   end
   
-  context "initializing" do
-    context "with server and name arguments" do
+  describe "initializing" do
+    describe "with server and name arguments" do
       before do
-        @db =DatabaseTest.new(@server, 'exegesis-test')
+        @db = DatabaseTest.new(@server, 'exegesis-test')
       end
 
-      expect { @db.is_a?(DatabaseTest).will == true }
-      expect { @db.uri.will == "#{@server.uri}/exegesis-test"}
+      expect { @db.must_be_kind_of DatabaseTest }
+      expect { @db.uri.must_equal "#{@server.uri}/exegesis-test"}
 
-      context "when the database does not exist" do
+      describe "when the database does not exist" do
         before do
           @action = lambda { DatabaseTest.new(@server, 'exegesis-test-nonexistent') }
         end
       
-        expect { @action.will raise_error(RestClient::ResourceNotFound) }
+        expect { @action.must_raise(RestClient::ResourceNotFound) }
       end
     end
     
-    context "with a url argument" do
+    describe "with a url argument" do
       before do
         @db = DatabaseTest.new('http://localhost:5984/exegesis-test')
       end
       
-      expect { @db.is_a?(DatabaseTest).will == true }
-      expect { @db.uri.will == 'http://localhost:5984/exegesis-test' }
+      expect { @db.must_be_kind_of DatabaseTest }
+      expect { @db.uri.must_equal 'http://localhost:5984/exegesis-test' }
     end
     
-    context "with a name argument" do
+    describe "with a name argument" do
       before do
         @db = DatabaseTest.new('exegesis-test')
       end
       
-      expect { @db.is_a?(DatabaseTest).will == true }
-      expect { @db.uri.will == "http://localhost:5984/exegesis-test" }
+      expect { @db.must_be_kind_of DatabaseTest }
+      expect { @db.uri.must_equal "http://localhost:5984/exegesis-test" }
     end
   end
   
-  context "retrieving documents by id" do
+  describe "retrieving documents by id" do
     before do
       @db = DatabaseTest.new @server, 'exegesis-test'
       RestClient.put "#{@db.uri}/test-document", {'key'=>'value', 'class'=>'DatabaseTestDocument'}.to_json rescue nil
@@ -77,63 +77,63 @@ class ExegesisDatabaseTest < Test::Unit::TestCase
       RestClient.delete("#{@db.uri}/test-document?rev=#{@doc['_rev']}") rescue nil
     end
     
-    expect { @doc.is_a?(DatabaseTestDocument).will == true }
-    expect { @doc.id.will == 'test-document' }
-    expect { @doc['key'].will == 'value' }
+    expect { @doc.must_be_kind_of DatabaseTestDocument }
+    expect { @doc.id.must_equal 'test-document' }
+    expect { @doc['key'].must_equal 'value' }
     
-    context "retrieving the raw document" do
+    describe "retrieving the raw document" do
       before do
         @doc = @db.raw_get('test-document')
       end
       
-      expect { @doc.is_a?(Hash).will == true }
-      expect { @doc['_id'].will == 'test-document' }
-      expect { @doc['key'].will == 'value' }
-      expect { @doc['class'].will == 'DatabaseTestDocument' }
+      expect { @doc.must_be_kind_of Hash }
+      expect { @doc['_id'].must_equal 'test-document' }
+      expect { @doc['key'].must_equal 'value' }
+      expect { @doc['class'].must_equal 'DatabaseTestDocument' }
     end
     
-    context "retrieving multiple documents" do
+    describe "retrieving multiple documents" do
       before do
         docs = [{"_id"=>"a"},{"_id"=>"b"},{"_id"=>"c"}].map{|d| d.update('class' => 'DatabaseTestDocument')}
         RestClient.post("#{@db.uri}/_bulk_docs", {"docs"=>docs}.to_json)
       end
       
-      expect { @db.get(%w(a b c)).size.will == 3 }
-      expect { @db.get(%w(a b c)).all?{|doc| doc.is_a?(DatabaseTestDocument)}.will == true }
+      expect { @db.get(%w(a b c)).size.must_equal 3 }
+      expect { @db.get(%w(a b c)).each{|doc| doc.must_be_kind_of DatabaseTestDocument} }
     end
   end
   
-  context "saving docs" do
+  describe "saving docs" do
     before do
       reset_db
       @db = DatabaseTest.new('exegesis-test')
     end
     
-    context "a single doc" do
+    describe "a single doc" do
       before { @doc = {'foo' => 'bar'} }
 
-      context "without an id" do
+      describe "without an id" do
         before do
           @db.save(@doc)
           @rdoc = @db.get(@doc['_id'])
         end
-        expect { @doc['_rev'].will == @rdoc['_rev'] }
-        expect { @rdoc['foo'].will == @doc['foo'] }
+        expect { @doc['_rev'].must_equal @rdoc['_rev'] }
+        expect { @rdoc['foo'].must_equal @doc['foo'] }
       end
       
-      context "with an id" do
+      describe "with an id" do
         before { @doc['_id'] = 'test-document' }
         
-        context "when the document doesn't exist yet" do
+        describe "when the document doesn't exist yet" do
           before do
             @db.save(@doc)
             @rdoc = @db.get('test-document')
           end
-          expect { @doc['_rev'].will == @rdoc['_rev'] }
-          expect { @rdoc['foo'].will == @doc['foo'] }
+          expect { @doc['_rev'].must_equal @rdoc['_rev'] }
+          expect { @rdoc['foo'].must_equal @doc['foo'] }
         end
         
-        context "when the document exists already" do
+        describe "when the document exists already" do
           before do 
             response = @db.post(@doc)
             @doc['_id'] = response['id']
@@ -141,18 +141,18 @@ class ExegesisDatabaseTest < Test::Unit::TestCase
             @doc['foo'] = 'bee'
           end
 
-          expect { lambda { @db.save(@doc) }.wont raise_error }
+          expect { @db.save(@doc)['_rev'].must_match /2-\d+/ }
           
-          context "without a valid rev" do
+          describe "without a valid rev" do
             before { @doc.delete('_rev') }
-            expect { lambda { @db.save(@doc) }.will raise_error }
+            expect { lambda{ @db.save(@doc) }.must_raise RestClient::RequestFailed }
           end
         end
         
       end
     end
     
-    context "multiple docs" do
+    describe "multiple docs" do
       before do
         @updated = @db.post({'_id' => 'updated', 'key' => 'original'})
         @deleted = @db.post({'_id' => 'deleted', 'key' => 'original'})
@@ -165,53 +165,53 @@ class ExegesisDatabaseTest < Test::Unit::TestCase
         }
       end
         
-      context "without conflicts" do
+      describe "without conflicts" do
         before { @saving.call }
-        expect { @db.get('new')['key'].will == 'new' }
-        expect { @db.get('updated')['key'].will == 'new' }
-        expect { lambda {@db.get('deleted')}.will raise_error(RestClient::ResourceNotFound) }
+        expect { @db.get('new')['key'].must_equal 'new' }
+        expect { @db.get('updated')['key'].must_equal 'new' }
+        expect { lambda {@db.get('deleted')}.must_raise RestClient::ResourceNotFound }
       end
     end
   end
   
-  context "setting the designs directory" do
-    expect { DatabaseTest.designs_directory.will == Pathname.new('designs') }
-    expect { CustomDesignDirDatabaseTest.designs_directory.will == Pathname.new('app/designs') }
+  describe "setting the designs directory" do
+    expect { DatabaseTest.designs_directory.must_equal Pathname.new('designs') }
+    expect { CustomDesignDirDatabaseTest.designs_directory.must_equal Pathname.new('app/designs') }
   end
   
-  context "with a named document" do
-    context "that doesn't exist yet" do
+  describe "with a named document" do
+    describe "that doesn't exist yet" do
       before do
         reset_db
         @db = NamedDocumentDatabaseTest.new('exegesis-test')
+        @db.settings
       end
       
-      expect { @db.settings.kind_of?(NamedDocumentDatabaseTest::Settings).will == true }
-      expect { @db.settings.rev.will =~ /1-\d{7,12}/ }
-      expect { @db.settings.respond_to?(:things).will == true }
-      expect { @db.settings; lambda{ @db.get('settings') }.wont raise_error(RestClient::ResourceNotFound) }
+      expect { @db.settings.must_be_kind_of NamedDocumentDatabaseTest::Settings }
+      expect { @db.settings.rev.must_match /1-\d{7,12}/ }
+      expect { @db.settings.must_respond_to :things }
+      expect { @db.get('settings').must_be_kind_of NamedDocumentDatabaseTest::Settings }
     end
     
-    context "that does exist" do
+    describe "that does exist" do
       before do
         reset_db
         @db = NamedDocumentDatabaseTest.new('exegesis-test')
         @doc = @db.save({'_id' => 'settings', 'things' => %w(foo bar baz), 'class' => 'NamedDocumentDatabaseTest::Settings'})
       end
       
-      expect { lambda { @db.get('settings') }.wont raise_error(RestClient::ResourceNotFound) }
-      expect { @db.settings.rev.will == @doc['_rev'] }
-      expect { @db.settings.rev.will =~ /1-\d{7,12}/ }
-      expect { @db.settings.things.will == %w(foo bar baz) }
+      expect { @db.settings.rev.must_equal @doc['_rev'] }
+      expect { @db.settings.rev.must_match /1-\d{7,12}/ }
+      expect { @db.settings.things.must_equal %w(foo bar baz) }
     end
     
-    context "when the declaration does not have a block" do
+    describe "when the declaration does not have a block" do
       before do
         reset_db
         @db = NamedDocumentWithoutBlockDatabaseTest.new('exegesis-test')
       end
       
-      expect { @db.blah.kind_of?(NamedDocumentWithoutBlockDatabaseTest::Blah).will == true }
+      expect { @db.blah.must_be_kind_of NamedDocumentWithoutBlockDatabaseTest::Blah }
     end
   end