spark_api 1.4.34 → 1.5.3

data/spec/unit/spark_api/options_hash_spec.rb

@@ -6,9 +6,9 @@ describe SparkApi::OptionsHash do
          "parameter_two" => 2,
          3 => 3}
     o_h = SparkApi::OptionsHash.new(h)
-    o_h.keys.size.should eq(3)
-    o_h["parameter_one"].should eq(1)
-    o_h["parameter_two"].should eq(2)
-    o_h[3].should eq(3)
+    expect(o_h.keys.size).to eq(3)
+    expect(o_h["parameter_one"]).to eq(1)
+    expect(o_h["parameter_two"]).to eq(2)
+    expect(o_h[3]).to eq(3)
   end
 end

data/spec/unit/spark_api/paginate_spec.rb

@@ -37,54 +37,54 @@ describe SparkApi::PaginateResponse do
       json = "{#{paginate_json}}"
       hash = JSON.parse(json)
       results = subject.paginate_response([1,2,3,4,5,6,7,8,9,10], hash["Pagination"])
-      results.offset.should eq(0)
-      results.next_page.should eq(2)
-      results.previous_page.should eq(nil)
-      results.current_page.should eq(1)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(1)
+      expect(results.offset).to eq(0)
+      expect(results.next_page).to eq(2)
+      expect(results.previous_page).to eq(nil)
+      expect(results.current_page).to eq(1)
+      expect(results.per_page).to eq(10)
+      expect(results.total_pages).to eq(4)
+      expect(results.total_entries).to eq(38)
+      expect(results[0]).to eq(1)
     end
     it "should give me the second page" do
       json = "{#{paginate_json(2)}}"
       hash = JSON.parse(json)
       results = subject.paginate_response([11,12,13,14,15,16,17,18,19,20], hash["Pagination"])
-      results.offset.should eq(10)
-      results.next_page.should eq(3)
-      results.previous_page.should eq(1)
-      results.current_page.should eq(2)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(11)
+      expect(results.offset).to eq(10)
+      expect(results.next_page).to eq(3)
+      expect(results.previous_page).to eq(1)
+      expect(results.current_page).to eq(2)
+      expect(results.per_page).to eq(10)
+      expect(results.total_pages).to eq(4)
+      expect(results.total_entries).to eq(38)
+      expect(results[0]).to eq(11)
     end
     it "should give me the third page" do
       json = "{#{paginate_json(3)}}"
       hash = JSON.parse(json)
       results = subject.paginate_response([21,22,23,24,25,26,27,28,29,30], hash["Pagination"])
-      results.offset.should eq(20)
-      results.next_page.should eq(4)
-      results.previous_page.should eq(2)
-      results.current_page.should eq(3)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(21)
+      expect(results.offset).to eq(20)
+      expect(results.next_page).to eq(4)
+      expect(results.previous_page).to eq(2)
+      expect(results.current_page).to eq(3)
+      expect(results.per_page).to eq(10)
+      expect(results.total_pages).to eq(4)
+      expect(results.total_entries).to eq(38)
+      expect(results[0]).to eq(21)
     end
     it "should give me the last page" do
       json = "{#{paginate_json(4)}}"
       hash = JSON.parse(json)
       results = subject.paginate_response([31,32,33,34,35,36,37,38], hash["Pagination"])
-      results.offset.should eq(30)
-      results.next_page.should eq(nil)
-      results.previous_page.should eq(3)
-      results.current_page.should eq(4)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results[0].should eq(31)
-      results[-1].should eq(38)
+      expect(results.offset).to eq(30)
+      expect(results.next_page).to eq(nil)
+      expect(results.previous_page).to eq(3)
+      expect(results.current_page).to eq(4)
+      expect(results.per_page).to eq(10)
+      expect(results.total_pages).to eq(4)
+      expect(results.total_entries).to eq(38)
+      expect(results[0]).to eq(31)
+      expect(results[-1]).to eq(38)
     end
   end
 end
