steno 1.2.4 → 1.3.5

data/spec/unit/json_prettifier_spec.rb

@@ -1,15 +1,15 @@
-require "spec_helper"
+require 'spec_helper'
 
-require "steno/json_prettifier"
+require 'steno/json_prettifier'
 
 describe Steno::JsonPrettifier do
   let(:prettifier) { Steno::JsonPrettifier.new }
   let(:codec) { Steno::Codec::Json.new }
 
-  describe "#prettify_line" do
-    it "should return a properly formatted string" do
-      record = Steno::Record.new("test", :info, "message",
-                                 ["filename", "line", "method"], "test" => "data")
+  describe '#prettify_line' do
+    it 'returns a properly formatted string' do
+      record = Steno::Record.new('test', :info, 'message',
+                                 %w[filename line method], 'test' => 'data')
       encoded = codec.encode_record(record)
       prettified = prettifier.prettify_line(encoded)
 
@@ -23,16 +23,16 @@ describe Steno::JsonPrettifier do
                    'test=data',                # User supplied data
                    'INFO',                     # Level
                    '--',
-                   'message',                  # Log message
+                   'message' # Log message
                    ].join("\s+") + "\n"
-      prettified.should match(exp_regex)
+      expect(prettified).to match(exp_regex)
     end
 
-    it "should always use the largest src len to determine src column width" do
+    it 'alwayses use the largest src len to determine src column width' do
       test_srcs = [
         'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH - 3),
         'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH - 1),
-        'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH),
+        'a' * Steno::JsonPrettifier::MIN_COL_WIDTH,
         'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH + 1),
         'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH - 3),
         'a' * (Steno::JsonPrettifier::MIN_COL_WIDTH + 3),
@@ -51,34 +51,34 @@ describe Steno::JsonPrettifier do
       test_srcs.each do |src|
         record = Steno::Record.new(src,
                                    :info,
-                                   "message",
-                                   ["filename", "line", "method"],
-                                   "test" => "data")
+                                   'message',
+                                   %w[filename line method],
+                                   'test' => 'data')
 
         encoded = codec.encode_record(record)
         prettified = prettifier.prettify_line(encoded)
         src_col = prettified.match(regex)[1]
 
         max_src_len = [max_src_len, src.length].max
-        src_col.length.should == max_src_len
+        expect(src_col.length).to eq(max_src_len)
       end
     end
 
-    it "should raise a parse error when the json-encoded string is not a hash" do
-      expect {
-        prettifier.prettify_line("[1,2,3]")
-      }.to raise_error(Steno::JsonPrettifier::ParseError)
+    it 'raises a parse error when the json-encoded string is not a hash' do
+      expect do
+        prettifier.prettify_line('[1,2,3]')
+      end.to raise_error(Steno::JsonPrettifier::ParseError)
     end
 
-    it "should raise a parse error when the json-encoded string is malformed" do
-      expect {
-        prettifier.prettify_line("blah")
-      }.to raise_error(Steno::JsonPrettifier::ParseError)
+    it 'raises a parse error when the json-encoded string is malformed' do
+      expect do
+        prettifier.prettify_line('blah')
+      end.to raise_error(Steno::JsonPrettifier::ParseError)
     end
 
-    it "should work with a nil data field" do
-      line = prettifier.prettify_line(%@{"data":null}@)
-      line.should include(" - ")
+    it 'works with a nil data field' do
+      line = prettifier.prettify_line('{"data":null}')
+      expect(line).to include(' - ')
     end
   end
 end

data/spec/unit/log_level_spec.rb

@@ -1,19 +1,18 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::LogLevel do
   let(:info_level) { Steno::LogLevel.new(:info, 2) }
   let(:debug_level) { Steno::LogLevel.new(:debug, 1) }
 
-  it "should be comparable" do
-    (info_level > debug_level).should be_true
-    (debug_level > info_level).should be_false
-    (info_level == info_level).should be_true
+  it 'is comparable' do
+    expect(info_level > debug_level).to be_truthy
+    expect(debug_level > info_level).to be_falsey
+    expect(info_level == info_level).to be_truthy
   end
 
