quiz_api_client 4.2.0 → 4.4.0

data/spec/contracts/shared_examples/http_put_example.rb

@@ -0,0 +1,60 @@
+shared_examples 'a http put request to quiz_api' do
+  let(:quizzes_api_path) { raise 'Override in spec' }
+  let(:consumer_key) { 'consumer key' }
+  let(:consumer_request_id) { 'consumer request id' }
+  let(:host) { 'localhost:1234' }
+  let(:shared_secret) { 'secret' }
+  let(:scope) { raise 'Override in spec' }
+  let(:resource_id) { nil }
+  let(:response_body) { raise 'Override in spec' }
+  let(:service_name) { raise 'Override in spec' }
+  let(:status) { 200 }
+  let(:provider_state) { raise 'Override in spec' }
+  let(:user) { nil }
+  let(:params) { raise 'Override in spec' }
+  let(:body) { raise 'Override in spec' }
+  let(:request_description) { raise 'Override in spec (must be unique!)' }
+
+  let(:client) do
+    QuizApiClient::Client.new(
+      consumer_key: consumer_key,
+      consumer_request_id: consumer_request_id,
+      host: host,
+      shared_secret: shared_secret,
+      protocol: 'http'
+    )
+  end
+
+  context 'updating a resource' do
+    let(:token) do
+      client.jwt_service.grant_permission(
+        exp: token_expiration_one_year,
+        scope: scope,
+        uuid: user,
+        resource_id: resource_id
+      )
+    end
+
+    before do
+      quiz_api
+        .given(provider_state)
+        .upon_receiving(request_description)
+        .with(
+          method: :put,
+          path: quizzes_api_path,
+          headers: headers(token),
+          body: body
+        )
+        .will_respond_with(
+          status: status,
+          headers: { 'Content-Type' => 'application/json; charset=utf-8' },
+          body: response_body
+        )
+    end
+
+    it 'verifies the request is valid' do
+      result = client.send(service_name).update(token: token, params: params)
+      expect(result).to be_truthy
+    end
+  end
+end

data/spec/http_client_spec.rb

