nagiosplugin 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bb7500269428bb2869fb2d1a2c072fb4211f98d
-  data.tar.gz: 68082b3cf61bb359310cd5503b0131a403632f80
+  metadata.gz: af2884fed9433c21dca8ac46fbb9839fdb21828c
+  data.tar.gz: 19ec4db414644ca3b8182ba0219e4354bc42178d
 SHA512:
-  metadata.gz: b0d12d8f990dd210ea2927d76c3727a5ff1d24c490a30489e8b986f3fb3dc585f6994d137fa790f291adc110897fd96800ecbc97e22bc3ed162115f70a4a2655
-  data.tar.gz: 4e8046957f75bac17ae00b663fdfc635da11eb244339dac15874c8f820845955be581952af3953a1d06710e169f136d8517f8473c86ff176030ceb89fa696056
+  metadata.gz: dc862fd67b4e48ed1379654eaadf1af2056e692001d4e6fdb5170fcb96cfcbce83a5303cdd32456e267ab3ccd06317d0ddd0af8fccd8416e654c8cb616dae2f3
+  data.tar.gz: fbff8aba3031f4e38ed2ef6efac1a1499710b2713e239f8bb4443f3e28748e15a0607f7d2b27e3ab85ed4eb5b6cecf4fe8359b562a806c858aac45c19171f304

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Björn Albers
+Copyright (c) 2011-2014 Björn Albers
 
 MIT License
 

data/README.md

@@ -1,18 +1,18 @@
-# NagiosPlugin
+# Nagios::Plugin
 
