yell 2.2.0 → 2.2.1

data/spec/yell/dsl_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe "Yell Adapter DSL spec" do
-
-  class DSLAdapter < Yell::Adapters::Base
-
-    setup do |options|
-      @test_setup = true
-    end
-
-    write do |event|
-      @test_write = true
-    end
-
-    close do
-      @test_close = true
-    end
-
-    def test_setup?; !!@test_setup; end
-    def test_write?; !!@test_write; end
-    def test_close?; !!@test_close; end
-  end
-
-  it "should perform #setup" do
-    adapter = DSLAdapter.new
-    expect(adapter.test_setup?).to be_truthy
-  end
-
-  it "should perform #write" do
-    event = 'event'
-    allow(event).to receive(:level) { 0 }
-
-    adapter = DSLAdapter.new
-    expect(adapter.test_write?).to be_falsey
-
-    adapter.write(event)
-    expect(adapter.test_write?).to be_truthy
-  end
-
-  it "should perform #close" do
-    adapter = DSLAdapter.new
-    expect(adapter.test_close?).to be_falsey
-
-    adapter.close
-    expect(adapter.test_close?).to be_truthy
-  end
-
-end
-

data/spec/yell/event_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-# Since Yell::Event.new is not called directly, but through
-# the logger methods, we need to divert here in order to get 
-# the correct caller.
-class EventFactory
-  def self.event(logger, level, message)
-    self._event(logger, level, message)
-  end
-
-  private
-
-  def self._event(logger, level, message)
-    Yell::Event.new(logger, level, message)
-  end
-
-end
-
-describe Yell::Event do
-  let(:logger) { Yell::Logger.new(:trace => true) }
-  let(:event) { Yell::Event.new(logger, 1, 'Hello World!') }
-
-  context "#level" do
-    subject { event.level }
-    it { should eq(1) }
-  end
-
-  context "#messages" do
-    subject { event.messages }
-    it { should eq(['Hello World!']) }
-  end
-
-  context "#time" do
-    let(:time) { Time.now }
-    subject { event.time.to_s }
-
-    before { Timecop.freeze(time) }
-
-    it { should eq(time.to_s) }
-  end
-
-  context "#hostname" do
-    subject { event.hostname }
-    it { should eq(Socket.gethostname) }
-  end
-
-  context "#pid" do
-    subject { event.pid }
-    it { should eq(Process.pid) }
-  end
-
-  context "#id when forked", :pending => RUBY_PLATFORM == 'java' ? "No forking with jruby" : false do
-    subject { @pid }
-
-    before do
-      read, write = IO.pipe
-
-      @pid = Process.fork do
-        event = Yell::Event.new(logger, 1, 'Hello World!')
-        write.puts event.pid
-      end
-      Process.wait
-      write.close
-
-      @child_pid = read.read.to_i
-      read.close
-    end
-
-    it { should_not eq(Process.pid) }
-    it { should eq(@child_pid) }
-  end
-
-  context "#progname" do
-    subject { event.progname }
-    it { should eq($0) }
-  end
-
-  context ":caller" do
-    subject { EventFactory.event(logger, 1, "Hello World") }
-
-    context "with trace" do
-      its(:file) { should eq(__FILE__) }
-      its(:line) { should eq("8") }
-      its(:method) { should eq("event") }
-    end
-
-    context "without trace" do
-      before { logger.trace = false }
-
-      its(:file) { should eq("") }
-      its(:line) { should eq("") }
-      its(:method) { should eq("") }
-    end
-  end
-
-end
-

