songkick-transport 1.2.0 → 1.9.0

data/spec/songkick/transport/response_spec.rb

@@ -9,11 +9,11 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 200, {"Content-Type" => "application/json; charset=utf-8"}, '{"hello":"world"}') }
     
     it "is an OK" do
-      response.should be_a(Songkick::Transport::Response::OK)
+      expect(response).to be_a(Songkick::Transport::Response::OK)
     end
     
     it "exposes its data" do
-      response.data.should == {"hello" => "world"}
+      expect(response.data).to eq({"hello" => "world"})
     end
   end
   
@@ -21,11 +21,11 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 200, {"Content-Type" => "application/json"}, "{\"hello\":\"world\"\n\n}") }
     
     it "is an OK" do
-      response.should be_a(Songkick::Transport::Response::OK)
+      expect(response).to be_a(Songkick::Transport::Response::OK)
     end
     
     it "exposes its data" do
-      response.data.should == {"hello" => "world"}
+      expect(response.data).to eq({"hello" => "world"})
     end
   end
   
@@ -33,7 +33,7 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 200, {"Content-Type" => "application/json"}, {"hello" => "world"}) }
     
     it "exposes its data" do
-      response.data.should == {"hello" => "world"}
+      expect(response.data).to eq({"hello" => "world"})
     end
   end
   
@@ -41,7 +41,7 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 200, {}, "") }
     
     it "exposes its data" do
-      response.data.should be_nil
+      expect(response.data).to be_nil
     end
   end
   
@@ -49,7 +49,7 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 201, {}, "") }
     
     it "is a Created" do
-      response.should be_a(Songkick::Transport::Response::Created)
+      expect(response).to be_a(Songkick::Transport::Response::Created)
     end
   end
   
@@ -57,7 +57,7 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 204, {}, "") }
     
     it "is a NoContent" do
-      response.should be_a(Songkick::Transport::Response::NoContent)
+      expect(response).to be_a(Songkick::Transport::Response::NoContent)
     end
   end
   
@@ -65,11 +65,11 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 409, {"Content-Type" => "application/json"}, '{"errors":[]}') }
     
     it "is a UserError" do
-      response.should be_a(Songkick::Transport::Response::UserError)
+      expect(response).to be_a(Songkick::Transport::Response::UserError)
     end
     
     it "exposes the errors" do
-      response.errors.should == []
+      expect(response.errors).to eq([])
     end
   end
 
@@ -77,11 +77,11 @@ describe Songkick::Transport::Response do
     let(:response) { process("", 422, {"Content-Type" => "application/json"}, '{"errors":[]}', [409, 422]) }
     
     it "is a UserError" do
-      response.should be_a(Songkick::Transport::Response::UserError)
+      expect(response).to be_a(Songkick::Transport::Response::UserError)
     end
     
     it "exposes the errors" do
-      response.errors.should == []
+      expect(response.errors).to eq([])
     end
   end
 end

data/spec/songkick/transport/service_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe Songkick::Transport::Service do
+  let(:http) { double(described_class::DEFAULT_TRANSPORT) }
+
+  before do
+    described_class.set_endpoints 'foo' => 'nonsuch:1111'
+    described_class.user_agent described_class.to_s
+
+    allow(described_class::DEFAULT_TRANSPORT).to receive(:new).and_return(http)
+    allow(http).to receive(:with_headers).and_return(http)
+  end
+
+  describe "given a Service class hierarchy" do
+    class A < Songkick::Transport::Service
+      endpoint :foo
+    end
+
+    class B < A
+      endpoint :foo
+    end
+
+    it "should inherit headers all the way down the class hierarchy" do
+      Songkick::Transport::Service.with_headers "S" => "sss"
+      B.with_headers "B" => "bbb"
+      A.with_headers "A" => "aaa"
+
+      expect(http).to receive(:with_headers).with("S" => "sss", "B" => "bbb", "A" => "aaa")
+      B.new.http
+    end
+
+    it "can change headers" do
+      Songkick::Transport::Service.with_headers "S" => "sss"
+      Songkick::Transport::Service.with_headers "STS" => "sts"
+      B.with_headers "B" => "bbb"
+      A.with_headers "A" => "aaa"
+
+      expect(http).to receive(:with_headers).with("STS" => "sts", "B" => "bbb", "A" => "aaa")
+      B.new.http
+    end
+
+    context 'with transport layer options' do
+      let(:global_options) { {:foo => 'bar'} }
+      let(:upper_options)  { {:bar => 'baz'} }
+      let(:lower_options)  { {:bar => 'qux'} }
+
+      before do
+        Songkick::Transport::Service.transport_layer_options global_options
+        A.transport_layer_options upper_options
+        B.transport_layer_options lower_options
+      end
+
+      it "global options can be specified and are passed to the transport initializer" do
+        expect(described_class::DEFAULT_TRANSPORT).to receive(:new).with(anything, hash_including(global_options))
+        B.new.http
+      end
+
+      it "options can be specified per-class and are passed to the transport initializer" do
+        expect(described_class::DEFAULT_TRANSPORT).to receive(:new).with(anything, hash_including(upper_options))
+        A.new.http
+      end
+
+      it "options can be overridden per-class and are passed to the transport initializer" do
+        expect(described_class::DEFAULT_TRANSPORT).not_to receive(:new).with(anything, hash_including(upper_options))
+        expect(described_class::DEFAULT_TRANSPORT).to receive(:new).with(anything, hash_including(lower_options))
+        B.new.http
+      end
+    end
+  end
+end