@@ -93,27 +93,27 @@ describe SparkApi::Paginate do
   describe "paginate" do
     it "should give me a will paginate collection" do
       results = PaginateModelTester.paginate(:page => 1)
-      results.should be_a(WillPaginate::Collection)
-      results.offset.should eq(0)
-      results.next_page.should eq(2)
-      results.previous_page.should eq(nil)
-      results.current_page.should eq(1)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
+      expect(results).to be_a(WillPaginate::Collection)
+      expect(results.offset).to eq(0)
+      expect(results.next_page).to eq(2)
+      expect(results.previous_page).to eq(nil)
+      expect(results.current_page).to eq(1)
+      expect(results.per_page).to eq(10)
+      expect(results.total_pages).to eq(4)
+      expect(results.total_entries).to eq(38)
       
-      results[0].should be_a(PaginateModelTester)
-      results[0].val.should eq(1)
+      expect(results[0]).to be_a(PaginateModelTester)
+      expect(results[0].val).to eq(1)
       
     end
       
     it "should give me pagination options" do
       PaginateModelTester.paginate(:page => 1)
       opts = PaginateModelTester.options
-      opts["_pagination"].should eq(1)
-      opts["_limit"].should eq(25)
-      opts["_page"].should eq(1)
-      opts.has_key?(:page).should eq(false)
+      expect(opts["_pagination"]).to eq(1)
+      expect(opts["_limit"]).to eq(25)
+      expect(opts["_page"]).to eq(1)
+      expect(opts.has_key?(:page)).to eq(false)
     end
   end
 
@@ -121,7 +121,7 @@ describe SparkApi::Paginate do
     it "should set the default model max results per page" do
       results = PaginateModelTester50.paginate(:page => 1)
       opts = PaginateModelTester50.options
-      opts["_limit"].should eq(50)
+      expect(opts["_limit"]).to eq(50)
     end
   end
   
@@ -151,18 +151,18 @@ describe SparkApi::Paginate do
         }).
         to_return(:body => json)
       results = subject.paginate(:page=>1, :per_page=>10)
-      results.should be_a(WillPaginate::Collection)
-      results.offset.should eq(0)
-      results.next_page.should eq(2)
-      results.previous_page.should eq(nil)
-      results.current_page.should eq(1)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
-      results.length.should eq(10)
+      expect(results).to be_a(WillPaginate::Collection)
+      expect(results.offset).to eq(0)
+      expect(results.next_page).to eq(2)
+      expect(results.previous_page).to eq(nil)
+      expect(results.current_page).to eq(1)
+      expect(results.per_page).to eq(10)
+      expect(results.total_pages).to eq(4)
+      expect(results.total_entries).to eq(38)
+      expect(results.length).to eq(10)
       
-      results[0].should be_a(subject)
-      results[0].ListPrice.should eq(50000.0)
+      expect(results[0]).to be_a(subject)
+      expect(results[0].ListPrice).to eq(50000.0)
       
     end
     it "gives me page two of listings" do
@@ -184,9 +184,9 @@ describe SparkApi::Paginate do
         }).
         to_return(:body => json)
       results = subject.paginate(:page=>2, :per_page=>10)
-      results.next_page.should eq(3)
-      results.previous_page.should eq(1)
-      results.current_page.should eq(2)
+      expect(results.next_page).to eq(3)
+      expect(results.previous_page).to eq(1)
+      expect(results.current_page).to eq(2)
     end
     it "gives me page four of listings" do
       json = <<-JSON 
@@ -207,16 +207,16 @@ describe SparkApi::Paginate do
         }).
         to_return(:body => json)
       results = subject.paginate(:page=>4, :per_page=>10)
