mattly-exegesis 0.0.10 → 0.2.0

data/test/design_doc_test.rb

@@ -1,120 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-
-class FoosDesign < Exegesis::Design
-  view_by :foo
-  view_by :foo, :bar
-end
-class CustomDesignDirDesign < Exegesis::Design
-  designs_directory File.join(File.dirname(__FILE__), 'fixtures')
-end
-
-
-class ComposingDesignDocTest < Test::Unit::TestCase
-  before(:all) { Exegesis.designs_directory = fixtures_path('designs') }
-  
-  context "setting a custom designs directory" do
-    before do
-      @custom_design_dir = File.join(File.dirname(__FILE__), 'fixtures')
-    end
-    
-    expect { CustomDesignDirDesign.designs_directory.to_s.will == @custom_design_dir }
-    
-  end
-  
-  context "composing design docs from local sources" do
-    before do
-      @design = FoosDesign.design_doc
-      @file = File.read(fixtures_path('designs/foos.js'))
-      @jsdoc = Johnson.evaluate("v=#{@file}")
-    end
-  
-    expect { @design.has_key?('_id').will be(true) }
-    expect { @design['_id'].will == '_design/foos' }
-    expect { @design['views']['by_bar']['map'].will == @jsdoc['views']['by_bar']['map'].toString }
-  end
-  
-  context "composing a design doc from view_by declarations" do
-    before do
-      @design = FoosDesign.design_doc
-      @by_foo = @design['views']['by_foo']['map']
-      @by_foo_and_bar = @design['views']['by_foo_and_bar']['map']
-    end
-    
-    expect { @by_foo.will include("if (doc['.kind'] == 'Foos' && doc['foo'])") }
-    expect { @by_foo.will include("emit(doc['foo'], null);") }
-    
-    expect { @by_foo_and_bar.will include("if (doc['.kind'] == 'Foos' && doc['foo'] && doc['bar'])") }
-    expect { @by_foo_and_bar.will include("emit([doc['foo'], doc['bar']], null)") }
-  end
-  
-  context "building a hash a design doc" do
-    before do
-      @design = {
-        'views' => {
-          'a' => {'map' => 'some value', 'reduce' => 'some value'},
-          'b' => {'map' => 'some value'}
-        }
-      }
-      funcs = @design['views'].map{|name, view| "//view/#{name}/#{view['map']}/#{view['reduce']}" }.sort
-      @hashed = Digest::MD5.hexdigest(funcs.join)
-    end
-    expect { FoosDesign.hash_for_design(@design).will == @hashed }
-  end
-
-  context "syncronising with a databae" do
-    before do
-      reset_db
-    end
-    
-    context "pushing design doc when it doesn't exist yet" do
-      before do
-        foo = FoosDesign.new(@db)
-        foo.push_design!
-        @get_design = lambda { @db.get('_design/foos') }
-        @design = @get_design.call rescue nil
-      end
-
-      expect { @get_design.wont raise_error }
-      expect { @design['_rev'].will =~ /^[0-9]+$/ }
-      expect { @design['language'].will == 'javascript' }
-      expect { @design['views'].has_key?('by_bar').will be(true) }
-    end
-
-    context "reading the existing design document" do
-      before do
-        @db.save_doc(FoosDesign.design_doc)
-        @foo = FoosDesign.new(@db)
-      end
-
-      expect { lambda {@foo.design_doc}.wont raise_error }
-      expect { @foo.design_doc['_rev'].will =~ /^[0-9]+$/ }
-      expect { @foo.design_doc['views'].keys.will == FoosDesign.design_doc['views'].keys }
-    end
-
-    context "updating an existing doc" do
-
-      context "when it hasn't changed" do
-        before do
-          @db.save_doc(FoosDesign.design_doc)
-          @foo = FoosDesign.new(@db)
-        end
-        
-        expect { lambda { @foo.push_design! }.wont change { @db.get('_design/foos')['_rev'] } }
-      end
-
-      context "when it has chagned" do
-        before do
-          @db.save_doc({'_id' => '_design/foos', 
-            'views' => {'a' => {'map' => 'function(doc) { emit(true, null)}'}}
-          })
-          @foo = FoosDesign.new(@db)
-          @pushing = lambda{ @foo.push_design! }
-        end
-
-        expect { @pushing.will change { @db.get('_design/foos')['_rev'] } }
-        expect { @pushing.call; @foo.design_doc_hash.will == FoosDesign.design_doc_hash }
-      end
-    end
-    
-  end
-end

