steno 1.3.4 → 1.3.5

data/spec/unit/config_spec.rb

@@ -1,29 +1,28 @@
-require "fileutils"
-require "yaml"
+require 'fileutils'
+require 'yaml'
 
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Config do
-
   if Steno::Sink::WINDOWS
-    describe ".from_hash" do
-      before :each do
-        @log_path = "some_file"
+    describe '.from_hash' do
+      before do
+        @log_path = 'some_file'
 
-        @mock_sink_file = double("sink")
+        @mock_sink_file = double('sink')
         expect(@mock_sink_file).to receive(:codec=)
         expect(Steno::Sink::IO).to receive(:for_file).with(@log_path,
-                                                       :max_retries => 5)
-        .and_return(@mock_sink_file)
+                                                           max_retries: 5)
+                                                     .and_return(@mock_sink_file)
 
-        @mock_sink_eventlog = double("sink")
+        @mock_sink_eventlog = double('sink')
         expect(@mock_sink_eventlog).to receive(:codec=)
-        expect(@mock_sink_eventlog).to receive(:open).with("test")
-        expect(Steno::Sink::Eventlog).to receive(:instance).twice()
-        .and_return(@mock_sink_eventlog)
+        expect(@mock_sink_eventlog).to receive(:open).with('test')
+        expect(Steno::Sink::Eventlog).to receive(:instance).twice
+                                                           .and_return(@mock_sink_eventlog)
       end
 
-      after :each do
+      after do
         @config = Steno::Config.from_hash(@hash)
 
         expect(@config.default_log_level).to eq(:debug2)
@@ -31,49 +30,48 @@ describe Steno::Config do
         expect(@config.codec.class).to eq(Steno::Codec::Json)
 
         expect(@config.sinks.size).to eq(2)
-        expect(@config.sinks).to match_array([@mock_sink_file, @mock_sink_eventlog])
+        expect(@config.sinks).to contain_exactly(@mock_sink_file, @mock_sink_eventlog)
       end
 
-      it "should work for symbolized keys" do
+      it 'works for symbolized keys' do
         @hash = {
-            :file => @log_path,
-            :level => "debug2",
-            :default_log_level => "warn",
-            :eventlog => "test",
-            :max_retries => 5,
+          file: @log_path,
+          level: 'debug2',
+          default_log_level: 'warn',
+          eventlog: 'test',
+          max_retries: 5
         }
       end
 
-      it "should work for non-symbolized keys" do
+      it 'works for non-symbolized keys' do
         @hash = {
-            "file" => @log_path,
-            "level" => "debug2",
-            "default_log_level" => "warn",
-            "eventlog" => "test",
-            "max_retries" => 5,
+          'file' => @log_path,
+          'level' => 'debug2',
+          'default_log_level' => 'warn',
+          'eventlog' => 'test',
+          'max_retries' => 5
         }
       end
-
     end
   else
-    describe ".from_hash" do
-      before :each do
-        @log_path = "some_file"
+    describe '.from_hash' do
+      before do
+        @log_path = 'some_file'
 
-        @mock_sink_file = double("sink")
+        @mock_sink_file = double('sink')
         allow(@mock_sink_file).to receive(:codec=)
         expect(Steno::Sink::IO).to receive(:for_file).with(@log_path,
-                                                       :max_retries => 5)
-        .and_return(@mock_sink_file)
+                                                           max_retries: 5)
+                                                     .and_return(@mock_sink_file)
 
-        @mock_sink_syslog = double("sink")
+        @mock_sink_syslog = double('sink')
         expect(@mock_sink_syslog).to receive(:codec=)
-        expect(@mock_sink_syslog).to receive(:open).with("test")
-        expect(Steno::Sink::Syslog).to receive(:instance).twice()
-        .and_return(@mock_sink_syslog)
+        expect(@mock_sink_syslog).to receive(:open).with('test')
+        expect(Steno::Sink::Syslog).to receive(:instance).twice
+                                                         .and_return(@mock_sink_syslog)
       end
 
