lumberjack 1.0.13 → 1.2.8

data/spec/device/size_rolling_log_file_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Device::SizeRollingLogFile do
-
-  before :all do
-    create_tmp_dir
-  end
-  
-  after :all do
-    delete_tmp_dir
-  end
-  
-  before :each do
-    delete_tmp_files
-  end
-
-  it "should roll a file when it gets to a specified size" do
-    log_file = File.join(tmp_dir, "a#{rand(1000000000)}.log")
-    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => 40, :template => ":message", :min_roll_check => 0)
-    logger = Lumberjack::Logger.new(device, :buffer_size => 2)
-    4.times do |i|
-      logger.error("test message #{i + 1}")
-      logger.flush
-    end
-    logger.close
-    
-    File.read("#{log_file}.1").split(Lumberjack::LINE_SEPARATOR).should == ["test message 1", "test message 2", "test message 3"]
-    File.read(log_file).should == "test message 4#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should be able to specify the max size in kilobytes" do
-    log_file = File.join(tmp_dir, "b#{rand(1000000000)}.log")
-    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "32K", :min_roll_check => 0)
-    device.max_size.should == 32768
-  end
-  
-  it "should be able to specify the max size in megabytes" do
-    log_file = File.join(tmp_dir, "c#{rand(1000000000)}.log")
-    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "100M", :min_roll_check => 0)
-    device.max_size.should == 104_857_600
-  end
-  
-  it "should be able to specify the max size in gigabytes" do
-    log_file = File.join(tmp_dir, "d#{rand(1000000000)}.log")
-    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "1G", :min_roll_check => 0)
-    device.max_size.should == 1_073_741_824
-  end
-  
-  it "should figure out the next archive file name available" do
-    log_file = File.join(tmp_dir, "filename.log")
-    (3..11).each do |i|
-      File.open("#{log_file}.#{i}", 'w'){|f| f.write(i.to_s)}
-    end
-    device = Lumberjack::Device::SizeRollingLogFile.new(log_file, :max_size => "100M", :min_roll_check => 0)
-    device.archive_file_suffix.should == "12"
-  end
-
-end

data/spec/device/writer_spec.rb