@@ -0,0 +1,347 @@
+describe QuizApiClient::HttpClient do
+  let(:uri) { 'http://api.quiz.docker' }
+  let(:jwt) { JWT.encode({ jwt: 'payload' }, 'secret') }
+  let(:default_request_data) { client.send(:default_request_data) }
+  let(:config) { QuizApiClient::Config.new { |c| c.consumer_request_id = 'hi' } }
+
+  subject(:client) { QuizApiClient::HttpClient.new(uri: uri, jwt: jwt, config: config) }
+
+  def url_for_path(path)
+    "http://api.quiz.docker#{path}"
+  end
+
+  def stub_quiz_api(path, item: 1, query: {}, headers: {}, status: 200)
+    stub_request(:get, url_for_path(path))
+      .with(query: query)
+      .to_return(
+        body: [item].to_json,
+        status: status,
+        headers: headers.merge(
+          'Content-Type' => 'application/json'
+        )
+      )
+  end
+
+  def link_header(path, page, last_page)
+    link_header = "<http://api.quiz.docker#{path}?page=#{last_page}>; rel=\"last\""
+    link_header += ", <http://api.quiz.docker#{path}?page=#{page + 1}>; rel=\"next\"" if page < last_page
+    link_header
+  end
+
+  def mock_time(duration)
+    mock = Time.now
+    allow(Time).to receive(:now).and_return(mock, mock + duration)
+    mock
+  end
+
+  def mock_metrics(mock_time)
+    mock = instance_double(QuizApiClient::HttpRequest::Metrics)
+    expect(mock).to receive(:increment)
+    expect(mock).to receive(:duration).with(mock_time, mock_time + 10)
+    mock
+  end
+
+  def expect_metrics_calls(config, method, url, code)
+    expect(QuizApiClient::HttpRequest::Metrics).to receive(:new)
+      .with(config, method, url, code)
+      .and_return(mock_metrics(mock_time(10)))
+  end
+
+  def expect_raise_error_call(config, method, url, response, current_error)
+    mock_failure = instance_double(QuizApiClient::HttpRequest::Failure)
+
+    expect(QuizApiClient::HttpRequest::Failure).to receive(:new).with(config).and_return(mock_failure)
+
+    expect(mock_failure).to(
+      receive(:raise_error)
+        .with(method, url, response: response, current_error: current_error)
+        .and_raise(QuizApiClient::HttpClient::RequestFailed.new(:context))
+    )
+  end
+
+  it { is_expected.to be_a HTTParty }
+
+  describe 'get' do
+    it 'makes a get request' do
+      path = '/api/quizzes'
+      stub_quiz_api path, query: { sort: 'alpha' }
+      expect_metrics_calls(client.config, :get, url_for_path(path), 200)
+      response = client.get(path, all: false, query: { sort: 'alpha' })
+      expect(response.parsed_response).to eq [1]
+    end
+
+    describe 'all' do
+      it 'retrieves single page when all is true' do
+        stub_quiz_api '/api/quizzes'
+        expect(client.get('/api/quizzes', all: true)).to eq [1]
+      end
+
+      context 'link pagination' do
+        it 'retrieves subsequent pages when all is true' do
+          path = '/api/quizzes'
+          stub_quiz_api path, headers: { link: link_header(path, 1, 2) }
+          stub_quiz_api path, item: 2, query: { page: 2 }, headers: { link: link_header(path, 2, 2) }
+          expect(client.get('/api/quizzes', all: true)).to eq [1, 2]
+        end
+      end
+
+      context 'dynamo pagination' do
+        let(:dynamo_headers) { { 'x-last-evaluated-hash-key' => 'foo', 'x-last-evaluated-range-key' => 'bar' } }
+        let(:dynamo_params) { { last_evaluated_hash_key: 'foo', last_evaluated_range_key: 'bar' } }
+
+        it 'retrieves subsequent pages when all is true' do
+          path = '/api/quizzes'
+          stub_quiz_api path, headers: dynamo_headers
+          stub_quiz_api path, item: 2, query: dynamo_params
+          expect(client.get('/api/quizzes', all: true)).to eq [1, 2]
+        end
+
+        it 'retrieves subsequent pages when all is true and query is present' do
+          path = '/api/quizzes'
+          stub_quiz_api path, query: { my_id: 12 }, headers: dynamo_headers
+          stub_quiz_api path, item: 2, query: { my_id: 12, **dynamo_params }
+          expect(client.get('/api/quizzes', query: { my_id: 12 }, all: true)).to eq [1, 2]
+        end
+      end
+    end
+  end
+
+  describe 'post' do
+    it 'makes a post request' do
+      url = 'http://api.quiz.docker/api/quizzes'
+      expect(client.class).to receive(:post).with(
+        url,
+        body: { title: 'ohai' }.to_json,
+        **default_request_data
+      ).and_return(instance_double('HTTParty::Response', success?: true, code: 200))
+      expect_metrics_calls(client.config, :post, url, 200)
+      client.post('/api/quizzes', title: 'ohai')
+    end
+  end
+
+  describe 'patch' do
+    it 'makes a patch request' do
+      url = 'http://api.quiz.docker/api/quizzes/1'
+      expect(client.class).to receive(:patch).with(
+        url,
+        body: { title: 'new title' }.to_json,
+        **default_request_data
+      ).and_return(instance_double('HTTParty::Response', success?: true, code: 200))
+      expect_metrics_calls(client.config, :patch, url, 200)
+      client.patch('/api/quizzes/1', title: 'new title')
+    end
+  end
+
+  describe 'put' do
+    it 'makes a put request' do
+      url = 'http://api.quiz.docker/api/quizzes/1'
+      expect(client.class).to receive(:put).with(
+        url,
+        body: { title: 'new title' }.to_json,
+        **default_request_data
+      ).and_return(instance_double('HTTParty::Response', success?: true, code: 200))
+      expect_metrics_calls(client.config, :put, url, 200)
+      client.put('/api/quizzes/1', title: 'new title')
+    end
+  end
+
+  describe 'delete' do
+    it 'makes a delete request' do
+      url = 'http://api.quiz.docker/api/quizzes/1'
+      expect(client.class).to receive(:delete).with(
+        url,
+        **default_request_data
+      ).and_return(instance_double('HTTParty::Response', success?: true, code: 200))
+      expect_metrics_calls(client.config, :delete, url, 200)
+      client.delete('/api/quizzes/1')
+    end
+  end
+
+  describe 'headers' do
+    it 'includes the correct headers' do
+      expect(default_request_data[:headers]).to eq(
+        'Authorization' => jwt,
+        'AuthType' => 'Signature',
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json',
+        'X-Consumer-Request-Id' => 'hi'
+      )
+    end
+  end
+
+  describe '#successful_response?' do
+    it 'returns true if the response is successful' do
+      resp = instance_double('HTTParty::Response', success?: true)
+      expect(client.send(:successful_response?, resp)).to be_truthy
+    end
+
+    it 'returns true if the response code is 401' do
+      resp = instance_double('HTTParty::Response', success?: false, code: 401)
+      expect(client.send(:successful_response?, resp)).to be_truthy
+    end
+
+    it 'returns false if the response is not successful' do
+      resp = instance_double('HTTParty::Response', success?: false, code: 404)
+      expect(client.send(:successful_response?, resp)).to be_falsey
+    end
+  end
+
+  describe 'error handling' do
+    context 'with :sentry_raven error handler' do
+      let(:error_handler) { :sentry_raven }
+      let(:path) { '/' }
+      let(:url) { "http://api.quiz.docker#{path}" }
+      let(:error_context) do
+        {
+          quiz_api_client: {
+            request: {
+              method: :get,
+              url: url
+            }
+          }
+        }
+      end
+
+      before do
+        client.config.error_handler = error_handler
+      end
+
+      context 'with non-success responses' do
+        let(:body) { '[2]' }
+        let(:code) { 404 }
+        let(:path) { '/api/quizzes' }
+        let(:context_url) { url }
+        let(:method) { :get }
+        let(:error_context) do
+          {
+            quiz_api_client: {
+              request: {
+                method: method,
+                url: context_url
+              },
+              response: {
+                body: body,
+                code: code
+              }
+            }
+          }
+        end
+        let(:mock_response) do
+          instance_double(
+            'HTTParty::Response',
+            success?: false,
+            body: body,
+            code: code
+          )
+        end
+        let(:success_response) do
+          # rubocop:disable Metrics/LineLength
+          instance_double(
+            'HTTParty::Response',
+            body: body,
+            code: 200,
+            parsed_response: [1],
+            headers: {
+              'link' => '<http://api.quiz.docker/api/quizzes?page=2>; rel="last", <http://api.quiz.docker/api/quizzes?page=2>; rel="next"',
+              'content-type' => ['application/json']
+            }
+          )
+          # rubocop:enable Metrics/LineLength
+        end
+
+        context ':get request' do
+          it 'raises error' do
+            expect(client).to receive(:successful_response?).with(mock_response).and_return(false)
+            expect(client.class).to receive(:get).and_return(mock_response)
+            expect_metrics_calls(client.config, method, url_for_path(path), code)
+            expect_raise_error_call(client.config, method, url_for_path(path), mock_response, nil)
+            expect { client.get(path, all: false, query: { sort: 'alpha' }) }
+              .to raise_error(QuizApiClient::HttpClient::RequestFailed)
+          end
+        end
+
+        context ':post request' do
+          let(:method) { :post }
+
+          it 'raises error' do
+            expect(client).to receive(:successful_response?).with(mock_response).and_return(false)
+            expect(client.class).to receive(:post).and_return(mock_response)
+            expect_metrics_calls(client.config, method, url_for_path(path), code)
+            expect_raise_error_call(client.config, method, url_for_path(path), mock_response, nil)
+            expect { client.post(path) }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+          end
+        end
+
+        context ':put request' do
+          let(:method) { :put }
+
+          it 'raises error' do
+            expect(client).to receive(:successful_response?).with(mock_response).and_return(false)
+            expect(client.class).to receive(:put).and_return(mock_response)
+            expect_metrics_calls(client.config, method, url_for_path(path), code)
+            expect_raise_error_call(client.config, method, url_for_path(path), mock_response, nil)
+            expect { client.put(path) }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+          end
+        end
+
+        context ':patch request' do
+          let(:method) { :patch }
+
+          it 'raises error' do
+            expect(client).to receive(:successful_response?).with(mock_response).and_return(false)
+            expect(client.class).to receive(:patch).and_return(mock_response)
+            expect_metrics_calls(client.config, method, url_for_path(path), code)
+            expect_raise_error_call(client.config, method, url_for_path(path), mock_response, nil)
+            expect { client.patch(path) }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+          end
+        end
+
+        context ':delete request' do
+          let(:method) { :delete }
+
+          it 'raises error' do
+            expect(client).to receive(:successful_response?).with(mock_response).and_return(false)
+            expect(client.class).to receive(:delete).and_return(mock_response)
+            expect_metrics_calls(client.config, method, url_for_path(path), code)
+            expect_raise_error_call(client.config, method, url_for_path(path), mock_response, nil)
+            expect { client.delete(path) }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+          end
+        end
+
+        context 'with pagination' do
+          let(:context_url) { "#{url}?page=2" }
+
+          it 'raises error if one of the linked pages does not return 200 response' do
+            stub_quiz_api path, headers: { link: link_header(path, 1, 2) }
+            stub_quiz_api path, item: 2, query: { page: 2 }, headers: { link: link_header(path, 2, 2) }, status: code
+            allow(HTTParty::Response).to receive(:new).and_return(success_response, mock_response)
+            expect(client).to receive(:successful_response?).and_return(true, false).twice
+            expect_raise_error_call(client.config, method, context_url, mock_response, nil)
+            expect { client.get('/api/quizzes', all: true) }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+          end
+        end
+      end
+
+      it 'handles an HTTParty::Error error' do
+        stub_request(:get, url).to_raise(HTTParty::Error)
+        expect_metrics_calls(client.config, :get, url_for_path(path), 0)
+        expect_raise_error_call(client.config, :get, url_for_path(path), nil, kind_of(HTTParty::Error))
+        expect { client.get('/') }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+      end
+
+      it 'handles an Errno::ECONNREFUSED error' do
+        stub_request(:get, url).to_raise(Errno::ECONNREFUSED)
+        expect_metrics_calls(client.config, :get, url_for_path(path), 0)
+        expect_raise_error_call(client.config, :get, url_for_path(path), nil, kind_of(Errno::ECONNREFUSED))
+        expect { client.get('/') }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+      end
+
+      it 'handles an Net::ReadTimeout error' do
+        stub_request(:get, url).to_raise(Net::ReadTimeout)
+        expect_metrics_calls(client.config, :get, url_for_path(path), 0)
+        expect_raise_error_call(client.config, :get, url_for_path(path), nil, kind_of(Net::ReadTimeout))
+        expect { client.get('/') }.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+      end
+    end
+  end
+end