-      after :each do
+      after do
         @config = Steno::Config.from_hash(@hash)
 
         expect(@config.default_log_level).to eq(:debug2)
@@ -81,44 +79,43 @@ describe Steno::Config do
         expect(@config.codec.class).to eq(Steno::Codec::Json)
 
         expect(@config.sinks.size).to eq(2)
-        expect(@config.sinks).to match_array([@mock_sink_file, @mock_sink_syslog])
+        expect(@config.sinks).to contain_exactly(@mock_sink_file, @mock_sink_syslog)
       end
 
-      it "should work for symbolized keys" do
+      it 'works for symbolized keys' do
         @hash = {
-            :file => @log_path,
-            :level => "debug2",
-            :default_log_level => "warn",
-            :syslog => "test",
-            :max_retries => 5,
+          file: @log_path,
+          level: 'debug2',
+          default_log_level: 'warn',
+          syslog: 'test',
+          max_retries: 5
         }
       end
 
-      it "should work for non-symbolized keys" do
+      it 'works for non-symbolized keys' do
         @hash = {
-            "file" => @log_path,
-            "level" => "debug2",
-            "default_log_level" => "warn",
-            "syslog" => "test",
-            "max_retries" => 5,
+          'file' => @log_path,
+          'level' => 'debug2',
+          'default_log_level' => 'warn',
+          'syslog' => 'test',
+          'max_retries' => 5
         }
       end
-
     end
   end
 
-  describe ".from_file" do
-    before :each do
+  describe '.from_file' do
+    before do
       @tmpdir = Dir.mktmpdir
-      @config_path = File.join(@tmpdir, "config.yml")
-      @log_path = File.join(@tmpdir, "test.log")
+      @config_path = File.join(@tmpdir, 'config.yml')
+      @log_path = File.join(@tmpdir, 'test.log')
     end
 
-    after :each do
+    after do
       FileUtils.rm_rf(@tmpdir)
     end
 
-    it "should return Steno::Config instance with sane defaults" do
+    it 'returns Steno::Config instance with sane defaults' do
       write_config(@config_path, {})
 
       config = Steno::Config.from_file(@config_path)
@@ -134,60 +131,60 @@ describe Steno::Config do
       expect(config.codec.iso8601_timestamps?).to eq(false)
     end
 
-    it "should configure json codec with readable dates if iso8601_timestamps is true" do
-      write_config(@config_path, {"iso8601_timestamps" => "true"})
+    it 'configures json codec with readable dates if iso8601_timestamps is true' do
+      write_config(@config_path, { 'iso8601_timestamps' => 'true' })
       config = Steno::Config.from_file(@config_path)
       expect(config.codec.class).to eq(Steno::Codec::Json)
       expect(config.codec.iso8601_timestamps?).to eq(true)
     end
 
-    it "should set the default_log_level if a key with the same name is supplied" do
-      write_config(@config_path, {"level" => "debug2"})
+    it 'sets the default_log_level if a key with the same name is supplied' do
+      write_config(@config_path, { 'level' => 'debug2' })
       expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
 
-      write_config(@config_path, {"default_log_level" => "debug2"})
+      write_config(@config_path, { 'default_log_level' => 'debug2' })
       expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
     end
 
-    it "should read the 'level' key if both default_log_level and level are spscified" do
-      write_config(@config_path, {"level" => "debug2",
-                                  "default_log_level" => "warn"})
+    it "reads the 'level' key if both default_log_level and level are spscified" do
+      write_config(@config_path, { 'level' => 'debug2',
+                                   'default_log_level' => 'warn' })
       expect(Steno::Config.from_file(@config_path).default_log_level).to eq(:debug2)
     end
 
-    it "should add a file sink if the 'file' key is specified" do
-      write_config(@config_path, {"file" => @log_path, "max_retries" => 2})
-      mock_sink = double("sink")
+    it "adds a file sink if the 'file' key is specified" do
+      write_config(@config_path, { 'file' => @log_path, 'max_retries' => 2 })
+      mock_sink = double('sink')
       expect(mock_sink).to receive(:codec=)
 