data/spec/songkick/transport_spec.rb

@@ -4,21 +4,21 @@ shared_examples_for "Songkick::Transport" do
   before(:all) { TestApp.listen(4567) }
   after(:all)  { TestApp.stop }
 
-  describe :get do
+  describe "#get" do
     it "retrieves data using GET" do
-      transport.get("/artists/99").data.should == {"id" => 99}
+      expect(transport.get("/artists/99").data).to eq({"id" => 99})
     end
 
     it "exposes the response headers" do
-      transport.get("/artists/99").headers["content-type"].should == "application/json"
+      expect(transport.get("/artists/99").headers["content-type"]).to eq("application/json")
     end
 
     it "can send array params" do
-      transport.get("/", :list => %w[a b]).data.should == {"list" => ["a", "b"]}
+      expect(transport.get("/", :list => %w[a b]).data).to eq({"list" => ["a", "b"]})
     end
 
     it "can send hash params" do
-      transport.get("/", :list => {:a => "b"}).data.should == {"list" => {"a" => "b"}}
+      expect(transport.get("/", :list => {:a => "b"}).data).to eq({"list" => {"a" => "b"}})
     end
 
     it "can send nested data structures" do
@@ -26,92 +26,89 @@ shared_examples_for "Songkick::Transport" do
         "hash" => {"a" => {"b" => ["c", "d"], "e" => "f"}},
         "lisp" => ["define", {"square" => ["x", "y"]}, "*", "x", "x"]
       }
-      transport.get("/", structure).data.should == structure
+      expect(transport.get("/", structure).data).to eq(structure)
     end
 
     it "raises an UpstreamError for a nonexistent resource" do
-      lambda { transport.get("/nothing") }.should raise_error(Songkick::Transport::UpstreamError)
+      expect { transport.get("/nothing") }.to raise_error(Songkick::Transport::UpstreamError)
     end
 
     it "raises an UpstreamError for a POST resource" do
-      lambda { transport.get("/artists") }.should raise_error(Songkick::Transport::UpstreamError)
+      expect { transport.get("/artists") }.to raise_error(Songkick::Transport::UpstreamError)
     end
 
     it "raises an UpstreamError for invalid JSON" do
-      lambda { transport.get("/invalid") }.should raise_error(Songkick::Transport::InvalidJSONError)
+      expect { transport.get("/invalid") }.to raise_error(Songkick::Transport::InvalidJSONError)
     end
+
   end
 
-  describe :with_headers do
+  describe "#with_headers" do
     it "adds the given headers to requests" do
       data = transport.with_headers("Authorization" => "correct password").get("/authenticate").data
-      data.should == {"successful" => true}
+      expect(data).to eq({"successful" => true})
     end
 
     it "reformats Rack-style headers" do
       data = transport.with_headers("HTTP_AUTHORIZATION" => "correct password").get("/authenticate").data
-      data.should == {"successful" => true}
+      expect(data).to eq({"successful" => true})
     end
 
     it "does not affect requests made directly on the transport object" do
       transport.with_headers("Authorization" => "correct password").get("/authenticate")
       data = transport.get("/authenticate").data
-      data.should == {"successful" => false}
+      expect(data).to eq({"successful" => false})
     end
 
     it "can set Content-Type" do
       data = transport.with_headers("Content-Type" => "application/json").post("/content").data
-      data.should == {"type" => "application/json"}
+      expect(data).to eq({"type" => "application/json"})
     end
   end
 
-  describe :options do
+  describe "#options" do
     it "sends an OPTIONS request" do
       response = transport.options("/.well-known/host-meta")
-      response.headers["Access-Control-Allow-Methods"].should == "GET, PUT, DELETE"
+      expect(response.headers["Access-Control-Allow-Methods"]).to eq("GET, PUT, DELETE")
     end
   end
 
-  describe :post do
+  describe "#post" do
     it "sends data using POST" do
       data = transport.post("/artists", :name => "Amon Tobin").data
-      data.should == {"id" => "new", "name" => "AMON TOBIN"}
+      expect(data).to eq({"id" => "new", "name" => "AMON TOBIN"})
     end
 
     it "can send array params" do
