nagi 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,104 @@
+# Nagi
+
+A Ruby DSL for writing Nagios plugins. It handles the tedium of argument
+parsing, exit statuses, output formatting and such, and lets you focus on
+writing the actual check.
+
+Written by Erik Grinaker <erik@bengler.no>, and licensed under the
+GNU GPL v3.
+
+## Example
+
+A typical plugin looks like this:
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'nagi'
+require Resolv
+
+Nagi do
+  name 'check_dns'
+  version '0.1'
+  prefix 'DNS'
+  argument :hostname
+  switch :ip, '-i', '--ip IP', 'Expected IP address'
+
+  check do |args|
+    begin
+      ip = Resolv.getaddress(args[:hostname])
+    rescue Resolv::ResolvError => e
+      critical e.message
+    end
+
+    if args[:ip] and ip != args[:ip]
+      critical "#{args[:hostname]} resolves to #{ip}, expected #{args[:ip]}
+    else
+      ok "#{args[:hostname]} resolves to #{ip}"
+    end
+  end
+end
+```
+
+Here we first set up some basic info like name and version, and specify a few
+command-line options. Then we write a block of code containing the actual
+check, which is given the parsed command-line options as a hash, and returns a
+status via methods like `ok` and `critical`.
+
+To run the plugin, type `./check_dns.rb --ip 127.0.0.1 localhost`, or try
+`./check_dns.rb --help` for more info.
+
+## Reference
+
+### Metadata
+
+These describe the program, and are usually given first, if necessary.
+
+* `name` *name*: the program name.
+* `version` *version*: the program version.
+* `prefix` *prefix*: a prefix for the check output.
+
+### Command-line arguments
+
+Command-line arguments can be specified, and will be parsed automatically and
+passed to the `check` method as a hash, with keys given by the argument name.
+
+* `argument` *name*: a mandatory, positional argument.
+* `switch` *name*, *args*: an optional switch. *args* are passed directory to
+  the standard Ruby OptionParser class - see its documentation for details.
+
+Command-line arguments for -h/--help and -V/--version are added and handled
+automatically.
+
+### Check
+
+The check is given as a code block to the `check` method, and is passed the
+parsed command-line arguments as a hash. It should use one of the methods `ok`,
+`warning`, `critical`, or `unknown` to return a status. If no status is given,
+or the block raises an unhandled exception, an Unknown status will be returned.
+
+* `check` *block*: the code block the the check. Parsed command-line arguments
+  are passed as a hash.
+* `ok` *message*: returns an OK status.
+* `warning` *message*: returns a Warning status.
+* `critical` *message*: returns a Critical status.
+* `unknown` *message*: returns an Unknown status.
+* `execute` *command*: executes a shell command, and returns any output (both
+  stdout and stderr). If the command exits with a non-zero status, it will
+  throw an exception. The shell is set to use the `pipefail` option, so non-zero
+  exit statuses in pipelines are detected as well.
+
+## License
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/nagi/dsl.rb

@@ -0,0 +1,57 @@
+module Nagi
+  class DSL
+    attr_reader :plugin
+
+    def initialize(&block)
+      @plugin = Nagi::Plugin.new
+      instance_eval &block
+    end
+
+    def argument(name)
+      @plugin.optionparser.argument(name)
+    end
+
+    def check(&block)
+      p = class << @plugin; self; end
+      p.send(:define_method, :check) do |options|
+        return catch(:status) { block.call(options) }
+      end
+    end
+
+    def critical(message)
+      throw :status, Nagi::Status::Critical.new(message)
+    end
+
+    def execute(command)
+      return Nagi::Utility.execute(command)
+    end
+
+    def name(name)
+      @plugin.name = name
+    end
+
+    def ok(message)
+      throw :status, Nagi::Status::OK.new(message)
+    end
+
+    def prefix(prefix)
+      @plugin.prefix = prefix
+    end
+
+    def switch(name, *args)
+      @plugin.optionparser.switch(name, *args)
+    end
+
+    def unknown(message)
+      throw :status, Nagi::Status::Unknown.new(message)
+    end
+
+    def version(version)
+      @plugin.version = version
+    end
+
+    def warning(message)
+      throw :status, Nagi::Status::Warning.new(message)
+    end
+  end
+end

data/lib/nagi/optionparser.rb

@@ -0,0 +1,48 @@
+module Nagi
+  class OptionParser < ::OptionParser
+
+    def initialize(*args, &block)
+      @arguments = []
+      @options = {}
+
+      super(*args, &block)
+
+      self.banner = "Usage: #{$0} [options]"
+
+      self.on_tail('-h', '--help', 'Display this help message') do
+        puts help
+        exit 0
+      end
+
+      self.on_tail('-V', '--version', 'Display version information') do
+        puts "#{program_name} #{version or "(unknown version)"}".strip
+        exit 0
+      end
+    end
+
+    def argument(name)
+      @arguments.push(name)
+      self.banner += " <#{name}>"
+    end
+
+    def parse!(args)
+      begin
+        @options.clear
+        super(args)
+        @arguments.each do |a|
+          @options[a] = args.shift or raise ArgumentError.new("Argument '#{a}' not given")
+        end
+        raise ArgumentError.new("Too many arguments") if args.length > 0
+      rescue ::OptionParser::ParseError => e
+        raise ArgumentError.new(e.message)
+      end
+      return @options
+    end
+
+    def switch(name, *args)
+      on(*args) do |value|
+        @options[name] = value
+      end
+    end
+  end
+end

data/lib/nagi/plugin.rb

@@ -0,0 +1,49 @@
+module Nagi
+  class Plugin
+    attr_accessor :name, :optionparser, :prefix, :version
+
+    def initialize
+      @optionparser = Nagi::OptionParser.new
+    end
+
+    def check(options)
+      raise NotImplementedError.new('No check defined')
+    end
+
+    def name=(value)
+      @name = value
+      @optionparser.program_name = value
+    end
+
+    def run(args)
+      options = @optionparser.parse(args)
+      begin
+        status = self.check(options)
+      rescue StandardError => e
+        status = Nagi::Status::Unknown.new(e.message)
+      end
+      if not status.is_a?Nagi::Status::Status
+        status = Nagi::Status::Unknown.new('Check did not provide a status')
+      end
+      return status
+    end
+
+    def run!
+      begin
+        status = run(ARGV)
+        puts "#{@prefix.upcase if @prefix} #{status}".strip
+        exit status.code
+      rescue ArgumentError => e
+        STDERR.puts("Error: #{e.message}")
+        puts ""
+        puts @optionparser
+        exit 4
+      end
+    end
+
+    def version=(value)
+      @version = value
+      @optionparser.version = value
+    end
+  end
+end

data/lib/nagi/status.rb

@@ -0,0 +1,42 @@
+module Nagi
+  module Status
+    class Status
+      attr_accessor :message
+      attr_reader :code, :name
+
+      def initialize(code, name, message)
+        @code = code
+        @name = name
+        @message = message
+      end
+
+      def to_s
+        return "#{@name.upcase}: #{@message}"
+      end
+    end
+
+    class Critical < Status
+      def initialize(message)
+        super(2, 'Critical', message)
+      end
+    end
+
+    class OK < Status
+      def initialize(message)
+        super(0, 'OK', message)
+      end
+    end
+
+    class Unknown < Status
+      def initialize(message)
+        super(3, 'Unknown', message)
+      end
+    end
+
+    class Warning < Status
+      def initialize(message)
+        super(1, 'Warning', message)
+      end
+    end
+  end
+end

data/lib/nagi/utility.rb

@@ -0,0 +1,11 @@
+module Nagi
+  module Utility
+    module_function
+
+    def execute(command)
+      output, status = Open3.capture2e("/bin/bash -o pipefail -c '#{command}'")
+      raise "Shell failure, '#{output.gsub(/^\/bin\/bash: /, '').strip}'" if status.exitstatus != 0
+      return output.strip
+    end
+  end
+end

data/lib/nagi/version.rb

@@ -0,0 +1,3 @@
+module Nagi
+  VERSION = '0.1.0'
+end

data/lib/nagi.rb

@@ -0,0 +1,16 @@
+require 'open3'
+require 'optparse'
+
+require 'nagi/dsl'
+require 'nagi/optionparser'
+require 'nagi/plugin'
+require 'nagi/status'
+require 'nagi/utility'
+require 'nagi/version'
+
+module Nagi
+end
+
+def Nagi(&block)
+  Nagi::DSL.new(&block).plugin.run!
+end

data/nagi.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'nagi/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'nagi'
+  s.version       = Nagi::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ['Erik Grinaker']
+  s.email         = ['erik@bengler.no']
+  s.homepage      = 'http://github.com/bengler/nagi'
+  s.summary       = 'A DSL for writing Nagios plugins'
+  s.description   = 'A DSL for writing Nagios plugins'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+end

data/spec/nagi/dsl_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Nagi::DSL do
+  before(:each) do
+    @dsl = Nagi::DSL.new do
+    end
+  end
+
+  describe '#plugin' do
+    it 'contains a Nagi::Plugin' do
+      @dsl.plugin.class.should eq Nagi::Plugin
+    end
+    
+    it 'is read-only' do
+      lambda { @sdl.plugin = nil }.should raise_error NoMethodError
+    end
+  end
+
+  describe '.argument' do
+    it 'sends argument to parser.optionparser' do
+      @dsl.argument(:name)
+      @dsl.plugin.optionparser.help.should match /<name>/
+    end
+  end
+
+  describe '.check' do
+    it 'sets the code block on plugin.check' do
+      @dsl.check do |options|
+        $nagi = options
+      end
+      @dsl.plugin.check({'a' => 1})
+      $nagi.should eq Hash['a' => 1]
+    end
+
+    it 'catches throwns :status and returns payload' do
+      @dsl.check do |options|
+        throw :status, 'status'
+      end
+      @dsl.plugin.check({}).should eq 'status'
+    end
+  end
+
+  describe '.critical' do
+    it 'throws :status with critical status' do
+      catch(:status) do
+        @dsl.critical('message')
+      end.class.should eq Nagi::Status::Critical
+    end
+  end
+
+  describe '.execute' do
+    it 'executes a command with Nagi::Utility.execute' do
+      @dsl.execute('echo test >&2').should eq 'test'
+    end
+  end
+
+  describe '.name' do
+    it 'sets plugin name' do
+      @dsl.name('name')
+      @dsl.plugin.name.should eq 'name'
+    end
+  end
+
+  describe '.ok' do
+    it 'throws :status with ok status' do
+      catch(:status) do
+        @dsl.ok('message')
+      end.class.should eq Nagi::Status::OK
+    end
+  end
+
+  describe '.prefix' do
+    it 'sets plugin prefix' do
+      @dsl.prefix('prefix')
+      @dsl.plugin.prefix.should eq 'prefix'
+    end
+  end
+
+  describe '.switch' do
+    it 'adds optionparser switch' do
+      @dsl.switch(:switch, '-s', '--switch', 'Test switch')
+      @dsl.plugin.optionparser.top.list[-1].short[0].should eq '-s'
+      @dsl.plugin.optionparser.top.list[-1].long[0].should eq '--switch'
+    end
+  end
+
+  describe '.unknown' do
+    it 'throws :status with unknown status' do
+      catch(:status) do
+        @dsl.unknown('message')
+      end.class.should eq Nagi::Status::Unknown
+    end
+  end
+
+  describe '.version' do
+    it 'sets plugin version' do
+      @dsl.version('version')
+      @dsl.plugin.version.should eq 'version'
+    end
+  end
+
+  describe '.warning' do
+    it 'throws :status with warning status' do
+      catch(:status) do
+        @dsl.warning('message')
+      end.class.should eq Nagi::Status::Warning
+    end
+  end
+end

data/spec/nagi/optionparser_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Nagi::OptionParser do
+  before(:each) do
+    @parser = Nagi::OptionParser.new
+  end
+
+  it 'subclasses OptionParser' do
+    @parser.is_a?(::OptionParser).should eq true
+  end
+
+  describe '.initialize' do
+    it 'set proper banner' do
+      @parser.banner.should eq "Usage: #{$0} [options]"
+    end
+
+    it 'sets up -h, --help' do
+      @parser.base.list[-2].short[0].should eq '-h'
+      @parser.base.list[-2].long[0].should eq '--help'
+    end
+
+    it 'sets up -V, --version' do
+      @parser.base.list[-1].short[0].should eq '-V'
+      @parser.base.list[-1].long[0].should eq '--version'
+    end
+  end
+
+  describe '.argument' do
+    it 'modifies banner' do
+      @parser.argument('test')
+      @parser.banner.should eq "Usage: #{$0} [options] <test>"
+    end
+  end
+
+  describe '.parse!' do
+    it 'parses arguments' do
+      @parser.argument(:test)
+      @parser.parse!(['testvalue']).should eq Hash[:test => 'testvalue']
+    end
+
+    it 'parses switches' do
+      @parser.switch(:test, '-t', '--test', 'Test switch')
+      @parser.parse!(['-t']).should eq Hash[:test => true]
+    end
+
+    it 'parses switches with value' do
+      @parser.switch(:test, '-t', '--test VALUE', 'Test switch')
+      @parser.parse!(['-t', 'testvalue']).should eq Hash[:test => 'testvalue']
+    end
+
+    it 'modifies input array' do
+      args = ['-t', 'testvalue', 'argument']
+      @parser.argument(:arg)
+      @parser.switch(:test, '-t', '--test VALUE', 'Test switch')
+      @parser.parse!(args)
+      args.should eq []
+    end
+
+    it 'raises ArgumentError on invalid switch' do
+      lambda { @parser.parse!(['-x']) }.should raise_error ArgumentError
+    end
+
+    it 'raises ArgumentError on too few arguments' do
+      @parser.argument(:test)
+      lambda { @parser.parse!([]) }.should raise_error ArgumentError
+    end
+
+    it 'raises ArgumentError on too many arguments' do
+      @parser.argument(:test)
+      lambda { @parser.parse!(['x', 'y']) }.should raise_error ArgumentError
+    end
+  end
+
+  describe '.switch' do
+    it 'adds a switch' do
+      @parser.switch('name', '-t', '--test TEST',) do |value|
+      end
+
+      @parser.top.list[-1].short[0].should eq '-t'
+      @parser.top.list[-1].long[0].should eq '--test'
+    end
+  end
+end

data/spec/nagi/plugin_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Nagi::Plugin do
+  before(:each) do
+    @plugin = Nagi::Plugin.new
+  end
+
+  describe '#optionparser' do
+    it 'contains OptionParser' do
+      @plugin.optionparser.class.should eq Nagi::OptionParser
+    end
+  end
+
+  describe '#name' do
+    it 'sets name' do
+      @plugin.name = 'name'
+      @plugin.name.should eq 'name'
+    end
+
+    it 'sets optionparser.program_name' do
+      @plugin.name = 'name'
+      @plugin.optionparser.program_name.should eq 'name'
+    end
+  end
+
+  describe '#prefix' do
+    it 'sets prefix' do
+      @plugin.prefix = 'prefix'
+      @plugin.prefix.should eq 'prefix'
+    end
+  end
+
+  describe '#version' do
+    it 'sets version' do
+      @plugin.version = 'version'
+      @plugin.version.should eq 'version'
+    end
+
+    it 'sets optionparser.version' do
+      @plugin.version = 'version'
+      @plugin.optionparser.version.should eq 'version'
+    end
+  end
+
+  describe '.check' do
+    it 'raises NotImplementedError' do
+      lambda { @plugin.check({}) }.should raise_error NotImplementedError
+    end
+  end
+
+  describe '.run' do
+    it 'passes parsed options to check' do
+      class << @plugin
+        def check(options)
+          $nagi = options
+        end
+      end
+      @plugin.optionparser.argument(:arg)
+      @plugin.optionparser.switch(:switch, '-s', '--switch VALUE', 'Test switch')
+      @plugin.run(['-s', 'value', 'argument'])
+      $nagi.should eq Hash[:arg => 'argument', :switch => 'value']
+    end
+
+    it 'returns check status' do
+      class << @plugin
+        def check(options)
+          return Nagi::Status::OK.new('ok')
+        end
+      end
+      @plugin.run([]).class.should eq Nagi::Status::OK
+    end
+
+    it 'returns unknown status on check exception' do
+      class << @plugin
+        def check(options)
+          raise StandardError.new('error')
+        end
+      end
+      @plugin.run([]).class.should eq Nagi::Status::Unknown
+    end
+
+    it 'doesnt catch errors from optionparser' do
+      lambda { @plugin.run(['--invalid']) }.should raise_error ArgumentError
+    end
+  end
+end

data/spec/nagi/status_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe Nagi::Status::Status do
+  before(:each) do
+    @status = Nagi::Status::Status.new(0, 'name', 'message')
+  end
+
+  describe '.code' do
+    it 'contains status code' do
+      @status.code.should eq 0
+    end
+
+    it 'is read-only' do
+      lambda { @status.code = 1 }.should raise_error NoMethodError
+    end
+  end
+
+  describe '.message' do
+    it 'contains message' do
+      @status.message.should eq 'message'
+    end
+
+    it 'is writable' do
+      @status.message = 'test'
+      @status.message.should eq 'test'
+    end
+  end
+
+  describe '.name' do
+    it 'contains name' do
+      @status.name.should eq 'name'
+    end
+
+    it 'is read-only' do
+      lambda { @status.name = 'test' }.should raise_error NoMethodError
+    end
+  end
+
+  describe '.to_s' do
+    it 'formats the status' do
+      @status.to_s.should eq 'NAME: message'
+    end
+  end
+end
+
+describe Nagi::Status::Critical do
+  before(:each) do
+    @status = Nagi::Status::Critical.new('message')
+  end
+
+  describe '.code' do
+    it 'is 2' do
+      @status.code.should eq 2
+    end
+  end
+
+  describe '.message' do
+    it 'contains message' do
+      @status.message.should eq 'message'
+    end
+  end
+
+  describe '.name' do
+    it 'is Critical' do
+      @status.name.should eq 'Critical'
+    end
+  end
+end
+
+describe Nagi::Status::OK do
+  before(:each) do
+    @status = Nagi::Status::OK.new('message')
+  end
+
+  describe '.code' do
+    it 'is 0' do
+      @status.code.should eq 0
+    end
+  end
+
+  describe '.message' do
+    it 'contains message' do
+      @status.message.should eq 'message'
+    end
+  end
+
+  describe '.name' do
+    it 'is OK' do
+      @status.name.should eq 'OK'
+    end
+  end
+end
+
+describe Nagi::Status::Unknown do
+  before(:each) do
+    @status = Nagi::Status::Unknown.new('message')
+  end
+
+  describe '.code' do
+    it 'is 3' do
+      @status.code.should eq 3
+    end
+  end
+
+  describe '.message' do
+    it 'contains message' do
+      @status.message.should eq 'message'
+    end
+  end
+
+  describe '.name' do
+    it 'is Unknown' do
+      @status.name.should eq 'Unknown'
+    end
+  end
+end
+
+describe Nagi::Status::Warning do
+  before(:each) do
+    @status = Nagi::Status::Warning.new('message')
+  end
+
+  describe '.code' do
+    it 'is 1' do
+      @status.code.should eq 1
+    end
+  end
+
+  describe '.message' do
+    it 'contains message' do
+      @status.message.should eq 'message'
+    end
+  end
+
+  describe '.name' do
+    it 'is Warning' do
+      @status.name.should eq 'Warning'
+    end
+  end
+end

data/spec/nagi/utility_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Nagi::Utility::execute' do
+  it 'raises exception on non-zero status' do
+    lambda { Nagi::Utility.execute('exit 1') }.should raise_error StandardError
+  end
+
+  it 'raises exception on non-zero status in pipelines' do
+    lambda { Nagi::Utility.execute('false | true') }.should raise_error StandardError
+  end
+
+  it 'returns command stdout' do
+    Nagi::Utility.execute('echo test').should eq 'test'
+  end
+
+  it 'returns command stderr' do
+    Nagi::Utility.execute('echo test >&2').should eq 'test'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'nagi'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: nagi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Erik Grinaker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70154071720240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70154071720240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70154071719820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70154071719820
+description: A DSL for writing Nagios plugins
+email:
+- erik@bengler.no
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/nagi.rb
+- lib/nagi/dsl.rb
+- lib/nagi/optionparser.rb
+- lib/nagi/plugin.rb
+- lib/nagi/status.rb
+- lib/nagi/utility.rb
+- lib/nagi/version.rb
+- nagi.gemspec
+- spec/nagi/dsl_spec.rb
+- spec/nagi/optionparser_spec.rb
+- spec/nagi/plugin_spec.rb
+- spec/nagi/status_spec.rb
+- spec/nagi/utility_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/bengler/nagi
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A DSL for writing Nagios plugins
+test_files:
+- spec/nagi/dsl_spec.rb
+- spec/nagi/optionparser_spec.rb
+- spec/nagi/plugin_spec.rb
+- spec/nagi/status_spec.rb
+- spec/nagi/utility_spec.rb
+- spec/spec_helper.rb