@@ -1,118 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Device::Writer do
-
-  let(:time_string){ "2011-01-15T14:23:45.123" }
-  let(:time){ Time.parse(time_string) }
-  let(:stream){ StringIO.new }
-  let(:entry){ Lumberjack::LogEntry.new(time, Lumberjack::Severity::INFO, "test message", "app", 12345, "ABCD") }
-  
-  it "should buffer output and not write directly to the stream" do
-    device = Lumberjack::Device::Writer.new(stream, :template => ":message", :buffer_size => 32767)
-    device.write(entry)
-    stream.string.should == ""
-    device.flush
-    stream.string.should == "test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-    
-  it "should flush the buffer when it gets to the specified size" do
-    device = Lumberjack::Device::Writer.new(stream, :buffer_size => 15, :template => ":message")
-    device.write(entry)
-    stream.string.should == ""
-    device.write(entry)
-    stream.string.should == "test message#{Lumberjack::LINE_SEPARATOR}test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should sync the stream and flush it when the device is flushed" do
-    # Create an IO like object that require flush to be called
-    io = Object.new
-    def io.init; @string = ""; @buffer = ""; @sync = false; end
-    def io.write(string); @buffer << string; end
-    def io.flush; @string << @buffer; @buffer = ""; end
-    def io.string; @string; end
-    def io.sync=(val); @sync = val; end
-    def io.sync; @sync; end
-    io.init
-    
-    device = Lumberjack::Device::Writer.new(io, :template => ":message", :buffer_size => 32767)
-    device.write(entry)
-    io.string.should == ""
-    device.flush
-    io.string.should == "test message#{Lumberjack::LINE_SEPARATOR}"
-    io.sync.should == true
-  end
-  
-  it "should be able to set the buffer size" do
-    device = Lumberjack::Device::Writer.new(stream, :buffer_size => 15)
-    device.buffer_size.should == 15
-    device.buffer_size = 100
-    device.buffer_size.should == 100
-  end
-  
-  it "should have a default buffer size of 0" do
-    device = Lumberjack::Device::Writer.new(stream)
-    device.buffer_size.should == 0
-  end
-  
-  it "should write entries out to the stream with a default template" do
-    device = Lumberjack::Device::Writer.new(stream)
-    device.write(entry)
-    device.flush
-    stream.string.should == "[2011-01-15T14:23:45.123 INFO app(12345) #ABCD] test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should write entries out to the stream with a custom template" do
-    device = Lumberjack::Device::Writer.new(stream, :template => ":message")
-    device.write(entry)
-    device.flush
-    stream.string.should == "test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should be able to specify the time format for the template" do
-    device = Lumberjack::Device::Writer.new(stream, :time_format => :microseconds)
-    device.write(entry)
-    device.flush
-    stream.string.should == "[2011-01-15T14:23:45.123000 INFO app(12345) #ABCD] test message#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should be able to specify a block template for log entries" do
-    device = Lumberjack::Device::Writer.new(stream, :template => lambda{|e| e.message.upcase})
-    device.write(entry)
-    device.flush
-    stream.string.should == "TEST MESSAGE#{Lumberjack::LINE_SEPARATOR}"
-  end
-  
-  it "should write to STDERR if an error is raised when flushing to the stream" do
-    stderr = $stderr
-    $stderr = StringIO.new
-    begin
-      device = Lumberjack::Device::Writer.new(stream, :template => ":message")
-      stream.should_receive(:write).and_raise(StandardError.new("Cannot write to stream"))
-      device.write(entry)
-      device.flush
-      $stderr.string.should include("test message#{Lumberjack::LINE_SEPARATOR}")
-      $stderr.string.should include("StandardError: Cannot write to stream")
-    ensure
-      $stderr = stderr
-    end
-  end
-  
-  context "multi line messages" do
-    let(:message){ "line 1#{Lumberjack::LINE_SEPARATOR}line 2#{Lumberjack::LINE_SEPARATOR}line 3" }
-    let(:entry){ Lumberjack::LogEntry.new(time, Lumberjack::Severity::INFO, message, "app", 12345, "ABCD") }
-    
-    it "should have a default template for multiline messages" do
-      device = Lumberjack::Device::Writer.new(stream)
-      device.write(entry)
-      device.flush
-      stream.string.split(Lumberjack::LINE_SEPARATOR).should == ["[2011-01-15T14:23:45.123 INFO app(12345) #ABCD] line 1", "> [#ABCD] line 2", "> [#ABCD] line 3"]
-    end
-  
-    it "should be able to specify a template for multiple line messages" do
-      device = Lumberjack::Device::Writer.new(stream, :additional_lines => " // :message")
-      device.write(entry)
-      device.flush
-      stream.string.should == "[2011-01-15T14:23:45.123 INFO app(12345) #ABCD] line 1 // line 2 // line 3#{Lumberjack::LINE_SEPARATOR}"
-    end
-  end
-end

data/spec/formatter/exception_formatter_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::ExceptionFormatter do
-
-  it "should convert an exception without a backtrace to a string" do
-    e = ArgumentError.new("not expected")
-    formatter = Lumberjack::Formatter::ExceptionFormatter.new
-    formatter.call(e).should == "ArgumentError: not expected"
-  end
-  
-  it "should convert an exception with a backtrace to a string" do
-    begin
-      raise ArgumentError.new("not expected")
-    rescue => e
-      formatter = Lumberjack::Formatter::ExceptionFormatter.new
-      formatter.call(e).should == "ArgumentError: not expected#{Lumberjack::LINE_SEPARATOR}  #{e.backtrace.join(Lumberjack::LINE_SEPARATOR + '  ')}"
-    end
-  end
-  
-end

data/spec/formatter/inspect_formatter_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::InspectFormatter do
-
-  it "should format objects as string by calling their inspect method" do
-    formatter = Lumberjack::Formatter::InspectFormatter.new
-    formatter.call("abc").should == "\"abc\""
-    formatter.call(:test).should == ":test"
-    formatter.call(1).should == "1"
-    formatter.call([:a, 1, "b"]).should == [:a, 1, "b"].inspect
-  end
-
-end