-      expect(Steno::Sink::IO).to receive(:for_file).
-          with(@log_path, :max_retries => 2).and_return(mock_sink)
+      expect(Steno::Sink::IO).to receive(:for_file)
+        .with(@log_path, max_retries: 2).and_return(mock_sink)
       config = Steno::Config.from_file(@config_path)
       expect(config.sinks.size).to eq(1)
       expect(config.sinks[0]).to eq(mock_sink)
     end
 
     if Steno::Sink::WINDOWS
-      it "should add a event sink if the 'eventlog' key is specified" do
-        write_config(@config_path, {"eventlog" => "test"})
-        mock_sink = double("sink")
-        expect(mock_sink).to receive(:open).with("test")
+      it "adds a event sink if the 'eventlog' key is specified" do
+        write_config(@config_path, { 'eventlog' => 'test' })
+        mock_sink = double('sink')
+        expect(mock_sink).to receive(:open).with('test')
         expect(mock_sink).to receive(:codec=)
 
-        expect(Steno::Sink::Eventlog).to receive(:instance).twice().and_return(mock_sink)
+        expect(Steno::Sink::Eventlog).to receive(:instance).twice.and_return(mock_sink)
 
         config = Steno::Config.from_file(@config_path)
         expect(config.sinks.size).to eq(1)
         expect(config.sinks[0]).to eq(mock_sink)
       end
     else
-      it "should add a syslog sink if the 'syslog' key is specified" do
-        write_config(@config_path, {"syslog" => "test"})
-        mock_sink = double("sink")
-        expect(mock_sink).to receive(:open).with("test")
+      it "adds a syslog sink if the 'syslog' key is specified" do
+        write_config(@config_path, { 'syslog' => 'test' })
+        mock_sink = double('sink')
+        expect(mock_sink).to receive(:open).with('test')
         expect(mock_sink).to receive(:codec=)
 
-        expect(Steno::Sink::Syslog).to receive(:instance).twice().and_return(mock_sink)
+        expect(Steno::Sink::Syslog).to receive(:instance).twice.and_return(mock_sink)
 
         config = Steno::Config.from_file(@config_path)
         expect(config.sinks.size).to eq(1)
@@ -195,11 +192,9 @@ describe Steno::Config do
       end
     end
 
-
-
-    it "should add an io sink to stdout if no sinks are explicitly specified in the config file" do
+    it 'adds an io sink to stdout if no sinks are explicitly specified in the config file' do
       write_config(@config_path, {})
-      mock_sink = double("sink")
+      mock_sink = double('sink')
       expect(mock_sink).to receive(:codec=)
 
       expect(Steno::Sink::IO).to receive(:new).with(STDOUT).and_return(mock_sink)
@@ -209,21 +204,19 @@ describe Steno::Config do
       expect(config.sinks[0]).to eq(mock_sink)
     end
 
-    it "should merge supplied overrides with the file based config" do
-      write_config(@config_path, {"default_log_level" => "debug"})
+    it 'merges supplied overrides with the file based config' do
+      write_config(@config_path, { 'default_log_level' => 'debug' })
 
       context = Steno::Context::ThreadLocal.new
       config = Steno::Config.from_file(@config_path,
-                                       :default_log_level => "warn",
-                                       :context => context)
+                                       default_log_level: 'warn',
+                                       context: context)
       expect(config.context).to eq(context)
       expect(config.default_log_level).to eq(:warn)
     end
   end
 
   def write_config(path, config)
-    File.open(path, "w+") do |f|
-      f.write(YAML.dump({"logging" => config}))
-    end
+    File.write(path, YAML.dump({ 'logging' => config }))
   end
 end

data/spec/unit/context_spec.rb

@@ -1,37 +1,37 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Context::Null do
-  include_context :steno_context
+  include_context 'steno context'
 
   let(:context) { Steno::Context::Null.new }
 
