aqua 0.1.6

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format specdoc
+--loadby mtime

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'aqua'
+require 'spec'
+require 'spec/autorun'
+                    
+ 
+def require_fixtures
+  Dir[ File.dirname(__FILE__) + "/object/object_fixtures/**/*.rb" ].each do |file|
+    require file
+  end
+end  
+
+
+Spec::Runner.configure do |config|
+end

data/spec/store/couchdb/attachments_spec.rb

@@ -0,0 +1,164 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+Aqua.set_storage_engine('CouchDB') # to initialize the Aqua::Store namespace 
+require File.dirname(__FILE__) + '/fixtures_and_data/document_fixture' # Document ... a Mash with the collection of methods
+
+# Conveniences for typing with tests ... 
+CouchDB =       Aqua::Store::CouchDB unless defined?( CouchDB ) 
+Attachments =   CouchDB::Attachments unless defined?( Attachments )
+
+describe CouchDB::Attachments do
+  before(:each) do
+    Aqua::Storage.database.delete_all
+    @doc = Document.new(:id => 'attachments_doc')
+    @attachments = Attachments.new( @doc )
+    @file = File.new( File.dirname( __FILE__ ) + '/fixtures_and_data/image_attach.png' )
+  end
+   
+  describe 'initialization' do
+    it 'should initialize with a document uri' do
+      lambda{ Attachments.new }.should raise_error( ArgumentError )
+      lambda{ Attachments.new( @doc )}.should_not raise_error( ArgumentError )
+    end
+  
+    it 'should initialize with an optional hash' do
+      lambda{ Attachments.new( @doc, {:my_file => @file})}.should_not raise_error( ArgumentError )
+    end
+    
+    it 'when initializing with a hash, it should check that each key is a string and each value is a file' do
+      lambda{ Attachments.new( @doc, { 1 => @file }) }.should raise_error( ArgumentError  )
+      lambda{ Attachments.new( @doc, {:my_file => 1}) }.should raise_error( ArgumentError )
+    end
+    
+    it 'document should be an object reference to the original document, not a dup' do 
+      @attachments.document.should === @doc
+    end       
+  end     
+  
+  describe 'attachment_uri' do 
+    it 'should raise an error if the document has no id' do
+      attachments = Attachments.new( Document.new )
+      attachments.add( :my_file, @file )
+      lambda{ attachments.uri_for( :my_file ) }.should raise_error( ArgumentError )
+    end 
+    
+    it 'should not include revision information if the document is new' do
+      @attachments.add( :my_file, @file )
+      @attachments.uri_for( :my_file ).should_not include( '?rev=')
+    end
+      
+    it 'should include revision information if the document has been saved' do 
+      @doc.save!
+      @attachments.add( :my_file, @file )
+      @attachments.uri_for( :my_file ).should include( '?rev=')
+    end
+    
+    it 'should construct a valid attachment uri' do
+      @attachments.add(:my_file, @file )
+      @attachments.uri_for( :my_file ).should == "http://127.0.0.1:5984/aqua/attachments_doc/my_file"
+    end
+    
+    it 'should construct a get attachment uri without the revision information' do 
+      @doc.save!
+      @attachments.add( :my_file, @file )
+      @attachments.uri_for( :my_file, false ).should_not include( '?rev=')
+    end      
+  end   
+  
+  describe 'adding attachments' do 
+    it 'should have a method #add that takes a name and a file' do 
+      @attachments.should respond_to( :add )
+      lambda{ @attachments.add }.should raise_error( ArgumentError )
+      lambda{ @attachments.add( :my_file ) }.should raise_error( ArgumentError )
+      lambda{ @attachments.add( :my_file, :not_a_file ) }.should raise_error( ArgumentError )
+      lambda{ @attachments.add( [], @file ) }.should raise_error( ArgumentError )
+      lambda{ @attachments.add( :my_file, @file ) }.should_not raise_error( ArgumentError )
+    end 
+  
+    it 'should add a valid hash to the attachments container' do
+      @attachments.add( :my_file, @file )
+      @attachments[:my_file].should == @file
+    end
+    
+    it 'should save the attachment to the database' do
+      lambda{ @attachments.add!( :my_file, @file ) }.should_not raise_error
+      lambda{ CouchDB.get( @attachments.uri_for(:my_file) ) }.should_not raise_error 
+    end
+    
+    it 'should have the right mime-type after addition to database' do 
+      @attachments.add!( :my_file, @file )
+      attach_hash = CouchDB.get( @attachments.uri_for(:my_file) )
+      attach_hash['content_type'].should == 'image/png'
+    end    
+  end
+  
+  describe 'removing attachments' do
+    it '#delete should delete an attachment from the collection' do 
+      @attachments.add( :my_file, @file )
+      @attachments.delete( :my_file ).should == @file
+      @attachments[:my_file].should be_nil
+    end
+    
+    it '#delete! should remove an attachment from the collection and database' do 
+      @attachments.add!( :my_file, @file )
+      @attachments.delete!( :my_file )
+      lambda{ CouchDB.get( @attachments.uri_for(:my_file) ) }.should raise_error #( Aqua::ObjectNotFound )
+    end   
+  end
+  
+  describe 'retrieving attachments' do
+    it 'should return a file if found locally' do
+      @attachments.add!( :my_file, @file )
+      @attachments.should_not_receive(:get!)
+      @attachments.get(:my_file).should == @file
+    end
+    
+    it 'should request a file from the database when not found locally' do 
+      @attachments.add!( :my_file, @file )
+      @attachments.delete( :my_file ) # just deletes the local reference
+      @attachments.should_receive(:get!)
+      @attachments.get(:my_file) 
+    end 
+    
+    it 'should return a Tempfile from the database' do
+      @attachments.add!( :my_file, @file )
+      @attachments.delete( :my_file ) # just deletes the local reference
+      @attachments.get(:my_file).class.should == Tempfile
+    end
+    
+    it 'should have the same data as the original file' do 
+      @attachments.add!( :my_file, @file )
+      file = @attachments.get!(:my_file)
+      file.read.should == @file.read
+    end
+    
+    it 'should stream an attachment' do
+      @attachments.add!( :my_file, @file )
+      data = @attachments.get!( :my_file, true ) 
+      data.should_not be_nil
+      data.should_not be_empty
+      data.should == @file.read
+    end         
+  end     
+  
+  describe 'packing all files' do 
+    before(:each) do
+      @attachments.add( :my_file, @file )
+      @attachments.add( 'dup.png', @file )
+      @pack = @attachments.pack 
+    end  
+    
+    it 'should pack all the added files' do
+      @pack.keys.sort.should == ['dup.png', 'my_file'] 
+    end
+   
+    it 'should have correct keys for each attachment' do   
+      @pack['dup.png'].keys.sort.should include( 'content_type', 'data' )
+    end 
+    
+    it 'should have the correct mime type' do
+      @pack['dup.png']['content_type'].should == 'image/png'
+    end   
+  end  
+    
+end

