pliny 1.2.0 → 2.0.0

data/spec/errors_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Errors do
@@ -9,7 +11,8 @@ describe Pliny::Errors do
 
   it "includes an HTTP error that will take generic parameters" do
     e = Pliny::Errors::HTTPStatusError.new(
-      "Custom HTTP error.", :custom_http_error, 499)
+      "Custom HTTP error.", :custom_http_error, 499,
+    )
     assert_equal "Custom HTTP error.", e.message
     assert_equal :custom_http_error, e.id
     assert_equal 499, e.status

data/spec/helpers/encode_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Helpers::Encode do

data/spec/helpers/params_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Helpers::Params do
@@ -11,35 +13,35 @@ describe Pliny::Helpers::Params do
   end
 
   it "loads json params" do
-    post "/", {hello: "world"}.to_json, {"CONTENT_TYPE" => "application/json"}
+    post "/", { hello: "world" }.to_json, { "CONTENT_TYPE" => "application/json" }
     assert_equal "{\"hello\":\"world\"}", last_response.body
   end
 
   it "loads json array of params" do
-    post "/", [{hello: "world"}, {goodbye: "moon"}].to_json, {"CONTENT_TYPE" => "application/json"}
+    post "/", [{ hello: "world" }, { goodbye: "moon" }].to_json, { "CONTENT_TYPE" => "application/json" }
     assert_equal "[{\"hello\":\"world\"},{\"goodbye\":\"moon\"}]", last_response.body
   end
 
   it "loads json array of arrays of params" do
-    post "/", [[{hello: "world"}], [{goodbye: "moon"}]].to_json, {"CONTENT_TYPE" => "application/json"}
+    post "/", [[{ hello: "world" }], [{ goodbye: "moon" }]].to_json, { "CONTENT_TYPE" => "application/json" }
     assert_equal "[[{\"hello\":\"world\"}],[{\"goodbye\":\"moon\"}]]", last_response.body
   end
 
   it "loads form data params" do
-    post "/", {hello: "world"}
+    post "/", { hello: "world" }
     assert_equal "{\"hello\":\"world\"}", last_response.body
   end
 
   it "loads from an unknown content type" do
-    post "/", "<hello>world</hello>", {"CONTENT_TYPE" => "application/xml"}
+    post "/", "<hello>world</hello>", { "CONTENT_TYPE" => "application/xml" }
     assert_equal "{}", last_response.body
   end
 
   it "should throw bad request when receiving invalid json via post" do
     err = assert_raises(Pliny::Errors::BadRequest) do
-      post "/", "{\"foo\"}", {"CONTENT_TYPE" => "application/json"}
+      post "/", "{\"foo\"}", { "CONTENT_TYPE" => "application/json" }
     end
 
-    assert_match /unexpected token/, err.message
+    assert_match(/expected ':' after object key at line 1 column 7/, err.message)
   end
 end

data/spec/helpers/serialize_spec.rb

@@ -1,5 +1,16 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
+class Serializer
+  def initialize(opts)
+  end
+
+  def serialize(data)
+    data
+  end
+end
+
 describe Pliny::Helpers::Serialize do
   context "without a serializer" do
     def app
@@ -20,13 +31,6 @@ describe Pliny::Helpers::Serialize do
   end
 
   context "with a serializer" do
-    class Serializer
-      def initialize(opts); end
-      def serialize(data)
-        data
-      end
-    end
-
     def app
       Sinatra.new do
         register Pliny::Helpers::Serialize

data/spec/helpers/zulu_time_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
+class ZuluTimeTest
+  extend Pliny::Helpers::ZuluTime
+end
+
 describe Pliny::Helpers::ZuluTime do
   context "zulu_time" do
-    class ZuluTimeTest
-      extend Pliny::Helpers::ZuluTime
-    end
-
     it "it formats Time instances" do
       formatted = ZuluTimeTest.zulu_time(Time.parse("2017-11-28T21:49:52.123+00:00"))
       assert_equal "2017-11-28T21:49:52Z", formatted

data/spec/integration_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "open3"
 
@@ -79,41 +81,41 @@ describe "Pliny integration test" do
 
     it "returns a migration in the DOWN state when not migrated" do
       bash "pliny-generate model artist"
-      migration_file = Dir.glob('db/migrate/*').first
+      migration_file = Dir.glob("db/migrate/*").first
 
-      stdout, stderr = bash_with_output("rake db:migrate:status")
+      stdout, _ = bash_with_output("rake db:migrate:status")
 
