yell 1.4.0 → 2.2.2

data/spec/yell/adapters/streams_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters::Stdout do
-
-  it { should be_kind_of(Yell::Adapters::Io) }
-
-  context "#stream" do
-    subject { Yell::Adapters::Stdout.new.send :stream }
-
-    it { should be_kind_of(IO) }
-  end
-
-end
-
-describe Yell::Adapters::Stderr do
-
-  it { should be_kind_of(Yell::Adapters::Io) }
-
-  context "#stream" do
-    subject { Yell::Adapters::Stderr.new.send(:stream) }
-
-    it { should be_kind_of(IO) }
-  end
-
-end
-

data/spec/yell/adapters_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Adapters do
-
-  context ".new" do
-    it "should accept an adapter instance" do
-      stdout = Yell::Adapters::Stdout.new
-      adapter = Yell::Adapters.new(stdout)
-
-      expect(adapter).to eq(stdout)
-    end
-
-    it "should accept STDOUT" do
-      mock.proxy(Yell::Adapters::Stdout).new(anything)
-
-      Yell::Adapters.new(STDOUT)
-    end
-
-    it "should accept STDERR" do
-      mock.proxy(Yell::Adapters::Stderr).new(anything)
-
-      Yell::Adapters.new(STDERR)
-    end
-
-    it "should raise an unregistered adapter" do
-      expect {
-        Yell::Adapters.new :unknown
-      }.to raise_error(Yell::AdapterNotFound)
-    end
-  end
-
-  context ".register" do
-    let(:name) { :test }
-    let(:klass) { mock }
-
-    before { Yell::Adapters.register(name, klass) }
-
-    it "should allow to being called from :new" do
-      mock(klass).new(anything)
-
-      Yell::Adapters.new(name)
-    end
-  end
-
-end

