opium 1.0.3 → 1.1.0

data/spec/opium/file_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+
+describe Opium::File do
+  it { expect( described_class ).to be <= Opium::Model::Connectable }
+  let!(:gif_file) do
+    Tempfile.new(['test', '.gif']).tap do |f|
+      f.binmode
+      f.write Base64.decode64('R0lGODlhFQAEAIAAACMtMP///yH5BAEAAAEALAAAAAAVAAQAAAINjI8Bya2wnINUMopZAQA7')
+    end
+  end
+  
+  let(:location) { 'http://files.example.com/1234-file.gif' }
+  
+  it { expect( described_class ).to respond_to(:upload, :to_ruby, :to_parse).with(1).argument }
+  it { is_expected.to respond_to( :delete, :name, :url, :mime_type, :to_parse ) }
+  
+  describe '.upload' do
+    subject { described_class }
+    let(:upload_options) { {} }
+    let(:result) { subject.upload( gif_file, upload_options ) }
+    
+    before do
+      stub_request( :post, %r{https://api\.parse\.com/1/files/.+} ).
+        with( 
+          body: "9a\x15\x00\x04\x00\x80\x00\x00#-0\xFF\xFF\xFF!\xF9\x04\x01\x00\x00\x01\x00,\x00\x00\x00\x00\x15\x00\x04\x00\x00\x02\r\x8C\x8F\x01\xC9\xAD\xB0\x9C\x83T2\x8AY\x01\x00;".force_encoding('ASCII-8BIT'),
+          headers: {content_type: 'image/gif', x_parse_application_id: 'PARSE_APP_ID', x_parse_rest_api_key: 'PARSE_API_KEY'}
+        ).to_return(status: 201, body: ->(request) { { url: location, name: "1234-#{ ::File.basename(request.uri) }" }.to_json }, headers: { content_type: 'application/json', location: location })
+    end
+        
+    context 'when the upload completes' do      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Opium::File }
+      it { expect( result.url ).to_not be_nil }
+      it { expect( result.name ).to_not be_nil }
+    end
+    
+    context 'with a :original_filename option' do
+      let(:upload_options) { { original_filename: 'chunky_bacon.jpg' } }
+      
+      it { expect { result }.to_not raise_exception }
+      it 'preferentially uses the :original_filename' do
+        expect( result.name ).to end_with 'chunky_bacon.jpg'
+      end
+    end
+    
+    context 'with a :content_type option' do
+      let(:upload_options) { { content_type: 'image/png', sent_headers: true } }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to have_key( 'Content-Type') }
+      it 'sends the given :content_type value' do
+        expect( result['Content-Type'] ).to eq 'image/png'
+      end
+      it { expect( result.keys ).to include( 'X-Parse-Rest-Api-Key' )}
+      it { expect( result.keys ).to_not include( 'X-Parse-Master-Key' )}
+    end
+    
+    context 'without a :content_type option' do
+      let(:upload_options) { { sent_headers: true } }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to have_key( 'Content-Type' ) }
+      it 'sends the proper content_type' do
+        expect( result['Content-Type'] ).to eq 'image/gif'
+      end
+      it { expect( result.keys ).to include( 'X-Parse-Rest-Api-Key' )}
+      it { expect( result.keys ).to_not include( 'X-Parse-Master-Key' )}
+    end
+  end
+  
+  describe '.to_ruby' do
+    subject { described_class }
+    
+    let(:result) { subject.to_ruby( object ) }
+    
+    context 'when given a hash with __type: "File"' do
+      let(:object) { { __type: 'File', url: location, name: 'chunky_bacon.jpg' } }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Opium::File }
+    end
+    
+    context 'when given a hash with just a :url and :name' do
+      let(:object) { { url: location, name: 'chunky_bacon.jpg' } }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Opium::File }
+    end
+    
+    context 'when given a hash with __type != "File"' do
+      let(:object) { { __type: 'Pointer' } }
+      
+      it { expect { result }.to raise_exception }
+    end
+    
+    context 'when given an Opium::File' do
+      let(:object) { Opium::File.new( url: location, name: 'chunky_bacon.jpg' ) }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Opium::File }
+      it { expect( result ).to eq object }
+    end
+    
+    context 'when given nil' do
+      let(:object) { nil }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_nil }
+    end
+    
+    context 'when not given a hash' do
+      let(:object) { 42 }
+      
+      it { expect { result }.to raise_exception }
+    end
+  end
+  
+  describe '.to_parse' do
+    subject { described_class }
+    
+    let(:result) { described_class.to_parse( object ) }
+    
+    context 'when given an Opium::File' do
+      let(:object) { subject.new( url: location, name: 'chunky_bacon.jpg' ) }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Hash }
+      it { expect( result ).to have_key '__type' }
+      it { expect( result ).to have_key 'name' }
+      it 'has the proper values for :__type and :name' do
+        expect( result ).to eq( '__type' => 'File', 'name' => 'chunky_bacon.jpg' )
+      end
+    end
+    
+    context 'when given nil' do
+      let(:object) { nil }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_nil }
+    end
+    
+    context 'when given anything else' do
+      let(:object) { 42 }
+      
+      it { expect { result }.to raise_exception }
+    end
+  end
+  
+  context '#initialize' do
+    let(:filename) { 'file.png' }
+    let(:location) { 'http://files.example.com/1234-file.png' }
+    subject { described_class.new( __type: 'File', url: location, name: filename ) }
+    
+    it 'sets the url' do 
+      expect( subject.url ).to eq location
+    end
+    
+    it 'sets the name' do
+      expect( subject.name ).to eq filename
+    end
+    
+    it 'infers the mime_type' do
+      expect( subject.mime_type ).to eq 'image/png'
+    end
+  end
+  
+  describe '#delete' do
+    subject { described_class.new( url: location, name: 'chunky_bacon.jpg' ) }
+    
+    before do
+      stub_request(:delete, "https://api.parse.com/1/files/chunky_bacon.jpg").
+        with(:headers => {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Master-Key'=>'PARSE_MASTER_KEY'}).
+        to_return(:status => 200, :body => "{}", :headers => { content_type: 'application/json' })
+    end
+    
+    let(:delete_options) { {} }
+    let(:result) { subject.delete( delete_options ) }
+    
+    context 'with a name' do
+      it { expect { result }.to_not raise_exception }
+      it 'freezes the Opium::File' do
+        result
+        expect( subject ).to be_frozen
+      end
+    end
+    
+    context 'without a name' do
+      subject { described_class.new }
+      
+      it { expect { result }.to raise_exception }
+    end
+    
+    context 'when executed' do
+      let(:delete_options) { { sent_headers: true } }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result.keys ).to include( 'X-Parse-Master-Key' ) }
+      it { expect( result.keys ).to_not include( 'X-Parse-Rest-Api-Key' ) }
+    end
+  end
+  
+  describe '#to_parse' do
+    let(:result) { subject.to_parse }
+    
+    context 'when #name has a value' do
+      subject { described_class.new( url: location, name: 'chunky_bacon.jpg' ) }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Hash }
+      it { expect( result ).to have_key '__type' }
+      it { expect( result ).to have_key 'name' }
+      it 'has the proper values for :__type and :name' do
+        expect( result ).to eq( '__type' => 'File', 'name' => 'chunky_bacon.jpg' )
+      end
+    end
+    
+    context 'when #name is empty' do
+      subject { described_class.new }
+      
+      it { expect { result }.to raise_exception }
+    end
+  end
+  
+  describe '#inspect' do
+    context 'with data' do
+      let(:filename) { 'file.gif' }
+      let(:mime) { 'image/gif' }
+      
+      subject { described_class.new( url: location, name: filename ) }
+
+      it 'has the values for all components' do
+        expect( subject.inspect ).to eq %{#<Opium::File name="#{ filename }" url="#{ location }" mime_type="#{ mime }">}
+      end
+    end
+    
+    context 'without data' do
+      subject { described_class.new }
+      
+      it 'has nil values for all components' do
+        expect( subject.inspect ).to eq '#<Opium::File name=nil url=nil mime_type=nil>'
+      end
+    end
+  end
+  
+  context 'when used as a field type' do
+    before do
+      stub_const( 'Game', Class.new do
+        include Opium::Model
+        field :cover_image, type: Opium::File
+      end )
+      
+      stub_request(:get, "https://api.parse.com/1/classes/Game/abcd1234").
+        with(:headers => {'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+        to_return(:status => 200, :body => { objectId: 'abcd1234', coverImage: { __type: 'File', name: 'chunky_bacon.jpg', url: location }, createdAt: '2015-01-01T12:00:00Z' }.to_json, :headers => { content_type: 'application/json' })
+        
+      stub_request(:post, "https://api.parse.com/1/classes/Game").
+        with(
+          :body => "{\"coverImage\":{\"__type\":\"File\",\"name\":\"chunky_bacon.jpg\"}}",
+          :headers => {'Content-Type'=>'application/json', 'X-Parse-Application-Id'=>'PARSE_APP_ID', 'X-Parse-Rest-Api-Key'=>'PARSE_API_KEY'}).
+        to_return(:status => 200, :body => { objectId: 'abcd1234', createdAt: '2015-01-01T12:00:00Z' }.to_json, :headers => { content_type: 'application/json' })
+      
+    end
+    
+    it 'is retrievable as an Opium::File' do
+      game = Game.find('abcd1234')
+      expect( game.cover_image ).to be_a Opium::File
+    end
+    
+    it 'is persistable as a Parse File object hash' do
+      game = Game.new cover_image: Opium::File.new( url: location, name: 'chunky_bacon.jpg' )
+      expect { game.save! }.to_not raise_exception
+    end
+  end
+end

data/spec/opium/model/attributable_spec.rb

@@ -3,42 +3,56 @@ require 'spec_helper'
 describe Opium::Model::Attributable do
   let( :model ) { Class.new { include Opium::Model::Attributable } }
   
-  describe 'instance' do
+  context 'within an instance' do
     subject { model.new }
     
-    it { should respond_to( :attributes, :attributes= ) }
-    it { should respond_to( :attributes_to_parse ) }
+    it { is_expected.to respond_to( :attributes, :attributes= ) }
+    it { is_expected.to respond_to( :attributes_to_parse ) }
   end
   
-  describe 'when included in a model' do
+  context 'when included in a model' do
     before do
       stub_const( 'Book', Class.new do
         include Opium::Model
         field :title, type: String
+        field :genre, type: Symbol
+        attr_accessor :not_a_field
       end )
     end
     
-    subject { Book.new( title: 'Little Brother', id: 'abc123', created_at: Time.now ) }
+    subject { Book.new( title: 'Little Brother', id: 'abc123', created_at: Time.now, genre: :sci_fi ) }
     
-    describe 'attributes_to_parse' do
-      it 'when called with no parameters, should have all fields present, with names and values converted to parse' do
-        subject.attributes_to_parse.should =~ { 'objectId' => 'abc123', 'title' => 'Little Brother', 'createdAt' => subject.created_at.to_parse, 'updatedAt' => nil }
+    describe '#attributes_to_parse' do
+      context 'when called with no parameters' do
+        it 'has all fields present, with names and values converted to parse' do
+          expect( subject.attributes_to_parse ).to eq( 'objectId' => 'abc123', 'title' => 'Little Brother', 'genre' => 'sci_fi', 'createdAt' => subject.created_at.to_parse, 'updatedAt' => nil )
+        end
       end
       
-      it 'when called with except, should exclude the excepted fields' do
-        subject.attributes_to_parse( except: [:id, :updated_at] ).should =~ { 'title' => 'Little Brother', 'createdAt' => subject.created_at.to_parse }
+      context 'when called with except' do
+        it 'excludes the excepted fields' do
+          expect( subject.attributes_to_parse( except: [:id, :updated_at] ) ).to eq( 'title' => 'Little Brother', 'genre' => 'sci_fi', 'createdAt' => subject.created_at.to_parse )
+        end
       end
       
-      it 'when called with not_readonly, should exclude all readonly fields' do
-        subject.attributes_to_parse( not_readonly: true ).should =~ { 'title' => 'Little Brother' }
+      context 'when called with not_readonly' do
+        it 'excludes all readonly fields' do
+          expect( subject.attributes_to_parse( not_readonly: true ) ).to eq( 'title' => 'Little Brother', 'genre' => 'sci_fi' )
+        end
       end
     end
     
-    describe ':attributes=' do
-      it 'should still store unrecognized fields in the attributes hash' do
+    describe '#attributes=' do
+      it 'stores unrecognized fields in the attributes hash' do
         expect { subject.attributes = { unknownField: 42 } }.to_not raise_exception
-        subject.attributes.should have_key('unknownField')
-        subject.attributes['unknownField'].should == 42
+        expect( subject.attributes ).to have_key('unknownField')
+        expect( subject.attributes['unknownField'] ).to eq 42
+      end
+      
+      it 'calls relevant setters rather for non fields if they exist' do
+        expect { subject.attributes = { not_a_field: 42 } }.to_not raise_exception
+        expect( subject.not_a_field ).to eq 42
+        expect( subject.attributes ).to_not have_key('not_a_field')
       end
     end
   end

data/spec/opium/model/batchable/batch_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe Opium::Model::Batchable::Batch do
+  let(:update_path) { '/1/classes/Game/abcd1234' }
+  let(:body) { { title: 'Skyrim' } }
+  
+  describe '#owner' do
+    it 'is a property' do
+      is_expected.to respond_to(:owner)
+    end
+  end
+  
+  describe '#depth' do
+    let(:depth) { subject.depth }
+    
+    context 'within a new batch' do
+      subject { described_class.new }
+      
+      it { expect(depth).to eq 0 }
+    end
+  end
+  
+  describe '#dive' do
+    after { subject.depth = 0 }
+    
+    it { expect { subject.dive }.to change( subject, :depth ).by(1) }
+  end
+  
+  describe '#ascend' do
+    after { subject.depth = 0 }
+    
+    it { expect { subject.ascend }.to change( subject, :depth ).by(-1) }
+  end
+    
+  describe '#queue' do
+    let(:queue) { subject.queue }
+    
+    context 'within a new batch' do
+      subject { described_class.new }
+      
+      it { expect(queue).to eq [] }
+    end
+  end
+  
+  describe '#enqueue' do
+    let(:perform) { subject.enqueue( operation ) }
+    
+    after { subject.queue.clear }
+    
+    context 'with a valid operation hash' do
+      let(:operation) { { method: :put, path: update_path, body: body } }
+      
+      it { expect { perform }.to_not raise_exception }
+      it { expect( perform ).to be_a Opium::Model::Batchable::Operation }
+    end
+    
+    context 'with an Operation object' do
+      let(:operation) { Opium::Model::Batchable::Operation.new( method: :put, path: update_path, body: body ) }
+      
+      it { expect { perform }.to_not raise_exception }
+      it { expect( perform ).to be_a Opium::Model::Batchable::Operation }
+    end
+    
+    context 'with an invalid operation hash' do
+      let(:operation) { { path: update_path, body: body } }
+      
+      it { expect { perform }.to raise_exception }
+    end
+  end
+  
+  describe '#execute' do
+    let(:execute) { subject.execute }
+    let(:operation) { Opium::Model::Batchable::Operation.new( method: :put, path: update_path, body: body ) }
+    
+    before do
+      subject.owner = double()
+      allow( subject.owner ).to receive(:http_post).and_return( [ { success: { objectId: 'abcd1234', createdAt: Time.now } } ] )
+      subject.enqueue( operation )
+    end
+    
+    after do 
+      subject.owner = nil 
+      subject.queue.clear
+    end
+    
+    context 'when #depth is 0' do      
+      it { expect( subject.depth ).to eq 0 }
+      it { expect { execute }.to_not change( subject, :depth ) }
+      it 'performs a POST of the batch' do
+        expect( subject.owner ).to receive(:http_post).with( subject.to_parse.first )
+        execute
+      end
+    end
+    
+    context 'when #depth is greater than 0' do
+      before { subject.dive }
+      after { subject.ascend }
+      
+      it { expect( subject.depth ).to eq 1 }
+      it { expect { execute }.to change( subject, :depth ).by(-1) }
+      it 'does not POST the batch' do
+        expect( subject.owner ).to_not receive(:http_post)
+        execute
+      end
+    end
+    
+    context 'when #queue is empty' do
+      before { subject.queue.clear }
+      
+      it { expect { subject.execute }.to raise_exception }
+    end
+    
+    context 'when #queue has more than MAX_BATCH_SIZE operations' do
+      before { subject.queue = [operation] * 51 }
+      after { subject.queue.clear }
+      
+      it 'performs multiple POSTs' do
+        expect( subject.owner ).to receive(:http_post).twice
+        execute
+      end
+    end
+  end
+  
+  describe '#to_parse' do
+    let(:result) { subject.to_parse }
+    
+    context 'with Operations in the queue' do
+      before { subject.enqueue( method: :put, path: update_path, body: body ) }
+      after { subject.queue.clear }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Array }
+      
+      it { expect( result.first ).to be_a Hash }
+      it { expect( result.first ).to have_key( :requests ) }
+      it { expect( result.first[:requests] ).to be_a Array }
+      it { expect( result.first[:requests] ).to_not be_empty }
+    end
+    
+    context 'with an empty queue' do
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to eq [] }
+    end
+  end
+end

data/spec/opium/model/batchable/operation_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Opium::Model::Batchable::Operation do
+  let(:update_path) { '/1/classes/Game/abcd1234' }
+  let(:body) { { title: 'Skyrim' } }
+  
+  describe '#initialize' do
+    let(:result) { described_class.new( properties ) }
+    
+    context 'with all properties' do
+      let(:properties) { { method: :put, path: update_path, body: body } }
+    
+      it { expect { result }.to_not raise_exception }
+      it 'sets the method' do
+        expect( result.method ).to eq :put
+      end
+      
+      it 'sets the path' do
+        expect( result.path ).to eq update_path
+      end
+      
+      it 'sets the body' do
+        expect( result.body ).to eq body
+      end
+    end
+    
+    context 'when :method is missing' do
+      let(:properties) { { path: update_path, body: body } }
+      
+      it { expect { result }.to raise_exception }
+    end
+    
+    context 'when :path is missing' do
+      let(:properties) { { method: :put, body: body } }
+      
+      it { expect { result }.to raise_exception }
+    end
+    
+    context 'when :body is missing' do
+      let(:properties) { { method: :put, path: update_path } }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result.body ).to be_nil }
+    end
+  end
+  
+  describe '#to_parse' do
+    let(:result) { subject.to_parse }
+    
+    context 'when a body is present' do
+      subject { described_class.new( method: :put, path: update_path, body: body ) }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Hash }
+      it { expect( result.keys ).to include( :method, :path, :body ) }
+      it 'stringifies and upcases the method' do
+        expect( result[:method] ).to eq 'PUT' 
+      end
+    end
+    
+    context 'without a body' do
+      subject { described_class.new( method: :put, path: update_path ) }
+      
+      it { expect { result }.to_not raise_exception }
+      it { expect( result ).to be_a Hash }
+      it { expect( result.keys ).to include( :method, :path ) }
+      it { expect( result ).to_not have_key( :body ) }
+      it 'stringifies and upcases the method' do
+        expect( result[:method] ).to eq 'PUT' 
+      end
+    end
+  end
+end