-      statuses = Hash[stdout.to_s.split(/\+[-]+\+[-]+\+/)[2..-1].map { |s| s.tr("\n", "") }.select(&:present?).map { |s| s.split("|").map { |s| s.tr(" ", "") }.select(&:present?).reverse }]
+      statuses = stdout.to_s.split(/\+-+\+-+\+/)[2..].map { |s| s.tr("\n", "") }.select(&:present?).map { |s| s.split("|").map { |s| s.tr(" ", "") }.select(&:present?).reverse }.to_h
       assert statuses[migration_file.split("/").last] == "DOWN"
     end
 
     it "returns a migration in the UP state when not migrated" do
       bash "pliny-generate model artist"
-      migration_file = Dir.glob('db/migrate/*').first
+      migration_file = Dir.glob("db/migrate/*").first
       bash "rake db:migrate"
 
-      stdout, stderr = bash_with_output("rake db:migrate:status")
+      stdout, _ = bash_with_output("rake db:migrate:status")
 
-      statuses = Hash[stdout.to_s.split(/\+[-]+\+[-]+\+/)[2..-1].map { |s| s.tr("\n", "") }.select(&:present?).map { |s| s.split("|").map { |s| s.tr(" ", "") }.select(&:present?).reverse }]
+      statuses = stdout.to_s.split(/\+-+\+-+\+/)[2..].map { |s| s.tr("\n", "") }.select(&:present?).map { |s| s.split("|").map { |s| s.tr(" ", "") }.select(&:present?).reverse }.to_h
       assert statuses[migration_file.split("/").last] == "UP"
     end
 
     it "returns a migration in the FILE MISSING state when the file is missing" do
       bash "pliny-generate model artist"
-      migration_file = Dir.glob('db/migrate/*').first
+      migration_file = Dir.glob("db/migrate/*").first
       bash "rake db:migrate"
 
       FileUtils.rm_f(migration_file)
 
-      stdout, stderr = bash_with_output("rake db:migrate:status")
+      stdout, _ = bash_with_output("rake db:migrate:status")
 
-      statuses = Hash[stdout.to_s.split(/\+[-]+\+[-]+\+/)[2..-1].map { |s| s.tr("\n", "") }.select(&:present?).map { |s| s.split("|").map { |s| s.gsub(/(^[ ]+|[ ]+$)/, "") }.select(&:present?).reverse }]
+      statuses = stdout.to_s.split(/\+-+\+-+\+/)[2..].map { |s| s.tr("\n", "") }.select(&:present?).map { |s| s.split("|").map { |s| s.gsub(/(^ +| +$)/, "") }.select(&:present?).reverse }.to_h
       assert statuses[migration_file.split("/").last] == "FILE MISSING"
     end
   end
 
   def bash_with_output(cmd)
-    bin  = File.expand_path('../bin', File.dirname(__FILE__))
+    bin = File.expand_path("../bin", File.dirname(__FILE__))
     path = "#{bin}:#{ENV["PATH"]}"
     env = { "PATH" => path }
     stdout, stderr, status = Open3.capture3(env, cmd)
@@ -122,11 +124,11 @@ describe "Pliny integration test" do
       raise "Failed to run #{cmd}, error was #{stderr}"
     end
 
-    return stdout, stderr
+    [stdout, stderr]
   end
 
   def bash(cmd)
-    bin  = File.expand_path('../bin', File.dirname(__FILE__))
+    bin = File.expand_path("../bin", File.dirname(__FILE__))
     path = "#{bin}:#{ENV["PATH"]}"
     env = { "PATH" => path }
     unless system(env, "#{cmd} > /dev/null")

data/spec/log_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Log do
@@ -66,7 +68,7 @@ describe Pliny::Log do
   it "local context does not overwrite default context" do
     Pliny.default_context = { app: "pliny" }
     expect(@io).to receive(:print).with("app=not_pliny foo=bar\n")
-    Pliny.log(app: 'not_pliny', foo: "bar")
+    Pliny.log(app: "not_pliny", foo: "bar")
     assert Pliny.default_context[:app] == "pliny"
   end
 
@@ -95,20 +97,20 @@ describe Pliny::Log do
   end
 
   describe "scrubbing" do
-
     it "allows a Proc to be assigned as a log scrubber" do
-      Pliny.log_scrubber = -> (hash) { hash }
+      Pliny.log_scrubber = ->(hash) { hash }
 
       begin
         Pliny.log_scrubber = Object.new
         fail