data/spec/store/couchdb/couch_db_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+Aqua.set_storage_engine('CouchDB') # to initialize the Aqua::Store namespace
+CouchDB = Aqua::Store::CouchDB unless defined?( CouchDB )
+describe CouchDB do
+  describe 'http_client setup' do
+    describe 'autoloading' do
+      it 'should not raise an error loading the default adapter' do 
+        lambda{ CouchDB.set_http_adapter }.should_not raise_error
+      end
+    
+      it 'should add rest methods to the Aqua module' do
+        CouchDB.set_http_adapter
+        CouchDB.should respond_to(:get)
+      end 
+    end
+    
+    describe 'manual loading of an alternate library' do
+      # TODO: when there is an alternate library
+    end         
+  end
+  
+  describe 'servers' do
+    before(:all) do 
+      CouchDB.servers.delete(:all)
+    end
+    
+    it 'should #clear_servers' do 
+      CouchDB.clear_servers
+      CouchDB.servers.should == {}
+    end  
+      
+    it '#servers should return an empty hash by default' do
+      CouchDB.servers.should == {}
+    end
+    
+    it 'should create a default server if no argument is passed' do 
+      server = CouchDB.server 
+      server.should_not be_nil
+      CouchDB.servers.should_not be_empty
+      CouchDB.servers[:aqua].should == server
+      server.namespace.should == 'aqua'
+    end    
+    
+    it 'should add servers when a symbol is requested that is not found as a servers key' do 
+      server = CouchDB.server(:users)
+      CouchDB.servers.size.should == 2
+      CouchDB.servers[:users].should == server
+      server.namespace.should == 'users'
+    end
+    
+    it 'should not duplicate servers' do
+      CouchDB.server(:users)
+      CouchDB.servers.size.should == 2
+      CouchDB.server
+      CouchDB.servers.size.should == 2
+    end    
+    
+    it 'should list the servers in use' do
+      CouchDB.server(:noodle)
+      CouchDB.servers.size.should == 3 
+      CouchDB.servers.each do |key, server|
+        server.class.should == Aqua::Store::CouchDB::Server
+      end   
+    end
+    
+    it 'should allow the addition of customized servers' do
+      new_host = 'http://newhost.com:8888' 
+      CouchDB.servers[:custom] = CouchDB::Server.new( :server => new_host )
+      CouchDB.servers.size.should == 4
+      CouchDB.servers[:custom].uri.should == new_host
+    end   
+  end  
+
+  describe 'text helper methods' do 
+    describe 'escaping names' do 
+      it 'should escape :: module/class separators with a double underscore __' do
+        string = CouchDB.escape('not::kosher')
+        string.should == 'not__kosher'
+      end
+      
+      it 'should remove non alpha-numeric, hyphen, underscores from a string' do 
+        string = CouchDB.escape('&not_!kosher*%')
+        string.should == 'not_kosher'
+      end        
+    end
+    
+    describe 'paramify_url' do
+      it 'should build a query filled url from a base url and a params hash' do 
+        url = CouchDB.paramify_url( 'http://localhost:5984', {:gerbil => true, :keys => 'you_know_it'} )
+        url.should match(/\?/)
+        url.should match(/&/)
+        url.should match(/keys=you_know_it/)
+        url.should match(/gerbil=true/)
+      end  
+    end     
+  end  
+
+  describe 'database strategies' do
+    # TODO: figure this out
+  end  
+
+end    
+  