data/spec/opium/model/batchable_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Opium::Model::Batchable do
+  it { expect( described_class.constants ).to include( :Batch, :Operation ) }
+end

data/spec/opium/model/connectable_spec.rb

@@ -215,4 +215,31 @@ describe Opium::Model::Connectable do
       subject.requires_heightened_privileges?.should == true
     end
   end
+  
+  describe '.with_heightened_privileges' do
+    it { expect {|b| subject.with_heightened_privileges &b}.to yield_control }
+    
+    it 'has heightened privileges within the block' do
+      subject.with_heightened_privileges do
+        expect( subject ).to have_heightened_privileges
+      end
+    end
+    
+    it 'does not have heightened privileges outside the block' do
+      subject.with_heightened_privileges {}
+      expect( subject ).to_not have_heightened_privileges 
+    end
+    
+    it 'turns off heightened privileges on exceptions' do
+      expect { subject.with_heightened_privileges { raise 'expected' } }.to raise_exception
+      expect( subject ).to_not have_heightened_privileges
+    end
+    
+    it 'keeps the previous value of requires_heightened_privileges? after the block' do
+      subject.requires_heightened_privileges!
+      subject.with_heightened_privileges {}
+      expect( subject ).to have_heightened_privileges
+      subject.instance_variable_set :@requires_heightened_privileges, nil
+    end
+  end
 end

