aqua 0.1.6 → 0.2.0

data/spec/object/translator_unpacking_spec.rb

@@ -0,0 +1,262 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require_fixtures
+
+Aqua.set_storage_engine('CouchDB') # to initialize CouchDB
+CouchDB = Aqua::Store::CouchDB unless defined?( CouchDB )
+Translator = Aqua::Translator unless defined?( Translator ) 
+Translator = Aqua::Translator unless defined?( Translator ) 
+
+describe Translator, 'unpacking' do
+  before(:each) do 
+    build_user_ivars
+    Translator.instance_eval "@classes = {}"
+  end
+    
+  describe 'finding a documents class' do 
+    it 'should return a class' do 
+      Translator.get_class( 'User' ).should == User
+    end
+      
+    it 'should cache the mapping of class name to class' do 
+      Translator.classes.should == {}
+      Translator.get_class( 'User' )
+      Translator.classes.should == {'User' => User}
+    end  
+  end
+  
+  describe 'class methods should unpack' do 
+    def round_trip( obj, debug=false ) 
+      @pack = Translator.pack_object(obj).pack
+      if debug
+        puts obj.inspect 
+        puts @pack.inspect
+      end  
+      @result = Translator.unpack_object(@pack)
+    end
+      
+    it 'string' do
+      round_trip( 'string' ).should == 'string'
+    end
+      
+    it 'true' do 
+      round_trip( true ).should == true
+    end
+      
+    it 'false' do
+      round_trip( false ).should == false
+    end
+    
+    it 'nil' do
+      round_trip( nil ).should == nil
+    end
+    
+    it 'Symbols' do 
+      round_trip( :symbol ).should == :symbol
+    end  
+          
+    it 'times' do
+      time = Time.now  
+      round_trip( time ).to_s.should == time.to_s
+    end
+      
+    it 'dates' do
+      date = Date.today
+      round_trip( date ).should == date 
+    end
+
+    it 'Fixnums' do 
+      round_trip( 3 ).should == 3
+    end
+      
+    it 'Bignums' do
+      round_trip( 12345678901234567890 ).should == 12345678901234567890 
+    end
+      
+    it 'Floats' do
+      round_trip( 1.68 ).should == 1.68
+    end
+      
+    it 'Rationals' do 
+      round_trip( Rational( 1,17 ) ).should == Rational( 1,17 )
+    end
+    
+    it 'Ranges' do 
+      round_trip( (1..3) ).should == (1..3)
+    end
+      
+    it 'arrays of string' do 
+      array = ['one', 'two', 'three']
+      round_trip( array ).should == array
+    end
+    
+    it 'mixed arrays' do
+      array = [1, 2, 3.4]
+      round_trip( array ).should == array
+    end
+    
+    it 'array derivatives' do 
+      array_udder = ArrayUdder.new([1,2,3])
+      array_udder.udder 
+      array_udder.instance_variables.should_not be_empty
+      unpacked = round_trip( array_udder )
+      unpacked.class.should == ArrayUdder
+      unpacked.should == array_udder # array values match
+      unpacked.instance_variables.should_not be_empty
+      unpacked.instance_variable_get('@udder').should == array_udder.instance_variable_get('@udder')
+    end  
+      
+    it 'simple hashes' do
+      hash = {'one' => 'two'} 
+      round_trip( hash ).should == hash
+    end
+    
+    it 'mixed hashes with string keys' do 
+      hash = {'one' => 1} 
+      round_trip( hash ).should == hash
+    end  
+      
+    it 'hashes with object keys' do 
+      hash = { 1 => 'one' }
+      round_trip( hash ).should == hash
+    end
+      
+    it 'hash derivatives' do 
+      canned_hash = CannedHash.new( :one => 'one', 1 => 'one' )
+      canned_hash.yum
+      canned_hash.instance_variables.should_not be_empty
+      unpacked = round_trip( canned_hash )
+      unpacked.class.should == CannedHash
+      unpacked.should == canned_hash
+      unpacked.instance_variables.should_not be_empty 
+      unpacked.instance_variable_get('@yum').should == canned_hash.instance_variable_get('@yum')
+    end  
+    
+    it 'open structs' do
+      struct = OpenStruct.new(:cots => 3, :beds => 'none') 
+      round_trip( struct ).should == struct
+    end  
+  end 
+
+  describe 'unpacking aquatic objects' do
+    before(:each) do 
+      @pack = Translator.pack_object( @user ).pack
+    end
+    
+    it 'embedable objects' do 
+      log = Translator.unpack_object( @pack['ivars']['@log'] ) 
+      log.class.should == Log
+      log.instance_variables.each do |ivar_name|
+        log.instance_variable_get(ivar_name).to_s.should == 
+          @log.instance_variable_get(ivar_name).to_s
+      end  
+    end
+  
+    describe 'external objects' do 
+      before(:each) do  
+        @sub_pack = @pack['ivars']['@other_user']
+        @sub_pack['init']['id'] = 'other_user_id' 
+        @returned_user = Translator.unpack_object( @sub_pack ) 
+      end
+        
+      it 'should reconstitute as an Aqua::Stub object' do 
+        @returned_user.class.should == Aqua::Stub
+      end 
+      
+      it 'should respond to stubbed methods' do
+        @returned_user.methods.should include( 'username' )
+      end
+      
+      it 'should request the delegate object when a non-stubbed method is requested' do 
+        User.should_receive(:load).with( 'other_user_id' ).and_return( @other_user )
+        @returned_user.name
+        @returned_user.delegate.should == @other_user
+      end       
+    end  
+  end  
+  
+  describe 'unpacking file-like things' do  
+    # Files have to be stored within an aquatic object, since they are handled as attachments
+    # Since attachments require the base object information in order to be retrieved,
+    # instance information (the base object) has to be passed in with the opts
+       
+    class Attachment 
+      aquatic
+      attr_accessor :file, :tempfile, :id
+    end
+    
+    before(:each) do
+      @file = File.new(File.dirname(__FILE__) + '/../store/couchdb/fixtures_and_data/image_attach.png')
+      
+      @tempfile = Tempfile.new('temp.txt')
+      @tempfile.write('I am a tempfile!')
+      @tempfile.rewind          
+      
+      @attachment = Attachment.new
+      @attachment.id = 'my_base_object_id' 
+      @attachment.file = @file 
+      @attachment.tempfile = @tempfile
+      
+      @pack = Translator.pack_object( @attachment ).pack 
+      @opts = Translator::Opts.new
+      @opts.base_object = @attachment
+      @opts.base_id = @attachment.id
+    end  
+    
+    describe 'files' do
+      before(:each) do
+        @stub = Translator.unpack_object( @pack['ivars']['@file'], @opts )
+      end  
+      
+      it 'should be reconstituted as Aqua::FileStub objects' do 
+        @stub.class.should == Aqua::FileStub
+      end
+    
+      it 'should have stubbed methods' do
+        @stub.methods.should include( 'content_type', 'content_length' )
+      end
+      
+      it 'should have a information about the base object' do 
+        @stub.base_id.should == @attachment.id
+        @stub.base_class.should == Attachment
+      end  
+      
+      it 'should get retrieved when other file methods are called' do
+        Attachment::Storage.should_receive(:attachment).with( 'my_base_object_id', 'image_attach.png' ).and_return( @file )
+        @stub.read
+        @stub.delegate.should == @file
+      end  
+    end    
+    
+    describe "tempfiles" do
+      before(:each) do
+        @stub = Translator.unpack_object( @pack['ivars']['@tempfile'], @opts )
+      end  
+      
+      it 'should be reconstituted as Aqua::FileStub objects' do 
+        @stub.class.should == Aqua::FileStub
+      end
+    
+      it 'should have stubbed methods' do
+        @stub.methods.should include( 'content_type', 'content_length' )
+      end
+      
+      it 'should have a information about the base object' do 
+        @stub.base_id.should == @attachment.id
+        @stub.base_class.should == Attachment
+      end  
+      
+      it 'should get retrieved when other file methods are called' do
+        Attachment::Storage.should_receive(:attachment).with( 'my_base_object_id', 'temp.txt' ).and_return( @tempfile )
+        @stub.read
+      end 
+    end
+  end     
+
+  describe 'reloading' do 
+    it 'should be tested separately' do
+      pending( 'regression tests are in unpack_spec')
+    end   
+  end         
+  
+
+end  