-  describe "#to_s" do
-    it "should return the name of the level" do
-      info_level.to_s.should == "info"
+  describe '#to_s' do
+    it 'returns the name of the level' do
+      expect(info_level.to_s).to eq('info')
     end
   end
-
 end

data/spec/unit/logger_spec.rb

@@ -1,101 +1,101 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Logger do
-  let(:logger) { Steno::Logger.new("test", []) }
+  let(:logger) { Steno::Logger.new('test', []) }
 
-  it "should provide #level, #levelf, and #level? methods for each log level" do
+  it 'provides #level, #levelf, and #level? methods for each log level' do
     Steno::Logger::LEVELS.each do |name, _|
-      [name, name.to_s + "f", name.to_s + "?"].each do |meth|
-        logger.respond_to?(meth).should be_true
+      [name, name.to_s + 'f', name.to_s + '?'].each do |meth|
+        expect(logger.respond_to?(meth)).to be_truthy
       end
     end
   end
 
-  describe "#level_active?" do
-    it "should return a boolean indicating if the level is enabled" do
-      logger.level_active?(:error).should be_true
-      logger.level_active?(:info).should be_true
-      logger.level_active?(:debug).should be_false
+  describe '#level_active?' do
+    it 'returns a boolean indicating if the level is enabled' do
+      expect(logger.level_active?(:error)).to be_truthy
+      expect(logger.level_active?(:info)).to be_truthy
+      expect(logger.level_active?(:debug)).to be_falsey
     end
   end
 
-  describe "#<level>?" do
-    it "should return a boolean indiciating if <level> is enabled" do
-      logger.error?.should be_true
-      logger.info?.should be_true
-      logger.debug?.should be_false
+  describe '#<level>?' do
+    it 'returns a boolean indiciating if <level> is enabled' do
+      expect(logger.error?).to be_truthy
+      expect(logger.info?).to be_truthy
+      expect(logger.debug?).to be_falsey
     end
   end
 
-  describe "#level" do
-    it "should return the name of the currently active level" do
-      logger.level.should == :info
+  describe '#level' do
+    it 'returns the name of the currently active level' do
+      expect(logger.level).to eq(:info)
     end
   end
 
-  describe "#level=" do
-    it "should allow the level to be changed" do
+  describe '#level=' do
+    it 'allows the level to be changed' do
       logger.level = :warn
-      logger.level.should == :warn
-      logger.level_active?(:info).should be_false
-      logger.level_active?(:warn).should be_true
+      expect(logger.level).to eq(:warn)
+      expect(logger.level_active?(:info)).to be_falsey
+      expect(logger.level_active?(:warn)).to be_truthy
     end
   end
 
-  describe "#log" do
-    it "should not forward any messages for levels that are inactive" do
-      sink = double("sink")
-      sink.should_not_receive(:add_record)
+  describe '#log' do
+    it 'does not forward any messages for levels that are inactive' do
+      sink = double('sink')
+      expect(sink).not_to receive(:add_record)
 
-      my_logger = Steno::Logger.new("test", [sink])
+      my_logger = Steno::Logger.new('test', [sink])
 
-      my_logger.debug("test")
+      my_logger.debug('test')
     end
 
-    it "should forward messages for levels that are active" do
-      sink = double("sink")
-      sink.should_receive(:add_record).with(any_args())
+    it 'forwards messages for levels that are active' do
+      sink = double('sink')
+      expect(sink).to receive(:add_record).with(any_args)
 
-      my_logger = Steno::Logger.new("test", [sink])
+      my_logger = Steno::Logger.new('test', [sink])
 
-      my_logger.warn("test")
+      my_logger.warn('test')
     end
 
-    it "should not invoke a supplied block if the level is inactive" do
+    it 'does not invoke a supplied block if the level is inactive' do
       invoked = false
       logger.debug { invoked = true }
-      invoked.should be_false
+      expect(invoked).to be_falsey
     end
 
-    it "should invoke a supplied block if the level is active" do
+    it 'invokes a supplied block if the level is active' do
       invoked = false
       logger.warn { invoked = true }
-      invoked.should be_true
+      expect(invoked).to be_truthy
     end
 