data/spec/json_formatter_spec.rb

@@ -0,0 +1,32 @@
+describe QuizApiClient::JSONFormatter do
+  let(:logger) { double('logger') }
+  let(:level) { :info }
+  let(:uri) { 'uri_here' }
+  let(:request) do
+    r = double('request')
+    allow(r).to receive(:last_uri) { uri }
+    r
+  end
+  let(:status_code) { 200 }
+  let(:request_id) { 'request_id' }
+  let(:response) do
+    r = double('response')
+    allow(r).to receive(:code) { status_code }
+    allow(r).to receive(:headers) { { 'x-request-id' => [request_id] } }
+    r
+  end
+
+  subject(:formatter) { QuizApiClient::JSONFormatter.new(logger, level) }
+
+  describe 'logging formatter' do
+    it 'processes logging calls into a JSON format' do
+      expect(logger).to receive(level).with(
+        client_request_id: request_id,
+        request_url: uri,
+        response_code: status_code
+      )
+
+      formatter.format(request, response)
+    end
+  end
+end

data/spec/quiz_api_client/http_request/failure_spec.rb

@@ -0,0 +1,100 @@
+require 'sentry-raven'
+
+describe QuizApiClient::HttpRequest::Failure do
+  let(:config) { QuizApiClient::Config.new }
+  let(:method) { 'GET' }
+  let(:url) { 'https://something.com' }
+  let(:response_code) { 500 }
+  let(:response_body) { 'I am a response body!' }
+  let(:response) { instance_double('HTTParty::Response', code: response_code, body: response_body) }
+
+  subject { described_class.new(config) }
+
+  describe '#raise_error' do
+    it 'raises the QuizApiClient::HttpClient::RequestFailed error' do
+      expect do
+        subject.raise_error(method, url)
+      end.to raise_error(QuizApiClient::HttpClient::RequestFailed)
+    end
+
+    context 'when there is a current exception' do
+      let(:error_context) do
+        {
+          quiz_api_client: {
+            request: {
+              method: method,
+              url: url
+            }
+          }
+        }
+      end
+      let(:current_error_message) { 'standard error message' }
+      let(:current_error) { StandardError.new(current_error_message) }
+      let(:raise_error_call) { -> { subject.raise_error(method, url, current_error: current_error) } }
+
+      it 'sets the context on the error' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.context).to eq error_context
+        end
+      end
+
+      it 'sets the error message' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.message).to eq current_error_message
+        end
+      end
+
+      context 'when error_handler is set to :sentry_raven' do
+        before do
+          config.error_handler = :sentry_raven
+        end
+
+        it 'sets the Raven context to the context on the error' do
+          expect(Raven).to receive(:extra_context).with(error_context)
+          expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed)
+        end
+      end
+    end
+
+    context 'when there is a response' do
+      let(:error_context) do
+        {
+          quiz_api_client: {
+            request: {
+              method: method,
+              url: url
+            },
+            response: {
+              body: response_body,
+              code: response_code
+            }
+          }
+        }
+      end
+      let(:raise_error_call) { -> { subject.raise_error(method, url, response: response) } }
+
+      it 'sets the context on the error' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.context).to eq error_context
+        end
+      end
+
+      it 'sets the error message' do
+        expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed) do |error|
+          expect(error.message).to eq "#{url} responded #{response_body} (#{response_code})"
+        end
+      end
+
+      context 'when error_handler is set to :sentry_raven' do
+        before do
+          config.error_handler = :sentry_raven
+        end
+
+        it 'sets the Raven context to the context on the error' do
+          expect(Raven).to receive(:extra_context).with(error_context)
+          expect(raise_error_call).to raise_error(QuizApiClient::HttpClient::RequestFailed)
+        end
+      end
+    end
+  end
+end

