timber 2.6.2 → 3.0.0

data/spec/timber/integrations/rails/rack_logger_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-if defined?(::Rails)
-  describe Timber::Integrations::Rails::RackLogger do
-    describe described_class::InstanceMethods do
-      let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
-      let(:io) { StringIO.new }
-      let(:logger) do
-        logger = Timber::Logger.new(io)
-        logger.level = ::Logger::INFO
-        logger
-      end
-
-      around(:each) do |example|
-        class RailsRackLoggerController < ActionController::Base
-          layout nil
-
-          def index
-            render json: {}
-          end
-
-          def method_for_action(action_name)
-            action_name
-          end
-        end
-
-        ::RailsApp.routes.draw do
-          get '/rails_rack_logger' => 'rails_rack_logger#index'
-        end
-
-        with_rails_logger(logger) do
-          Timecop.freeze(time) { example.run }
-        end
-
-        Object.send(:remove_const, :RailsRackLoggerController)
-      end
-
-      describe "#started_request_message" do
-        it "should mute the default rails logs" do
-          allow(::Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("production")) # Rails 3.2.X
-
-          dispatch_rails_request("/rails_rack_logger")
-
-          lines = clean_lines(io.string.split("\n"))
-          expect(lines.length).to eq(3)
-          expect(lines[0]).to start_with("Started GET \"/rails_rack_logger\" @metadata")
-          expect(lines[1]).to start_with("Processing by RailsRackLoggerController#index as HTML @metadata")
-          expect(lines[2]).to start_with("Completed 200 OK in 0.0ms @metadata")
-        end
-      end
-    end
-
-    # Remove blank lines since Rails does this to space out requests in the logs
-    def clean_lines(lines)
-      lines.select { |line| !line.start_with?(" @metadat") }
-    end
-  end
-end

data/spec/timber/util/attribute_normalizer_spec.rb

@@ -1,90 +0,0 @@
-require "spec_helper"
-
-describe Timber::Util::AttributeNormalizer, :rails_23 => true do
-  describe "#fetch" do
-    it "should return nil values" do
-      normalizer = described_class.new({:key => nil})
-      v = normalizer.fetch(:key, :string)
-      expect(v).to be_nil
-    end
-
-    it "should nillify blank strings" do
-      normalizer = described_class.new({:key => ""})
-      v = normalizer.fetch(:key, :string)
-      expect(v).to be_nil
-    end
-
-    it "should nillify empty arrays" do
-      normalizer = described_class.new({:key => []})
-      v = normalizer.fetch(:key, :string)
-      expect(v).to be_nil
-    end
-
-    it "should nillify empty hashes" do
-      normalizer = described_class.new({:key => {}})
-      v = normalizer.fetch(:key, :string)
-      expect(v).to be_nil
-    end
-
-    it "should raise an error for non arrays" do
-      normalizer = described_class.new({:key => "value"})
-      expect(lambda { normalizer.fetch(:key, :array) }).to raise_error(ArgumentError)
-    end
-
-    it "should return arrays" do
-      normalizer = described_class.new({:key => [1]})
-      v = normalizer.fetch(:key, :array)
-      expect(v).to eq([1])
-    end
-
-    it "should return a float with the correct precision" do
-      normalizer = described_class.new({:key => 1.111111})
-      v = normalizer.fetch(:key, :float, :precision => 2)
-      expect(v).to eq(1.11)
-    end
-
-    it "should sanitize a hash" do
-      normalizer = described_class.new({:key => {:PASSWORD => "password"}})
-      v = normalizer.fetch(:key, :hash, :sanitize => ["password"])
-      expect(v).to eq({"password"=>"[sanitized]"})
-    end
-
-    it "should normalize encodings" do
-      value = "test".force_encoding('ASCII-8BIT')
-      normalizer = described_class.new({:key => {:key => value}})
-      v = normalizer.fetch(:key, :hash)
-      expect(v[:key].encoding).to eq(::Encoding::UTF_8)
-    end
-
-    it "should drop large binaries" do
-      value = ("a" * 1_001).force_encoding('ASCII-8BIT')
-      normalizer = described_class.new({:key => {:key => value}})
-      v = normalizer.fetch(:key, :hash)
-      expect(v).to be_nil
-    end
-
-    it "should return an integer" do
-      normalizer = described_class.new({:key => "1"})
-      v = normalizer.fetch(:key, :integer)
-      expect(v).to eq(1)
-    end
-
-    it "should limit a string" do
-      normalizer = described_class.new({:key => "aaa"})
-      v = normalizer.fetch(:key, :string, :limit => 1)
-      expect(v).to eq("a")
-    end
-
-    it "should upcase a string" do
-      normalizer = described_class.new({:key => "aaa"})
-      v = normalizer.fetch(:key, :string, :upcase => true)
-      expect(v).to eq("AAA")
-    end
-
-    it "should return a symbol" do
-      normalizer = described_class.new({:key => "sym"})
-      v = normalizer.fetch(:key, :symbol)
-      expect(v).to eq(:sym)
-    end
-  end
-end

data/spec/timber/util/hash_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Timber::Util::Hash, :rails_23 => true do
-  describe "jsonify" do
-    it "should return the original for simple 1 level hash" do
-      original = { a: "a", b: 1, c: 123.11 }
-      v = jsonify(original)
-      expect(v).to eq(original)
-    end
-
-    it "should return the original when it's a multilevel hash but with supported values" do
-      original = { a: "a", nested: { b: 1 } }
-      v = jsonify(original)
-      expect(v).to eq(original)
-    end
-
-    it "cuts out ASCII strings longer than 1000 characters from the hash" do
-      file1 = ("a" * 1005).encode("ASCII-8BIT")
-      file2 = ("x" * 1010).encode("ASCII-8BIT")
-      original = { path: "abc", file: file1, nested: { path: "def", file: file2 } }
-      v = jsonify(original)
-      expect(v).to eq({ path: "abc", nested: { path: "def" } })
-    end
-
-    def jsonify(h)
-      Timber::Util::Hash.jsonify(h)
-    end
-  end
-
-end

data/spec/timber/util/request_spec.rb

@@ -1,10 +0,0 @@
-require "spec_helper"
-
-describe Timber::Util::Request, :rails_23 => true do
-  describe ".headers" do
-    it "should ignore symbol keys" do
-      req = described_class.new({test: "value"})
-      expect(req.headers).to eq({})
-    end
-  end
-end