data/spec/store/couchdb/database_spec.rb

@@ -0,0 +1,161 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+Aqua.set_storage_engine('CouchDB') # to initialize the Aqua::Store namespace
+# Conveniences for typing with tests ... 
+CouchDB =   Aqua::Store::CouchDB unless defined?( CouchDB ) 
+Database =  CouchDB::Database unless defined?( Database )
+Server =    CouchDB::Server unless defined?( Server)
+
+describe 'Aqua::Store::CouchDB::Database' do
+  describe 'initialization' do 
+    describe 'name' do
+      it 'should not require name for initialization' do
+        lambda{ Database.new }.should_not raise_error( ArgumentError )
+      end
+    
+      it 'should escape the name, when one is provided' do
+        db = Database.new('&not::kosher*%')
+        db.name.should == 'not__kosher'
+      end  
+    end
+    
+    describe 'server' do
+      it 'should default to CouchDB\'s default server if no server option is provided' do
+        db = Database.new
+        db.server.should_not be_nil
+        db.server.class.should == Aqua::Store::CouchDB::Server
+        db.server.uri.should == 'http://127.0.0.1:5984'
+        db.server.namespace.should == 'aqua'
+      end
+      
+      it 'a custom server held in CouchDB can be used' do 
+        new_host = 'http://newhost.com:8888' 
+        CouchDB.servers[:customized] = CouchDB::Server.new( :server => new_host )
+        db = Database.new('things', :server => :customized )
+        db.server.uri.should == new_host
+      end   
+    end        
+    
+    describe 'uri' do
+      it 'should use the server namespace as the path when no name is provided' do
+        db = Database.new
+        db.name.should == nil
+        db.uri.should == "http://127.0.0.1:5984/aqua"
+      end
+      
+      it 'should use the default server namespace and the name in the path when a name is provided but server info is not' do
+        db = Database.new('things')
+        db.name.should == 'things'
+        db.uri.should == 'http://127.0.0.1:5984/aqua_things'
+      end
+      
+      it 'should use the server namespace provided and the name in the path when a name and server symbol are provided' do
+        db = Database.new('things', :server => :not_so_aqua )
+        db.uri.should == 'http://127.0.0.1:5984/not_so_aqua_things'
+      end
+      
+      it 'should user a custome database\'s namespace along with the name in a path if both are provided' do 
+        server = Server.new(:namespace => 'different')
+        db = Database.new('things', :server => server )
+        db.uri.should == 'http://127.0.0.1:5984/different_things'
+      end      
+    end      
+  end
+  
+  describe 'create' do
+    before(:each) do
+      CouchDB.delete( Database.new('things').uri ) rescue nil
+    end  
+    
+    it 'should create a couchdb database for this instance if it doesn\'t yet exist' do 
+      db = Database.create('things')
+      db.should be_exists
+    end
+      
+    it 'create should not return false if the database already exists' do
+      db = Database.create('things')
+      db.should_not be( false ) 
+    end
+    
+    it 'create should return false if an HTTP error occurs' do
+      CouchDB.should_receive(:put).and_raise( CouchDB::RequestFailed )
+      db = Database.create('things')
+      db.should == false
+    end  
+    
+    it 'create! should create and return a couchdb database if it doesn\'t yet exist' do
+      Database.new('things').should_not be_exists
+      db = Database.create!('things')
+      db.should be_exists
+    end
+    
+    it 'create! should not raise an error if the database already exists' do 
+      Database.create('things') 
+      lambda{ Database.create!('things') }.should_not raise_error
+    end
+    
+    it 'create should raise an error if an HTTP error occurs' do
+      CouchDB.should_receive(:put).and_raise( CouchDB::RequestFailed )
+      lambda{ Database.create!('things') }.should raise_error
+    end      
+  end    
+  
+  describe 'misc managment stuff' do 
+    before(:each) do
+      CouchDB.delete( Database.new('things').uri ) rescue nil
+    end
+      
+    it '#exists? should be false if the database doesn\'t yet exist in CouchDB land' do
+      db = Database.new('things')
+      db.should_not be_exists
+    end
+    
+    it '#exists? should be true if the database does exist in CouchDB land' do
+      db = Database.create('things')
+      db.should be_exists
+    end
+     
+    it '#info raise an error if the database doesn\'t exist' do 
+      db = Database.new('things')
+      db.delete
+      lambda{ db.info }.should raise_error( CouchDB::ResourceNotFound )
+    end
+  
+    it '#info should provide a hash of detail if it exists' do
+      db = Database.create('things')
+      info = db.info
+      info.class.should == Hash
+      info['db_name'].should == 'aqua_things'
+    end 
+  end
+  
+  describe 'deleting' do    
+    it 'should #delete itself' do 
+      db = Database.create('things')
+      db.should be_exists
+      db.delete 
+      db.should_not be_exist
+    end
+    
+    it '#delete should return nil if it doesn\'t exist' do 
+      db = Database.new('things')
+      db.should_not be_exists
+      lambda{ db.delete }.should_not raise_error
+      db.delete.should be_nil 
+    end  
+  
+    it 'should #delete! itself' do 
+      db = Database.create('things')
+      db.should be_exists
+      db.delete! 
+      db.should_not be_exist
+    end
+    
+    it '#delete! should raise an error if the database doesn\'t exist' do 
+      db = Database.new('things')
+      db.should_not be_exists
+      lambda{ db.delete! }.should raise_error
+    end
+  end   
+  
+end