-  it "should store no data" do
+  it 'stores no data' do
     expect(context.data).to eq({})
-    context.data["foo"] = "bar"
+    context.data['foo'] = 'bar'
     expect(context.data).to eq({})
   end
 end
 
 describe Steno::Context::ThreadLocal do
-  include_context :steno_context
+  include_context 'steno context'
 
-  let (:context) { Steno::Context::ThreadLocal.new }
+  let(:context) { Steno::Context::ThreadLocal.new }
 
-  it "should store data local to threads" do
+  it 'stores data local to threads' do
     b1 = Barrier.new
     b2 = Barrier.new
 
     t1 = Thread.new do
-      context.data["thread"] = "t1"
+      context.data['thread'] = 't1'
       b1.release
       b2.wait
-      expect(context.data["thread"]).to eq("t1")
+      expect(context.data['thread']).to eq('t1')
     end
 
     t2 = Thread.new do
       b1.wait
-      expect(context.data["thread"]).to be_nil
-      context.data["thread"] = "t2"
+      expect(context.data['thread']).to be_nil
+      context.data['thread'] = 't2'
       b2.release
     end
 
@@ -41,20 +41,20 @@ describe Steno::Context::ThreadLocal do
 end
 
 describe Steno::Context::FiberLocal do
-  include_context :steno_context
+  include_context 'steno context'
 
   let(:context) { Steno::Context::FiberLocal.new }
 
-  it "should store data local to fibers" do
+  it 'stores data local to fibers' do
     f2 = Fiber.new do
-      expect(context.data["fiber"]).to be_nil
-      context.data["fiber"] = "f2"
+      expect(context.data['fiber']).to be_nil
+      context.data['fiber'] = 'f2'
     end
 
     f1 = Fiber.new do
-      context.data["fiber"] = "f1"
+      context.data['fiber'] = 'f1'
       f2.resume
-      expect(context.data["fiber"]).to eq("f1")
+      expect(context.data['fiber']).to eq('f1')
     end
 
     f1.resume

data/spec/unit/core_ext_spec.rb

@@ -1,6 +1,6 @@
-require "spec_helper"
+require 'spec_helper'
 
-require "steno/core_ext"
+require 'steno/core_ext'
 
 module Foo
   class Bar
@@ -8,31 +8,31 @@ module Foo
 end
 
 describe Module do
-  describe "#logger" do
-    it "should request a logger named after itself" do
+  describe '#logger' do
+    it 'requests a logger named after itself' do
       x = Foo.logger
       expect(x).to be_a(Steno::Logger)
-      expect(x.name).to include("Foo")
+      expect(x.name).to include('Foo')
     end
   end
 end
 
 describe Class do
-  describe "#logger" do
-    it "should request a logger named after itself" do
+  describe '#logger' do
+    it 'requests a logger named after itself' do
       x = Foo::Bar.logger
       expect(x).to be_a(Steno::Logger)
-      expect(x.name).to include("Foo::Bar")
+      expect(x.name).to include('Foo::Bar')
     end
   end
 end
 
 describe Object do
-  describe "#logger" do
-    it "should request a logger named after its class" do
+  describe '#logger' do
+    it 'requests a logger named after its class' do
       x = Foo::Bar.new.logger
       expect(x).to be_a(Steno::Logger)
-      expect(x.name).to include("Foo::Bar")
+      expect(x.name).to include('Foo::Bar')
     end
   end
 end

data/spec/unit/json_codec_spec.rb

@@ -1,68 +1,68 @@
-require "spec_helper"
+require 'spec_helper'
 
 describe Steno::Codec::Json do
   let(:codec) { Steno::Codec::Json.new }
-  let(:record) { make_record(:data => { "user" => "data" }) }
+  let(:record) { make_record(data: { 'user' => 'data' }) }
 
-  describe "#encode_record" do
-    it "should encode records as json hashes" do
+  describe '#encode_record' do
+    it 'encodes records as json hashes' do
       parsed = Yajl::Parser.parse(codec.encode_record(record))
       expect(parsed.class).to eq(Hash)
     end
 
