sensu-logger 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4db534173e30cf3979d6da7ff7f265295ec81355
-  data.tar.gz: 67965cb16d8007580121d805571a05dbfdff7ebf
+  metadata.gz: d438ad15896f27c173da421d082fd92fc248eaa7
+  data.tar.gz: 5782ee85752b9458722bbc5f57065b81622426e7
 SHA512:
-  metadata.gz: bea338ccf9f40ca351c1b1a30c8bbe880c041f0544bd45eb670c12db9af20c4c2c60f548ad4707b0f3e64df55a1afdef67ca66c2ebb8b8807e789bcf0d49c183
-  data.tar.gz: 97207727a424296216289e5a9476a6c4ab012285f9df9a04c2694b4d7b4673172461d2877bb203eeb8c7b788bc50e9b5269f2c00f1a15f2923e6a145a425d1f2
+  metadata.gz: d61ec07629c6b621b0aa72fa7345bd7aec6d63f5227583c2d166cf454ba79956997088aba13201dd27d2b52dd24b2b85e3f7239dfe244954a944a94593999f7a
+  data.tar.gz: a46e3338e9e3f359c98769ef1746e3c888f52d7afabdda60853833e492fbe79cdce69d3cd99421d1c360c33020474b9fe18cca84738a3f3e4f45e216d46d0935

data/sensu-logger.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "sensu-logger"
-  spec.version       = "0.0.1"
+  spec.version       = "1.0.0"
   spec.authors       = ["Sean Porter"]
   spec.email         = ["portertech@gmail.com"]
   spec.summary       = "The Sensu logger library"

data/spec/logger_spec.rb

@@ -5,42 +5,42 @@ describe "Sensu::Logger" do
   include Helpers
 
   it "can provide the logger API" do
-    Sensu::Logger.should respond_to(:setup, :get)
+    expect(Sensu::Logger).to respond_to(:setup, :get)
   end
 
   it "can set up a log stream" do
     logger = Sensu::Logger.setup
-    logger.info("some info", {:foo => "bar"}).should be_true
+    expect(logger.info("some info", {:foo => "bar"})).to be(true)
     logger.level = :warn
-    logger.info("some info", {:foo => "bar"}).should be_false
+    expect(logger.info("some info", {:foo => "bar"})).to be(false)
   end
 
   it "can retrive the current log stream" do
     logger = Sensu::Logger.setup
-    Sensu::Logger.get.should eq(logger)
-    Sensu::Logger.get.should eq(logger)
+    expect(Sensu::Logger.get).to eq(logger)
+    expect(Sensu::Logger.get).to eq(logger)
   end
 
   it "can setup a log stream if one doesn't exist" do
     logger = Sensu::Logger.get
-    logger.info("some info", {:foo => "bar"}).should be_true
+    expect(logger.info("some info", {:foo => "bar"})).to be(true)
   end
 
   it "can setup a log stream with a log level and file" do
     stdout = STDOUT.dup
     file = Tempfile.new("sensu-logger")
     logger = Sensu::Logger.setup(:log_level => :warn, :log_file => file.path)
-    logger.info("some info", {:foo => "bar"}).should be_false
-    logger.warn("a warning", {:foo => "bar"}).should be_true
+    expect(logger.info("some info", {:foo => "bar"})).to be(false)
+    expect(logger.warn("a warning", {:foo => "bar"})).to be(true)
     file_contents = IO.read(file.path)
-    file_contents.should match(/a warning/)
+    expect(file_contents).to match(/a warning/)
     logger.reopen(stdout)
-    logger.warn("a warning", {:foo => "bar"}).should be_true
+    expect(logger.warn("a warning", {:foo => "bar"})).to be(true)
   end
 
   it "can setup a log stream with options if one doesn't exist" do
     logger = Sensu::Logger.get(:log_level => :warn)
-    logger.info("some info", {:foo => "bar"}).should be_false
-    logger.warn("a warning", {:foo => "bar"}).should be_true
+    expect(logger.info("some info", {:foo => "bar"})).to be(false)
+    expect(logger.warn("a warning", {:foo => "bar"})).to be(true)
   end
 end

data/spec/stream_spec.rb

@@ -10,60 +10,60 @@ describe "Sensu::Logger::Stream" do
   end
 
   it "can log events with different levels" do
-    @stream.debug("some debug info", {:foo => "bar"}).should be_false
-    @stream.info("some info", {:foo => "bar"}).should be_true
-    @stream.warn("a warning", {:foo => "bar"}).should be_true
-    @stream.error("an error", {:foo => "bar"}).should be_true
-    @stream.fatal("something exploded", {:foo => "bar"}).should be_true
+    expect(@stream.debug("some debug info", {:foo => "bar"})).to be(false)
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
+    expect(@stream.warn("a warning", {:foo => "bar"})).to be(true)
+    expect(@stream.error("an error", {:foo => "bar"})).to be(true)
+    expect(@stream.fatal("something exploded", {:foo => "bar"})).to be(true)
     @stream.level = :debug
-    @stream.debug("some debug info", {:foo => "bar"}).should be_true
-    @stream.info("some info", {:foo => "bar"}).should be_true
+    expect(@stream.debug("some debug info", {:foo => "bar"})).to be(true)
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
     @stream.level = :warn
