rack-berater 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a5812fba3c2523be30274bcc192d67ba7cebbb1d2b52dcc0ca403d69c39630c
-  data.tar.gz: 46152472d4af26a86e506a9150ff9c56743490707b630ecddc94beb0e63f7448
+  metadata.gz: 3475519672f1074d749de982b36d3a2d0d15a468d38d35b91e0f237de02ba2f8
+  data.tar.gz: fd08c05ccc694adc8ca540a2468956144c0d180611dd4622070e15aa8dd120ef
 SHA512:
-  metadata.gz: '079407a6fd8d63c849809c972ef15739de09bd490c1e3a4046ae047dbba8b36cb7e5f0606c17b5e5a6a74ce8ec9fa95f61139afc3937a5c30643fe85ff59e91d'
-  data.tar.gz: 7d6ede65719ed13181c25aca35a48c941ee9c4777caa4f56eede0552b4acdc39d2989069659217327a0b3bc494d0c178b1ee1faa21e42f5c70dd4067f4fb077e
+  metadata.gz: 88428422463a296369f8a2f141c74dadc90f132e2d2072c3505bf33012e344668277e23146125cf43bca55a7d6ec83da0871d6e5b23684a72f3875e48f5d43d7
+  data.tar.gz: be42f6faa19469ccbfed7995f02b81533051b828e688779d8b5986be6a83174baf71c8ca399b9fabb419766a59fbd8a0c366eefdee977865d7c215970e815527

data/lib/rack/berater/railtie.rb

@@ -1,7 +1,7 @@
 require 'rails/railtie'
 
 module Rack
-  module Berater
+  class Berater
     class Railtie < Rails::Railtie
       initializer "rack.berater.initializer" do |app|
         app.middleware.use Rack::Berater

data/lib/rack/berater/version.rb

@@ -1,5 +1,5 @@
 module Rack
-  module Berater
-    VERSION = "0.0.2"
+  class Berater
+    VERSION = "0.1.0"
   end
 end

data/lib/rack/berater.rb

@@ -1,9 +1,61 @@
+require "berater"
+require "rack"
 require "rack/berater/version"
+require "set"
 
 module Rack
-  module Berater
-    autoload :Handler, "rack/berater/handler"
-    # autoload :Limiter, "rack/berater/limiter"
+  class Berater
     autoload :Railtie, "rack/berater/railtie"
+
+    ERROR_TYPES = Set.new([ ::Berater::Overloaded ])
+
+    def initialize(app, options = {})
+      @app = app
+      @enabled = options[:enabled?]
+      @limiter = options[:limiter]
+      @options = {
+        headers: {},
+        status_code: options.fetch(:status_code, 429),
+      }
+
+      # configure body
+      @options[:body] = case options[:body]
+        when true, nil
+          Rack::Utils::HTTP_STATUS_CODES[@options[:status_code]]
+        when false
+          nil
+        when String
+          options[:body]
+        else
+          raise ArgumentError, "invalid :body option: #{options[:body]}"
+        end
+
+      # configure headers
+      if @options[:body]
+        @options[:headers][Rack::CONTENT_TYPE] = "text/plain"
+      end
+      @options[:headers].update(options.fetch(:headers, {}))
+    end
+
+    def call(env)
+      if enabled?(env)
+        @limiter.limit { @app.call(env) }
+      else
+        @app.call(env)
+      end
+    rescue *ERROR_TYPES => e
+      [
+        @options[:status_code],
+        @options[:headers],
+        [ @options[:body] ].compact,
+      ]
+    end
+
+    private
+
+    def enabled?(env)
+      return false unless @limiter
+      @enabled.nil? ? true : @enabled.call(env)
+    end
   end
 end

data/lib/rack-berater.rb

@@ -1,3 +1 @@
-require "berater"
-require "rack"
 require "rack/berater"

data/spec/limiter_spec.rb