data/test/document_class_definitions_test.rb

@@ -1,284 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-
-class Foo < Exegesis::Document
-  expose :ref, :as => :reference
-end
-class Bar < Exegesis::Document; end
-
-class WithDefault < Exegesis::Document
-  default :foo => 'bar'
-end
-
-class Exposer < Exegesis::Document
-  expose :foo, :bar
-  expose :read_only, :writer => false
-  expose :custom_writer, :writer => lambda {|val| {'value' => val} }
-  expose :castee, :castees, :as => :given
-  expose :time, :times, :as => Time
-  expose :regex, :regexen, :as => Regexp
-  expose :other_doc, :other_docs, :as => :reference
-end
-
-class Timestamper < Exegesis::Document
-  timestamps!
-end
-
-class UniqueSnowflake < Exegesis::Document
-  unique_id :set_id
-  def set_id
-    @unique_id_attempt.zero? ? "snowflake" : "snowflake-#{@unique_id_attempt}"
-  end
-end
-
-class ExegesisDocumentClassDefinitionsTest < Test::Unit::TestCase
-  
-  context "a bare Exegesis::Document" do
-    before do
-      reset_db
-      @obj = Foo.new
-      @obj.database = @db
-      @obj.save
-    end
-    
-    expect { @obj['.kind'].will == "Foo" }
-    expect { @obj['foo'].will == nil }
-    expect { @obj.will_not respond_to(:foo) }
-    expect { @obj['created_at'].will == nil }
-    expect { @obj['updated_at'].will == nil }
-  end
-  
-  context "instantiating" do
-    expect { Exegesis::Document.instantiate({'.kind' => 'Foo'}).will be_kind_of(Foo) }
-
-    context "transitions" do
-      before do
-        @foo = Foo.new
-        @foo['.kind'] = 'Bar'
-        @bar = Exegesis::Document.instantiate(@foo)
-      end
-      
-      expect { @bar.will be_kind_of(Bar) }
-    end
-  end
-  
-  context "default objects" do
-    expect { WithDefault.new['foo'].will == 'bar' }
-    expect { WithDefault.new({'foo' => 'baz'})['foo'].will == 'baz' }
-  end
-  
-  context "exposing keys" do
-    context "regular declarations" do
-      before do 
-        @obj = Exposer.new(:foo => 'bar', :bar => 'foo')
-        @writing = lambda { @obj.bar = "bee" }
-      end
-      expect { @obj.foo.will == 'bar' }
-      expect { @obj.bar.will == 'foo' }
-      expect { @writing.wont raise_error }
-      expect { @writing.call; @obj.bar.will == "bee" }
-    end
-    
-    context "with a custom writer" do
-      context "when false" do
-        before { @obj = Exposer.new(:read_only => 'value') }
-        expect { @obj.read_only.will == 'value' }
-        expect { lambda{@obj.read_only = "other value"}.will raise_error(NoMethodError) }
-      end
-      
-      context "when lambda" do
-        before do
-          @obj = Exposer.new(:custom_writer => 'value')
-          @obj.custom_writer = 'other value'
-          @expected = {'value' => 'other value'}
-        end
-        expect { @obj.custom_writer.will == @expected }
-      end
-    end
-    
-    context "when casting a value" do
-      context "when as given" do
-        before do
-          @obj = Exposer.new({
-            :castee => {'foo' => 'foo', '.kind' => 'Foo'},
-            :castees => [{'foo' => 'foo', '.kind' => 'Foo'}, {'foo' => 'bar', '.kind' => 'Bar'}]
-          })
-        end
-        
-        expect { @obj.castee.class.will == Foo }
-        expect { @obj.castee['foo'].will == 'foo' }
-        expect { @obj.castee.parent.will == @obj }
-        
-        expect { @obj.castees.class.will == Array }
-        expect { @obj.castees[0].class.will == Foo }
-        expect { @obj.castees[0]['foo'].will == 'foo' }
-        expect { @obj.castees[0].parent.will == @obj }
-        expect { @obj.castees[1].class.will == Bar }
-        expect { @obj.castees[1]['foo'].will == 'bar' }
-        expect { @obj.castees[1].parent.will == @obj }
-      end
-      
-      context "when as time" do
-        before do
-          @obj = Exposer.new({:time => Time.now.to_json, :times => [Time.local(2009,3,1).to_json, Time.local(2009,2,1).to_json]})
-        end
-        
-        expect { @obj.time.class.will == Time }
-        expect { @obj.time.to_f.will be_close(Time.now.to_f, 1) }
-        
-        expect { @obj.times.class.will == Array }
-        expect { @obj.times[0].class.will == Time }
-        expect { @obj.times[0].will == Time.local(2009,3,1) }
-        expect { @obj.times[1].class.will == Time }
-        expect { @obj.times[1].will == Time.local(2009,2,1) }
-      end
-      
-      context "when as non document class" do
-        before do
-          @obj = Exposer.new({
-            :regex => 'foo',
-            :regexen => ['foo', 'bar']
-          })
-        end
-        
-        expect { @obj.regex.will == /foo/ }
-        
-        expect { @obj.regexen.class.will == Array }
-        expect { @obj.regexen[0].will == /foo/ }
-        expect { @obj.regexen[1].will == /bar/ }
-      end
-      
-      context "when as reference" do
-        context "with a database present" do
-          before do
-            reset_db
-            @obj = Exposer.new(:other_doc => "other_doc", :other_docs => ["other_docs_1", "other_docs_2"])
-            @obj.database = @db
-          end
-          
-          context "when the document exists" do
-            before do
-              @db.bulk_save([
-                {'.kind' => 'Foo', '_id' => 'other_doc'},
-                {'.kind' => 'Foo', '_id' => 'other_docs_1'}, 
-                {'.kind' => 'Foo', '_id' => 'other_docs_2'}
-              ])
-            end
-            
-            expect { @obj.other_doc.rev.will == @db.get('other_doc')['_rev'] }
-            expect { @obj.other_doc.class.will == Foo }
-            expect { @obj.other_docs.class.will == Array }
-            expect { @obj.other_docs[0].rev.will == @db.get('other_docs_1')['_rev'] }
-            expect { @obj.other_docs[0].class.will == Foo }
-            expect { @obj.other_docs[1].rev.will == @db.get('other_docs_2')['_rev'] }
-            expect { @obj.other_docs[1].class.will == Foo }
-            
-            context "caching" do
-              before do
-                @obj.other_doc
-                doc = @db.get('other_doc')
-                doc['foo'] = "updated"
-                doc.save
-              end
-              
-              expect { @obj.other_doc['foo'].will be(nil) }
-              expect { @obj.other_doc(true)['foo'].will == 'updated' }
-            end
-          end
-          
-          context "when the document is missing" do
-            expect { lambda{@obj.other_doc}.will raise_error(RestClient::ResourceNotFound) }
-            expect { lambda{@obj.other_docs}.will raise_error(RestClient::ResourceNotFound) }
-          end
-          
-          context "when the doucment has a parent" do
-            before do
-              @obj.castee = Foo.new({})
-              @obj.castee.ref = 'other_doc'
-              @obj.save
-              @db.save_doc({'.kind' => 'Foo', '_id' => 'other_doc'})
-            end
-            
-            expect { @obj.castee.ref.rev.will == @db.get('other_doc')['_rev'] }
-          end
-        end
-        
-        context "without a database present" do
-          before { @obj = Exposer.new(:other_doc => "some_doc_id") }
-          expect { lambda{@obj.other_doc}.will raise_error(ArgumentError) }
-        end
-      end
-      
-      context "when the value is nil" do
-        before do
-          @obj = Exposer.new({:castee => nil, :castees => nil, :regexen => ['foo', nil]})
-        end
-        expect { @obj.castee.will be(nil) }
-        expect { @obj.castees.will be(nil) }
-        expect { @obj.regexen.will == [/foo/] }
-      end
-    end
-  end
-  
-  context "with timestamps" do
-    before do
-      reset_db
-      @obj = Timestamper.new
-      @obj.database = @db
-      @obj.save
-      @obj = Timestamper.new(@db.get(@obj.id))
-    end
-    
-    context "initial save" do
-      expect { @obj.created_at.to_f.will be_close(Time.now.to_f, 1) }
-      expect { @obj.updated_at.to_f.will be_close(Time.now.to_f, 1) }
-    end
-    
-    context "when created_at already exists" do
-      before do
-        @obj.database = @db
-        @obj['created_at'] = Time.now
-        @obj.save
-        @obj = Timestamper.new(@db.get(@obj.id))
-      end
-      
-      expect { @obj.created_at.to_f.will be_close(Time.now.to_f, 1) }
-      expect { @obj.updated_at.to_f.will be_close(Time.now.to_f, 1) }
-    end
-    
-  end
-  
-  context "with a custom unique_id setter" do
-    before do
-      reset_db
-      @obj = UniqueSnowflake.new
-      @obj.database = @db
-    end
-    
-    context "when the id isn't in use yet" do
-      before do
-        @obj.save
-      end
-      
-      expect { @obj.id.will == "snowflake" }
-    end
-    
-    context "when there is an id in place already" do
-      before do
-        @obj['_id'] = 'foo'
-        @obj.save
-      end
-      
-      expect { @obj.id.will == "foo" }
-    end
-    
-    context "when the desired id is already in use" do
-      before do
-        @db.save_doc({'_id' => 'snowflake', 'foo' => 'bar'})
-        @obj.save
-      end
-      
-      expect { @obj.id.will == 'snowflake-1' }
-    end
-  end
-  
-end