-      results.next_page.should eq(nil)
-      results.previous_page.should eq(3)
-      results.current_page.should eq(4)
-      results.per_page.should eq(10)
-      results.total_pages.should eq(4)
-      results.total_entries.should eq(38)
+      expect(results.next_page).to eq(nil)
+      expect(results.previous_page).to eq(3)
+      expect(results.current_page).to eq(4)
+      expect(results.per_page).to eq(10)
+      expect(results.total_pages).to eq(4)
+      expect(results.total_entries).to eq(38)
       
-      results.length.should eq(8)
-      results[0].should be_a(subject)
-      results[0].ListPrice.should eq(50000.0)
+      expect(results.length).to eq(8)
+      expect(results[0]).to be_a(subject)
+      expect(results[0].ListPrice).to eq(50000.0)
     end
     
   end

data/spec/unit/spark_api/primary_array_spec.rb

@@ -18,12 +18,12 @@ describe SparkApi::PrimaryArray do
     d = PrimaryModel.new(4, true)
     e = PrimaryModel.new(5)
     tester = subject.class.new([d,e])
-    tester.primary.should eq(d)
+    expect(tester.primary).to eq(d)
     tester = subject.class.new([a,b,c,d,e])
-    tester.primary.should eq(d)
+    expect(tester.primary).to eq(d)
     # Note, it doesn't care if there is more than one primary, just returns first in the list.
     b.Primary = true
-    tester.primary.should eq(b)
+    expect(tester.primary).to eq(b)
   end
   it "should return nil when there is no primary element" do
     a = PrimaryModel.new(1)
@@ -32,9 +32,9 @@ describe SparkApi::PrimaryArray do
     d = PrimaryModel.new(4)
     e = PrimaryModel.new(5)
     tester = subject.class.new([])
-    tester.primary.should be(nil)
+    expect(tester.primary).to be(nil)
     tester = subject.class.new([a,b,c,d,e])
-    tester.primary.should be(nil)
+    expect(tester.primary).to be(nil)
   end
 end
 

data/spec/unit/spark_api/request_spec.rb

@@ -4,45 +4,45 @@ describe SparkApi do
   describe SparkApi::ClientError do
     subject { SparkApi::ClientError.new({:message=>"OMG FAIL", :code=>1234, :status=>500, :request_path => '/v1/foo', :request_id => 'deadbeef'}) }
     it "should print a helpful to_s" do
-      subject.to_s.should == "OMG FAIL"
-      subject.message.should == "OMG FAIL"
+      expect(subject.to_s).to eq("OMG FAIL")
+      expect(subject.message).to eq("OMG FAIL")
     end
     it "should have an api code" do
-      subject.code.should == 1234
+      expect(subject.code).to eq(1234)
     end
     it "should have an http status" do
-      subject.status.should == 500
+      expect(subject.status).to eq(500)
     end
 
     it "should have a request_path" do
-      subject.request_path.should == '/v1/foo'
+      expect(subject.request_path).to eq('/v1/foo')
     end
 
     it "should have a request_id" do
-      subject.request_id.should == 'deadbeef'
+      expect(subject.request_id).to eq('deadbeef')
     end
 
     it "should raise and exception with attached message" do
       expect { raise subject.class, {:message=>"My Message", :code=>1000, :status=>404}}.to raise_error(SparkApi::ClientError)  do |e| 
-        e.message.should == "My Message" 
-        e.code.should == 1000
-        e.status.should == 404
+        expect(e.message).to eq("My Message") 
+        expect(e.code).to eq(1000)
+        expect(e.status).to eq(404)
       end
       expect { raise subject.class.new({:message=>"My Message", :code=>1000, :status=>404}) }.to raise_error(SparkApi::ClientError)  do |e| 
-        e.message.should == "My Message" 
-        e.code.should == 1000
-        e.status.should == 404
+        expect(e.message).to eq("My Message") 
+        expect(e.code).to eq(1000)
+        expect(e.status).to eq(404)
       end
       expect { raise subject.class.new({:code=>1000, :status=>404}), "My Message"}.to raise_error(SparkApi::ClientError)  do |e| 
