lumberjack_aziz_light 1.0.5

data/spec/device/writer_spec.rb

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,45 @@
+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(Fixnum){|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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,390 @@
+require 'spec_helper'
+
+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 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 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).and_return(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).and_return(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).and_return(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).and_return(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 block" do
+      time = Time.parse("2011-01-30T12:31:56.123")
+      Time.stub!(:now).and_return(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).and_return(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).and_return(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).and_return(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