apress-api 1.22.0

data/spec/controllers/api_controller/rescue_spec.rb

@@ -0,0 +1,167 @@
+require "spec_helper"
+
+describe Apress::Api::ApiController::Base, type: :controller do
+  render_views
+
+  let(:client) { create "api/client" }
+  let(:json) { JSON.parse(response.body) }
+
+  before do
+    allow(controller).to receive(:authenticate)
+    allow(controller).to receive(:current_api_client).and_return(client)
+  end
+
+  describe "#render_error" do
+
+    context "when exception given" do
+      controller do
+        def index
+          exception = ArgumentError.new(:message)
+          exception.set_backtrace(%w(path/to/file))
+          render_error(400, exception)
+        end
+      end
+
+      it do
+        get :index
+
+        expect(response.status).to eq 400
+        expect(json["status"]).to eq 400
+        expect(json["error"]["message"]).to eq "message"
+        expect(json["error"]["backtrace"][0]).to eq "path/to/file"
+      end
+    end
+
+    context "when server error" do
+      controller do
+        def index
+          exception = ArgumentError.new(:message)
+          exception.set_backtrace(%w(path/to/file))
+          server_error(exception)
+        end
+      end
+
+      it do
+        get :index
+
+        expect(response.status).to eq 500
+        expect(json["status"]).to eq 500
+        expect(json["error"]["message"]).to eq "message"
+        expect(json["error"]["backtrace"][0]).to eq "path/to/file"
+      end
+    end
+
+    context "when no exception" do
+      controller do
+        def index
+          not_found
+        end
+      end
+
+      it do
+        get :index
+
+        expect(response.status).to eq 404
+        expect(json["status"]).to eq 404
+        expect(json["error"]).to be nil
+      end
+    end
+  end
+
+  describe '#unproccesable' do
+    let(:record) { build 'api/client' }
+
+    before do
+      record.errors.add(:access_id, 'empty')
+      allow(controller).to receive(:record).and_return(record)
+    end
+
+    context 'when rescued from record invalid' do
+      controller do
+        def index
+          raise ActiveRecord::RecordInvalid.new(record)
+        end
+      end
+
+      it 'renders errors' do
+        get :index
+
+        expect(response.status).to eq 422
+        expect(json['status']).to eq 422
+        expect(json['errors']).to eq [{"access_id" => "empty"}]
+      end
+    end
+
+    context 'when rescued from standard error' do
+      controller do
+        class CustomError < StandardError
+        end
+
+        rescue_from CustomError, with: :unprocessable
+
+        def index
+          raise CustomError.new("custom error")
+        end
+      end
+
+      it "renders error" do
+        get :index
+
+        expect(response.status).to eq 422
+        expect(json['status']).to eq 422
+        expect(json['errors']).to eq [{"message" => "custom error"}]
+      end
+    end
+
+    context 'when called from action' do
+      controller do
+        def index
+          unprocessable(record.errors)
+        end
+      end
+
+      it 'renders errors' do
+        get :index
+
+        expect(response.status).to eq 422
+        expect(json['status']).to eq 422
+        expect(json['errors']).to eq [{"access_id" => "empty"}]
+      end
+    end
+
+    context 'when called from action with multiple errors' do
+      controller do
+        def index
+          unprocessable([record.errors, 'other' => 'error'])
+        end
+      end
+
+      it 'renders errors' do
+        get :index
+
+        expect(response.status).to eq 422
+        expect(json['status']).to eq 422
+        expect(json['errors']).to eq [{"access_id" => "empty"}, {'other' => 'error'}]
+      end
+    end
+  end
+
+  context '#parameter_missing' do
+    context 'when rescued' do
+      controller do
+        def index
+          params = ActionController::Parameters.new
+          params.require(:a)
+        end
+      end
+
+      it 'renders errors' do
+        get :index
+
+        expect(response.status).to eq 400
+        expect(json['status']).to eq 400
+        expect(json['errors']).to eq [{"a" => "missing"}]
+      end
+    end
+  end
+end