data/spec/quiz_api_client/http_request/metrics_spec.rb

@@ -0,0 +1,75 @@
+require 'inst_statsd'
+
+describe QuizApiClient::HttpRequest::Metrics do
+  let(:config) { QuizApiClient::Config.new }
+  let(:method) { 'GET' }
+  let(:url) { 'https://something.com' }
+  let(:code) { 200 }
+
+  subject { described_class.new(config, method, url, code) }
+
+  describe '#increment' do
+    it 'does nothing when the metrics handler is nil' do
+      allow(config).to receive(:metrics_handler).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:increment).never
+
+      subject.increment
+    end
+
+    it 'does nothing when the metrics namespace is nil' do
+      allow(config).to receive(:metrics_namespace).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:increment).never
+
+      subject.increment
+    end
+
+    it 'calls the #increment method for InstStatsd' do
+      config.setup_metrics(:inststatsd, 'fake-namespace')
+      expect(InstStatsd::Statsd).to receive(:increment).with(
+        'fake-namespace.quiz_api_client.request.count',
+        tags: {
+          method: method,
+          status: code,
+          url: url
+        }
+      )
+
+      subject.increment
+    end
+  end
+
+  describe '#duration' do
+    let(:duration_in_secs) { 10 }
+    let(:start_time) { Time.parse('2021-11-09 15:11:48 -0500') }
+    let(:end_time) { start_time + duration_in_secs }
+
+    it 'does nothing when the metrics handler is nil' do
+      allow(config).to receive(:metrics_handler).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:timing).never
+
+      subject.duration(start_time, end_time)
+    end
+
+    it 'does nothing when the metrics namespace is nil' do
+      allow(config).to receive(:metrics_namespace).and_return(nil)
+      expect(InstStatsd::Statsd).to receive(:timing).never
+
+      subject.duration(start_time, end_time)
+    end
+
+    it 'calls the #timing method for InstStatsd' do
+      config.setup_metrics(:inststatsd, 'fake-namespace')
+      expect(InstStatsd::Statsd).to receive(:timing).with(
+        'fake-namespace.quiz_api_client.request.duration_ms',
+        duration_in_secs * 1_000,
+        tags: {
+          method: method,
+          status: code,
+          url: url
+        }
+      )
+
+      subject.duration(start_time, end_time)
+    end
+  end
+end