-      rescue ArgumentError; end
+      rescue ArgumentError
+      end
     end
 
     describe "when a scrubber is present" do
       before do
-        Pliny.log_scrubber = -> (hash) {
-          Hash.new.tap do |h|
+        Pliny.log_scrubber = ->(hash) {
+          {}.tap do |h|
             hash.keys.each do |k|
               h[k] = "*SCRUBBED*"
             end

data/spec/metrics/backends/logger_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Metrics::Backends::Logger do
@@ -18,27 +20,29 @@ describe Pliny::Metrics::Backends::Logger do
 
   context "#count" do
     it "logs a single key with a value" do
-      backend.report_counts('app.foo' => 1)
+      backend.report_counts("app.foo" => 1)
       expect(io).to have_received(:print).with("count#app.foo=1\n")
     end
 
     it "logs multiple keys with values" do
-      backend.report_counts('app.foo' => 1, 'app.bar' => 2)
+      backend.report_counts("app.foo" => 1, "app.bar" => 2)
       expect(io).to have_received(:print).with(
-        "count#app.foo=1 count#app.bar=2\n")
+        "count#app.foo=1 count#app.bar=2\n",
+      )
     end
   end
 
   context "#measure" do
     it "logs a single key with a value" do
-      backend.report_measures('pliny.foo' => 0.001)
+      backend.report_measures("pliny.foo" => 0.001)
       expect(io).to have_received(:print).with("measure#pliny.foo=0.001\n")
     end
 
     it "logs multiple keys with values" do
-      backend.report_measures('pliny.foo' => 0.3, 'pliny.bar' => 0.5)
+      backend.report_measures("pliny.foo" => 0.3, "pliny.bar" => 0.5)
       expect(io).to have_received(:print).with(
-        "measure#pliny.foo=0.300 measure#pliny.bar=0.500\n")
+        "measure#pliny.foo=0.300 measure#pliny.bar=0.500\n",
+      )
     end
   end
 end

data/spec/metrics_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Metrics do
@@ -8,7 +10,7 @@ describe Pliny::Metrics do
   end
 
   before do
-    allow(Config).to receive(:app_name).and_return('pliny')
+    allow(Config).to receive(:app_name).and_return("pliny")
   end
 
   around do |example|
@@ -41,7 +43,7 @@ describe Pliny::Metrics do
       metrics.count(:foo, :bar)
       expect(test_backend).to have_received(:report_counts).once.with(
         "pliny.foo" => 1,
-        "pliny.bar" => 1
+        "pliny.bar" => 1,
       )
     end
   end
@@ -57,9 +59,9 @@ describe Pliny::Metrics do
     end
 
     it "measures a block's execution time with a single key" do
-      metrics.measure(:foo) { }
+      metrics.measure(:foo) {}
       expect(test_backend).to have_received(:report_measures).once.with(
-        "pliny.foo" => 0
+        "pliny.foo" => 0,
       )
     end
 
@@ -69,37 +71,37 @@ describe Pliny::Metrics do
       end
 
       expect(test_backend).to have_received(:report_measures) do |opts|
-        assert(60 <= opts['pliny.foo'] && opts['pliny.foo'] <= 61)
+        assert(opts["pliny.foo"].between?(60, 61))
       end
     end
 
     it "measures a block's execution time with multiple keys" do
-      metrics.measure(:foo, :bar) { }
+      metrics.measure(:foo, :bar) {}
       expect(test_backend).to have_received(:report_measures).once.with(
         "pliny.foo" => 0,
-        "pliny.bar" => 0
+        "pliny.bar" => 0,
       )
     end
 
     it "measures a given value for a single key without a block" do
       metrics.measure(:baz, value: 3.14)
       expect(test_backend).to have_received(:report_measures).once.with(
-        "pliny.baz" => 3.14
+        "pliny.baz" => 3.14,
       )
     end
 
     it "measures a given value for multiple keys with a block" do
-      metrics.measure(:qux, :corge, value: 42) { }
+      metrics.measure(:qux, :corge, value: 42) {}
       expect(test_backend).to have_received(:report_measures).once.with(
         "pliny.qux" => 42,
-        "pliny.corge" => 42
+        "pliny.corge" => 42,
       )
     end
 
     it "measures a value of 0 when no key or block is provided" do
       metrics.measure(:waldo)
       expect(test_backend).to have_received(:report_measures).once.with(
-        "pliny.waldo" => 0
+        "pliny.waldo" => 0,
       )
     end
 