data/test/document_instance_methods_test.rb

@@ -1,40 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-
-class DocInstance < Exegesis::Document
-  expose :foo
-end
-
-class ExegesisDocumentInstanceMethodsTest < Test::Unit::TestCase
-  
-  context "update_attributes" do
-    before do
-      reset_db
-    end
-    
-    context "an existing doc" do
-      before do
-        @doc = DocInstance.new({'foo' => 'bar'})
-        @doc.database = @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) }
-      end
-      
-      context "with a matching rev" do
-        before do
-          @doc.update_attributes({'_rev' => @doc.rev, 'foo' => 'bee', 'bar' => 'boo'})
-        end
-        
-        expect { @doc['foo'].will == 'bee' }
-        expect { @doc['bar'].will be(nil) }
-        expect { @doc.rev.wont == @old_rev }
-      end
-    end
-    
-  end
-  
-end

data/test/exegesis_test.rb

@@ -1,28 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-
-class ExegesisTest < Test::Unit::TestCase
-  
-  context "designs directory" do
-    context "setting custom" do
-      before do
-        @custom_design_dir = File.join(File.dirname(__FILE__), 'fixtures', 'designs')
-        Exegesis.designs_directory = @custom_design_dir
-      end
-      
-      expect { Exegesis.designs_directory.to_s.will == @custom_design_dir }
-    end
-    
-    
-  end
-  
-  context "database template" do
-    before do
-      @template_string = "http://localhost:5984/appname-%s"
-      @account = "foo"
-      Exegesis.database_template = @template_string
-    end
-    
-    expect { Exegesis.database_for(@account).will == @template_string % @account }
-  end
-  
-end