-        e.message.should == "My Message" 
-        e.code.should == 1000
-        e.status.should == 404
+        expect(e.message).to eq("My Message") 
+        expect(e.code).to eq(1000)
+        expect(e.status).to eq(404)
       end
       expect { raise subject.class, "My Message"}.to raise_error(SparkApi::ClientError)  do |e| 
-        e.message.should == "My Message" 
-        e.code.should be == nil
-        e.status.should be == nil
-        e.request_id.should be == nil
+        expect(e.message).to eq("My Message") 
+        expect(e.code).to eq(nil)
+        expect(e.status).to eq(nil)
+        expect(e.request_id).to eq(nil)
       end
     end
   end
@@ -54,34 +54,34 @@ describe SparkApi do
     end
     it "should have results when successful" do
       r = SparkApi::ApiResponse.new({"D"=>{"Success" => true, "Results" => []}})
-      r.success?.should be(true)
-      r.results.empty?.should be(true)
-      r.request_id.should eq nil
+      expect(r.success?).to be(true)
+      expect(r.results.empty?).to be(true)
+      expect(r.request_id).to eq nil
     end
 
     it "should return the request_id" do
       r = SparkApi::ApiResponse.new({"D"=>{"Success" => true, "Results" => []}}, 'foobar')
-      r.success?.should be(true)
-      r.request_id.should eq('foobar')
+      expect(r.success?).to be(true)
+      expect(r.request_id).to eq('foobar')
     end
     it "should have a message on error" do
       r = SparkApi::ApiResponse.new({"D"=>{"Success" => false, "Message" => "I am a failure."}})
-      r.success?.should be(false)
-      r.message.should be == "I am a failure."
+      expect(r.success?).to be(false)
+      expect(r.message).to eq("I am a failure.")
     end
     it "should have SparkQLErrors when present" do
       err = {"Token" => "ExpirationDate", "Status" => "Dropped"}
       r = SparkApi::ApiResponse.new({"D"=>{"Success" => false, "Message" => "I am a failure from .",
         "SparkQLErrors" => [err]
       }})
-      r.sparkql_errors.first.should eq(err)
+      expect(r.sparkql_errors.first).to eq(err)
     end
     it "should have Errors when present" do
       err = {"Type" => "InvalidAttribute", "Attribute" => "DisplayName", "Message" => "DisplayName is wrong."}
       r = SparkApi::ApiResponse.new({"D"=>{"Success" => false, "Message" => "I am a failure from .",
         "Errors" => [err]
       }})
-      r.errors.first.should eq(err)
+      expect(r.errors.first).to eq(err)
     end
   end
   
@@ -160,7 +160,13 @@ describe SparkApi do
           }
           }'] 
         }
-
+        # For testing http_method_override. See associated test for more details.
+        stub.post('/v1/routetoproveweareposting?ApiSig=SignedToken&AuthToken=1234', 'some_param=some_value') { [200, {}, '{"D": {
+          "Success": true,
+          "Results": []
+          }
+          }']
+        }
       end
       @connection = test_connection(stubs)
     end  
@@ -193,62 +199,72 @@ describe SparkApi do
         r
       end
       it "should get a service" do
-        subject.get('/system')[0]["Name"].should == "My User"
+        expect(subject.get('/system')[0]["Name"]).to eq("My User")
       end
       it "should get a service with parameters" do
-        subject.get('/marketstatistics/price', "Options" => "ActiveAverageListPrice")[0]["ActiveAverageListPrice"].should == [100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000]
+        expect(subject.get('/marketstatistics/price', "Options" => "ActiveAverageListPrice")[0]["ActiveAverageListPrice"]).to eq([100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000,100000])
       end
       it "should post to a service" do
         data = {"Contacts" => [{"DisplayName"=>"Wades Contact","PrimaryEmail"=>"wade11@fbsdata.com"}]}