@@ -107,7 +109,7 @@ describe Pliny::Metrics do
       metrics.measure("metric.name", "another.name", value: 3.14, foo: :bar)
       expect(test_backend).to have_received(:report_measures).once.with(
         "pliny.metric.name" => 3.14,
-        "pliny.another.name" => 3.14
+        "pliny.another.name" => 3.14,
       )
     end
 
@@ -115,7 +117,7 @@ describe Pliny::Metrics do
       metrics.measure("metric.name", "another.name", { value: 3.14, foo: :bar })
       expect(test_backend).to have_received(:report_measures).once.with(
         "pliny.metric.name" => 3.14,
-        "pliny.another.name" => 3.14
+        "pliny.another.name" => 3.14,
       )
     end
   end

data/spec/middleware/canonical_log_line_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::CanonicalLogLine do
@@ -7,7 +9,7 @@ describe Pliny::Middleware::CanonicalLogLine do
         use Pliny::Middleware::RequestID
 
         use Pliny::Middleware::CanonicalLogLine,
-          emitter: -> (data) { Pliny.log_without_context(data) }
+          emitter: ->(data) { Pliny.log_without_context(data) }
 
         use Pliny::Middleware::RescueErrors, raise: false
 
@@ -48,7 +50,8 @@ describe Pliny::Middleware::CanonicalLogLine do
 
   it "never fails a request on failure" do
     expect(Pliny).to receive(:log).with(
-      message: "Failed to emit canonical log line")
+      message: "Failed to emit canonical log line",
+    )
     expect(Pliny).to receive(:log_without_context) { |d| raise "bang!" }
 
     get "/apps/123"

data/spec/middleware/cors_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::CORS do

data/spec/middleware/instruments_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::Instruments do
@@ -25,17 +27,17 @@ describe Pliny::Middleware::Instruments do
   it "performs logging" do
     expect(Pliny).to receive(:log).with(hash_including(
       instrumentation: true,
-      at:              "start",
-      method:          "GET",
-      path:            "/apps/123",
+      at: "start",
+      method: "GET",
+      path: "/apps/123",
     ))
     expect(Pliny).to receive(:log).with(hash_including(
       instrumentation: true,
-      at:              "finish",
-      method:          "GET",
-      path:            "/apps/123",
+      at: "finish",
+      method: "GET",
+      path: "/apps/123",
       route_signature: "/apps/:id",
-      status:          201
+      status: 201,
     ))
     get "/apps/123"
   end
@@ -43,7 +45,7 @@ describe Pliny::Middleware::Instruments do
   it "respects Pliny error status codes" do
     expect(Pliny).to receive(:log)
     expect(Pliny).to receive(:log).with(hash_including(
-      status: 404
+      status: 404,
     ))
     get "/error"
   end

data/spec/middleware/metrics_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::Instruments do
@@ -57,7 +59,7 @@ describe Pliny::Middleware::Instruments do
   it "measures the request latency" do
     expect(Pliny::Metrics).to receive(:measure) do |key, opts|
       assert_equal(key, "requests.latency")
-      assert(4 < opts[:value] && opts[:value] < 6)
+      assert_in_delta(5, opts[:value], 1)
     end
 
     get "/hello"

data/spec/middleware/request_id_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::RequestID do

data/spec/middleware/request_store/clear_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::RequestStore::Clear do

data/spec/middleware/request_store/seed_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::RequestStore::Seed do

data/spec/middleware/rescue_errors_spec.rb

@@ -1,21 +1,21 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-describe Pliny::Middleware::RescueErrors do
-  include Rack::Test::Methods
+require "spec_helper"
 
-  class BadMiddleware
-    def call(env)
-      if env["PATH_INFO"] == "/api-error"
-        raise Pliny::Errors::ServiceUnavailable
-      else
-        raise "Omg!"
-      end
+class BadMiddleware
+  def call(env)
+    if env["PATH_INFO"] == "/api-error"
+      raise Pliny::Errors::ServiceUnavailable
+    else
+      raise "Omg!"
     end
   end
+end
 
-  def app
-    @app
-  end
+describe Pliny::Middleware::RescueErrors do
+  include Rack::Test::Methods
+
+  attr_reader :app
 
   it "intercepts Pliny errors and renders" do
     @app = new_rack_app

data/spec/middleware/versioning_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::Middleware::Versioning do
@@ -10,7 +12,7 @@ describe Pliny::Middleware::Versioning do
   def app
     Rack::Builder.new do
       use Rack::Lint
