sensu-extensions 0.0.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f22bdfd2101a4eed988383d6e556628c8aebbb9
-  data.tar.gz: 9fb6182c93f47b801663a53a3ff97949f00a7842
+  metadata.gz: 4f57126991763e89e26528b447af7a360ef8dc68
+  data.tar.gz: 0544fed9f3a43312082531cf59db8ddae44f2fc0
 SHA512:
-  metadata.gz: 37554eff083995189efe88e118a62535f816b51748a7b9139b5aa0138ecdd2eace226d3e952445cd12ab3ddf0b3ef1a40cfa0bf45354d68735fe8477c9ddb079
-  data.tar.gz: 42e83135922064522c13ff2c02635a7a60bc5dab13401545420841e4e29611fce4580d3dd0df9dcb6a6d75c6a5bcda584d200c19d198ff6d515793200970c228
+  metadata.gz: 12db8e2e16ac764b716d58f2745c067c8b7550f66dbd7de5397ca76be5855c7de2f0140cccff865ddcf2a657d0f539778dca3a3721485f9b8a350ab48018303d
+  data.tar.gz: 330bff41a52ef0283f81fc47623d7b2c5b746e702132f4a97dd9aa7c00f55ef400d2326feca48c8d512a55ab8313aebc2fd8fd4c9963f5c06a1f8dfd97151bb7

data/sensu-extensions.gemspec

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

data/spec/extensions_spec.rb

@@ -11,52 +11,52 @@ describe "Sensu::Extensions" do
   end
 
   it "can provide the extensions API" do
-    Sensu::Extensions.should respond_to(:load)
+    expect(Sensu::Extensions).to respond_to(:load)
   end
 
   it "can provide an instance of Loader" do
     extensions = Sensu::Extensions.load
-    extensions.should be_instance_of(Sensu::Extensions::Loader)
-    extensions.loaded_files.should be_empty
+    expect(extensions).to be_instance_of(Sensu::Extensions::Loader)
+    expect(extensions.loaded_files).to be_empty
   end
 
   it "can retrive the current loaded loader" do
     extensions = Sensu::Extensions.load
-    Sensu::Extensions.get.should eq(extensions)
-    Sensu::Extensions.get.should eq(extensions)
+    expect(Sensu::Extensions.get).to eq(extensions)
+    expect(Sensu::Extensions.get).to eq(extensions)
   end
 
   it "can load up a loader if one doesn't exist" do
     extensions = Sensu::Extensions.get
-    extensions.should be_an_instance_of(Sensu::Extensions::Loader)
-    Sensu::Extensions.get.should eq(extensions)
+    expect(extensions).to be_an_instance_of(Sensu::Extensions::Loader)
+    expect(Sensu::Extensions.get).to eq(extensions)
   end
 
   it "can load an extension from a file" do
     extensions = Sensu::Extensions.load(:extension_file => @extension_file)
-    extensions.loaded_files.size.should eq(1)
-    extensions.handler_exists?("test").should be_true
+    expect(extensions.loaded_files.size).to eq(1)
+    expect(extensions.handler_exists?("test")).to be(true)
   end
 
   it "can load extensions from a directory" do
     extensions = Sensu::Extensions.load(:extension_dir => @extension_dir)
-    extensions.loaded_files.size.should eq(2)
-    extensions.handler_exists?("test").should be_true
-    extensions.check_exists?("mock_check").should be_true
+    expect(extensions.loaded_files.size).to eq(2)
+    expect(extensions.handler_exists?("test")).to be(true)
+    expect(extensions.check_exists?("mock_check")).to be(true)
   end
 
   it "can load extensions from one or more directories" do
     extensions = Sensu::Extensions.load(:extension_dirs => [@extension_dir])
