harpy 1.0.0 → 2.0.0.preview1

data/spec/harpy/client_spec.rb

@@ -5,92 +5,141 @@ describe Harpy::Client do
   let(:users_url) { "http://localhost/users" }
 
   context "by default" do
-    its(:options) { should be_empty }
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to be_empty }
+    end
   end
 
   context "initialized with options" do
     let(:options) { {:username => "harpy", :password => "spec"} }
     subject { Harpy::Client.new(options) }
-    its(:options) { should == options }
+
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to eq(options) }
+    end
   end
 
   [:get, :head, :post, :put, :patch, :delete].each do |method|
     describe "##{method}(url, opts={})" do
       context "with one url" do
         before do
-          @expected = Typhoeus::Response.new :code => 200
-          Typhoeus.stub(entry_url, method: method){@expected}
+          stub_request(method, entry_url).to_return(status: 200)
         end
+
         it "sends a #{method.to_s.upcase} to the url" do
-          subject.send(method, entry_url).should == @expected
+          response = subject.send(method, entry_url)
+          expect(response.status).to eq(200)
+          expect(WebMock).to have_requested(method, entry_url)
         end
+
         it "merges options" do
           client = Harpy::Client.new :headers => {"Authorization" => "spec"}
-          Typhoeus.stub(entry_url, method: method){Typhoeus::Response.new :code => 200}
+          stub_request(method, entry_url).to_return(status: 200)
           response = client.send method, entry_url, :headers => {"X-Files" => "Harpy"}
-          response.request.options[:headers].should include({"X-Files" => "Harpy", "Authorization" => "spec"})
+          expect(WebMock).to have_requested(method, entry_url).with(headers: {
+            "X-Files" => "Harpy",
+            "Authorization" => "spec"
+          })
         end
       end
+
       context "with multiple urls" do
         it "does not execute requests" do
-          lambda {
+          expect {
             subject.send method, [entry_url, users_url]
-          }.should_not raise_error
+          }.not_to raise_error
         end
-        it "returns one requests per url" do
+
+        it "returns one request per url" do
           requests = subject.send method, [entry_url, users_url]
-          requests.size.should == 2
-          requests.collect{|r| r.options[:method]}.should =~ [method, method]
-          requests.collect(&:url).should =~ [entry_url, users_url]
+          expect(requests.size).to eq(2)
+          expect(requests.collect{|request| request.verb.downcase.to_sym}).to match_array([method, method])
+          expect(requests.collect{|request| request.uri.to_s}).to match_array([entry_url, users_url])
         end
+
         it "merges options" do
           client = Harpy::Client.new :headers => {"Authorization" => "spec"}
           requests = client.send method, [entry_url, users_url], :headers => {"X-Files" => "Harpy"}
           requests.each do |request|
-            request.options[:headers].should include({"X-Files" => "Harpy", "Authorization" => "spec"})
+            expect(request.headers["x-files"]).to eq("Harpy")
+            expect(request.headers["authorization"]).to eq("spec")
           end
         end
       end
     end
   end
+
+  describe "HTTPX request options" do
+    it "encodes query parameters" do
+      stub_request(:get, "#{users_url}?active=true").to_return(status: 200)
+
+      response = subject.get(users_url, params: {active: true})
+
+      expect(response.status).to eq(200)
+      expect(WebMock).to have_requested(:get, "#{users_url}?active=true")
+    end
+
+    it "maps username and password to basic authentication" do
+      stub_request(:get, entry_url).with(headers: {"Authorization" => "Basic aGFycHk6c3BlYw=="}).to_return(status: 200)
+
+      response = Harpy::Client.new(username: "harpy", password: "spec").get(entry_url)
+
+      expect(response.status).to eq(200)
+    end
+
+    it "maps legacy timeout and SSL options" do
+      request = Harpy::Client.new(timeout: 5000, ssl_verifypeer: false, ssl_verifyhost: 0).get([entry_url]).first
+
+      expect(request.options.timeout.total_request_timeout).to eq(5)
+      expect(request.options.ssl).to include(verify_mode: OpenSSL::SSL::VERIFY_NONE, verify_hostname: false)
+    end
+  end
+
   describe "#run(requests)" do
     before do
-      @entry_response = Typhoeus::Response.new :code => 200, :body => "entry"
-      @users_response = Typhoeus::Response.new :code => 200, :body => "users"
-
-      Typhoeus.stub(entry_url, method: :get){ @entry_response }
-      Typhoeus.stub(users_url, method: :get){ @users_response }
+      stub_request(:get, entry_url).to_return(status: 200, body: "entry")
+      stub_request(:get, users_url).to_return(status: 200, body: "users")
     end
-    it "executes requests in parallel" do
-      Typhoeus::Hydra.hydra.should_receive(:run).once
-      subject.run subject.get([entry_url, users_url])
+
+    it "submits the requests together to HTTPX" do
+      requests = subject.get([entry_url, users_url])
+      expect(subject.instance_variable_get(:@session)).to receive(:request).with(*requests).and_call_original
+      subject.run requests
     end
+
     it "returns responses" do
       responses = subject.run subject.get([entry_url, users_url])
-      responses.should =~ [@entry_response, @users_response]
+      expect(responses.map(&:body)).to match_array(["entry", "users"])
     end
-    it "requests response is filled in" do
+
+    it "fills in each request response" do
       requests = subject.get([entry_url, users_url])
       subject.run requests