data/spec/object/unpack_spec.rb

@@ -4,358 +4,200 @@ require_fixtures
 Aqua.set_storage_engine('CouchDB') # to initialize CouchDB
 CouchDB = Aqua::Store::CouchDB unless defined?( CouchDB )  
 
-require File.dirname(__FILE__) + "/../../lib/aqua/support/set"
-
 describe Aqua::Unpack do
   before(:each) do
     User::Storage.database.delete_all
-    @time = Time.now
-    @date = Date.parse('12/23/1969')
-    @log = Log.new( :message => "Hello World! This is a log entry", :created_at => Time.now )
-    @user = User.new(
-      :username => 'kane',
-      :name => ['Kane', 'Baccigalupi'],
-      :dob => @date,
-      :created_at => @time,
-      :log => @log,
-      :password => 'my secret!' 
-    )
+    build_user_ivars
+    @file = File.new( File.dirname(__FILE__) + '/../store/couchdb/fixtures_and_data/image_attach.png' )
+    @user.grab_bag = @file
     @user.commit!
-  end  
+  end 
   
-  describe 'loading from storage' do
-    
-    it 'should raise in error if the id doesn\'t exist in the data store' do 
-      user = User.new(:id => 'gerbil_farts')
-      user.id.should == 'gerbil_farts'
-      lambda{ user.reload! }.should raise_error
-    end  
+  describe 'loading' do
+    describe 'retreiving the storage document from the database' do
+      it 'should work if the document exists' do
+        document = User._get_store( @user.id )
+        document.class.should == User::Storage
+      end
     