data/spec/yell/formatter_spec.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Yell::Formatter do
-  let(:logger) { Yell::Logger.new(:stdout, name: 'Yell') }
-  let(:message) { "Hello World!" }
-  let(:event) { Yell::Event.new(logger, 1, message) }
-  let(:time) { Time.now }
-
-  let(:pattern) { "%m" }
-  let(:formatter) { Yell::Formatter.new(pattern) }
-
-  let(:output) { formatter.call(event) }
-
-  before do
-    Timecop.freeze(time)
-  end
-
-  describe "patterns" do
-    context "%m" do
-      let(:pattern) { "%m" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{event.messages.join(' ')}\n")
-      end
-    end
-
-    context "%l" do
-      let(:pattern) { "%l" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{Yell::Severities[event.level][0,1]}\n")
-      end
-    end
-
-    context "%L" do
-      let(:pattern) { "%L" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{Yell::Severities[event.level]}\n")
-      end
-    end
-
-    context "%d" do
-      let(:pattern) { "%d" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{event.time.iso8601}\n")
-      end
-    end
-
-    context "%p" do
-      let(:pattern) { "%p" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{event.pid}\n")
-      end
-    end
-
-    context "%P" do
-      let(:pattern) { "%P" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{event.progname}\n")
-      end
-    end
-
-    context "%t" do
-      let(:pattern) { "%t" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{event.thread_id}\n")
-      end
-    end
-
-    context "%h" do
-      let(:pattern) { "%h" }
-
-      it "returns correctly" do
-        expect(output).to eq("#{event.hostname}\n")
-      end
-    end
-
-    context ":caller" do
-      let(:_caller) { [nil, nil, "/path/to/file.rb:123:in `test_method'"] }
-
-      before do
-        allow(event).to receive(:file) { "/path/to/file.rb" }
-        allow(event).to receive(:line) { "123" }
-        allow(event).to receive(:method) { "test_method" }
-      end
-
-      context "%F" do
-        let(:pattern) { "%F" }
-
-        it "returns correctly" do
-          expect(output).to eq("/path/to/file.rb\n")
-        end
-      end
-
-      context "%f" do
-        let(:pattern) { "%f" }
-
-        it "returns correctly" do
-          expect(output).to eq("file.rb\n")
-        end
-      end
-
-      context "%M" do
-        let(:pattern) { "%M" }
-
-        it "returns correctly" do
-          expect(output).to eq("test_method\n")
-        end
-      end
-
-      context "%n" do
-        let(:pattern) { "%n" }
-
-        it "returns correctly" do
-          expect(output).to eq("123\n")
-        end
-      end
-    end
-
-    context "%N" do
-      let(:pattern) { "%N" }
-
-      it "returns correctly" do
-        expect(output).to eq("Yell\n")
-      end
-    end
-  end
-
-  describe "presets" do
-    context "NoFormat" do
-      let(:pattern) { Yell::NoFormat }
-
-      it "Retrns correctly" do
-        expect(output).to eq("Hello World!\n")
-      end
-    end
-
-    context "DefaultFormat" do
-      let(:pattern) { Yell::DefaultFormat }
-
-      it "returns correctly" do
-        expect(output).to eq("#{time.iso8601} [ INFO] #{$$} : Hello World!\n")
-      end
-    end
-
-    context "BasicFormat" do
-      let(:pattern) { Yell::BasicFormat }
-
-      it "returns correctly" do
-        expect(output).to eq("I, #{time.iso8601} : Hello World!\n")
-      end
-    end
-
-    context "ExtendedFormat" do
-      let(:pattern) { Yell::ExtendedFormat }
-
-      it "Returns correctly" do
-        expect(output).to eq("#{time.iso8601} [ INFO] #{$$} #{Socket.gethostname} : Hello World!\n")
-      end
-    end
-  end
-
-  describe "Exception" do
-    let(:message) { StandardError.new("This is an Exception") }
-
-    before do
-      allow(message).to receive(:backtrace) { ["backtrace"] }
-    end
-
-    it "returns correctly" do
-      expect(output).to eq("StandardError: This is an Exception\n\tbacktrace\n")
-    end
-  end
-
-  describe "Hash" do
-    let(:message) { {test: 'message'} }
-
-    it "Returns correctly" do
-      expect(output).to eq("test: message\n")
-    end
-  end
-
-  describe "custom message modifiers" do
-    let(:formatter) do
-      Yell::Formatter.new(pattern) { |f| f.modify(String) { |m| "Modified! #{m}" } }
-    end
-
-    it "Returns correctly" do
-      expect(output).to eq("Modified! #{message}\n")
-    end
-  end
-end

data/spec/yell/level_spec.rb

@@ -1,200 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Level do
-
-  context "default" do
-    let(:level) { Yell::Level.new }
-
-    it "should should return correctly" do
-      expect(level.at?(:debug)).to be_truthy
-      expect(level.at?(:info)).to be_truthy
-      expect(level.at?(:warn)).to be_truthy
-      expect(level.at?(:error)).to be_truthy
-      expect(level.at?(:fatal)).to be_truthy
-    end
-  end
-
-  context "given a Symbol" do
-    let(:level) { Yell::Level.new(severity) }
-
-    context ":debug" do
-      let(:severity) { :debug }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_truthy
-        expect(level.at?(:info)).to be_truthy
-        expect(level.at?(:warn)).to be_truthy
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_truthy
-      end
-    end
-
-    context ":info" do
-      let(:severity) { :info }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_truthy
-        expect(level.at?(:warn)).to be_truthy
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_truthy
-      end
-    end
-
-    context ":warn" do
-      let(:severity) { :warn }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_falsey
-        expect(level.at?(:warn)).to be_truthy
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_truthy
-      end
-    end
-
-    context ":error" do
-      let(:severity) { :error }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_falsey
-        expect(level.at?(:warn)).to be_falsey
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_truthy
-      end
-    end
-
-    context ":fatal" do
-      let(:severity) { :fatal }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_falsey
-        expect(level.at?(:warn)).to be_falsey
-        expect(level.at?(:error)).to be_falsey
-        expect(level.at?(:fatal)).to be_truthy
-      end
-    end
-  end
-
-  context "given a String" do
-    let(:level) { Yell::Level.new(severity) }
-
-    context "basic string" do
-      let(:severity) { 'error' }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_falsey
-        expect(level.at?(:warn)).to be_falsey
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_truthy
-      end
-    end
-
-    context "complex string with outer boundaries" do
-      let(:severity) { 'gte.info lte.error' }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_truthy
-        expect(level.at?(:warn)).to be_truthy
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_falsey
-      end
-    end
-
-    context "complex string with inner boundaries" do
-      let(:severity) { 'gt.info lt.error' }
-
-      it "should be valid" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_falsey
-        expect(level.at?(:warn)).to be_truthy
-        expect(level.at?(:error)).to be_falsey
-        expect(level.at?(:fatal)).to be_falsey
-      end
-    end
-
-    context "complex string with precise boundaries" do
-      let(:severity) { 'at.info at.error' }
-
-      it "should be valid" do
-        expect(level.at?(:debug)).to be_falsey
-        expect(level.at?(:info)).to be_truthy
-        expect(level.at?(:warn)).to be_falsey
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_falsey
-      end
-    end
-
-    context "complex string with combined boundaries" do
-      let(:severity) { 'gte.error at.debug' }
-
-      it "should be valid" do
-        expect(level.at?(:debug)).to be_truthy
-        expect(level.at?(:info)).to be_falsey
-        expect(level.at?(:warn)).to be_falsey
-        expect(level.at?(:error)).to be_truthy
-        expect(level.at?(:fatal)).to be_truthy
-      end
-    end
-  end
-
-  context "given an Array" do
-    let(:level) { Yell::Level.new( %i[debug warn fatal] ) }
-
-    it "should return correctly" do
-      expect(level.at?(:debug)).to be_truthy
-      expect(level.at?(:info)).to be_falsey
-      expect(level.at?(:warn)).to be_truthy
-      expect(level.at?(:error)).to be_falsey
-      expect(level.at?(:fatal)).to be_truthy
-    end
-  end
-
-  context "given a Range" do
-    let(:level) { Yell::Level.new( (1..3) ) }
-
-    it "should return correctly" do
-      expect(level.at?(:debug)).to be_falsey
-      expect(level.at?(:info)).to be_truthy
-      expect(level.at?(:warn)).to be_truthy
-      expect(level.at?(:error)).to be_truthy
-      expect(level.at?(:fatal)).to be_falsey
-    end
-  end
-
-  context "given a Yell::Level instance" do
-    let(:level) { Yell::Level.new(:warn) }
-
-    it "should return correctly" do
-      expect(level.at?(:debug)).to be_falsey
-      expect(level.at?(:info)).to be_falsey
-      expect(level.at?(:warn)).to be_truthy
-      expect(level.at?(:error)).to be_truthy
-      expect(level.at?(:fatal)).to be_truthy
-    end
-  end
-
-  context "backwards compatibility" do
-    let(:level) { Yell::Level.new :warn }
-
-    it "should return correctly to :to_i" do
-      expect(level.to_i).to eq(2)
-    end
-
-    it "should typecast with Integer correctly" do
-      expect(Integer(level)).to eq(2)
-    end
-
-    it "should be compatible when passing to array (https://github.com/rudionrails/yell/issues/1)" do
-      severities = %w(FINE INFO WARNING SEVERE SEVERE INFO)
-
-      expect(severities[level]).to eq("WARNING")
-    end
-  end
-
-end
-