data/spec/controllers/deprecated_versions_controller_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe Apress::Api::DeprecatedVersionsController, type: :controller do
+  describe "#show" do
+    it "returns 410" do
+      get :show
+      expect(response.status).to eq 410
+    end
+  end
+end

data/spec/controllers/v1/callbacks_controller_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+def form_params(p)
+  if Rails::VERSION::MAJOR > 4
+    {params: p}
+  else
+    p
+  end
+end
+
+describe Apress::Api::V1::CallbacksController, type: :controller do
+  let!(:client) { create "api/client" }
+  before do
+    allow(controller).to receive(:authenticate)
+    allow(controller).to receive(:current_api_client).and_return(client)
+  end
+
+  describe "#create" do
+    context "when client present and allowed" do
+      before do
+        client.update_attributes(access_id: 'service_access_id')
+      end
+
+      context 'when params are valid' do
+        it 'calls enqueueing job for each handler' do
+          expect(Resque).to receive(:enqueue).with(Apress::Api::EventHandlerEnqueueingJob, 'handler_job', {})
+          expect(Resque).to receive(:enqueue).with(Apress::Api::EventHandlerEnqueueingJob, 'second_handler_job', {})
+          post :create, form_params(service: 'external_service', event: 'other_event')
+          expect(response.status).to eq 201
+        end
+      end
+
+      context 'when job is missing' do
+        it 'raises KeyError' do
+          expect do
+            post :create, form_params(service: 'service', event: 'some_event')
+          end.to raise_error(KeyError)
+        end
+      end
+    end
+
+    context "when client isn't allowed" do
+      it 'returns 403' do
+        post :create, form_params(service: 'service', event: 'some_event')
+
+        expect(response.status).to eq 403
+      end
+    end
+  end
+end

data/spec/controllers/v1/tokens_controller_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+def form_params(p)
+  if Rails::VERSION::MAJOR > 4
+    {params: p}
+  else
+    p
+  end
+end
+
+describe Apress::Api::V1::TokensController, type: :controller do
+  render_views
+
+  let!(:client) { create "api/client" }
+
+  describe "#create" do
+    context "when client doesn't exist" do
+      it do
+        post :create, form_params(client_id: "no-name")
+        expect(response.status).to eq 404
+      end
+    end
+
+    context "when refresh token not valid" do
+      it do
+        post :create, form_params(client_id: client.access_id, refresh_token: "bad-token")
+        expect(response.status).to eq 400
+      end
+    end
+
+    context "when refresh token expired" do
+      it do
+        Timecop.travel(1.year.from_now)
+        post :create, form_params(client_id: client.access_id, refresh_token: client.refresh_token)
+        expect(response.status).to eq 403
+        Timecop.return
+      end
+    end
+
+    context "when refresh token is valid" do
+      it "returns regenerated tokens" do
+        post :create, form_params(client_id: client.access_id, refresh_token: client.refresh_token)
+        expect(response.status).to eq 200
+
+        client.reload
+        json = JSON.parse(response.body)
+
+        expect(json["client"]["secret_token"]).to eq client.secret_token
+        expect(json["client"]["refresh_token"]).to eq client.refresh_token
+      end
+    end
+  end
+end

data/spec/factories/client_factory.rb

@@ -0,0 +1,4 @@
+FactoryGirl.define do
+  factory 'api/client', class: Apress::Api::Client do
+  end
+end