data/spec/yell/configuration_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Configuration do
-
-  describe ".load!" do
-    let(:file) { fixture_path + '/yell.yml' }
-    let(:config) { Yell::Configuration.load!(file) }
-
-    subject { config }
-
-    it { should be_kind_of(Hash) }
-    it { should have_key(:level) }
-    it { should have_key(:adapters) }
-
-    context ":level" do
-      subject { config[:level] }
-
-      it { should eq("info") }
-    end
-
-    context ":adapters" do
-      subject { config[:adapters] }
-
-      it { should be_kind_of(Array) }
-
-      # stdout
-      it { expect(subject.first).to eq(:stdout) }
-
-      # stderr
-      it { expect(subject.last).to be_kind_of(Hash) }
-      it { expect(subject.last).to eq(:stderr => {:level => 'gte.error'}) }
-    end
-  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,136 +0,0 @@
-require 'spec_helper'
-
-describe Yell::Formatter do
-
-  let(:logger) { Yell::Logger.new }
-  let(:event) { Yell::Event.new(logger, 1, 'Hello World!') }
-  let(:time) { Time.now }
-
-  let(:pattern) { "%m" }
-  let(:formatter) { Yell::Formatter.new(pattern) }
-
-  before do
-    Timecop.freeze(time)
-  end
-
-  describe "#format" do
-    subject { formatter.format(event) }
-
-    context "%m" do
-      let(:pattern) { "%m" }
-      it { should eq(event.messages.join(' ')) }
-    end
-
-    context "%l" do
-      let(:pattern) { "%l" }
-      it { should eq(Yell::Severities[event.level][0,1]) }
-    end
-
-    context "%L" do
-      let(:pattern) { "%L" }
-      it { should eq(Yell::Severities[event.level]) }
-    end
-
-    context "%d" do
-      let(:pattern) { "%d" }
-      it { should eq(event.time.iso8601) }
-    end
-
-    context "%p" do
-      let(:pattern) { "%p" }
-      it { should eq(event.pid.to_s) }
-    end
-
-    context "%P" do
-      let(:pattern) { "%P" }
-      it { should eq(event.progname) }
-    end
-    context "%t" do
-      let(:pattern) { "%t" }
-      it { should eq(event.thread_id.to_s) }
-    end
-
-    context "%h" do
-      let(:pattern) { "%h" }
-      it { should eq(event.hostname) }
-    end
-
-    context ":caller" do
-      let(:_caller) { [nil, nil, "/path/to/file.rb:123:in `test_method'"] }
-
-      before do
-        any_instance_of(Yell::Event) do |e|
-          stub(e).file { "/path/to/file.rb" }
-          stub(e).line { "123" }
-          stub(e).method { "test_method" }
-        end
-      end
-
-      context "%F" do
-        let(:pattern) { "%F" }
-        it { should eq("/path/to/file.rb") }
-      end
-
-      context "%f" do
-        let(:pattern) { "%f" }
-        it { should eq("file.rb") }
-      end
-
-      context "%M" do
-        let(:pattern) { "%M" }
-        it { should eq("test_method") }
-      end
-
-      context "%n" do
-        let(:pattern) { "%n" }
-        it { should eq("123") }
-      end
-    end
-  end
-
-  describe "#format from presets" do
-    subject { formatter.format(event) }
-
-    context "NoFormat" do
-      let(:pattern) { Yell::NoFormat }
-      it { should eq("Hello World!") }
-    end
-
-    context "DefaultFormat" do
-      let(:pattern) { Yell::DefaultFormat }
-      it { should eq("#{time.iso8601} [ INFO] #{$$} : Hello World!")  }
-    end
-
-    context "BasicFormat" do
-      let(:pattern) { Yell::BasicFormat }
-      it { should eq("I, #{time.iso8601} : Hello World!") }
-    end
-
-    context "ExtendedFormat" do
-      let(:pattern) { Yell::ExtendedFormat }
-      it { should eq("#{time.iso8601} [ INFO] #{$$} #{Socket.gethostname} : Hello World!") }
-    end
-  end
-
-  describe "#format from exception" do
-    let(:exception) { StandardError.new( "This is an Exception" ) }
-    let(:event) { Yell::Event.new(logger, 1, exception) }
-    subject { formatter.format(event) }
-
-    before do
-      mock(exception).backtrace.times(any_times) { ["backtrace"] }
-    end
-
-    it { should eq("StandardError: This is an Exception\n\tbacktrace") }
-  end
-
-  describe "#format from hash messages" do
-    let(:hash) { { :test => 'message' } }
-    let(:event) { Yell::Event.new(logger, 1, hash) }
-    subject { formatter.format(event) }
-
-    it { should eq("test: message") }
-  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_true
-      expect(level.at?(:info)).to be_true
-      expect(level.at?(:warn)).to be_true
-      expect(level.at?(:error)).to be_true
-      expect(level.at?(:fatal)).to be_true
-    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_true
-        expect(level.at?(:info)).to be_true
-        expect(level.at?(:warn)).to be_true
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_true
-      end
-    end
-
-    context ":info" do
-      let(:severity) { :info }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_false
-        expect(level.at?(:info)).to be_true
-        expect(level.at?(:warn)).to be_true
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_true
-      end
-    end
-
-    context ":warn" do
-      let(:severity) { :warn }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_false
-        expect(level.at?(:info)).to be_false
-        expect(level.at?(:warn)).to be_true
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_true
-      end
-    end
-
-    context ":error" do
-      let(:severity) { :error }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_false
-        expect(level.at?(:info)).to be_false
-        expect(level.at?(:warn)).to be_false
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_true
-      end
-    end
-
-    context ":fatal" do
-      let(:severity) { :fatal }
-
-      it "should should return correctly" do
-        expect(level.at?(:debug)).to be_false
-        expect(level.at?(:info)).to be_false
-        expect(level.at?(:warn)).to be_false
-        expect(level.at?(:error)).to be_false
-        expect(level.at?(:fatal)).to be_true
-      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_false
-        expect(level.at?(:info)).to be_false
-        expect(level.at?(:warn)).to be_false
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_true
-      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_false
-        expect(level.at?(:info)).to be_true
-        expect(level.at?(:warn)).to be_true
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_false
-      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_false
-        expect(level.at?(:info)).to be_false
-        expect(level.at?(:warn)).to be_true
-        expect(level.at?(:error)).to be_false
-        expect(level.at?(:fatal)).to be_false
-      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_false
-        expect(level.at?(:info)).to be_true
-        expect(level.at?(:warn)).to be_false
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_false
-      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_true
-        expect(level.at?(:info)).to be_false
-        expect(level.at?(:warn)).to be_false
-        expect(level.at?(:error)).to be_true
-        expect(level.at?(:fatal)).to be_true
-      end
-    end
-  end
-
-  context "given an Array" do
-    let(:level) { Yell::Level.new( [:debug, :warn, :fatal] ) }
-
-    it "should return correctly" do
-      expect(level.at?(:debug)).to be_true
-      expect(level.at?(:info)).to be_false
-      expect(level.at?(:warn)).to be_true
-      expect(level.at?(:error)).to be_false
-      expect(level.at?(:fatal)).to be_true
-    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_false
-      expect(level.at?(:info)).to be_true
-      expect(level.at?(:warn)).to be_true
-      expect(level.at?(:error)).to be_true
-      expect(level.at?(:fatal)).to be_false
-    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_false
-      expect(level.at?(:info)).to be_false
-      expect(level.at?(:warn)).to be_true
-      expect(level.at?(:error)).to be_true
-      expect(level.at?(:fatal)).to be_true
-    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
-

data/spec/yell/loggable_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-class LoggableFactory
-  include Yell::Loggable
-end
-
-describe Yell::Loggable do
-  let(:factory) { LoggableFactory.new }
-  subject { factory }
-
-  it { should respond_to(:logger) }
-
-  it "should make a lookup in the Yell::Repository" do
-    mock(Yell::Repository)[LoggableFactory]
-
-    factory.logger
-  end
-
-end
-