opium 1.3.5 → 1.4.0

data/spec/opium/file_spec.rb

@@ -8,61 +8,61 @@ describe Opium::File do
       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'),
+        with(
+          body: "GIF89a\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      
+
+    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 non-standard characters in filename' do
       let(:upload_options) { { original_filename: 'chunky&bacon$with cheddar@cheese.jpg' } }
-      
+
       it { expect { result }.to_not raise_exception }
       it 'paramterizes the name' do
         expect( result.name ).to end_with 'chunky-bacon-with-cheddar-cheese.jpg'
       end
     end
-    
+
     context 'when executed' do
       let(:upload_options) { { sent_headers: true } }
-      
+
       it { expect { result }.to_not raise_exception }
       it { expect( result.keys ).to include( 'Content-Length' ) }
       it { expect( result['Content-Length'] ).to eq gif_file.size.to_s }
     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
@@ -71,10 +71,10 @@ describe Opium::File do
       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
@@ -84,76 +84,76 @@ describe Opium::File do
       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 given a JSON string' do
       let(:object) { { url: location, name: 'chunky_bacon.jpg' }.to_json }
-      
+
       it { expect { result }.to_not raise_exception }
       it { expect( result ).to be_a Opium::File }
     end
-    
+
     context 'when given an empty string' do
       let(:object) { '' }
-      
+
       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' }
@@ -162,51 +162,51 @@ describe Opium::File 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 
+
+    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
@@ -214,28 +214,28 @@ describe Opium::File do
         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' }
@@ -244,62 +244,62 @@ describe Opium::File 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
+end

data/spec/opium/model/connectable_spec.rb

@@ -7,63 +7,107 @@ describe Opium::Model::Connectable do
       stub('model_name').and_return(ActiveModel::Name.new(klass, nil, 'Model'))
     end )
   end
-  
+
   after do
     Opium::Model::Criteria.models.clear
   end
-    
+
   subject { Model }
   let( :response ) { double('Response').tap {|r| allow(r).to receive(:body) } }
-  
+
+  it { is_expected.to respond_to( :parse_server_url ) }
   it { is_expected.to respond_to( :connection, :reset_connection! ) }
   it { is_expected.to respond_to( :object_prefix, :no_object_prefix! ) }
   it { is_expected.to respond_to( :as_resource, :resource_name ).with(1).argument }
   it { is_expected.to respond_to( :http_get, :http_post, :http_delete ).with(1).argument }
   it { is_expected.to respond_to( :http_put ).with(2).arguments }
   it { is_expected.to respond_to( :requires_heightened_privileges!, :requires_heightened_privileges?, :has_heightened_privileges? ) }
-  
+
+  describe '.parse_server_url' do
+    after do
+      Opium.reset
+    end
+
+    context 'with a default config' do
+      it { expect( subject.parse_server_url ).to eq 'https://api.parse.com/1' }
+    end
+
+    context 'with altered server settings' do
+      before do
+        Opium.configure do |config|
+          config.server_url = 'https://example.com'
+          config.mount_point = '/parse'
+        end
+      end
+
+      it { expect( subject.parse_server_url ).to eq 'https://example.com/parse' }
+    end
+  end
+
   describe '.object_prefix' do
     it { expect( subject.object_prefix ).to eq 'classes' }
   end
-  
+
+  describe '.connection' do
+    after do
+      Opium.reset
+      subject.reset_connection!
+    end
+
+    context 'with a default config' do
+      it { expect( subject.connection.url_prefix ).to eq ::URI.join( 'https://api.parse.com/1' ) }
+    end
+
+    context 'with altered server settings' do
+      before do
+        Opium.configure do |config|
+          config.server_url = 'https://example.com'
+          config.mount_point = '/parse'
+        end
+      end
+
+      it { expect( subject.connection.url_prefix ).to eq ::URI.join( 'https://example.com/parse' ) }
+    end
+  end
+
   describe '.reset_connection!' do
     it { expect { subject.reset_connection! }.to change( subject, :connection ) }
   end
-  
+
   describe '.no_object_prefix!' do
     after do
       Model.instance_variable_set :@object_prefix, nil
     end
-    
+
     it 'has an empty object_prefix' do
       expect { subject.no_object_prefix! }.to change( subject, :object_prefix ).from( 'classes' ).to( '' )
     end
   end
-  
+
   describe '.as_resource' do
     it { expect { subject.as_resource }.to raise_exception(ArgumentError) }
     it do
       expect {|b| subject.as_resource( :masked, &b ) }.to yield_control
     end
-    
+
     it { expect { subject.as_resource( :masked ) {} }.to_not change( subject, :resource_name ) }
-    
+
     it 'changes the .resource_name within a block' do
       subject.as_resource( :masked ) do
         expect( subject.resource_name ).to eq 'masked'
       end
     end
   end
-  
+
   describe '.resource_name' do
     it 'is based off the class name' do
       subject.resource_name.should == 'classes/Model'
     end
-    
+
     it 'is able to include a resource id' do
       subject.resource_name('abc123').should == 'classes/Model/abc123'
     end
-    
+
     it 'demodulizes the model_name' do
       namespaced_model = subject
       namespaced_model.stub(:model_name).and_return(ActiveModel::Name.new(subject, nil, 'Namespace::Model'))
@@ -72,110 +116,110 @@ describe Opium::Model::Connectable do
       namespaced_model.resource_name.should == 'classes/Model'
     end
   end