-The one Nagios Plugin framework, forged in the fires of Mount Doom.
+A Nagios Plugin framework that fits on a folded napkin.
 
 [![Gem Version](https://badge.fury.io/rb/nagiosplugin.svg)](http://badge.fury.io/rb/nagiosplugin)
 [![Build Status](https://secure.travis-ci.org/bjoernalbers/nagiosplugin.png)](http://travis-ci.org/bjoernalbers/nagiosplugin)
 
+
 ## Introduction
 
-NagiosPlugin is an
-[embarrassingly simple](https://github.com/bjoernalbers/nagiosplugin/blob/master/lib/nagiosplugin/plugin.rb)
-framework to write custom monitoring plugins for
-[Nagios](http://www.nagios.org/).
-It was born out of duplication, because all nagios plugins share some
-common behaviour...
+*Nagios::Plugin* helps you write [Nagios](http://www.nagios.org/) Plugins with Ruby:
+It ensures that your plugin returns a [compliant](http://nagiosplug.sourceforge.net/developer-guidelines.html) exit code and status output.
+
+Besides, it is [easy to understand](https://github.com/bjoernalbers/nagiosplugin/blob/master/lib/nagiosplugin/plugin.rb) and comes with automated tests.
+
 
 ## Installation
 
@@ -25,94 +25,71 @@ gem 'nagiosplugin'
 Manually via Rubygems: Run `gem install nagiosplugin`.
 
 
-## Usage
-
-Writing your custom plugin is really simple:
+## Quick Start
 
-### Step 1: Describe when something is critical, warning and ok.
-
-Create your subclass from `NagiosPlugin::Plugin` and define these
-instance methods to determine the status:
+Here, a full working (but totally useless) example plugin named `check_fancy`:
 
 ```Ruby
+#!/usr/bin/env ruby
+
 require 'nagiosplugin'
 
-class MyFancyPlugin < NagiosPlugin::Plugin
+# Create your custom plugin as subclass from Nagios::Plugin 
+class Fancy < Nagios::Plugin
+  # Required method: Is the status critical?
   def critical?
-    # Enter your code here (returns true when critical, else false).
+    @number < 3
   end
 
+  # Required method: Is the status warning?
   def warning?
-    # Enter your code here (returns true when warning, else false).
+    @number < 5
   end
 
+  # Required method: Is the... I see, you got it.
   def ok?
-    # Enter your code... you get the idea.
+    @number > 6
   end
-end
-```
-
-**Please keep in mind that the "worst" status always wins, i.e. if both
-`critical?` and `warning?` are true then the status would be critical
-(if none is true, then the status would be unknown of course)!**
-
-You may use your `initialize` method to setup check data (NagiosPlugin
-doesn't use that either), parse CLI options, etc.
 
-### Step 2: Provide some context via status message (optionally).
-
-Ask yourself what might be important to know (and fits into a text
-message) when Nagios send you an alert in the middle of the night.
+  # Optional method that is executed once before determining the status.
+  def chec
+    @number = rand(10)
+  end
 
-```Ruby
-def message
-  # Create an info string (this will be printed after the
-  # status on stdout).
-  # Service name, status and message should be longer than 78 chars!!!
+  # Optional method: The returned stuff will be appended to plugin output.
+  def message
+    "#{@number} was picked"
+  end
 end
-```
-
-### Step 3: Perform the actual check.
 
-In your binary then just call the build-in class method `check` and you're done:
-
-```Ruby
-MyFancyPlugin.check(options)
+# Call the build-in class method to display the status and exit properly:
+Fancy.run!
 ```
 
-(Optional arguments, i.e. from your favorite [CLI option
-parser](https://www.ruby-toolbox.com/categories/CLI_Option_Parsers), will be
-forwarded to you initializer method.)
-
-This will output the check result and exits in compliance with the
-official
-[Nagios plug-in development
-guidelines](http://nagiosplug.sourceforge.net/developer-guidelines.html)
-
-If anything funky happens in your code: NagiosPlugin does a "blind
-rescue mission" and transforms any execptions to an unknown status.
-
-
-## Note on Patches/Pull Requests
-
-* Fork the project and run `bundle install` to resolve all development
-  dependencies.
-* Add specs and/or features for it. This is important so I don't break
-  it in a future version unintentionally.
-* Make your feature addition or bug fix.
-* Commit, do not mess with the Rakefile or gemspec.
-  (If you want to have your own version, that is fine but bump version
-in a commit by itself I can ignore when I pull.)
-* Send me a pull request. Bonus points for topic branches.
+When you run it you'd something like this:
 
+```
+$ check_fancy; echo $?                                                                                                                                  
+FANCY CRITICAL: 2 was picked
+2
+$ check_fancy; echo $?
+FANCY UNKNOWN: 6 was picked
+3
+$ check_fancy; echo $?
+FANCY OK: 7 was picked
+0
+```
 
-## Acknowledgments
 
-Thanks to the following contributors for improving NagiosPlugin:
+## Thinks to remember
 
-* [szuecs (Sandor Szücs)](https://github.com/szuecs)
+- the "worst" status always wins, for example if both `critical?` and
+  `warning?` return true then the status would be critical
+- `Nagios::Plugin.run!` does a "blind rescue mission" and transforms any
+  execptions to an unknown status.
+- drink more water!
 
 
 ## Copyright
 
-Copyright (c) 2011-2013 Björn Albers. See LICENSE for details.
+Copyright (c) 2011-2014 Björn Albers

data/features/nagiosplugin_usage.feature

@@ -1,15 +1,15 @@
 Feature: NagiosPlugin Usage
 
-  In order to write awesome Nagios Plugins with minimal effort
+  In order to write Nagios Plugins with Ruby
   As a busy (developer|sysadmin|devop|hacker|superhero|rockstar)
-  I want to use the one NagiosPlugin framework
+  I want to use the one Nagios Plugin framework.
 
   Scenario Outline: Subclass from NagiosPlugin
-    Given a file named "check_fancy.rb" with:
+    Given a file named "check_chunky_bacon.rb" with:
       """
       require 'nagiosplugin'
 
-      class FancyPlugin < NagiosPlugin::Plugin
+      class ChunkyBacon < Nagios::Plugin
         def critical?
           <critical>
         end
@@ -23,14 +23,14 @@ Feature: NagiosPlugin Usage
         end
 
         def message
-          'answer is 42'
+          42
         end
       end
 
-      FancyPlugin.check
+      ChunkyBacon.run!
       """
-    When I run `ruby check_fancy.rb`
-    Then the exit status should be <code>
+    When I run `ruby check_chunky_bacon.rb`
+    Then the exit status should be <es>
     And the stdout should contain exactly:
       """
       <stdout>
@@ -38,8 +38,8 @@ Feature: NagiosPlugin Usage
       """
 
     Examples:
-     | critical | warning | ok    | status   | code | stdout                       |
-     | true     | true    | true  | CRITICAL | 2    | FANCY CRITICAL: answer is 42 |
-     | false    | true    | true  | WARNING  | 1    | FANCY WARNING: answer is 42  |
-     | false    | false   | true  | OK       | 0    | FANCY OK: answer is 42       |
-     | false    | false   | false | UNKNOWN  | 3    | FANCY UNKNOWN: answer is 42  |
+     | critical | warning | ok    | status   | es | stdout                   |
+     | true     | true    | true  | CRITICAL | 2  | CHUNKYBACON CRITICAL: 42 |
+     | false    | true    | true  | WARNING  | 1  | CHUNKYBACON WARNING: 42  |
+     | false    | false   | true  | OK       | 0  | CHUNKYBACON OK: 42       |
+     | false    | false   | false | UNKNOWN  | 3  | CHUNKYBACON UNKNOWN: 42  |

data/lib/nagios/plugin.rb

@@ -0,0 +1,42 @@
+module Nagios
+  class Plugin
+    VERSION = '3.0.0'
+
+    EXIT_CODE =
+      { unknown:  3,
+        critical: 2,
+        warning:  1,
+        ok:       0 }
+
+    def self.run!(*args)
+      plugin = new(*args)
+      plugin.check if plugin.respond_to?(:check)
+      puts plugin.output
+      exit EXIT_CODE[plugin.status]
+    rescue => e
+      puts "PLUGIN UNKNOWN: #{e.message}\n\n" << e.backtrace.join("\n")
+      exit EXIT_CODE[:unknown]
+    end
+
+    def output
+      s = "#{name.upcase} #{status.upcase}"
+      s << ": #{message}" if ( respond_to?(:message) && !message.to_s.empty? )
+      s
+    end
+
+    def status
+      return :critical if critical?
+      return :warning  if warning?
+      return :ok       if ok?
+      :unknown
+    end
+
+    def name
+      self.class.name.split('::').last.upcase
+    end
+
+    def to_s
+      output
+    end
+  end
+end

data/lib/nagiosplugin.rb

@@ -1,2 +1 @@
-require 'nagiosplugin/version'
-require 'nagiosplugin/plugin'
+require 'nagios/plugin'

data/nagiosplugin.gemspec

@@ -1,19 +1,19 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'nagiosplugin/version'
+require 'nagiosplugin'
 
 Gem::Specification.new do |spec|
   spec.name        = 'nagiosplugin'
-  spec.version     = NagiosPlugin::VERSION
+  spec.version     = Nagios::Plugin::VERSION
   spec.authors     = ['Björn Albers']
   spec.email       = ['bjoernalbers@gmail.com']
   spec.homepage    = 'https://github.com/bjoernalbers/nagiosplugin'
   spec.summary     = "#{spec.name}-#{spec.version}"
-  spec.description = 'The one Nagios Plugin framework, forged in the fires of Mount Doom.'
+  spec.description = 'A Nagios Plugin framework that fits on a folded napkin.'
   spec.license     = 'MIT'
 
-  spec.files         = `git ls-files`.split("\n") - %w(.gitignore .rbenv-version .travis.yml)
+  spec.files         = `git ls-files`.split("\n") - %w(.gitignore .travis.yml)
   spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   spec.require_paths = ['lib']
@@ -21,7 +21,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'cucumber'
   spec.add_development_dependency 'aruba'
-  spec.add_development_dependency 'guard-cucumber'
   spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'guard-rspec'
 end

data/spec/nagios/plugin_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+module Nagios
+  describe Plugin do
+    let(:plugin) { Plugin.new }
+
+    describe '.run!' do
+      before do
+        allow(plugin).to receive_messages(
+          output: '',
+          check: nil)
+        allow(Plugin).to receive_messages(
+          puts: nil,
+          exit: nil,
+          new: plugin)
+      end
+
+      it 'displays the plugin output on stdout' do
+        allow(plugin).to receive(:output).and_return('chunky bacon')
+        Plugin.run!
+        expect(Plugin).to have_received(:puts).with('chunky bacon')
+      end
+
+      it 'exits with exit code 3 when plugin status unknown' do
+        allow(plugin).to receive(:status).and_return(:unknown)
+        Plugin.run!
+        expect(Plugin).to have_received(:exit).with(3)
+      end
+
+      it 'exits with exit code 2 when plugin status critical' do
+        allow(plugin).to receive(:status).and_return(:critical)
+        Plugin.run!
+        expect(Plugin).to have_received(:exit).with(2)
+      end
+
+      it 'exits with exit code 1 when plugin status warning' do
+        allow(plugin).to receive(:status).and_return(:warning)
+        Plugin.run!
+        expect(Plugin).to have_received(:exit).with(1)
+      end
+
+      it 'exits with exit code 0 when plugin status ok' do
+        allow(plugin).to receive(:status).and_return(:ok)
+        Plugin.run!
+        expect(Plugin).to have_received(:exit).with(0)
+      end
+
+      it 'forwards any arguments to the plugin initializer' do
+        Plugin.run!(42, fancy: true)
+        expect(Plugin).to have_received(:new).with(42, fancy: true)
+      end
+
+      it 'calls the plugin check callback first' do
+        Plugin.run!
+        expect(plugin).to have_received(:check).ordered
+        expect(plugin).to have_received(:output).ordered
+      end
+
+      context 'when an exception was raised' do
+        let(:exception) { StandardError.new('Oops!') }
+
+        before do
+          allow(Plugin).to receive(:new).and_raise(exception)
+        end
+
+        it 'rescues the exception' do
+          expect { Plugin.run! }.to_not raise_error
+        end
+
+        it 'exits with status 3' do
+          Plugin.run!
+          expect(Plugin).to have_received(:exit).with(3)
+        end
+
+        it 'displays the exception and backtrace on stdout' do
+          allow(StandardError).to receive(:new).and_return(exception)
+          allow(exception).to receive(:backtrace).and_return(%w(Chunky Bacon))
+          Plugin.run!
+          expect(Plugin).to have_received(:puts).
+            with("PLUGIN UNKNOWN: Oops!\n\nChunky\nBacon")
+        end
+      end
+    end
+
+    describe '#name' do
+      it 'returns the upcased class name' do
+        class Foo < Plugin; end
+        plugin = Foo.new
+        expect(plugin.name).to eq('FOO')
+      end
+
+      it 'strips "Nagios" prefix from the class name' do
+        class Nagios::Bar < Plugin; end
+        plugin = Nagios::Bar.new
+        expect(plugin.name).to eq('BAR')
+      end
+    end
+
+    describe '#status' do
+      it 'returns :unknown when status not critical, not warning and not ok' do
+        allow(plugin).to receive_messages(
+          critical?: false,
+          warning?:  false,
+          ok?:       false)
+        expect(plugin.status).to eq(:unknown)
+      end
+
+      it 'returns :critical when status critical' do
+        allow(plugin).to receive_messages(
+          critical?: true,
+          warning?:  true,
+          ok?:       true)
+        expect(plugin.status).to eq(:critical)
+      end
+
+      it 'returns :warning when status not critical but warning' do 
+        allow(plugin).to receive_messages(
+          critical?: false,
+          warning?:  true,
+          ok?:       true)
+        expect(plugin.status).to eq(:warning)
+      end
+
+      it 'returns :ok when when status not critical, not warning but ok' do
+        allow(plugin).to receive_messages(
+          critical?: false,
+          warning?:  false,
+          ok?:       true)
+        expect(plugin.status).to eq(:ok)
+      end
+    end
+
+    describe '#output' do
+      before do
+        allow(plugin).to receive_messages(
+          name: 'chunkybacon',
+          status: 'tasty')
+      end
+
+      context 'without a message' do
+        before do
+          allow(plugin).to receive(:message).and_return(nil)
+        end
+
+        it 'returns the name and status' do
+          expect(plugin.output).to eq('CHUNKYBACON TASTY')
+        end
+      end
+
+      context 'with an empty message' do
+        before do
+          allow(plugin).to receive(:message).and_return('')
+        end
+
+        it 'returns the name and status' do
+          expect(plugin.output).to eq('CHUNKYBACON TASTY')
+        end
+      end
+
+      context 'with a message' do
+        before do
+          allow(plugin).to receive(:message).and_return(42)
+        end
+
+        it 'returns the name, status and message' do
+          expect(plugin.output).to eq('CHUNKYBACON TASTY: 42')
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nagiosplugin
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Björn Albers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-09 00:00:00.000000000 Z
+date: 2014-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: guard-cucumber
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -80,21 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: The one Nagios Plugin framework, forged in the fires of Mount Doom.
+description: A Nagios Plugin framework that fits on a folded napkin.
 email:
 - bjoernalbers@gmail.com
 executables: []
@@ -102,17 +74,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
-- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - features/nagiosplugin_usage.feature
 - features/support/env.rb
+- lib/nagios/plugin.rb
 - lib/nagiosplugin.rb
-- lib/nagiosplugin/plugin.rb
-- lib/nagiosplugin/version.rb
 - nagiosplugin.gemspec
-- spec/nagiosplugin/plugin_spec.rb
+- spec/nagios/plugin_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/bjoernalbers/nagiosplugin
 licenses:
@@ -137,9 +107,9 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: nagiosplugin-2.2.0
+summary: nagiosplugin-3.0.0
 test_files:
 - features/nagiosplugin_usage.feature
 - features/support/env.rb
-- spec/nagiosplugin/plugin_spec.rb
+- spec/nagios/plugin_spec.rb
 - spec/spec_helper.rb

data/Guardfile

@@ -1,15 +0,0 @@
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-
-guard 'rspec', :cli => '--color' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})           { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')        { "spec" }
-end
-
-guard 'cucumber' do
-  watch(%r{^lib/.+$})                 { 'features' }
-  watch(%r{^features/.+\.feature$})
-  watch(%r{^features/support/.+$})    { 'features' }
-  watch(%r{^features/steps/(.+)_steps\.rb$}) { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'features' }
-end

data/lib/nagiosplugin/plugin.rb

@@ -1,49 +0,0 @@
-module NagiosPlugin
-  class Plugin
-    NAGIOS_PLUGIN_EXIT_CODES = {
-      :unknown  => 3,
-      :critical => 2,
-      :warning  => 1,
-      :ok       => 0
-    }
-
-    class << self
-      def check(*args)
-        plugin = new(*args)
-        puts plugin.nagios_plugin_output
-        exit plugin.nagios_plugin_exit_code
-      rescue => e
-        pretty_error = ([e.to_s, nil] + e.backtrace).join("\n")
-        puts "PLUGIN UNKNOWN: #{pretty_error}"
-        exit NAGIOS_PLUGIN_EXIT_CODES[:unknown]
-      end
-    end
-
-    def nagios_plugin_exit_code
-      NAGIOS_PLUGIN_EXIT_CODES[nagios_plugin_status]
-    end
-
-    def nagios_plugin_output
-      output = [nagios_plugin_service] << ' '
-      output << nagios_plugin_status.to_s.upcase
-      output << ': ' + message if ( respond_to?(:message) && !message.empty? )
-      output.join
-    end
-
-  private
-
-    def nagios_plugin_status
-      @nagios_plugin_status ||=
-        case
-        when critical? then :critical
-        when warning?  then :warning
-        when ok?       then :ok
-        else                :unknown
-        end
-    end
-
-    def nagios_plugin_service
-      self.class.name.split('::').last.gsub(/plugin$/i, '').upcase
-    end
-  end
-end

data/lib/nagiosplugin/version.rb

@@ -1,3 +0,0 @@
-module NagiosPlugin
-  VERSION = '2.2.0'
-end

data/spec/nagiosplugin/plugin_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-module NagiosPlugin
-  describe Plugin do
-    let(:plugin) { Plugin.new }
-
-    describe '.check' do
-      before do
-        allow(plugin).to receive_messages(
-          nagios_plugin_exit_code:  nil,
-          nagios_plugin_output:     nil)
-        allow(Plugin).to receive_messages(
-          puts: nil,
-          exit: nil,
-          new: plugin)
-      end
-
-      it 'displays the plugin output on stdout' do
-        allow(plugin).to receive(:nagios_plugin_output).
-          and_return('chunky bacon')
-        Plugin.check
-        expect(Plugin).to have_received(:puts).with('chunky bacon')
-      end
-
-      it 'exits with the status exit code' do
-        allow(plugin).to receive(:nagios_plugin_exit_code).and_return(42)
-        Plugin.check
-        expect(Plugin).to have_received(:exit).with(42)
-      end
-
-      it 'passed all arguments to the initializer' do
-        Plugin.check(42, fancy: true)
-        expect(Plugin).to have_received(:new).with(42, fancy: true)
-      end
-
-      context 'when an exception was raised' do
-        let(:exception) { StandardError.new('Oops!') }
-
-        before do
-          allow(Plugin).to receive(:new).and_raise(exception)
-        end
-
-        it 'rescues the exception' do
-          expect { Plugin.check }.to_not raise_error
-        end
-
-        it 'exits with exit code unknown' do
-          Plugin.check
-          expect(Plugin).to have_received(:exit).with(3)
-        end
-
-        it 'displays the exception and backtrace on stdout' do
-          allow(StandardError).to receive(:new).and_return(exception)
-          allow(exception).to receive(:backtrace).and_return(%w(Chunky Bacon))
-          Plugin.check
-          expect(Plugin).to have_received(:puts).
-            with("PLUGIN UNKNOWN: Oops!\n\nChunky\nBacon")
-        end
-      end
-    end
-
-    describe '#nagios_plugin_service' do
-      it 'returns the upcased class name' do
-        class Foo < Plugin; end
-        plugin = Foo.new
-        expect(plugin.send(:nagios_plugin_service)).to eq('FOO')
-      end
-
-      it 'strips "Plugin" from the class name' do
-        class BarPlugin < Plugin; end
-        plugin = BarPlugin.new
-        expect(plugin.send(:nagios_plugin_service)).to eq('BAR')
-      end
-    end
-
-    describe '#nagios_plugin_status' do
-      it 'returns unknown when not critical, warning or ok' do
-        allow(plugin).to receive_messages(
-          critical?: false,
-          warning?:  false,
-          ok?:       false)
-        expect(plugin.send(:nagios_plugin_status)).to eq(:unknown)
-      end
-
-      it 'returns critical when critical' do
-        allow(plugin).to receive_messages(
-          critical?: true,
-          warning?:  true,
-          ok?:       true)
-        expect(plugin.send(:nagios_plugin_status)).to eq(:critical)
-      end
-
-      it 'returns warning when warning but not critical' do 
-        allow(plugin).to receive_messages(
-          critical?: false,
-          warning?:  true,
-          ok?:       true)
-        expect(plugin.send(:nagios_plugin_status)).to eq(:warning)
-      end
-
-      it 'returns ok when ok but not critical or warning' do
-        allow(plugin).to receive_messages(
-          critical?: false,
-          warning?:  false,
-          ok?:       true)
-        expect(plugin.send(:nagios_plugin_status)).to eq(:ok)
-      end
-
-      it 'caches the status' do
-        [:critical?, :warning?, :ok?].each do |check|
-          allow(plugin).to receive(check).once.and_return(false)
-        end
-        expect(plugin.send(:nagios_plugin_status)).to eq(:unknown)
-        expect(plugin.send(:nagios_plugin_status)).to eq(:unknown)
-      end
-    end
-
-    describe '#nagios_plugin_exit_code' do
-      it 'returns 3 when unknown' do
-        allow(plugin).to receive(:nagios_plugin_status).and_return(:unknown)
-        expect(plugin.send(:nagios_plugin_exit_code)).to eq(3)
-      end
-
-      it 'returns 2 when critical' do
-        allow(plugin).to receive(:nagios_plugin_status).and_return(:critical)
-        expect(plugin.send(:nagios_plugin_exit_code)).to eq(2)
-      end
-
-      it 'returns 1 when warning' do
-        allow(plugin).to receive(:nagios_plugin_status).and_return(:warning)
-        expect(plugin.send(:nagios_plugin_exit_code)).to eq(1)
-      end
-      
-      it 'returns 0 when ok' do
-        allow(plugin).to receive(:nagios_plugin_status).and_return(:ok)
-        expect(plugin.send(:nagios_plugin_exit_code)).to eq(0)
-      end
-    end
-
-    describe '#nagios_plugin_output' do
-      before do
-        allow(plugin).to receive(:nagios_plugin_status)
-      end
-
-      it 'joins the service name and the upcased status' do
-        allow(plugin).to receive(:nagios_plugin_service).and_return('FRIED')
-        allow(plugin).to receive(:nagios_plugin_status).and_return(:chicken)
-        expect(plugin.send(:nagios_plugin_output)).to match(/^FRIED CHICKEN$/)
-      end
-
-      it 'includes a custom plugin message if present' do
-        allow(plugin).to receive(:message).and_return('ALL U CAN EAT!')
-        expect(plugin.send(:nagios_plugin_output)).to match(/: ALL U CAN EAT!$/)
-      end
-
-      it 'does not append message if message is empty' do
-        allow(plugin).to receive(:message).and_return('')
-        expect(plugin.send(:nagios_plugin_output)).not_to match(/:/)
-      end
-
-    end
-  end
-end