@@ -0,0 +1,96 @@
+describe Rack::Berater do
+  before do
+    app.use described_class, limiter: limiter, enabled?: enabled?
+  end
+  let(:limiter) { nil }
+  let(:enabled?) { nil }
+
+  let(:app) do
+    Rack::Builder.new do
+      use Rack::Lint
+      run (lambda do |env|
+        [200, {"Content-Type" => "text/plain"}, ["OK"]]
+      end)
+    end
+  end
+  let(:response) { get "/" }
+
+  shared_examples "works nominally" do
+    it "has the correct status code" do
+      expect(response.status).to eq 200
+    end
+
+    it "has the correct headers" do
+      expect(response.headers).to eq({
+        "Content-Type" => "text/plain",
+        "Content-Length" => "2",
+      })
+    end
+
+    it "has the correct body" do
+      expect(response.body).to eq "OK"
+    end
+  end
+
+  context "without a limiter" do
+    before { Berater.test_mode = :fail }
+
+    include_examples "works nominally"
+  end
+
+  describe "limiter option" do
+    let(:limiter) { ::Berater::Unlimiter.new }
+
+    include_examples "works nominally"
+
+    it "calls the limiter" do
+      expect(limiter).to receive(:limit).and_call_original
+      response
+    end
+
+    context "when operating beyond limits" do
+      before { Berater.test_mode = :fail }
+
+      it "returns an error" do
+        expect(response.status).to eq 429
+      end
+    end
+  end
+
+  describe "enabled? option" do
+    after { expect(response.status).to eq 200 }
+
+    let(:enabled?) { double }
+
+    context "when there is a limiter" do
+      let(:limiter) { ::Berater::Unlimiter.new }
+
+      it "should be called with the env hash" do
+        expect(enabled?).to receive(:call) do |env|
+          expect(env).to be_a Hash
+          expect(Rack::Request.new(env).path).to eq "/"
+        end
+      end
+
+      context "when enabled" do
+        it "should call the limiter" do
+          expect(enabled?).to receive(:call).and_return(true)
+          expect(limiter).to receive(:limit).and_call_original
+        end
+      end
+
+      context "when disabled" do
+        it "should not call the limiter" do
+          expect(enabled?).to receive(:call).and_return(false)
+          expect(limiter).not_to receive(:limit)
+        end
+      end
+    end
+
+    context "when there is no limiter" do
+      it "should not call enabled?" do
+        expect(enabled?).not_to receive(:call)
+      end
+    end
+  end
+end

data/spec/rescuer_spec.rb

@@ -0,0 +1,145 @@
+describe Rack::Berater do
+  let(:app) do
+    Rack::Builder.new do
+      use Rack::Lint
+      run (lambda do |env|
+        Berater::Unlimiter() do
+          [200, {"Content-Type" => "text/plain"}, ["OK"]]
+        end
+      end)
+    end
+  end
+  let(:response) { get "/" }
+
+  shared_examples "works nominally" do
+    it "has the correct status code" do
+      expect(response.status).to eq 200
+    end
+
+    it "has the correct headers" do
+      expect(response.headers).to eq({
+        "Content-Type" => "text/plain",
+        "Content-Length" => "2",
+      })
+    end
+
+    it "has the correct body" do
+      expect(response.body).to eq "OK"
+    end
+  end
+
+  context "without middleware" do
+    include_examples "works nominally"
+
+    it "does not catch limit errors" do
+      Berater.test_mode = :fail
+      expect {
+        response
+      }.to be_overloaded
+    end
+  end
+
+  context "with middleware using default settings" do
+    before { app.use described_class }
+
+    include_examples "works nominally"
+
+    it "catches and transforms limit errors" do
+      Berater.test_mode = :fail
+      expect(response.status).to eq 429
+      expect(response.body).to eq "Too Many Requests"
+    end
+  end
+
+  context "with middleware using custom settings" do
+    before do
+      app.use described_class, options
+      Berater.test_mode = :fail
+    end
+
+    context "with a custom body" do
+      context "with body nil" do
+        let(:options) { { body: nil } }
+
+        it "should default to sending a body" do
+          expect(response.body).to eq "Too Many Requests"
+        end
+      end
+
+      context "with body disabled" do
+        let(:options) { { body: false } }
+
+        it "should not send a body" do
+          expect(response.body).to be_empty
+        end
+
+        it "should not send the Content-Type header" do
+          expect(response.headers.keys).not_to include(Rack::CONTENT_TYPE)
+        end
+      end
+
+      context "with a string" do
+        let(:body) { "none shall pass!" }
+        let(:options) { { body: body } }
+
+        it "should send the custom string" do
+          expect(response.body).to eq body
+        end
+      end
+    end
+
+    context "with custom headers" do
+      context "with an extra header" do
+        let(:options) { { headers: { Rack::CACHE_CONTROL => "no-cache" } } }
+
+        it "should contain the default headers" do
+          expect(response.headers.keys).to include(Rack::CONTENT_TYPE)
+        end
+
+        it "should also contain the custom header" do
+          expect(response.headers).to include(options[:headers])
+        end
+      end
+
+      context "with a new content type" do
+        let(:options) { { headers: { Rack::CONTENT_TYPE => "application/json" } } }
+
+        it "should override the Content-Type header" do
+          expect(response.headers).to include(options[:headers])
+        end
+      end
+    end
+
+    context "with custom status code" do
+      let(:options) { { status_code: 503 } }
+
+      it "catches and transforms limit errors" do
+        expect(response.status).to eq 503
+        expect(response.body).to eq "Service Unavailable"
+      end
+    end
+  end
+
+  context "with custom error type" do
+    before do
+      app.use described_class
+      expect(Berater::Limiter).to receive(:new).and_raise(IOError)
+    end
+
+    it "normally crashes the app" do
+      expect { response }.to raise_error(IOError)
+    end
+
+    context "when an error type is registered with middleware" do
+      around do |example|
+        Rack::Berater::ERROR_TYPES << IOError
+        example.run
+        Rack::Berater::ERROR_TYPES.delete(IOError)
+      end
+
+      it "catches and transforms limit errors" do
+        expect(response.status).to eq 429
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-berater
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-13 00:00:00.000000000 Z
+date: 2021-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: berater
@@ -116,10 +116,10 @@ extra_rdoc_files: []
 files:
 - lib/rack-berater.rb
 - lib/rack/berater.rb