data/spec/opium/model/fieldable_spec.rb

@@ -130,4 +130,39 @@ describe Opium::Model::Fieldable do
       end
     end
   end
+  
+  context 'when a model has fields' do
+    before do
+      stub_const( 'Model', Class.new do
+        include Opium::Model
+        field :symbolic_with_string_default, type: Symbol, default: 'value'
+        field :symbolic_with_symbol_default, type: Symbol, default: :value
+      end )
+    end
+    
+    subject { Model }
+    let(:instance) { subject.new }
+    
+    it 'converts default values correctly' do
+      expect( Model.default_attributes ).to include( 'symbolic_with_string_default' => :value, 'symbolic_with_symbol_default' => :value )
+    end
+    
+    describe '.field' do
+      subject { Model.new }
+      
+      it 'converts default values' do
+        expect( subject.symbolic_with_string_default ).to be_a Symbol
+        expect( subject.symbolic_with_symbol_default ).to be_a Symbol
+      end
+    end
+    
+    describe '.field=' do
+      subject { Model.new }
+      
+      it 'converts strings appropriately' do
+        expect { subject.symbolic_with_symbol_default = 'updated_value' }.to change( subject, :symbolic_with_symbol_default ).from(:value).to(:updated_value)
+        expect( subject.symbolic_with_symbol_default ).to be_a Symbol
+      end
+    end
+  end
 end