-    it 'should raise an error if the id is nil' do
-      lambda{ User.new.reload! }.should raise_error
-    end  
-  
-  end
-  
-  describe 'unpacking to a new object' do 
-    describe 'init' do
-      it 'should initialize an Aquatic object' do
-        user = User.load( @user.id )
-        user.class.should == User
+      it 'should raise an error if the document does not exist' do
+        lambda{ User._get_store( 'not_no_here' ) }.should raise_error
       end  
-      
-      describe 'Array derivatives' do
-        before(:each) do 
-          class Arrayed < Array
-            aquatic
-            attr_accessor :my_accessor
-          end
-          arrayish = Arrayed['a', 'b', 'c', 'd']
-          arrayish.my_accessor = 'Newt'
-          arrayish.commit!
-          @id = arrayish.id
-        end
-           
-        it 'should create an aquatic Array derivative' do 
-          arrayish_2 = Arrayed.load( @id )
-          arrayish_2.class.should == Arrayed 
-        end
-      
-        it 'should load init values into an aquatic Array derivative' do
-          arrayish_2 = Arrayed.load( @id )
-          arrayish_2.first.should == 'a'
-        end 
-      end   
-      
-      describe 'Hash derivatives' do
-        before(:each) do 
-          class Hashed < Hash
-            aquatic
-            attr_accessor :my_accessor
-          end
-          hashish = Hashed.new
-          hashish['1'] = '2'
-          hashish.my_accessor = 'Newt'
-          hashish.commit!
-          @id = hashish.id
-        end 
-           
-        it 'should create an aquatic Hash derivative' do 
-          Hashed.load( @id ).class.should == Hashed
-        end
-           
-        it 'should load init values into an aquatic Hash derivative' do
-          hashish = Hashed.load( @id )
-          hashish['1'].should == '2'  
-        end  
-      end  
-    end 
+    end
     