-      use Pliny::Middleware::Versioning, default: '2', app_name: 'pliny'
+      use Pliny::Middleware::Versioning, default: "2", app_name: "pliny"
       run Sinatra.new {
         get "/" do
           JSON.generate env
@@ -20,48 +22,48 @@ describe Pliny::Middleware::Versioning do
   end
 
   it "produces default version on application/json" do
-    get '/', {}, {'HTTP_ACCEPT' => 'application/json'}
+    get "/", {}, { "HTTP_ACCEPT" => "application/json" }
     json = JSON.parse(last_response.body)
-    assert_equal 'application/json', json['HTTP_ACCEPT']
-    assert_equal '2', json['HTTP_X_API_VERSION']
+    assert_equal "application/json", json["HTTP_ACCEPT"]
+    assert_equal "2", json["HTTP_X_API_VERSION"]
   end
 
   it "errors without a version specified on application/vnd.pliny+json" do
-    get '/', {}, {'HTTP_ACCEPT' => 'application/vnd.pliny+json'}
-    error = { id: :bad_version, message: <<-eos }
-Please specify a version along with the MIME type. For example, `Accept: application/vnd.pliny+json; version=1`.
-    eos
+    get "/", {}, { "HTTP_ACCEPT" => "application/vnd.pliny+json" }
+    error = { id: :bad_version, message: <<~EOS }
+      Please specify a version along with the MIME type. For example, `Accept: application/vnd.pliny+json; version=1`.
+    EOS
 
     assert_equal 400, last_response.status
     assert_equal JSON.generate(error), last_response.body
   end
 
   it "ignores a wrong app name" do
-    get '/', {}, {'HTTP_ACCEPT' => 'application/vnd.chuck_norris+json'}
+    get "/", {}, { "HTTP_ACCEPT" => "application/vnd.chuck_norris+json" }
     json = JSON.parse(last_response.body)
-    assert_equal 'application/vnd.chuck_norris+json', json['HTTP_ACCEPT']
-    assert_equal '2', json['HTTP_X_API_VERSION']
+    assert_equal "application/vnd.chuck_norris+json", json["HTTP_ACCEPT"]
+    assert_equal "2", json["HTTP_X_API_VERSION"]
   end
 
   it "produces a version on application/vnd.pliny+json; version=3" do
-    get '/', {}, {'HTTP_ACCEPT' => 'application/vnd.pliny+json; version=3'}
+    get "/", {}, { "HTTP_ACCEPT" => "application/vnd.pliny+json; version=3" }
     json = JSON.parse(last_response.body)
-    assert_equal 'application/json', json['HTTP_ACCEPT']
-    assert_equal '3', json['HTTP_X_API_VERSION']
+    assert_equal "application/json", json["HTTP_ACCEPT"]
+    assert_equal "3", json["HTTP_X_API_VERSION"]
   end
 
   # this behavior is pretty sketchy, but a pretty extreme edge case
   it "handles multiple MIME types" do
-    get '/', {}, {'HTTP_ACCEPT' => 'application/vnd.pliny+json; version=3; q=0.5, text/xml'}
+    get "/", {}, { "HTTP_ACCEPT" => "application/vnd.pliny+json; version=3; q=0.5, text/xml" }
     json = JSON.parse(last_response.body)
-    assert_equal 'text/xml, application/json; q=0.5', json['HTTP_ACCEPT']
-    assert_equal '3', json['HTTP_X_API_VERSION']
+    assert_equal "text/xml, application/json; q=0.5", json["HTTP_ACCEPT"]
+    assert_equal "3", json["HTTP_X_API_VERSION"]
   end
 
   it "produces the priority version on multiple types" do
-    get '/', {}, {'HTTP_ACCEPT' => 'application/vnd.pliny+json; version=4; q=0.5, application/vnd.pliny+json; version=3'}
+    get "/", {}, { "HTTP_ACCEPT" => "application/vnd.pliny+json; version=4; q=0.5, application/vnd.pliny+json; version=3" }
     json = JSON.parse(last_response.body)
-    assert_equal 'application/json, application/json; q=0.5', json['HTTP_ACCEPT']
-    assert_equal '3', json['HTTP_X_API_VERSION']
+    assert_equal "application/json, application/json; q=0.5", json["HTTP_ACCEPT"]
+    assert_equal "3", json["HTTP_X_API_VERSION"]
   end
 end

data/spec/request_store_spec.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Pliny::RequestStore do
   before do
     @env = {
-      "REQUEST_IDS" => ["abc", "def"]
+      "REQUEST_IDS" => ["abc", "def"],
     }
   end