-        subject.post('/contacts', data)[0]["ResourceUri"].should == "1000"
+        expect(subject.post('/contacts', data)[0]["ResourceUri"]).to eq("1000")
       end
       it "should put to a service" do
         # This is a hypothetical unsupported service action at this time
         data = {"Contacts" => [{"DisplayName"=>"WLMCEWENS Contact","PrimaryEmail"=>"wlmcewen789@fbsdata.com"}]}
-        subject.put('/contacts/1000', data).size.should be(0)
+        expect(subject.put('/contacts/1000', data).size).to be(0)
         # No validation here, if no error is raised, everything is hunky dory
       end
       it "should delete from a service" do
         # This is a hypothetical unsupported service action at this time
-        subject.delete('/contacts/1000').size.should be(0)
+        expect(subject.delete('/contacts/1000').size).to be(0)
         # No validation here, if no error is raised, everything is hunky dory
       end
       
       it "should escape a path correctly" do
-        subject.get('/test path with spaces').length.should == 0
+        expect(subject.get('/test path with spaces').length).to eq(0)
         # now try this with an already escaped path.  Kaboom!
         expect { subject.get('/test%20path%20with%20spaces') }.to raise_error()
       end
       
       it "post data should support non json data" do
         # Other MISC requests
-        subject.post('/stringdata', 'I am a lonely String!').success?.should == true
+        expect(subject.post('/stringdata', 'I am a lonely String!').success?).to eq(true)
       end
 
       it "should support arrays in the body" do
-        subject.put('/arraydata', ["A","B","C"]).success?.should == true
+        expect(subject.put('/arraydata', ["A","B","C"]).success?).to be true
       end
 
       it "should allow response object to be returned instead of body" do
-        r = subject.get('/system', { full_response: true })
+        r = subject.get('/system', { some_param: 'something', full_response: true })
 
-        r.is_a?(Faraday::Response).should be(true)
-        r.status.should eq(200)
+        expect(r.is_a?(Faraday::Response)).to be(true)
+        expect(r.status).to eq(200)
       end
 
       it "should give me BigDecimal results for large floating point numbers" do
-        MultiJson.default_adapter.should eq(:yajl) unless jruby?
+        expect(MultiJson.default_adapter).to eq(:yajl) unless jruby?
         result = subject.get('/listings/1000')[0]
-        result["StandardFields"]["BuildingAreaTotal"].should be_a(Float)
-        pending("our JSON parser does not support large decimal types.  Anyone feel like writing some c code?") do
-          result["StandardFields"]["BuildingAreaTotal"].should be_a(BigDecimal)
+        expect(result["StandardFields"]["BuildingAreaTotal"]).to be_a(Float)
+        skip("our JSON parser does not support large decimal types.  Anyone feel like writing some c code?") do
+          expect(result["StandardFields"]["BuildingAreaTotal"]).to be_a(BigDecimal)
           number = BigDecimal.new(result["StandardFields"]["BuildingAreaTotal"].to_s)
-          number.to_s.should eq(BigDecimal.new("0.000000000000000000000000001").to_s)
+          expect(number.to_s).to eq(BigDecimal.new("0.000000000000000000000000001").to_s)
           number = BigDecimal.new(result["StandardFields"]["ListPrice"].to_s)
-          number.to_s.should eq(BigDecimal.new("9999999999999999999999999.99").to_s)
+          expect(number.to_s).to eq(BigDecimal.new("9999999999999999999999999.99").to_s)
         end
       end
-      
+
+      # This is a weird feature and it also gets a weird test that probably
+      # merits explanation:
+      #
+      # We have only stubbed POST for this route, so the below succeeding
+      # proves that we have converted our GET into a POST. It is additionally
+      # stubbed to prove that we turn the params into a body which excludes the
+      # http_method_override options as well as the override_headers options.
+      it "should convert GET to POST if http_method_override: true is supplied" do
+        expect(subject.get('/routetoproveweareposting', { http_method_override: true, some_param: "some_value" }).success?).to be true
+      end
     end
     
     context "when unauthenticated" do