-    describe 'unpacking the instance variables' do
-      it 'should reinstantiate all the instance variables' do 
-        user = User.load(@user.id) 
-        ['@created_at', '@dob', '@log', '@name', '@username'].each do |ivar|
-          user.instance_variables.should include( ivar )
-        end   
-      end 
-      
-      it 'should unpack Dates' do
-        user = User.load(@user.id)
-        user.dob.should == @user.dob
-      end 
-      
-      it 'should unpack Times' do
-        user = User.load(@user.id)
-        user.created_at.to_s.should == @user.created_at.to_s
-      end    
-      
-      it 'should unpack Strings' do
-        user = User.load(@user.id)
-        user.username.should == @user.username
-      end
-      
-      it 'should unpack true and false' do 
-        # true
-        @user.grab_bag = true 
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == true
-        # false
-        @user.grab_bag = false
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == false
-      end    
-      
-      it 'should unpack Fixnums' do
-        @user.grab_bag = 3
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == 3
+    describe 'unpacking the document' do
+      before(:each) do 
+        @new_user = User.load( @user.id )
       end
       
-      it 'should unpack Bignums' do
-        @user.grab_bag = 12345678901234567890
-        @user.grab_bag.class.should == Bignum
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == 12345678901234567890
+      it 'should add the base_id to the translator' do 
+        @new_user._translator.base_id.should == @user.id
+      end  
+        
+      it 'should initiate the right kind of object' do 
+        @new_user.class.should == User 
       end 
       
-      it 'should unpack Floats' do 
-        @user.grab_bag = 1.681
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == 1.681
+      it 'should have the right id' do
+        @new_user.id.should == @user.id
       end 
       
-      it 'should unpack Rationals' do 
-        @user.grab_bag = Rational( 1, 17 )
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == Rational( 1, 17 )
-      end
-      
-      it 'should unpack an Array' do 
-        user = User.load(@user.id)
-        user.name.should == @user.name
-      end
-      
-      it 'should unpace an Array with non-string objects' do 
-        @user.grab_bag = ['1', 2]
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == @user.grab_bag
+      it 'should have a revision' do
+        doc = User::Storage.get( @user.id )
+        doc.rev.should_not be_nil
+        doc.rev.should_not be_empty 
+        @new_user._rev.should == doc.rev
       end  
       
-      it 'should unpack a deeply nested Array' do
-        @user.grab_bag = ['1','1','1', ['2','2', ['3']]]
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == @user.grab_bag
-      end        
-        
-      it 'should unpack an Array derivative' do
-        array_udder = ArrayUdder['1','2','3']
-        array_udder.udder
-        @user.grab_bag = array_udder
-        @user.commit! 
-        user = User.load( @user.id )
-        user.grab_bag.should == @user.grab_bag
-      end
+      describe 'instance variables' do
+        it 'should reinstantiate the simple types' do
+          @new_user.created_at.class.should == Time
+          @new_user.created_at.to_s.should == @time.to_s
+          @new_user.dob.should == @date
+          @new_user.name.should == ['Kane', 'Baccigalupi']
+        end  
       
-      describe 'hash' do
-        it 'should unpack a basic hash' do 
-        @user.grab_bag = {'1' => '2'}
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == @user.grab_bag
-      end
+        it 'should reinstantiate embedded aquatic objects' do
+          # todo: should add a method to log so that it isn't doing equality by object_id
+          @new_user.log.class.should == Log
+          @new_user.log.created_at.to_s.should == @log.created_at.to_s
+          @new_user.log.message.should == @log.message
+        end 
       
-        describe 'hash keys' do
-          it 'should unpack as symbol and strings' do  
-            @user.grab_bag = {'first' => '1', :second => '2'}
-            @user.commit!
-            user = User.load(@user.id)
-            user.grab_bag.keys.should include('first', :second)
+        it 'should have nil for hidden variables' do
+          @new_user.password.should be_nil 
+        end 
+        
+        describe 'that are external aquatic' do
+          before(:each) do 
+            @external = @new_user.other_user
           end
-      
-          it 'should unpack a numeric object' do
-            @user.grab_bag = {1 => 'first', 2 => 'second'}
-            @user.commit!
-            user = User.load(@user.id)
-            user.grab_bag.keys.should include( 1, 2 )
+             
+          it 'should be of class Aqua::Stub' do
+            @external.class.should == Aqua::Stub
+          end  
+          
+          it 'should respond to stubbed methods' do
+            @external.methods.should include( 'username' )
+          end
+            
+          it 'should retrieve external object when non-stubbed method is called' do 
+            User.should_receive(:load).with( @other_user.id ).and_return( @other_user )
+            @external.name 
+            @external.delegate.should == @other_user
           end