-    @stream.info("some info", {:foo => "bar"}).should be_false
-    @stream.warn("a warning", {:foo => "bar"}).should be_true
+    expect(@stream.info("some info", {:foo => "bar"})).to be(false)
+    expect(@stream.warn("a warning", {:foo => "bar"})).to be(true)
   end
 
   it "can reopen STDERR/STDOUT and redirect them to a log file" do
     stdout = STDOUT.dup
     file = Tempfile.new("sensu-logger")
     @stream.reopen(file.path)
-    @stream.info("some info", {:foo => "bar"}).should be_true
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
     @stream.reopen(stdout)
     file_contents = IO.read(file.path)
-    file_contents.should match(/timestamp/)
-    file_contents.should match(/"message":"some info"/)
-    file_contents.should match(/"foo":"bar"/)
+    expect(file_contents).to match(/timestamp/)
+    expect(file_contents).to match(/"message":"some info"/)
+    expect(file_contents).to match(/"foo":"bar"/)
     @stream.reopen("/untouchable.log")
-    @stream.info("some info", {:foo => "bar"}).should be_true
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
   end
 
   it "can setup signal traps to toggle debug logging and reopen the log file" do
     @stream.setup_signal_traps
-    @stream.debug("some debug info", {:foo => "bar"}).should be_false
-    @stream.info("some info", {:foo => "bar"}).should be_true
+    expect(@stream.debug("some debug info", {:foo => "bar"})).to be(false)
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
     Process.kill("TRAP", Process.pid)
     sleep 0.5
-    @stream.debug("some debug info", {:foo => "bar"}).should be_true
-    @stream.info("some info", {:foo => "bar"}).should be_true
+    expect(@stream.debug("some debug info", {:foo => "bar"})).to be(true)
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
     Process.kill("TRAP", Process.pid)
     sleep 0.5
-    @stream.debug("some debug info", {:foo => "bar"}).should be_false
-    @stream.info("some info", {:foo => "bar"}).should be_true
+    expect(@stream.debug("some debug info", {:foo => "bar"})).to be(false)
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
     @stream.level = :warn
-    @stream.info("some info", {:foo => "bar"}).should be_false
+    expect(@stream.info("some info", {:foo => "bar"})).to be(false)
     Process.kill("TRAP", Process.pid)
     sleep 0.5
-    @stream.debug("some debug info", {:foo => "bar"}).should be_true
-    @stream.info("some info", {:foo => "bar"}).should be_true
+    expect(@stream.debug("some debug info", {:foo => "bar"})).to be(true)
+    expect(@stream.info("some info", {:foo => "bar"})).to be(true)
     Process.kill("TRAP", Process.pid)
     sleep 0.5
-    @stream.debug("some debug info", {:foo => "bar"}).should be_false
-    @stream.info("some info", {:foo => "bar"}).should be_false
-    @stream.warn("a warning", {:foo => "bar"}).should be_true
+    expect(@stream.debug("some debug info", {:foo => "bar"})).to be(false)
+    expect(@stream.info("some info", {:foo => "bar"})).to be(false)
+    expect(@stream.warn("a warning", {:foo => "bar"})).to be(true)
     @stream.reopen(STDOUT)
     Process.kill("USR2", Process.pid)
     sleep 0.5
-    @stream.error("an error", {:foo => "bar"}).should be_true
+    expect(@stream.error("an error", {:foo => "bar"})).to be(true)
   end
 
   it "can operate as expected within the eventmachine reactor" do
@@ -71,10 +71,10 @@ describe "Sensu::Logger::Stream" do
       stdout = STDOUT.dup
       file = Tempfile.new("sensu-logger")
       @stream.reopen(file.path)
-      @stream.debug("some debug info", {:foo => "bar"}).should be_false
-      @stream.info("some info", {:foo => "bar"}).should be_true
-      @stream.warn("a warning", {:foo => "bar"}).should be_true
-      @stream.error("an error", {:foo => "bar"}).should be_true
+      expect(@stream.debug("some debug info", {:foo => "bar"})).to be(false)
+      expect(@stream.info("some info", {:foo => "bar"})).to be(true)
+      expect(@stream.warn("a warning", {:foo => "bar"})).to be(true)
+      expect(@stream.error("an error", {:foo => "bar"})).to be(true)
       timer(1) do
         @stream.reopen(stdout)
         expected = [
@@ -88,7 +88,7 @@ describe "Sensu::Logger::Stream" do
           parsed_line.delete(:timestamp)
           parsed_line
         end
-        parsed_contents.should eq(expected)
+        expect(parsed_contents).to eq(expected)
         async_done
       end
     end
@@ -100,11 +100,11 @@ describe "Sensu::Logger::Stream" do
     async_wrapper do
       @stream.reopen(file.path)
       1000.times do
-        @stream.info("some info", {:foo => "bar"}).should be_true
+        expect(@stream.info("some info", {:foo => "bar"})).to be(true)
       end
       EM.stop
     end
     @stream.reopen(stdout)
-    IO.read(file.path).split("\n").size.should eq(1000)
+    expect(IO.read(file.path).split("\n").size).to eq(1000)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sensu-logger
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Sean Porter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-20 00:00:00.000000000 Z
+date: 2014-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sensu-em