-      transport.post("/", :list => %w[a b]).data.should == {"list" => ["a", "b"]}
+      expect(transport.post("/", :list => %w[a b]).data).to eq({"list" => ["a", "b"]})
     end
 
     it "can send hash params" do
-      transport.post("/", :list => {:a => "b"}).data.should == {"list" => {"a" => "b"}}
+      expect(transport.post("/", :list => {:a => "b"}).data).to eq({"list" => {"a" => "b"}})
     end
 
     it "can send a raw body" do
       response = transport.with_headers("Content-Type" => "text/plain").post("/process", "Hello, world!")
-      response.data.should == {"body" => "Hello, world!", "type" => "text/plain"}
+      expect(response.data).to eq({"body" => "Hello, world!", "type" => "text/plain"})
     end
 
     it "raises an UpstreamError for a PUT resource" do
-      lambda { transport.post("/artists/64") }.should raise_error(Songkick::Transport::UpstreamError)
+      expect { transport.post("/artists/64") }.to raise_error(Songkick::Transport::UpstreamError)
     end
   end
 
-  describe :put do
+  describe "#put" do
     it "sends data using PUT" do
       data = transport.put("/artists/64", :name => "Amon Tobin").data
-      data.should == {"id" => 64, "name" => "amon tobin"}
+      expect(data).to eq({"id" => 64, "name" => "amon tobin"})
     end
 
     it "raises an UpstreamError for a POST resource" do
-      lambda{transport.put("/artists")}.should raise_error(Songkick::Transport::UpstreamError)
+      expect{transport.put("/artists")}.to raise_error(Songkick::Transport::UpstreamError)
     end
   end
 
   describe "file uploads" do
-    before do
-      pending if Songkick::Transport::RackTest === transport
-    end
-
     after { file.close }
 
     let(:file)   { File.open(File.expand_path("../../songkick.png", __FILE__)) }
@@ -131,20 +128,78 @@ shared_examples_for "Songkick::Transport" do
     end
 
     it "uploads files using POST" do
-      @http_method = "post"
-      response = transport.post('/upload', params)
-      response.status.should == 200
-      response.data.should == expected_response
+      if Songkick::Transport::RackTest === transport
+      else
+        @http_method = "post"
+        response = transport.post('/upload', params)
+        expect(response.status).to eq(200)
+        expect(response.data).to eq(expected_response)
+      end
     end
 
     it "uploads files using PUT" do
-      @http_method = "put"
-      response = transport.put('/upload', params)
-      response.status.should == 200
-      response.data.should == expected_response
+      if Songkick::Transport::RackTest === transport
+      else
+        @http_method = "put"
+        response = transport.put('/upload', params)
+        expect(response.status).to eq(200)
+        expect(response.data).to eq(expected_response)
+      end
     end
   end
 
+  describe 'instrumentation' do
+    let(:events) { [] }
+    let(:options) { { :instrumenter => ActiveSupport::Notifications } }
+
+    around do |example|
+      label = options[:instrumentation_label] || Songkick::Transport::Base::DEFAULT_INSTRUMENTATION_LABEL
+      options[:instrumenter].subscribed(subscriber, label) do
+        example.run
+      end
+    end
+
+    let(:subscriber) do
+      lambda { |*args| events << options[:instrumenter]::Event.new(*args) }
+    end
+
+    context 'for a successful request' do
+      let(:path) { '/artists/123' }
+
+      let(:expected_payload) do
+        hash_including(:adapter => /#{described_class.to_s}/,
+                       :path => path, :endpoint => transport.endpoint,
+                       :params => {}, :verb => 'get', :status => 200,
+                       :request_headers => an_instance_of(Hash),
+                       :response_headers => an_instance_of(Hash))
+      end
+
+
+      it 'instruments the request' do
+        transport.get(path)
+        expect(events.last.payload).to match(expected_payload)
+      end
+    end
+
+    context 'for an unsuccessful request' do
+      let(:path) { '/nothing' }
+
+      let(:expected_payload) do
+        hash_including(:adapter => /#{described_class.to_s}/,
+                       :path => path, :endpoint => transport.endpoint,
+                       :params => {}, :verb => 'post', :status => 404,
+                       :request_headers => an_instance_of(Hash),
+                       :response_headers => an_instance_of(Hash))
+      end
+
+      it 'instruments the request' do
+        expect { transport.post(path) }.to raise_error(Songkick::Transport::UpstreamError)
+        expect(events.last.payload).to match(expected_payload)
+      end
+    end
+
+  end
+
   describe "reporting" do
     before do
       Songkick::Transport::Reporting.start
@@ -152,36 +207,36 @@ shared_examples_for "Songkick::Transport" do
     end
 
     it "executes a block and returns its value" do