+            
+          it 'should delegate non-stubbed methods to the external object' do
+            @external.name.should == ['What', 'Ever']
+          end  
+        end  
       
-          it 'should unpack a more complex object' do
-            struct = OpenStruct.new( :gerbil => true ) 
-            @user.grab_bag = { struct => 'first' }
-            @user.commit!
-            user = User.load(@user.id) 
-            user.grab_bag.keys.should include( struct )
-          end      
+        describe 'that are attachments' do
+          before(:each) do 
+            @attachment = @new_user.grab_bag
+          end
+            
+          it 'should be of class Aqua::FileStub' do
+            @attachment.class.should == Aqua::FileStub
+          end
+            
+          it 'should have basic data about the file' do 
+            @attachment.methods.should include( 'content_type', 'content_length' )
+          end
+            
+          it 'should retrieve the attachment as a delegate when non-stubbed methods are called' do
+            User::Storage.should_receive(:attachment).with( @new_user.id, 'image_attach.png' ).and_return( @file )
+            @attachment.read
+          end
+            
+          it 'should delegate to the loaded attachment' do
+            @attachment.read.should == @file.read
+          end  
         end
+      end   
+    end     
+  end
+  
+  describe 'reloading' do 
+    describe 'with no-initialization' do
+      before(:each) do
+        # dup the @user and change everything! but don't save
+        @changed_user = @user.dup
+        @changed_user.username = 'not kane'
+        @changed_user.name = []
+        @changed_user.dob = Date.parse('1/1/2001')
+        @changed_user.created_at = Time.parse('1/1/2001')
+        @changed_user.log = Log.new(:message => 'some other message')
+        @changed_user.other_user = @user
+      end 
       
-        it 'should unpack non-string values' do 
-          @user.grab_bag = {'1' => 2}
-          @user.commit!
-          user = User.load(@user.id)
-          user.grab_bag.should == @user.grab_bag
-        end    
-      
-        it 'should unpack deep nesting' do
-          @user.grab_bag = {'1' => {'2' => {'3' => 4}}}
-          @user.commit!
-          user = User.load(@user.id)
-          user.grab_bag.should == @user.grab_bag 
-        end
-        
-        it 'should unpack a Hash derivative' do
-          @struct = OpenStruct.new(
-            :gerbil => true, 
-            :cat => 'yup, that too!', 
-            :disaster => ['pow', 'blame', 'chase', 'spew'],
-            :nipples => 'yes'
-          )
-        
-          @hash_derivative = CannedHash.new( 
-            :ingredients => ['Corned Beef', 'Potatoes', 'Tin Can'],
-            :healthometer => false,
-            :random_struct => @struct 
-          )
-        
-          @user.grab_bag = @hash_derivative
-          @user.commit! 
-        
-          user = User.load(@user.id)
-          user.grab_bag.should == @user.grab_bag 
-        end 
+      it 'should not raise an error' do  
+        lambda{ @changed_user.reload }.should_not raise_error
       end  
       
-      it 'should unpack a Struct' do 
-        @struct = OpenStruct.new(
-          :gerbil => true, 
-          :cat => 'yup, that too!', 
-          :disaster => ['pow', 'blame', 'chase', 'spew'],
-          :nipples => 'yes'
-        ) 
+      it 'should reset to saved instance variables' do 
+        @changed_user.reload
+        @changed_user.username.should == @user.username
+        @changed_user.name.should == @user.name
+        @changed_user.dob.should == @user.dob
+        @changed_user.created_at.to_s.should == @user.created_at.to_s
+        @changed_user.log.created_at.to_s.should == @user.log.created_at.to_s
+        @changed_user.log.message.should == @user.log.message
+        # since this is a stub, not the same object, lets test how it works 
+        @changed_user.other_user.name.should == @user.other_user.name
+      end   
+    end
+    
+    describe 'with initialization and #replace methods' do
+      class ArrayD < Array
+        aquatic
+        attr_accessor :bucket
+      end
         
