Пишем Pastebin на Hanami (часть 1)

  require_relative '../../../../apps/api/controllers/pastes/create'

  RSpec.describe Api::Controllers::Pastes::Create do
    let(:action) { described_class.new }

    after do
      PasteRepository.clear
    end

    context 'with invalid parameters' do
      let(:params) { Hash[] }

      it 'is 422 Unprocessable Entity' do
        response = action.call(params)
        expect(response[0]).to eq(422)
      end
    end

    context 'with valid parameters' do
      let(:params) { Hash[content: 'some content'] }

      it 'is successful' do
        response = action.call(params)
        expect(response[0]).to eq(200)
      end
    end
  end

  require_relative '../../../../apps/api/views/pastes/create'

  RSpec.describe Api::Views::Pastes::Create do
    let(:paste) { Paste.new(id: 42, content: 'some content', token: 'some token') }
    let(:exposures) { Hash[paste: paste] }
    let(:template)  { Hanami::View::Template.new('apps/api/templates/pastes/create.text.erb') }
    let(:view)      { described_class.new(template, exposures) }
    let(:rendered)  { view.render }

    it 'displays the URL of the paste' do
      expect(rendered).to match(%r{/api/pastes/42})
    end

    it 'displays the access token' do
      expect(rendered).to match('some token')
    end
  end

  module Api::Controllers::Pastes
    class Create
      include Api::Action

      params do
        required(:content).filled(:str?)
      end

      expose :paste

      def call(params)
        halt 422 unless params.valid?
        @paste = PasteRepository.create(Paste.new(content: params[:content],
                                                  token: generate_token))
      end

      private

      def generate_token
        SecureRandom.hex(8)
      end
    end
  end

  module Api::Views::Pastes
    class Create
      include Api::View

      def paste_url
        raw routes.paste_url(paste.id)
      end

      def access_token
        raw paste.token
      end
    end
  end

  require_relative '../../../../apps/api/controllers/pastes/show'

  RSpec.describe Api::Controllers::Pastes::Show do
    let(:action) { described_class.new }
    let(:id) { 42 }
    let(:params) { Hash[id: id] }

    before do
      allow(PasteRepository).to receive(:find).with(id).and_return(paste)
      expect(PasteRepository).to receive(:find).with(id)
    end

    context 'with an existing paste' do
      let(:paste) { Paste.new(id: id, content: 'some content', token: 'deadbeef') }

      it 'is successful' do
        response = action.call(params)
        expect(response[0]).to eq(200)
      end
    end

    context 'with a non-existing paste' do
      let(:paste) { nil }

      it 'is 404 Not Found' do
        response = action.call(params)
        expect(response[0]).to eq(404)
      end
    end
  end

  require_relative '../../../../apps/api/views/pastes/show'

  RSpec.describe Api::Views::Pastes::Show do
    let(:paste) { Paste.new(id: 42, content: 'some content', token: 'deadbeef') }
    let(:exposures) { Hash[paste: paste] }
    let(:template)  { nil }
    let(:view)      { described_class.new(template, exposures) }
    let(:rendered)  { view.render }

    it 'renders paste content' do
      expect(rendered).to eq(paste.content)
    end
  end

  module Api::Controllers::Pastes
    class Show
      include Api::Action

      expose :paste

      def call(params)
        @paste = PasteRepository.find(params[:id])
        halt 404 if @paste.nil?
      end
    end
  end

  module Api::Views::Pastes
    class Show
      include Api::View

      def render
        raw paste.content
      end
    end
  end

  require_relative '../../../../apps/api/controllers/pastes/update'

  RSpec.describe Api::Controllers::Pastes::Update do
    let(:action) { described_class.new }
    let(:id) { 42 }
    let(:access_token) { 'token' }
    let(:content) { 'new content' }
    let(:params) { Hash[id: 42, access_token: access_token, content: content] }

    context 'with invalid params' do
      context 'when access token is missing' do
        let(:access_token) { nil }

        it 'is 422 Unprocessable Entity' do
          response = action.call(params)
          expect(response[0]).to eq(422)
        end
      end

      context 'when content is missing' do
        let(:content) { nil }

        it 'is 422 Unprocessable Entity' do
          response = action.call(params)
          expect(response[0]).to eq(422)
        end
      end
    end

    context 'with valid params' do
      before do
        allow(PasteRepository).to receive(:find).with(id).and_return(paste)
        expect(PasteRepository).to receive(:find).with(id)
      end

      context 'with a non-existing paste' do
        let(:paste) { nil }

        it 'is 404 Not Found' do
          response = action.call(params)
          expect(response[0]).to eq(404)
        end
      end

      context 'with an existing paste' do
        let(:paste) { Paste.new(id: id, content: 'some content', token: 'deadbeef') }

        context 'with a matching access token' do
          let(:access_token) { 'deadbeef' }

          it 'is 204 No Content' do
            response = action.call(params)
            expect(response[0]).to eq(204)
          end
        end

        context 'with a non-matching access token' do
          let(:access_token) { 'deadbabe' }

          it 'is 403 Forbidden' do
            response = action.call(params)
            expect(response[0]).to eq(403)
          end
        end
      end
    end
  end

  module Api::Controllers::Pastes
    class Update
      include Api::Action

      params do
        required(:id).filled(:int?)
        required(:access_token).filled(:str?)
        required(:content).filled(:str?)
      end

      def call(params)
        halt 422 unless params.valid?

        paste = PasteRepository.find(params[:id])

        halt 404 if paste.nil?
        halt 403 unless paste.token == params[:access_token]

        paste.update(content: params[:content], updated_at: Time.now)
        PasteRepository.update(paste)
        self.status = 204
      end
    end
  end

  require_relative '../../../../apps/api/controllers/pastes/destroy'

  RSpec.describe Api::Controllers::Pastes::Destroy do
    let(:action) { described_class.new }
    let(:id) { 42 }
    let(:access_token) { 'token' }
    let(:params) { Hash[id: 42, access_token: access_token] }

    context 'with invalid params' do
      context 'when access token is missing' do
        let(:access_token) { nil }

        it 'is 422 Unprocessable Entity' do
          response = action.call(params)
          expect(response[0]).to eq(422)
        end
      end
    end

    context 'with valid params' do
      before do
        allow(PasteRepository).to receive(:find).with(id).and_return(paste)
        expect(PasteRepository).to receive(:find).with(id)
      end

      context 'with a non-existing paste' do
        let(:paste) { nil }

        it 'is 404 Not Found' do
          response = action.call(params)
          expect(response[0]).to eq(404)
        end
      end

      context 'with an existing paste' do
        let(:paste) { Paste.new(id: id, content: 'some content', token: 'deadbeef') }

        context 'with a matching access token' do
          let(:access_token) { 'deadbeef' }

          it 'is 204 No Content' do
            response = action.call(params)
            expect(response[0]).to eq(204)
          end
        end

        context 'with a non-matching access token' do
          let(:access_token) { 'deadbabe' }

          it 'is 403 Forbidden' do
            response = action.call(params)
            expect(response[0]).to eq(403)
          end
        end
      end
    end
  end

  module Api::Controllers::Pastes
    class Destroy
      include Api::Action

      params do
        required(:id).filled(:int?)
        required(:access_token).filled(:str?)
      end

      def call(params)
        halt 422 unless params.valid?

        paste = PasteRepository.find(params[:id])

        halt 404 if paste.nil?
        halt 403 unless paste.token == params[:access_token]

        PasteRepository.delete(paste)
        self.status = 204
      end
    end
  end