@@ -279,11 +295,11 @@ describe SparkApi do
         r
       end
       it "should authenticate and then get a service" do
-        subject.get('/system')[0]["Name"].should == "My User"
+        expect(subject.get('/system')[0]["Name"]).to eq("My User")
       end
       it "should authenticate and then post to a service" do
         data = {"Contacts" => [{"DisplayName"=>"Wades Contact","PrimaryEmail"=>"wade11@fbsdata.com"}]}
-        subject.post('/contacts', data)[0]["ResourceUri"].should == "1000"
+        expect(subject.post('/contacts', data)[0]["ResourceUri"]).to eq("1000")
       end
     end
 
@@ -322,13 +338,13 @@ describe SparkApi do
         r
       end
       it "should reauthenticate and then get a service" do
-        subject.get('/system')[0]["Name"].should == "My User"
-        subject.reauthenticated?.should == true
+        expect(subject.get('/system')[0]["Name"]).to eq("My User")
+        expect(subject.reauthenticated?).to eq(true)
       end
       it "should reauthenticate and then post to a service" do
         data = {"Contacts" => [{"DisplayName"=>"Wades Contact","PrimaryEmail"=>"wade11@fbsdata.com"}]}
-        subject.post('/contacts', data)[0]["ResourceUri"].should == "1000"
-        subject.reauthenticated?.should == true
+        expect(subject.post('/contacts', data)[0]["ResourceUri"]).to eq("1000")
+        expect(subject.reauthenticated?).to eq(true)
       end
     end
 
@@ -340,13 +356,13 @@ describe SparkApi do
         r
       end
       it "should reauthenticate and then get a service" do
-        subject.get('/system')[0]["Name"].should == "My User"
-        subject.reauthenticated?.should == true
+        expect(subject.get('/system')[0]["Name"]).to eq("My User")
+        expect(subject.reauthenticated?).to eq(true)
       end
       it "should reauthenticate and then post to a service" do
         data = {"Contacts" => [{"DisplayName"=>"Wades Contact","PrimaryEmail"=>"wade11@fbsdata.com"}]}
-        subject.post('/contacts', data)[0]["ResourceUri"].should == "1000"
-        subject.reauthenticated?.should == true
+        expect(subject.post('/contacts', data)[0]["ResourceUri"]).to eq("1000")
+        expect(subject.reauthenticated?).to eq(true)
       end
     end
 
@@ -384,19 +400,19 @@ describe SparkApi do
       end
       it "should fail horribly on a get" do
         expect { subject.get('/system')}.to raise_error(SparkApi::PermissionDenied) do |e| 
-          e.code.should == SparkApi::ResponseCodes::SESSION_TOKEN_EXPIRED
-          e.request_path.should == '/system'
+          expect(e.code).to eq(SparkApi::ResponseCodes::SESSION_TOKEN_EXPIRED)
+          expect(e.request_path.to_s).to match(/\/system/)
         end
-        subject.reauthenticated.should == 2
+        expect(subject.reauthenticated).to eq(2)
 
       end
       it "should fail horribly on a post" do
         data = {"Contacts" => [{"DisplayName"=>"Wades Contact","PrimaryEmail"=>"wade11@fbsdata.com"}]}
         expect { subject.post('/contacts', data)}.to raise_error(SparkApi::PermissionDenied) do |e| 
-          e.code.should == SparkApi::ResponseCodes::SESSION_TOKEN_EXPIRED
-          e.request_path.should == '/contacts'
+          expect(e.code).to eq(SparkApi::ResponseCodes::SESSION_TOKEN_EXPIRED)
+          expect(e.request_path.to_s).to match(/\/contacts/)
         end
-        subject.reauthenticated.should == 2
+        expect(subject.reauthenticated).to eq(2)
       end
     end