-        @user.grab_bag = @struct
-        @user.commit!
-        user = User.load(@user.id)
+      before(:each) do
+        @arrayd = ArrayD.new([1,2])
+        @arrayd.bucket = 34
+        @arrayd.commit!
         
-        user.grab_bag.should == @user.grab_bag
-      end 
-      
-      it 'should unpack a Range' do
-        @user.grab_bag = 1..3
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == (1..3)
+        # change the instance, but don't commit
+        @arrayd[0] = 'one'
+        @arrayd[1] = 'two'
+        @arrayd << 'and more'
+        @arrayd.bucket = @arrayd.join(' ... ') 
       end
+        
+      it 'should not raise an error' do
+        lambda{ @arrayd.reload }.should_not raise_error
+      end 
       
-      it 'should unpack a Set' do
-        set = Set.new([1,2,3])   
-        @user.grab_bag = set
-        @user.commit!
-        user = User.load(@user.id)
-        user.grab_bag.should == set
+      it 'should reset to saved initialization' do
+        @arrayd.reload
+        @arrayd[0].should == 1
+        @arrayd[1].should == 2
+        @arrayd[2].should == nil
       end  
       
-      describe 'embedded IO:' do
-        describe 'File' do
-          before(:each) do 
-            @file = File.new(File.dirname(__FILE__) + '/../store/couchdb/fixtures_and_data/image_attach.png')
-            @user.grab_bag = @file
-            @user.commit!
-            user = User.load(@user.id) 
-            @grab_bag = user.grab_bag
-          end
-            
-          it 'should unpack Files as FileStubs' do 
-            @grab_bag.class.should == Aqua::FileStub
-          end
-          
-          it 'stub should have methods for content_type and content_length' do 
-            @grab_bag.methods.should include('content_type', 'content_length')
-          end
-          
-          it 'should retrieve the attachment' do  
-            data = @grab_bag.read
-            data.should_not be_nil
-            data.should == @file.read
-          end    
-        end
-      end      
-      
-      it 'should unpack an aquatic object' do 
-        @user.commit!
-        @user.log.should == @log
-      end
-      
-      describe 'externally saved aquatic objects' do
-        before(:all) do
-          User.configure_aqua( :embed => {:stub =>  [:username, :name] } )
+      it 'should reset to saved instance variables' do
+        @reloaded = @arrayd.reload 
+        @reloaded.should == @arrayd
+        @arrayd.bucket.should == 34
+      end  
+    end
+    
+    describe 'with initialization and no #replace methods' do 
+      it 'should raise an exception' do 
+        class Event < Range
+          aquatic
+          attr_accessor :name 
         end
+        event = Event.new( Time.parse('11/19/2009'), Time.parse('11/21/2009') )
+        event.name = 'RubyConf 09', 
+        event.commit!
         
-        after(:all) do
-          User.configure_aqua( :embed => {:stub =>  :username } )
-        end  
-          
-        before(:each) do
-          @time2 = Time.now - 3600 
-          @graeme = User.new(:username => 'graeme', :name => ['Graeme', 'Nelson'], :created_at => @time2 )
-          @user = User.new(
-            :username => 'kane',
-            :name => ['Kane', 'Baccigalupi'],
-            :dob => @date,
-            :created_at => @time,
-            :log => @log,
-            :password => 'my secret!',
-            :other_user => @graeme 
-          )
-          @user.commit!  
-        end
-           
-        it 'should load a Stub' do 
-          user = User.load(@user.id)
-          user.other_user.class.should == Aqua::Stub
-        end
-          
-        it 'should retrieve cached methods' do
-          user = User.load(@user.id)
-          User.should_not_receive(:load)
-          user.other_user.username.should == 'graeme'
-          user.other_user.name.should == ['Graeme', 'Nelson']
-        end
-          
-        it 'should retrieve the stubbed object when an additional method is required' do
-          user = User.load(@user.id)
-          user.other_user.created_at.to_s.should == @time2.to_s
-        end  
-      end    
-      
-    end  
-  end
+        lambda {event.reload}.should raise_error( NotImplementedError )  
+      end  
+    end     
+  end         
+  
 end