-      requests[0].response.should == @entry_response
-      requests[1].response.should == @users_response
+      expect(requests.map{|request| request.response.body}).to eq(["entry", "users"])
     end
   end
+
   describe "#invalid_code(response)" do
     it "raises Harpy::ClientTimeout on request timeout" do
-      lambda {
-        subject.invalid_code double("Response", :timed_out? => true)
-      }.should raise_error Harpy::ClientTimeout
+      error = HTTPX::RequestTimeoutError.new(nil, nil, 1)
+      expect {
+        subject.invalid_code httpx_error_response(error)
+      }.to raise_error Harpy::ClientTimeout
     end
-    it "raises Harpy::ClientError on code 0" do
-      lambda {
-        subject.invalid_code double("Response", :timed_out? => false, :code => 0, :return_message => "Could not connect to server")
-      }.should raise_error Harpy::ClientError, "Could not connect to server"
+
+    it "raises Harpy::ClientError on transport error" do
+      error = HTTPX::ConnectionError.new("Could not connect to server")
+      expect {
+        subject.invalid_code httpx_error_response(error)
+      }.to raise_error Harpy::ClientError, "Could not connect to server"
     end
+
     it "raises Harpy::InvalidResponseCode with code otherwise" do
-      lambda {
-        subject.invalid_code double("Response", :timed_out? => false, :code => 404)
-      }.should raise_error Harpy::InvalidResponseCode, "404"
+      expect {
+        subject.invalid_code httpx_response(:code => 404)
+      }.to raise_error Harpy::InvalidResponseCode, "404"
     end
   end
 end

data/spec/harpy/entry_point_spec.rb

@@ -5,29 +5,29 @@ describe Harpy::EntryPoint do
   subject { Harpy::EntryPoint.new url}
 
   it "should store url" do
-    subject.url.should == url
+    expect(subject.url).to eq(url)
   end
 
   describe "#resource_url(resource_type)" do
     let(:company_url) { "#{url}/company"}
     let(:json_response) { %Q|{"link": [{"rel": "company", "href": "#{company_url}"}]}| }
-    let(:success_response) {  Typhoeus::Response.new :code => 200, :body => json_response }
-    let(:error_response) {  Typhoeus::Response.new :code => 500 }
+    let(:success_response) {  httpx_response :code => 200, :body => json_response }
+    let(:error_response) {  httpx_response :code => 500 }
     it "gets entry point from url using client" do
-      Harpy.client.should_receive(:get).with(url).and_return success_response
+      expect(Harpy.client).to receive(:get).with(url).and_return success_response
       subject.resource_url "user"
     end
     it "return nil if no link for resource_type" do
-      Harpy.client.should_receive(:get).with(url).and_return success_response
-      subject.resource_url("user").should be_nil
+      expect(Harpy.client).to receive(:get).with(url).and_return success_response
+      expect(subject.resource_url("user")).to be_nil
     end
     it "return url for existing resource_type" do
-      Harpy.client.should_receive(:get).with(url).and_return success_response
-      subject.resource_url("company_url").should be_nil
+      expect(Harpy.client).to receive(:get).with(url).and_return success_response
+      expect(subject.resource_url("company_url")).to be_nil
     end
     it "delegates response code != 200 to client" do
-      Harpy.client.should_receive(:get).with(url).and_return error_response
-      Harpy.client.should_receive(:invalid_code).with error_response
+      expect(Harpy.client).to receive(:get).with(url).and_return error_response
+      expect(Harpy.client).to receive(:invalid_code).with error_response
       subject.resource_url("company_url")
     end
   end
@@ -35,20 +35,20 @@ describe Harpy::EntryPoint do
   describe "#urn(urn)" do
     let(:urn) { "urn:harpy:company:1" }
     let(:company_url) { "#{url}/company/1"}
-    let(:success_response) {  Typhoeus::Response.new :code => 301, :headers => "Location: #{company_url}" }
-    let(:error_response) {  Typhoeus::Response.new :code => 500 }
-    let(:not_found_response) {  Typhoeus::Response.new :code => 404 }
+    let(:success_response) {  httpx_response :code => 301, :headers => "Location: #{company_url}" }
+    let(:error_response) {  httpx_response :code => 500 }
+    let(:not_found_response) {  httpx_response :code => 404 }
     it "query remote for this urn using client" do
-      Harpy.client.should_receive(:get).with("#{url}/#{urn}").and_return success_response
-      subject.urn(urn).should == company_url
+      expect(Harpy.client).to receive(:get).with("#{url}/#{urn}").and_return success_response
+      expect(subject.urn(urn)).to eq(company_url)
     end
     it "return nil if not found" do
-      Harpy.client.should_receive(:get).with("#{url}/#{urn}").and_return not_found_response
-      subject.urn(urn).should be_nil
+      expect(Harpy.client).to receive(:get).with("#{url}/#{urn}").and_return not_found_response
+      expect(subject.urn(urn)).to be_nil
     end
     it "delegates response code != 301 or 404 to client" do
-      Harpy.client.should_receive(:get).with("#{url}/#{urn}").and_return error_response
-      Harpy.client.should_receive(:invalid_code).with error_response
+      expect(Harpy.client).to receive(:get).with("#{url}/#{urn}").and_return error_response
+      expect(Harpy.client).to receive(:invalid_code).with error_response
       subject.urn(urn)
     end
   end