-    it "creates a record with the proper level" do
-      sink = double("sink")
-      Steno::Record.should_receive(:new).with("test", :warn, "message", anything, anything).and_call_original
-      sink.stub(:add_record)
+    it 'creates a record with the proper level' do
+      sink = double('sink')
+      expect(Steno::Record).to receive(:new).with('test', :warn, 'message', anything, anything).and_call_original
+      allow(sink).to receive(:add_record)
 
-      my_logger = Steno::Logger.new("test", [sink])
+      my_logger = Steno::Logger.new('test', [sink])
 
-      my_logger.warn("message")
+      my_logger.warn('message')
     end
   end
 
-  describe "#logf" do
-    it "should format messages according to the supplied format string" do
-      logger.should_receive(:log).with(:debug, "test 1 2.20")
-      logger.debugf("test %d %0.2f", 1, 2.2)
+  describe '#logf' do
+    it 'formats messages according to the supplied format string' do
+      expect(logger).to receive(:log).with(:debug, 'test 1 2.20')
+      logger.debugf('test %d %0.2f', 1, 2.2)
     end
   end
 
-  describe "#tag" do
-    it "should return a tagged logger" do
-      tagged_logger = logger.tag("foo" => "bar")
-      tagged_logger.should_not be_nil
-      tagged_logger.user_data.should == { "foo" => "bar" }
+  describe '#tag' do
+    it 'returns a tagged logger' do
+      tagged_logger = logger.tag('foo' => 'bar')
+      expect(tagged_logger).not_to be_nil
+      expect(tagged_logger.user_data).to eq({ 'foo' => 'bar' })
     end
   end
 end

data/spec/unit/record_spec.rb

@@ -1,30 +1,30 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Record do
-  let(:message) { Array("test message") }
-  let(:record) { Steno::Record.new("test", :info, message) }
+  let(:message) { Array('test message') }
+  let(:record) { Steno::Record.new('test', :info, message) }
 
-  it "should set the process id" do
-    record.process_id.should == Process.pid
+  it 'sets the process id' do
+    expect(record.process_id).to eq(Process.pid)
   end
 
-  it "should set the thread id" do
-    record.thread_id.should == Thread.current.object_id
+  it 'sets the thread id' do
+    expect(record.thread_id).to eq(Thread.current.object_id)
   end
 
-  it "should set the fiber id(if available)", :needs_fibers => true do
-    record.fiber_id.should == Fiber.current.object_id
+  it 'sets the fiber id(if available)', :needs_fibers do
+    expect(record.fiber_id).to eq(Fiber.current.object_id)
   end
 
-  it "should set the source" do
-    record.source.should == "test"
+  it 'sets the source' do
+    expect(record.source).to eq('test')
   end
 
-  it "should stringify the message" do
-    record.message.should be_a(String)
+  it 'stringifies the message' do
+    expect(record.message).to be_a(String)
   end
 
-  it "should use a UTC timestamp" do
-    record.timestamp.to_f.should be_within(0.1).of(Time.now.utc.to_f)
+  it 'uses a UTC timestamp' do
+    expect(record.timestamp.to_f).to be_within(0.1).of(Time.now.utc.to_f)
   end
 end

data/spec/unit/sink/counter_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Sink::Counter do
   let(:level) do
@@ -6,11 +6,11 @@ describe Steno::Sink::Counter do
   end
 
   let(:record) do
-    Steno::Record.new("source", level.name, "message")
+    Steno::Record.new('source', level.name, 'message')
   end
 
-  describe "add_record" do
-    it "counts added records" do
+  describe 'add_record' do
+    it 'counts added records' do
       expect(subject.counts).to be_empty
       subject.add_record(record)
       expect(subject.counts.size).to eq 1
@@ -18,10 +18,10 @@ describe Steno::Sink::Counter do
     end
   end
 
-  describe "to_json" do
-    it "produces a valid json representation" do
+  describe 'to_json' do
+    it 'produces a valid json representation' do
       subject.add_record(record)
       expect(subject.to_json).to match '"info":1'
     end
   end
-end
+end

data/spec/unit/sink/eventlog_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 if Steno::Sink::WINDOWS
   describe Steno::Sink::Eventlog do
     let(:level) do
@@ -6,34 +6,33 @@ if Steno::Sink::WINDOWS
     end
 
     let(:record) do
-      Steno::Record.new("source", level.name, "message")
+      Steno::Record.new('source', level.name, 'message')
     end
 