-    extensions.loaded_files.size.should eq(2)
-    extensions.handler_exists?("test").should be_true
-    extensions.check_exists?("mock_check").should be_true
+    expect(extensions.loaded_files.size).to eq(2)
+    expect(extensions.handler_exists?("test")).to be(true)
+    expect(extensions.check_exists?("mock_check")).to be(true)
   end
 
   it "can load the built-in extensions" do
     extensions = Sensu::Extensions.load
-    extensions.mutator_exists?("json").should be_true
-    extensions.mutator_exists?("ruby_hash").should be_true
-    extensions.mutator_exists?("only_check_output").should be_true
-    extensions.handler_exists?("debug").should be_true
+    expect(extensions.mutator_exists?("json")).to be(true)
+    expect(extensions.mutator_exists?("ruby_hash")).to be(true)
+    expect(extensions.mutator_exists?("only_check_output")).to be(true)
+    expect(extensions.handler_exists?("debug")).to be(true)
   end
 end

data/spec/handlers/debug_spec.rb

@@ -17,8 +17,8 @@ describe "Sensu::Extension::Debug" do
       }
     }
     @extension.safe_run(event) do |output, status|
-      output.should eq(event)
-      status.should eq(0)
+      expect(output).to eq(event)
+      expect(status).to eq(0)
     end
   end
 end

data/spec/loader_spec.rb

@@ -12,86 +12,86 @@ describe "Sensu::Extensions::Loader" do
   end
 
   it "can provide the extensions loader API" do
-    @loader.should respond_to(:load_file, :load_directory, :load_instances,
-                              :warnings, :loaded_files, :[], :all,
-                              :bridges, :checks, :mutators, :handlers)
+    expect(@loader).to respond_to(:load_file, :load_directory, :load_instances,
+                                  :warnings, :loaded_files, :[], :all,
+                                  :bridges, :checks, :mutators, :handlers)
   end
 
   it "can load an extension from a file" do
     @loader.load_file(@extension_file)
-    @loader.warnings.size.should eq(1)
-    @loader.loaded_files.size.should eq(1)
-    @loader.loaded_files.first.should eq(File.expand_path(@extension_file))
+    expect(@loader.warnings.size).to eq(1)
+    expect(@loader.loaded_files.size).to eq(1)
+    expect(@loader.loaded_files.first).to eq(File.expand_path(@extension_file))
     extension = Sensu::Extension::Test.new
-    extension.should respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
+    expect(extension).to respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
   end
 
   it "can attempt to load an extension with a script error" do
     script = File.join(@extension_dir, "error.rb")
     @loader.load_file(script)
     warnings = @loader.warnings
-    warnings.size.should eq(3)
+    expect(warnings.size).to eq(3)
     messages = warnings.map do |warning|
       warning[:message]
     end
-    messages.should include("loading extension file")
-    messages.should include("ignoring extension")
-    @loader.loaded_files.should be_empty
+    expect(messages).to include("loading extension file")
+    expect(messages).to include("ignoring extension")
+    expect(@loader.loaded_files).to be_empty
   end
 
   it "can load extensions from a directory" do
     @loader.load_directory(@extension_dir)
-    @loader.warnings.size.should eq(6)
-    @loader.loaded_files.size.should eq(2)
+    expect(@loader.warnings.size).to eq(6)
+    expect(@loader.loaded_files.size).to eq(2)
     extension = Sensu::Extension::Test.new
-    extension.should respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
+    expect(extension).to respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
     extension = Sensu::Extension::MockCheck.new
-    extension.should respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
+    expect(extension).to respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
   end
 
   it "can attempt to load extensions from a nonexistent directory" do
     @loader.load_directory("/tmp/bananaphone")
-    @loader.warnings.size.should eq(1)
-    @loader.loaded_files.should be_empty
+    expect(@loader.warnings.size).to eq(1)
+    expect(@loader.loaded_files).to be_empty
   end
 
   it "can load instances of the built-in extensions and provide accessors" do
     @loader.load_instances
-    @loader.handler_exists?("debug").should be_true
+    expect(@loader.handler_exists?("debug")).to be(true)
     extension = @loader[:handlers]["debug"]