-    it "should encode the timestamp as a float" do
+    it 'encodes the timestamp as a float' do
       parsed = Yajl::Parser.parse(codec.encode_record(record))
-      expect(parsed["timestamp"].class).to eq(Float)
+      expect(parsed['timestamp'].class).to eq(Float)
     end
 
-    it "should escape newlines" do
-      rec = make_record(:message => "newline\ntest")
+    it 'escapes newlines' do
+      rec = make_record(message: "newline\ntest")
       expect(codec.encode_record(rec)).to match(/newline\\ntest/)
     end
 
-    it "should escape carriage returns" do
-      rec = make_record(:message => "newline\rtest")
+    it 'escapes carriage returns' do
+      rec = make_record(message: "newline\rtest")
       expect(codec.encode_record(rec)).to match(/newline\\rtest/)
     end
 
-    it "should allow messages with valid encodings to pass through untouched" do
+    it 'allows messages with valid encodings to pass through untouched' do
       msg = "HI\u2600"
-      rec = make_record(:message => msg)
+      rec = make_record(message: msg)
       expect(codec.encode_record(rec)).to match(/#{msg}/)
     end
 
-    it "should treat messages with invalid encodings as binary data" do
-      msg = "HI\u2026".force_encoding("US-ASCII")
-      rec = make_record(:message => msg)
+    it 'treats messages with invalid encodings as binary data' do
+      msg = "HI\u2026".force_encoding('US-ASCII')
+      rec = make_record(message: msg)
       expect(codec.encode_record(rec)).to match(/HI\\\\xe2\\\\x80\\\\xa6/)
     end
 
-    it "shouldn't use readable dates by default" do
+    it 'does not use readable dates by default' do
       expect(codec.iso8601_timestamps?).to eq(false)
     end
 
-    context "when iso8601_timestamps is set" do
-      let(:codec) { Steno::Codec::Json.new( :iso8601_timestamps => true ) }
+    context 'when iso8601_timestamps is set' do
+      let(:codec) { Steno::Codec::Json.new(iso8601_timestamps: true) }
 
-      it "should encode timestamps as UTC-formatted strings" do
-        allow(record).to receive(:timestamp).and_return 1396473763.811278 # 2014-04-02 22:22:43 +01:00
+      it 'encodes timestamps as UTC-formatted strings' do
+        allow(record).to receive(:timestamp).and_return 1_396_473_763.811278 # 2014-04-02 22:22:43 +01:00
         parsed = Yajl::Parser.parse(codec.encode_record(record))
 
-        expect(parsed["timestamp"].class).to eq(String)
-        expect(parsed["timestamp"]).to eq("2014-04-02T21:22:43.811278Z")
+        expect(parsed['timestamp'].class).to eq(String)
+        expect(parsed['timestamp']).to eq('2014-04-02T21:22:43.811278Z')
       end
 
-      it "should surface the property in a getter" do
+      it 'surfaces the property in a getter' do
         expect(codec.iso8601_timestamps?).to eq(true)
       end
     end
   end
 
   def make_record(opts = {})
-    Steno::Record.new(opts[:source]  || "my_source",
+    Steno::Record.new(opts[:source]  || 'my_source',
                       opts[:level]   || :debug,
-                      opts[:message] || "test message",
+                      opts[:message] || 'test message',
                       nil,
-                      opts[:data]    || {})
+                      opts[:data] || {})
   end
 end

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"
       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,9 +51,9 @@ 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)
@@ -64,21 +64,21 @@ describe Steno::JsonPrettifier do
       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
+    it 'works with a nil data field' do
       line = prettifier.prettify_line('{"data":null}')
-      expect(line).to include(" - ")
+      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
+  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
-      expect(info_level.to_s).to eq("info")
+  describe '#to_s' do
+    it 'returns the name of the level' do
+      expect(info_level.to_s).to eq('info')
     end
   end
-
 end