-    describe "#add_record" do
-
-      it "should append an encoded record with the correct priority" do
-        eventlog = double("Win32::EventLog")
-        Win32::EventLog.should_receive(:open) \
-            .with('Application') \
-            .and_return(eventlog)
+    describe '#add_record' do
+      it 'appends an encoded record with the correct priority' do
+        eventlog = double('Win32::EventLog')
+        Win32::EventLog.should_receive(:open)
+                       .with('Application')
+                       .and_return(eventlog)
 
         sink = Steno::Sink::Eventlog.instance
         sink.open
 
-        codec = double("codec")
+        codec = double('codec')
         codec.should_receive(:encode_record).with(record).and_return(record.message)
         sink.codec = codec
 
-        eventlog.should_receive(:report_event).with(:source      => "CloudFoundry",
-                                                    :event_type  => Win32::EventLog::INFO_TYPE,
-                                                    :data        => record.message)
+        eventlog.should_receive(:report_event).with(source: 'CloudFoundry',
+                                                    event_type: Win32::EventLog::INFO_TYPE,
+                                                    data: record.message)
 
         sink.add_record(record)
       end
     end
 
-    describe "#flush" do
-      it "should do nothing" do
+    describe '#flush' do
+      it 'does nothing' do
         Steno::Sink::Eventlog.instance.flush
       end
     end

data/spec/unit/sink/fluentd_spec.rb

@@ -1,4 +1,4 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Sink::IO do
   let(:level) do
@@ -6,41 +6,41 @@ describe Steno::Sink::IO do
   end
 
   let(:record) do
-    Steno::Record.new("source", level.name, "message")
+    Steno::Record.new('source', level.name, 'message')
   end
 
-  describe "#initialize" do
-    it "should initialize FluentLogger with the default option" do
-      Fluent::Logger::FluentLogger.should_receive(:new).with("steno", {
-        :host => "127.0.0.1",
-        :port => 24224,
-        :buffer_limit => Fluent::Logger::FluentLogger::BUFFER_LIMIT,
-        }).and_return()
-      sink = Steno::Sink::Fluentd.new()
+  describe '#initialize' do
+    it 'initializes FluentLogger with the default option' do
+      expect(Fluent::Logger::FluentLogger).to receive(:new).with('steno', {
+                                                                   host: '127.0.0.1',
+                                                                   port: 24_224,
+                                                                   buffer_limit: Fluent::Logger::FluentLogger::BUFFER_LIMIT
+                                                                 }).and_return(nil)
+      sink = Steno::Sink::Fluentd.new
     end
 
-    it "should initialize FliuentLogger with override options" do
-      Fluent::Logger::FluentLogger.should_receive(:new).with("vcap", {
-        :host => "localhost",
-        :port => 8080,
-        :buffer_limit => 1024,
-        }).and_return()
+    it 'initializes FliuentLogger with override options' do
+      expect(Fluent::Logger::FluentLogger).to receive(:new).with('vcap', {
+                                                                   host: 'localhost',
+                                                                   port: 8080,
+                                                                   buffer_limit: 1024
+                                                                 }).and_return(nil)
       sink = Steno::Sink::Fluentd.new({
-        :tag_prefix => "vcap",
-        :host => "localhost",
-        :port => 8080,
-        :buffer_limit => 1024
-        })
+                                        tag_prefix: 'vcap',
+                                        host: 'localhost',
+                                        port: 8080,
+                                        buffer_limit: 1024
+                                      })
     end
   end
 
-  describe "#add_record" do
-    it "should post an record with the correct tag" do
-      fluentd = double("fluentd")
-      Fluent::Logger::FluentLogger.should_receive(:new).and_return(fluentd)
-      fluentd.should_receive(:post).with("source", record)
-      sink = Steno::Sink::Fluentd.new()
+  describe '#add_record' do
+    it 'posts an record with the correct tag' do
+      fluentd = double('fluentd')
+      expect(Fluent::Logger::FluentLogger).to receive(:new).and_return(fluentd)
+      expect(fluentd).to receive(:post).with('source', record)
+      sink = Steno::Sink::Fluentd.new
       sink.add_record(record)
     end
   end
-end
+end