data/spec/formatter/pretty_print_formatter_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::PrettyPrintFormatter do
-
-  it "should convert an object to a string using pretty print" do
-    object = Object.new
-    def object.pretty_print(q)
-      q.text "woot!"
-    end
-    formatter = Lumberjack::Formatter::PrettyPrintFormatter.new
-    formatter.call(object).should == "woot!"
-  end
-
-end

data/spec/formatter/string_formatter_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter::StringFormatter do
-
-  it "should format objects as string by calling their to_s method" do
-    formatter = Lumberjack::Formatter::StringFormatter.new
-    formatter.call("abc").should == "abc"
-    formatter.call(:test).should == "test"
-    formatter.call(1).should == "1"
-  end
-
-end

data/spec/formatter_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::Formatter do
-
-  let(:formatter){ Lumberjack::Formatter.new }
-  
-  it "should have a default set of formatters" do
-    formatter.format("abc").should == "abc"
-    formatter.format([1, 2, 3]).should == "[1, 2, 3]"
-    formatter.format(ArgumentError.new("boom")).should == "ArgumentError: boom"
-  end
-  
-  it "should be able to add a formatter object for a class" do
-    formatter.add(Numeric, lambda{|obj| "number: #{obj}"})
-    formatter.format(10).should == "number: 10"
-  end
-  
-  it "should be able to add a formatter block for a class" do
-    formatter.add(Numeric){|obj| "number: #{obj}"}
-    formatter.format(10).should == "number: 10"
-  end
-  
-  it "should be able to remove a formatter for a class" do
-    formatter.remove(String)
-    formatter.format("abc").should == "\"abc\""
-  end
-  
-  it "should be able to chain add and remove calls" do
-    formatter.remove(String).should == formatter
-    formatter.add(String, Lumberjack::Formatter::StringFormatter.new).should == formatter
-  end
-  
-  it "should format an object based on the class hierarchy" do
-    formatter.add(Numeric){|obj| "number: #{obj}"}
-    formatter.add(Integer){|obj| "fixed number: #{obj}"}
-    formatter.format(10).should == "fixed number: 10"
-    formatter.format(10.1).should == "number: 10.1"
-  end
-  
-  it "should have a default formatter" do
-    formatter.remove(Object)
-    formatter.format(:test).should == ":test"
-  end
-
-end