-  
+
   shared_examples_for 'a sent-headers response' do |method, *args|
     let(:options) { args.last.is_a?(Hash) ? args.pop : {} }
     let(:params) { args.push options.merge( sent_headers: true ) }
     let(:request) { subject.send( :"http_#{method}", *params ) }
-    
+
     it { expect { request }.to_not raise_exception }
-    
+
     it { expect( request ).to be_a(Hash) }
-    
+
     if [:put, :post].include? method
       context 'when including a JSON encoded body' do
         it { expect( request ).to have_key 'Content-Type' }
         it { expect( request['Content-Type'] ).to eq 'application/json' }
       end
     end
-    
+
     context 'when not .requires_heightened_prvileges?' do
       before { subject.instance_variable_set :@requires_heightened_privileges, nil }
-      
+
       it { expect( subject.requires_heightened_privileges? ).to eq false }
-      
+
       it { expect( request.keys ).to include( 'X-Parse-Application-Id', 'X-Parse-Rest-Api-Key' ) }
       it { expect( request.keys ).to_not include( 'X-Parse-Master-Key', 'X-Parse-Session-Token' ) }
     end
-    
+
     unless method == :get
       context 'when .requires_heightened_privileges?' do
         subject do
           Model.requires_heightened_privileges!
           Model.send( :"http_#{method}", *params )
         end
-        
+
         after { Model.instance_variable_set :@requires_heightened_privileges, nil }
-                
+
         it { expect( subject.keys ).to include( 'X-Parse-Application-Id', 'X-Parse-Master-Key' ) }
         it { expect( subject.keys ).to_not include( 'X-Parse-Rest-Api-Key', 'X-Parse-Session-Token' ) }
       end
     end
   end
-  
+
   describe '.http_get' do
     before do
       stub_request( :get, %r{https://api.parse.com/1/classes/Model(\?.+)?} ).
         to_return( status: 200, body: { objectId: 'abc123' }.to_json, headers: { 'Content-Type' => 'application/json' } )
     end
-    
+
     it 'executes a :get on :connection' do
       subject.connection.should_receive(:get) { response }.with( 'classes/Model' )
       subject.http_get
     end
-    
+
     it 'uses a resource id if passed an :id option' do
       subject.connection.should_receive(:get) { response }.with( 'classes/Model/abcd1234' )
       subject.http_get id: 'abcd1234'
     end
-    
+
     it 'returns a raw response if passed :raw_response' do
       subject.http_get( raw_response: true ).should be_a( Faraday::Response )
     end
-    
+
     it 'sets params for everything within the :query hash' do
       response = subject.http_get query: { keys: 'title,price', order: '-title', limit: 5 }, raw_response: true
       request_params = response.env.url.query.split('&').map {|p| p.split('=')}
       request_params.should =~ { 'keys' => 'title%2Cprice', 'order' => '-title', 'limit' => '5' }
     end
-    
+
     it 'special cases a :query key of "where", making it json encoded' do
       criteria = { price: { '$lte' => 5 } }
       response = subject.http_get query: { where: criteria }, raw_response: true
       query = URI.decode response.env.url.query
       query.should == "where=#{criteria.to_json}"
     end
-    
+
     it_behaves_like 'a sent-headers response', :get
   end
-  
+
   describe '.http_post' do
     it 'executes a :post on :connection' do
       subject.connection.should_receive(:post) { response }
       subject.http_post( {} )
     end
-    
+
     it_behaves_like 'a sent-headers response', :post, {}, {}
   end
-  
+
   describe '.http_put' do
     it 'executes a :put on :connection' do
       subject.connection.should_receive(:put) { response }
       subject.http_put( 'abcd1234', {} )
     end
-    
+
     it_behaves_like 'a sent-headers response', :put, 'abcd1234', {}, {}
   end
-  
+
   describe '.http_delete' do
     it 'executes a :delete on :connection' do
       subject.connection.should_receive(:delete) { response }
       subject.http_delete( 'abcd1234' )
     end
-    
+
     it_behaves_like 'a sent-headers response', :delete, 'abcd1234'
   end
-  
+
   describe '.requires_heightened_privileges!' do
     shared_examples_for 'it has heightened privileges on' do |method, *args|
       before do
@@ -189,52 +233,52 @@ describe Opium::Model::Connectable do
             )
           ).to_return(:status => 200, :body => "{}", :headers => {content_type: 'application/json'})
       end
-      
+
       it "causes :http_#{method} to add a master-key header" do
         subject.requires_heightened_privileges!
         expect { subject.send( :"http_#{method}", *args ) }.to_not raise_exception
       end
     end
-    
+
     after { subject.instance_variable_set :@requires_heightened_privileges, nil }
-    
+
     it { subject.requires_heightened_privileges!.should == true }
-    
+
     it_behaves_like 'it has heightened privileges on', :post, {}
     it_behaves_like 'it has heightened privileges on', :put, 'abcd1234', {}
     it_behaves_like 'it has heightened privileges on', :delete, 'abcd1234'
   end
-  
+
   describe '.requires_heightened_privileges?' do
     after { subject.instance_variable_set :@requires_heightened_privileges, nil }
-    
+
     it { subject.requires_heightened_privileges?.should == false }
-    
+
     it 'is true if privileges have been raised' do
       subject.requires_heightened_privileges!
       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 
+      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 {}
@@ -242,4 +286,4 @@ describe Opium::Model::Connectable do
       subject.instance_variable_set :@requires_heightened_privileges, nil
     end
   end
-end
+end