data/spec/helpers/paginating_cache_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+SIMPLE_TEST = <<-JBUILDER
+  json.paginating_cache! @collection, nil, skip_digest: true do
+    json.title 'test'
+  end
+JBUILDER
+
+TEST_WITH_CACHING = <<-JBUILDER
+  json.paginating_cache! @collection, ['v1', @collection], expire_in: 30.minutes, skip_digest: true do
+    json.title 'test'
+  end
+JBUILDER
+
+def jbuild(source_key, collection)
+  partials = {
+    'test.json.jbuilder' => SIMPLE_TEST,
+    'test_with_cache_key.json.jbuilder' => TEST_WITH_CACHING
+  }
+
+  resolver = ActionView::FixtureResolver.new(partials)
+  lookup_context.view_paths = [resolver]
+  assign(:collection, collection)
+  MultiJson.load(render(template: source_key))
+end
+
+def view_prefix
+  if Rails::VERSION::MAJOR > 4
+    'jbuilder/views'
+  else
+    'jbuilder'
+  end
+end
+
+describe 'paginating_cache', type: :view do
+  let(:collection) { double(total_entries: 30, total_pages: 10, per_page: 5, current_page: 2, cache_key: 'test') }
+  context 'when caching disabled' do
+    it 'sets headers and yield view' do
+      result = jbuild('test.json.jbuilder', collection)
+      expect(result['title']).to eq 'test'
+      expect(view.controller.response.headers['X-Total-Count']).to eq '30'
+      expect(view.controller.response.headers['X-Total-Pages']).to eq '10'
+      expect(view.controller.response.headers['X-Per-Page']).to eq '5'
+      expect(view.controller.response.headers['X-Page']).to eq '2'
+    end
+  end
+
+  context 'when caching enable' do
+    before do
+      view.controller.perform_caching = true
+    end
+
+    it 'cache result with collection key' do
+      expect(Rails.cache).to receive(:fetch).with("#{view_prefix}/test", skip_digest: true).and_call_original
+
+      jbuild('test.json.jbuilder', collection)
+    end
+
+    it 'cache results with custom composite key' do
+      expect(Rails.cache).to \
+        receive(:fetch).with("#{view_prefix}/v1/test", expire_in: 30.minutes, skip_digest: true).and_call_original
+
+      jbuild('test_with_cache_key.json.jbuilder', collection)
+    end
+
+    it 'sets headers and yield view' do
+      result = jbuild('test.json.jbuilder', collection)
+      expect(result['title']).to eq 'test'
+      expect(view.controller.response.headers['X-Total-Count']).to eq '30'
+      expect(view.controller.response.headers['X-Total-Pages']).to eq '10'
+    end
+  end
+end

data/spec/interactors/apress/api/delayed_fire_callback_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Apress::Api::DelayedFireCallback, type: :interactor do
+  let(:result) { described_class.call(event: 'some_event', params: {test: 1}) }
+
+  describe '#call' do
+    it 'calls job with correct params' do
+      expect(Resque).to receive(:enqueue).with(
+        ::Apress::Api::FireCallbackJob,
+        'service',
+        'some_event',
+        test: 1
+      )
+
+      result
+    end
+
+    context 'when multiple services' do
+      before do
+        allow(Apress::Api::Callbacks::Config).to \
+          receive(:services).with('some_event').and_return(%w(service_1 service_2))
+      end
+
+      it 'calls 2 jobs' do
+        expect(Resque).to receive(:enqueue).with(
+          ::Apress::Api::FireCallbackJob,
+          'service_1',
+          'some_event',
+          test: 1
+        )
+
+        expect(Resque).to receive(:enqueue).with(
+          ::Apress::Api::FireCallbackJob,
+          'service_2',
+          'some_event',
+          test: 1
+        )
+
+        result
+      end
+    end
+  end
+end

data/spec/internal/app/integrations/error_client/fire_callback.rb

@@ -0,0 +1,14 @@
+module ErrorClient
+  class FireCallback < Apress::Api::Callbacks::BaseCallback
+    class RepeatError < StandardError
+    end
+    add_retry_exceptions ArgumentError
+    add_repeat_exceptions RepeatError
+
+    delegate :event, to: :context
+    def call
+      raise RepeatError if event == 'repeat_error'
+      raise ArgumentError
+    end
+  end
+end

data/spec/internal/app/integrations/service_client/fire_callback.rb

@@ -0,0 +1,7 @@
+module ServiceClient
+  class FireCallback < Apress::Api::Callbacks::BaseCallback
+    def call
+      "Fired"
+    end
+  end
+end

data/spec/internal/app/jobs/handler_job.rb

@@ -0,0 +1,5 @@
+class HandlerJob
+  def self.perform
+    "Do work"
+  end
+end

data/spec/internal/app/jobs/second_handler_job.rb

@@ -0,0 +1,5 @@
+class SecondHandlerJob
+  def self.perform
+    "Do work"
+  end
+end