-      @report.execute { transport.get("/artists/99").data }.should == {"id" => 99}
+      expect(@report.execute { transport.get("/artists/99").data }).to eq({"id" => 99})
     end
 
     it "reports a successful request" do
       @report.execute { transport.get("/artists/99") }
-      @report.size.should == 1
+      expect(@report.size).to eq(1)
 
       request = @report.first
-      request.endpoint.should == endpoint
-      request.http_method.should == "get"
-      request.path.should == "/artists/99"
-      request.response.data.should == {"id" => 99}
+      expect(request.endpoint).to eq(endpoint)
+      expect(request.http_method).to eq("get")
+      expect(request.path).to eq("/artists/99")
+      expect(request.response.data).to eq({"id" => 99})
     end
 
     it "reports a failed request" do
       @report.execute { transport.get("/invalid") } rescue nil
-      @report.size.should == 1
+      expect(@report.size).to eq(1)
 
       request = @report.first
-      request.http_method.should == "get"
-      request.path.should == "/invalid"
-      request.response.should == nil
-      request.error.should be_a(Songkick::Transport::InvalidJSONError)
+      expect(request.http_method).to eq("get")
+      expect(request.path).to eq("/invalid")
+      expect(request.response).to eq(nil)
+      expect(request.error).to be_a(Songkick::Transport::InvalidJSONError)
     end
 
     it "reports the total duration" do
       @report.execute { transport.get("/artists/99") }
       request = @report.first
-      request.stub(:duration).and_return 3.14
-      @report.total_duration.should == 3.14
+      allow(request).to receive(:duration).and_return 3.14
+      expect(@report.total_duration).to eq(3.14)
     end
   end
 
@@ -190,30 +245,85 @@ shared_examples_for "Songkick::Transport" do
 
     it "can be provided on initialization" do
       transport = described_class.new(endpoint, :user_error_codes => codes)
-      transport.user_error_codes.should == codes
+      expect(transport.user_error_codes).to eq(codes)
     end
 
     it "default to 409" do
-      transport.user_error_codes.should == [409]
+      expect(transport.user_error_codes).to eq([409])
     end
   end
+
 end
 
-describe Songkick::Transport::Curb do
-  let(:endpoint)  { "http://localhost:4567" }
-  let(:transport) { Songkick::Transport::Curb.new(endpoint) }
-  it_should_behave_like "Songkick::Transport"
+# Curb always times out talking to the web server in the other thread when run on 1.8
+unless RUBY_VERSION =~ /^1.8/
+  describe Songkick::Transport::Curb do
+    let(:options)   { {} }
+    let(:endpoint)  { "http://localhost:4567" }
+    let(:transport) { described_class.new(endpoint, options) }
+    it_should_behave_like "Songkick::Transport"
+  end
 end
 
 describe Songkick::Transport::HttParty do
+  let(:options)   { {} }
   let(:endpoint)  { "http://localhost:4567" }
-  let(:transport) { Songkick::Transport::HttParty.new(endpoint) }
+  let(:transport) { described_class.new(endpoint, options) }
   it_should_behave_like "Songkick::Transport"
 end
 
 describe Songkick::Transport::RackTest do
+  let(:options)   { {} }
   let(:endpoint)  { TestApp }
-  let(:transport) { Songkick::Transport::RackTest.new(endpoint) }
+  let(:transport) { described_class.new(endpoint, options) }
   it_should_behave_like "Songkick::Transport"
 end
 
+describe Songkick::Transport do
+  describe "registering parsers" do
+    context "for JSON" do
+      it 'should use the JSON parser' do
+        expect(described_class.parser_for('application/json')).to eq(Yajl::Parser)
+      end
+    end
+
+    context "for anything else" do
+      context 'when there is no registered parser' do
+        it 'should raise an error' do
+          expect { described_class.parser_for('application/xml') }.to raise_error(TypeError)
+        end
+      end
+
+      context 'when there is a registered parser' do
+        before do
+          described_class.register_parser('application/xml', :my_parser)
+        end
+
+        it 'should return that parser' do
+          expect(described_class.parser_for('application/xml')).to eq(:my_parser)
+        end
+
+        context 'when there is no registered parser' do
+          it 'should raise an error' do
+            expect { described_class.parser_for('application/x-something-else') }.to raise_error(TypeError)
+          end
+        end
+
+        context 'when there is a default registered parser' do
+          before do
+            described_class.register_default_parser(:my_default_parser)
+          end
+
+          it 'should return that parser' do
+            expect(described_class.parser_for('application/x-something-else')).to eq(:my_default_parser)
+          end
+
+          it 'should return the already defined parser if specified' do
+            expect(described_class.parser_for('application/xml')).to eq(:my_parser)
+            expect(described_class.parser_for('application/json')).to eq(Yajl::Parser)
+          end
+        end
+      end
+    end
+  end
+end