data/spec/log_entry_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe Lumberjack::LogEntry do
-  
-  it "should have a time" do
-    t = Time.now
-    entry = Lumberjack::LogEntry.new(t, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.time.should == t
-    entry.time = t + 1
-    entry.time.should == t + 1
-  end
-  
-  it "should have a severity" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.severity.should == Lumberjack::Severity::INFO
-    entry.severity = Lumberjack::Severity::WARN
-    entry.severity.should == Lumberjack::Severity::WARN
-  end
-  
-  it "should convert a severity label to a numeric level" do
-    entry = Lumberjack::LogEntry.new(Time.now, "INFO", "test", "app", 1500, "ABCD")
-    entry.severity.should == Lumberjack::Severity::INFO
-  end
-  
-  it "should get the severity as a string" do
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::DEBUG, "test", "app", 1500, nil).severity_label.should == "DEBUG"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, nil).severity_label.should == "INFO"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::WARN, "test", "app", 1500, nil).severity_label.should == "WARN"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::ERROR, "test", "app", 1500, nil).severity_label.should == "ERROR"
-    Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::FATAL, "test", "app", 1500, nil).severity_label.should == "FATAL"
-    Lumberjack::LogEntry.new(Time.now, -1, "test", "app", 1500, nil).severity_label.should == "UNKNOWN"
-    Lumberjack::LogEntry.new(Time.now, 1000, "test", "app", 1500, nil).severity_label.should == "UNKNOWN"
-  end
-  
-  it "should have a message" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.message.should == "test"
-    entry.message = "new message"
-    entry.message.should == "new message"
-  end
-  
-  it "should have a progname" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.progname.should == "app"
-    entry.progname = "prog"
-    entry.progname.should == "prog"
-  end
-  
-  it "should have a pid" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.pid.should == 1500
-    entry.pid = 150
-    entry.pid.should == 150
-  end
-  
-  it "should have a unit_of_work_id" do
-    entry = Lumberjack::LogEntry.new(Time.now, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.unit_of_work_id.should == "ABCD"
-    entry.unit_of_work_id = "1234"
-    entry.unit_of_work_id.should == "1234"
-  end
-  
-  it "should be converted to a string" do
-    t = Time.parse("2011-01-29T12:15:32.001")
-    entry = Lumberjack::LogEntry.new(t, Lumberjack::Severity::INFO, "test", "app", 1500, "ABCD")
-    entry.to_s.should == "[2011-01-29T12:15:32.001 INFO app(1500) #ABCD] test"
-  end
-
-end

data/spec/logger_spec.rb

@@ -1,411 +0,0 @@
-require 'spec_helper'
-require 'pathname'
-
-describe Lumberjack::Logger do
-
-  context "initialization" do
-
-    before :all do
-      create_tmp_dir
-    end
-
-    after :all do
-      delete_tmp_dir
-    end
-
-    it "should wrap an IO stream in a device" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output)
-      logger.device.class.should == Lumberjack::Device::Writer
-    end
-
-    it "should have a formatter" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output)
-      logger.formatter.should be
-    end
-
-    it "should open a file path in a device" do
-      logger = Lumberjack::Logger.new(File.join(tmp_dir, "log_file_1.log"))
-      logger.device.class.should == Lumberjack::Device::LogFile
-    end
-
-    it "should open a pathname in a device" do
-      logger = Lumberjack::Logger.new(Pathname.new(File.join(tmp_dir, "log_file_1.log")))
-      logger.device.class.should == Lumberjack::Device::LogFile
-    end
-
-    it "should use the null device if the stream is :null" do
-      logger = Lumberjack::Logger.new(:null)
-      logger.device.class.should == Lumberjack::Device::Null
-    end
-
-    it "should set the level with a numeric" do
-      logger = Lumberjack::Logger.new(:null, :level => Lumberjack::Severity::WARN)
-      logger.level.should == Lumberjack::Severity::WARN
-    end
-
-    it "should set the level with a level" do
-      logger = Lumberjack::Logger.new(:null, :level => :warn)
-      logger.level.should == Lumberjack::Severity::WARN
-    end
-
-    it "should default the level to INFO" do
-      logger = Lumberjack::Logger.new(:null)
-      logger.level.should == Lumberjack::Severity::INFO
-    end
-
-    it "should set the progname"do
-      logger = Lumberjack::Logger.new(:null, :progname => "app")
-      logger.progname.should == "app"
-    end
-
-    it "should create a thread to flush the device" do
-      Thread.should_receive(:new)
-      logger = Lumberjack::Logger.new(:null, :flush_seconds => 10)
-    end
-  end
-
-  context "attributes" do
-    it "should have a level" do
-      logger = Lumberjack::Logger.new
-      logger.level = Lumberjack::Severity::DEBUG
-      logger.level.should == Lumberjack::Severity::DEBUG
-    end
-
-    it "should have a progname" do
-      logger = Lumberjack::Logger.new
-      logger.progname = "app"
-      logger.progname.should == "app"
-    end
-
-    it "should be able to silence the log in a block" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      logger.info("one")
-      logger.silence do
-        logger.level.should == Lumberjack::Severity::ERROR
-        logger.info("two")
-        logger.error("three")
-      end
-      logger.info("four")
-      output.string.split.should == ["one", "three", "four"]
-    end
-
-    it "should be able to customize the level of silence in a block" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      logger.info("one")
-      logger.silence(Lumberjack::Severity::FATAL) do
-        logger.level.should == Lumberjack::Severity::FATAL
-        logger.info("two")
-        logger.error("three")
-        logger.fatal("woof")
-      end
-      logger.info("four")
-      output.string.split.should == ["one", "woof", "four"]
-    end
-
-    it "should not be able to silence the logger if silencing is disabled" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      logger.silencer = false
-      logger.info("one")
-      logger.silence do
-        logger.level.should == Lumberjack::Severity::INFO
-        logger.info("two")
-        logger.error("three")
-      end
-      logger.info("four")
-      output.string.split.should == ["one", "two", "three", "four"]
-    end
-
-    it "should be able to set the progname in a block" do
-      logger = Lumberjack::Logger.new
-      logger.set_progname("app")
-      logger.progname.should == "app"
-      block_executed = false
-      logger.set_progname("xxx") do
-        block_executed = true
-        logger.progname.should == "xxx"
-      end
-      block_executed.should == true
-      logger.progname.should == "app"
-    end
-
-    it "should only affect the current thread when silencing the logger" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":message")
-      # status is used to make sure the two threads are executing at the same time
-      status = 0
-      begin
-        Thread.new do
-          logger.silence do
-            logger.info("inner")
-            status = 1
-            loop{ sleep(0.001); break if status == 2}
-          end
-        end
-        loop{ sleep(0.001); break if status == 1}
-        logger.info("outer")
-        status = 2
-        logger.close
-        output.string.should include("outer")
-        output.string.should_not include("inner")
-      ensure
-        status = 2
-      end
-    end
-
-    it "should only affect the current thread when changing the progname in a block" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :progname => "thread1", :buffer_size => 0, :level => Lumberjack::Severity::INFO, :template => ":progname :message")
-      # status is used to make sure the two threads are executing at the same time
-      status = 0
-      begin
-        Thread.new do
-          logger.set_progname("thread2") do
-            logger.info("inner")
-            status = 1
-            loop{ sleep(0.001); break if status == 2}
-          end
-        end
-        loop{ sleep(0.001); break if status == 1}
-        logger.info("outer")
-        status = 2
-        logger.close
-        output.string.should include("thread1")
-        output.string.should include("thread2")
-      ensure
-        status = 2
-      end
-    end
-  end
-
-  context "flushing" do
-    it "should autoflush the buffer if it hasn't been flushed in a specified number of seconds" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :flush_seconds => 0.1, :level => Lumberjack::Severity::INFO, :template => ":message", :buffer_size => 32767)
-      logger.info("message 1")
-      logger.info("message 2")
-      output.string.should == ""
-      sleep(0.15)
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1", "message 2"]
-      logger.info("message 3")
-      output.string.should_not include("message 3")
-      sleep(0.15)
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1", "message 2", "message 3"]
-    end
-
-    it "should write the log entries to the device on flush and update the last flushed time" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :level => Lumberjack::Severity::INFO, :template => ":message", :buffer_size => 32767)
-      logger.info("message 1")
-      output.string.should == ""
-      last_flushed_at = logger.last_flushed_at
-      logger.flush
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1"]
-      logger.last_flushed_at.should >= last_flushed_at
-    end
-
-    it "should flush the buffer and close the devices" do
-      output = StringIO.new
-      logger = Lumberjack::Logger.new(output, :level => Lumberjack::Severity::INFO, :template => ":message", :buffer_size => 32767)
-      logger.info("message 1")
-      output.string.should == ""
-      logger.close
-      output.string.split(Lumberjack::LINE_SEPARATOR).should == ["message 1"]
-      output.should be_closed
-    end
-  end
-
-  context "logging" do
-    let(:output){ StringIO.new }
-    let(:device){ Lumberjack::Device::Writer.new(output, :buffer_size => 0) }
-    let(:logger){ Lumberjack::Logger.new(device, :level => Lumberjack::Severity::INFO, :progname => "test") }
-    let(:n){ Lumberjack::LINE_SEPARATOR }
-
-    it "should add entries with a numeric severity and a message" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(Lumberjack::Severity::INFO, "test")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a severity label" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(:info, "test")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a custom progname and message" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(Lumberjack::Severity::INFO, "test", "app")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO app(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a local progname and message" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.set_progname("block") do
-        logger.add(Lumberjack::Severity::INFO, "test")
-      end
-      output.string.should == "[2011-01-30T12:31:56.123 INFO block(#{$$}) #] test#{n}"
-    end
-
-    it "should add entries with a progname but no message or block" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.set_progname("default") do
-        logger.add(Lumberjack::Severity::INFO, nil, "message")
-      end
-      output.string.should == "[2011-01-30T12:31:56.123 INFO default(#{$$}) #] message#{n}"
-    end
-
-    it "should add entries with a block" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.add(Lumberjack::Severity::INFO){"test"}
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should log entries (::Logger compatibility)" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger.log(Lumberjack::Severity::INFO, "test")
-      output.string.should == "[2011-01-30T12:31:56.123 INFO test(#{$$}) #] test#{n}"
-    end
-
-    it "should append messages with unknown severity to the log" do
-      time = Time.parse("2011-01-30T12:31:56.123")
-      Time.stub(:now => time)
-      logger << "test"
-      output.string.should == "[2011-01-30T12:31:56.123 UNKNOWN test(#{$$}) #] test#{n}"
-    end
-
-    it "should ouput entries to STDERR if they can't be written the the device" do
-      stderr = $stderr
-      $stderr = StringIO.new
-      begin
-        time = Time.parse("2011-01-30T12:31:56.123")
-        Time.stub(:now => time)
-        device.should_receive(:write).and_raise(StandardError.new("Cannot write to device"))
-        logger.add(Lumberjack::Severity::INFO, "test")
-        $stderr.string.should include("[2011-01-30T12:31:56.123 INFO test(#{$$})] test")
-        $stderr.string.should include("StandardError: Cannot write to device")
-      ensure
-        $stderr = stderr
-      end
-    end
-
-    context "log helper methods" do
-      let(:device){ Lumberjack::Device::Writer.new(output, :buffer_size => 0, :template => ":message") }
-
-      it "should only add messages whose severity is greater or equal to the logger level" do
-        logger.add(Lumberjack::Severity::DEBUG, "debug")
-        logger.add(Lumberjack::Severity::INFO, "info")
-        logger.add(Lumberjack::Severity::ERROR, "error")
-        output.string.should == "info#{n}error#{n}"
-      end
-
-      it "should only log fatal messages when the level is set to fatal" do
-        logger.level = Lumberjack::Severity::FATAL
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == false
-        logger.warn("warn")
-        logger.warn?.should == false
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}unknown#{n}"
-      end
-
-      it "should only log error messages and higher when the level is set to error" do
-        logger.level = Lumberjack::Severity::ERROR
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == false
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}unknown#{n}"
-      end
-
-      it "should only log warn messages and higher when the level is set to warn" do
-        logger.level = Lumberjack::Severity::WARN
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == true
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}warn#{n}unknown#{n}"
-      end
-
-      it "should only log info messages and higher when the level is set to info" do
-        logger.level = Lumberjack::Severity::INFO
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == true
-        logger.info("info")
-        logger.info?.should == true
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}warn#{n}info#{n}unknown#{n}"
-      end
-
-      it "should log all messages when the level is set to debug" do
-        logger.level = Lumberjack::Severity::DEBUG
-        logger.fatal("fatal")
-        logger.fatal?.should == true
-        logger.error("error")
-        logger.error?.should == true
-        logger.warn("warn")
-        logger.warn?.should == true
-        logger.info("info")
-        logger.info?.should == true
-        logger.debug("debug")
-        logger.debug?.should == true
-        logger.unknown("unknown")
-        output.string.should == "fatal#{n}error#{n}warn#{n}info#{n}debug#{n}unknown#{n}"
-      end
-
-      it "should only log unkown messages when the level is set above fatal" do
-        logger.level = Lumberjack::Severity::FATAL + 1
-        logger.fatal("fatal")
-        logger.fatal?.should == false
-        logger.error("error")
-        logger.error?.should == false
-        logger.warn("warn")
-        logger.warn?.should == false
-        logger.info("info")
-        logger.info?.should == false
-        logger.debug("debug")
-        logger.debug?.should == false
-        logger.unknown("unknown")
-        output.string.should == "unknown#{n}"
-      end
-    end
-  end
-
-end