-- lib/rack/berater/handler.rb
 - lib/rack/berater/railtie.rb
 - lib/rack/berater/version.rb
-- spec/handler_spec.rb
+- spec/limiter_spec.rb
+- spec/rescuer_spec.rb
 homepage: https://github.com/dpep/rack-berater
 licenses:
 - MIT
@@ -139,9 +139,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Rack::Berater
 test_files:
-- spec/handler_spec.rb
+- spec/rescuer_spec.rb
+- spec/limiter_spec.rb

data/lib/rack/berater/handler.rb

@@ -1,43 +0,0 @@
-module Rack
-  module Berater
-    class Handler
-      def initialize(app, options = {})
-        @app = app
-        @options = {
-          status_code: options.fetch(:status_code, 429),
-          headers: {
-            Rack::CONTENT_TYPE => "text/plain",
-          }.update(options.fetch(:headers, {})),
-          body: options.fetch(:body, true),
-        }
-      end
-
-      def call(env)
-        @app.call(env)
-      rescue ::Berater::Overloaded => e
-        code = @options[:status_code]
-
-        body = case @options[:body]
-          when true
-            Rack::Utils::HTTP_STATUS_CODES[code]
-          when nil, false
-            nil
-          when String
-            @options[:body]
-          when Proc
-            @options[:body].call(env, e)
-          else
-            raise ArgumentError, "invalid :body option: #{@options[:body]}"
-          end
-
-        headers = body ? @options[:headers] : {}
-
-        [
-          code,
-          headers,
-          [ body ].compact,
-        ]
-      end
-    end
-  end
-end

data/spec/handler_spec.rb

@@ -1,126 +0,0 @@
-describe Rack::Berater::Handler do
-  let(:app) do
-    Rack::Builder.new do
-      use Rack::Lint
-      run (lambda do |env|
-        raise ::Berater::Overloaded if ::Berater.test_mode == :fail
-        [200, {"Content-Type" => "text/plain"}, ["OK"]]
-      end)
-    end
-  end
-  let(:response) { get "/" }
-
-  shared_examples "works nominally" do
-    it "has the correct status code" do
-      expect(response.status).to eq 200
-    end
-
-    it "has the correct headers" do
-      expect(response.headers).to eq({
-        "Content-Type" => "text/plain",
-        "Content-Length" => "2",
-      })
-    end
-
-    it "has the correct body" do
-      expect(response.body).to eq "OK"
-    end
-  end
-
-  context "without Handler" do
-    include_examples "works nominally"
-
-    it "does not catch limit errors" do
-      Berater.test_mode = :fail
-      expect {
-        response
-      }.to be_overloaded
-    end
-  end
-
-  context "with Handler using default settings" do
-    context "with default settings" do
-      before { app.use described_class }
-
-      include_examples "works nominally"
-
-      it "catches and transforms limit errors" do
-        Berater.test_mode = :fail
-        expect(response.status).to eq 429
-        expect(response.body).to eq "Too Many Requests"
-      end
-    end
-  end
-
-  context "with Handler using custom settings" do
-    before do
-      app.use described_class, options
-      Berater.test_mode = :fail
-    end
-
-    context "with custom status code" do
-      let(:options) { { status_code: 503 } }
-
-      it "catches and transforms limit errors" do
-        expect(response.status).to eq 503
-        expect(response.body).to eq "Service Unavailable"
-      end
-    end
-
-    context "with body disabled" do
-      let(:options) { { body: false } }
-
-      it "should not send a body" do
-        expect(response.body).to be_empty
-      end
-
-      it "should not send the Content-Type header" do
-        expect(response.headers.keys).not_to include(Rack::CONTENT_TYPE)
-      end
-    end
-
-    context "with body nil" do
-      let(:options) { { body: nil } }
-
-      it "should not send a body" do
-        expect(response.body).to be_empty
-      end
-    end
-
-    context "with custom body" do
-      let(:body) { "none shall pass!" }
-      let(:options) { { body: body } }
-
-      it "should send the custom string" do
-        expect(response.body).to eq body
-      end
-    end
-
-    context "with a dynamic body" do
-      let(:body) { "none shall pass!" }
-      let(:fn) { proc { body } }
-      let(:options) { { body: fn } }
-
-      it "should call the Proc and send the result" do
-        expect(response.body).to eq body
-      end
-
-      it "should pass in the env and error" do
-        expect(fn).to receive(:call).with(Hash, ::Berater::Overloaded)
-        response
-      end
-    end
-
-    context "with custom headers" do
-      let(:options) { { headers: { Rack::CACHE_CONTROL => "no-cache" } } }
-
-      it "should contain the default headers" do
-        expect(response.headers.keys).to include(Rack::CONTENT_TYPE)
-      end
-
-      it "should also contain custom header" do
-        expect(response.headers).to include(options[:headers])
-      end
-    end
-  end
-end