-    extension.should be_instance_of(Sensu::Extension::Debug)
-    extension.should respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
-    @loader.handlers.should include(extension.definition)
-    @loader.all.should include(extension)
-    @loader.mutator_exists?("json").should be_true
-    @loader.mutator_exists?("ruby_hash").should be_true
-    @loader.mutator_exists?("only_check_output").should be_true
+    expect(extension).to be_instance_of(Sensu::Extension::Debug)
+    expect(extension).to respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
+    expect(@loader.handlers).to include(extension.definition)
+    expect(@loader.all).to include(extension)
+    expect(@loader.mutator_exists?("json")).to be(true)
+    expect(@loader.mutator_exists?("ruby_hash")).to be(true)
+    expect(@loader.mutator_exists?("only_check_output")).to be(true)
   end
 
   it "can load instances of the built-in and loaded extensions" do
     @loader.load_file(@extension_file)
     @loader.load_instances
-    @loader.handler_exists?("test").should be_true
+    expect(@loader.handler_exists?("test")).to be(true)
     extension = @loader[:handlers]["test"]
-    extension.should be_instance_of(Sensu::Extension::Test)
-    extension.should respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
-    @loader.handlers.should include(extension.definition)
-    @loader.all.should include(extension)
-    @loader.handler_exists?("debug").should be_true
-    @loader.mutator_exists?("only_check_output").should be_true
+    expect(extension).to be_instance_of(Sensu::Extension::Test)
+    expect(extension).to respond_to(:name, :description, :definition, :safe_run, :stop, :has_key?, :[])
+    expect(@loader.handlers).to include(extension.definition)
+    expect(@loader.all).to include(extension)
+    expect(@loader.handler_exists?("debug")).to be(true)
+    expect(@loader.mutator_exists?("only_check_output")).to be(true)
   end
 
   it "can load specific extension categories for a sensu client" do
     @loader.load_instances("client")
-    @loader.handler_exists?("debug").should be_false
-    @loader.mutator_exists?("only_check_output").should be_false
-    @loader.check_exists?("mock_check").should be_true
+    expect(@loader.handler_exists?("debug")).to be(false)
+    expect(@loader.mutator_exists?("only_check_output")).to be(false)
+    expect(@loader.check_exists?("mock_check")).to be(true)
   end
 
   it "can load specific extension categories for a sensu server" do
     @loader.load_instances("server")
-    @loader.handler_exists?("debug").should be_true
-    @loader.mutator_exists?("only_check_output").should be_true
-    @loader.check_exists?("mock_check").should be_false
+    expect(@loader.handler_exists?("debug")).to be(true)
+    expect(@loader.mutator_exists?("only_check_output")).to be(true)
+    expect(@loader.check_exists?("mock_check")).to be(false)
   end
 end

data/spec/mutators/json_spec.rb

@@ -17,8 +17,8 @@ describe "Sensu::Extension::Json" do
       }
     }
     @extension.safe_run(event) do |output, status|
-      output.should eq(MultiJson.dump(event))
-      status.should eq(0)
+      expect(output).to eq(MultiJson.dump(event))
+      expect(status).to eq(0)
     end
   end
 end

data/spec/mutators/only_check_output_spec.rb

@@ -17,8 +17,8 @@ describe "Sensu::Extension::OnlyCheckOutput" do
       }
     }
     @extension.safe_run(event) do |output, status|
-      output.should eq("foo")
-      status.should eq(0)
+      expect(output).to eq("foo")
+      expect(status).to eq(0)
     end
   end
 end

data/spec/mutators/ruby_hash_spec.rb

@@ -17,8 +17,8 @@ describe "Sensu::Extension::RubyHash" do
       }
     }
     @extension.safe_run(event) do |output, status|
-      output.should eq(event)
-      status.should eq(0)
+      expect(output).to eq(event)
+      expect(status).to eq(0)
     end
   end
 end

metadata

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