sensu-plugins-cucumber 0.0.1.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9c216905081998e9ce597513b19044cb75b2c83c
+  data.tar.gz: 73ed8e64e71c6443b65b020891b21827228917e0
+SHA512:
+  metadata.gz: 8c5db2a1034753d33889d8e2d234ba131ba3134596b6f0fc1249561804cd272043afbf8c4b643d881f8f759d5b1221337e86f68de2e9c21b5376ae597cf1506d
+  data.tar.gz: 3abadaa0dab57436340a4e9ba8bc9d11f1257441570ed460fece397b5f8231580fdbee5ae17e8dd21787a7362a313e333db283b91629808146cb19931ddff71c

data/CHANGELOG.md

@@ -0,0 +1 @@
+#### 0.0.1.alpha.1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 devops@yieldbot.com
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+## Sensu-Plugins-cucumber
+
+[![Build Status](https://travis-ci.org/sensu-plugins/sensu-plugins-cucumber.svg?branch=master)](https://travis-ci.org/sensu-plugins/sensu-plugins-cucumber)
+[![Gem Version](https://badge.fury.io/rb/sensu-plugins-cucumber.svg)](http://badge.fury.io/rb/sensu-plugins-cucumber)
+[![Code Climate](https://codeclimate.com/github/sensu-plugins/sensu-plugins-cucumber/badges/gpa.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-cucumber)
+[![Test Coverage](https://codeclimate.com/github/sensu-plugins/sensu-plugins-cucumber/badges/coverage.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-cucumber)
+[![Dependency Status](https://gemnasium.com/sensu-plugins/sensu-plugins-cucumber.svg)](https://gemnasium.com/sensu-plugins/sensu-plugins-cucumber)
+
+## Functionality
+
+## Files
+ * bin.check-cucumber
+ *
+ *
+ *
+
+## Usage
+
+Example check_cucumber.json:
+
+``` json
+{
+  "checks": {
+    "check_cucumber_example": {
+      "handlers": ["default"],
+      "command": "check-cucumber.rb --name cucumber-example --handler cucumber --metric-handler metrics --metric-prefix example-metrics-prefix --command \"cucumber-js -f json features/\" --working-dir cucumber-example/",
+      "interval": 60,
+      "subscribers": [ "cucumber" ]
+    }
+  }
+}
+```
+
+
+## Installation
+
+Add the public key (if you haven’t already) as a trusted certificate
+
+```
+gem cert --add <(curl -Ls https://raw.githubusercontent.com/sensu-plugins/sensu-plugins.github.io/master/certs/sensu-plugins.pem)
+gem install sensu-plugins-cucumber -P MediumSecurity
+```
+
+You can also download the key from /certs/ within each repository.
+
+#### Rubygems
+
+`gem install sensu-plugins-cucumber`
+
+#### Bundler
+
+Add *sensu-plugins-cucumber* to your Gemfile and run `bundle install` or `bundle update`
+
+#### Chef
+
+Using the Sensu **sensu_gem** LWRP
+```
+sensu_gem 'sensu-plugins-cucumber' do
+  options('--prerelease')
+  version '0.0.1'
+end
+```
+
+Using the Chef **gem_package** resource
+```
+gem_package 'sensu-plugins-cucumber' do
+  options('--prerelease')
+  version '0.0.1'
+end
+```
+
+## Notes
+
+Sensu check that executes Cucumber tests
+
+The check supports:
+* cucumber-js
+* cucumber-jvm
+* Ruby Cucumber
+* parallel-cucumber-js

data/bin/README.md

@@ -0,0 +1,5 @@
+# check-cucumber
+
+
+## Example Sensu config
+

data/bin/check-cucumber.rb

@@ -0,0 +1,515 @@
+#! /usr/bin/env ruby
+#
+#   check-cucumber
+#
+# DESCRIPTION:
+#   A check that executes Cucumber tests
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: <?>
+#
+# USAGE:
+#   #YELLOW
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2014 Simon Dean <simon@simondean.org>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'optparse'
+require 'timeout'
+require 'json'
+require 'yaml'
+require 'socket'
+require 'English'
+
+#
+# Check Cucumber
+#
+class CheckCucumber < Sensu::Plugin::Check::CLI
+  OK = 0
+  WARNING = 1
+  CRITICAL = 2
+  UNKNOWN = 3
+
+  INFINITE_TIMEOUT = 0
+
+  option :name,
+         description: 'Name to use in sensu events',
+         short: '-n NAME',
+         long: '--name NAME'
+
+  option :handler,
+         description: 'Handler to use for sensu events',
+         short: '-h HANDLER',
+         long: '--handler HANDLER'
+
+  option :metric_handler,
+         description: 'Handler to use for metric events',
+         short: '-m HANDLER',
+         long: '--metric-handler HANDLER'
+
+  option :metric_prefix,
+         description: 'Metric prefix to use with metric paths in sensu events',
+         short: '-p METRIC_PREFIX',
+         long: '--metric-prefix METRIC_PREFIX'
+
+  option :command,
+         description: 'Cucumber command line, including arguments',
+         short: '-c COMMAND',
+         long: '--command COMMAND'
+
+  option :working_dir,
+         description: 'Working directory to use with Cucumber',
+         short: '-w WORKING_DIR',
+         long: '--working-dir WORKING_DIR'
+
+  option :timeout,
+         description: 'Amount of seconds to wait for Cucumber to wait before killing the Cucumber process',
+         short: '-t TIMEOUT',
+         long: '--timeout TIMEOUT'
+
+  option :env,
+         description: 'Environment variable to pass to Cucumber. Can be specified more than once to set multiple environment variables',
+         short: '-n NAME=VALUE',
+         long: '--env NAME=VALUE'
+
+  option :event_data,
+         description: 'Used to add custom data to the sensu events that are raised.  Can be specified more than once to set multiple data items',
+         short: '-d NAME=VALUE',
+         long: '--event-data NAME=VALUE'
+
+  option :attachments,
+         description: 'Specifies whether Cucumber attachments should be included in sensu events. ' \
+             'Cucumber attachments can be multi-megabyte if they include screenshots',
+         short: '-a BOOLEAN',
+         long: '--attachments BOOLEAN'
+
+  option :debug,
+         description: 'Print debug information',
+         long: '--debug',
+         boolean: true
+
+  def parse_options(argv) # rubocop:disable all
+    env = {}
+    event_data = {}
+
+    process_env_option = lambda do |config_value|
+      name, value = config_value.split('=', 2)
+      env[name] = value
+      env
+    end
+
+    process_event_data_option = lambda do |config_value|
+      name, value = config_value.split('=', 2)
+      event_data[name] = value
+      event_data
+    end
+
+    options[:env][:proc] = process_env_option
+    options[:event_data][:proc] = process_event_data_option
+
+    super(argv)
+  end
+
+  def run # rubocop:disable all
+    return unless config_is_valid?
+
+    result = nil
+
+    begin
+      result = execute_cucumber(config[:env], config[:command], config[:working_dir], config[:timeout])
+    rescue Timeout::Error
+      unknown_error "Cucumber exceeded the timeout of #{config[:timeout]} seconds"
+      return
+    end
+
+    puts "Results: #{result[:results]}" if config[:debug]
+    puts "Exit status: #{result[:exit_status]}" if config[:debug]
+
+    unless [0, 1].include? result[:exit_status]
+      unknown_error "Cucumber returned exit code #{result[:exit_status]}"
+      return
+    end
+
+    results = JSON.parse(result[:results], symbolize_names: true)
+
+    outcome = :ok
+    scenario_count = 0
+    statuses = [:passed, :failed, :pending, :undefined]
+    status_counts = {}
+    statuses.each { |scenario_status| status_counts[scenario_status] = 0 }
+    sensu_events = []
+    utc_timestamp = Time.now.getutc.to_i
+
+    results.each do |feature|
+      # #YELLOW
+      Array(feature[:elements]).each do |element| # rubocop:disable Style/Next
+        if element[:type] == 'scenario'
+          event_name = "#{config[:name]}.#{generate_name_from_scenario(feature, element)}"
+          scenario_status = get_scenario_status(element)
+
+          sensu_events << generate_sensu_event(event_name, feature, element, scenario_status)
+
+          metrics = generate_metrics_from_scenario(feature, element, scenario_status, utc_timestamp)
+
+          unless metrics.nil?
+            sensu_events << generate_metric_event(event_name, metrics)
+          end
+
+          scenario_count += 1
+          status_counts[scenario_status] += 1
+        end
+      end
+    end
+
+    puts "Sensu events: #{JSON.pretty_generate(sensu_events)}" if config[:debug]
+
+    errors = raise_sensu_events(sensu_events)
+
+    if errors.length > 0
+      outcome = :unknown
+    elsif scenario_count == 0
+      outcome = :warning
+    end
+
+    data = {
+      'status' => outcome.to_s,
+      'scenarios' => scenario_count
+    }
+
+    statuses.each do |status|
+      data[status.to_s] = status_counts[status] if status_counts[status] > 0
+    end
+
+    data['errors'] = errors if errors.length > 0
+
+    data = dump_yaml(data)
+
+    case outcome
+    when :ok
+      ok data
+    when :warning
+      warning data
+    when :unknown
+      unknown data
+    end
+  end
+
+  def config_is_valid? # rubocop:disable all
+    if config[:name].nil?
+      unknown_error 'No name specified'
+      return false
+    end
+
+    if config[:handler].nil?
+      unknown_error 'No handler specified'
+      return false
+    end
+
+    if config[:metric_handler].nil?
+      unknown_error 'No metric handler specified'
+      return false
+    end
+
+    if config[:metric_prefix].nil?
+      unknown_error 'No metric prefix specified'
+      return false
+    end
+
+    if config[:command].nil?
+      unknown_error 'No cucumber command line specified'
+      return false
+    end
+
+    if config[:working_dir].nil?
+      unknown_error 'No working directory specified'
+      return false
+    end
+
+    config[:timeout] ||= INFINITE_TIMEOUT
+    config[:timeout] = Float(config[:timeout]) unless config[:timeout].nil?
+    config[:env] ||= {}
+    config[:event_data] ||= {}
+
+    config[:attachments] = 'true' if config[:attachments].nil?
+
+    case config[:attachments]
+    when 'true'
+      config[:attachments] = true
+    when 'false'
+      config[:attachments] = false
+    else
+      unknown_error 'Attachments argument is not a valid boolean'
+      return false
+    end
+
+    true
+  end
+
+  def remove_attachments_from_scenario(scenario)
+    Array(scenario[:steps]).each do |step|
+      step[:embeddings] = [] if step.key?(:embeddings)
+    end
+  end
+
+  def generate_name_from_scenario(feature, scenario) # rubocop:disable all
+    name = scenario[:id]
+    name += ";#{feature[:profile]}" if feature.key? :profile
+
+    name = name.gsub(/\./, '-')
+           .gsub(/;/, '.')
+           .gsub(/[^a-zA-Z0-9\._-]/, '-')
+           .gsub(/^\.+/, '')
+           .gsub(/\.+$/, '')
+           .gsub(/\.+/, '.')
+
+    parts = []
+
+    name.split('.').each do |part|
+      part = part.gsub(/^-+/, '')
+             .gsub(/-+$/, '')
+             .gsub(/-+/, '-')
+
+      parts << part unless part.length == 0
+    end
+
+    name = parts.join('.')
+    name
+  end
+
+  def raise_sensu_events(sensu_events)
+    errors = []
+
+    sensu_events.each do |sensu_event|
+      data = escape_unicode_characters_in_json(sensu_event.to_json)
+
+      begin
+        send_sensu_event(data)
+      rescue StandardError => error
+        errors << {
+          'message' => "Failed to raise event #{sensu_event[:name]}",
+          'error' => {
+            'message' => error.message,
+            'backtrace' => error.backtrace
+          }
+        }
+      end
+    end
+
+    errors
+  end
+
+  def generate_metrics_from_scenario(feature, scenario, scenario_status, utc_timestamp) # rubocop:disable all
+    metrics = []
+
+    if scenario_status == :passed
+      scenario_duration = 0
+
+      if scenario.key?(:steps)
+        has_step_durations = false
+        scenario_metric_prefix = "#{config[:metric_prefix]}.#{generate_name_from_scenario(feature, scenario)}"
+
+        scenario[:steps].each.with_index do |step, step_index|
+          if step.key?(:result) && step[:result].key?(:duration)
+            has_step_durations = true
+            step_duration = step[:result][:duration]
+            step_duration = step_duration
+            metrics << "#{scenario_metric_prefix}.step-#{step_index + 1}.duration #{step_duration} #{utc_timestamp}"
+            scenario_duration += step_duration
+          end
+        end
+
+        if has_step_durations
+          scenario_metrics = [
+            "#{scenario_metric_prefix}.duration #{scenario_duration} #{utc_timestamp}",
+            "#{scenario_metric_prefix}.step-count #{scenario[:steps].length} #{utc_timestamp}"
+          ]
+          metrics.unshift scenario_metrics
+        end
+      end
+    end
+
+    if metrics.length == 0
+      metrics = nil
+    else
+      metrics = metrics.join("\n")
+    end
+
+    metrics
+  end
+
+  private
+
+  def output(msg)
+    puts msg
+  end
+
+  def execute_cucumber(env, command, working_dir, timeout)
+    results = nil
+    pipe = nil
+
+    begin
+      begin
+        Timeout.timeout(timeout) do
+          pipe = IO.popen(env, command, chdir: working_dir, external_encoding: Encoding::UTF_8)
+          results = pipe.read
+        end
+      rescue Timeout::Error
+        Process.kill 9, pipe.pid
+        raise Timeout::Error, 'Cucumber timed out'
+      end
+    ensure
+      pipe.close unless pipe.nil?
+    end
+
+    { results: results, exit_status: $CHILD_STATUS.exitstatus }
+  end
+
+  def send_sensu_event(data)
+    socket = TCPSocket.new('127.0.0.1', 3030)
+    socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+    index = 0
+    length = data.length
+
+    while index < length
+      bytes_sent = socket.send data[index..-1], 0
+      index += bytes_sent
+    end
+
+    socket.close
+  end
+
+  def generate_sensu_event(event_name, feature, scenario, scenario_status) # rubocop:disable all
+    scenario_clone = deep_dup(scenario)
+    remove_attachments_from_scenario(scenario_clone) unless config[:attachments]
+    feature_clone = deep_dup(feature)
+    feature_clone[:elements] = [scenario_clone]
+    scenario_results = [feature_clone]
+
+    scenario_output = get_output_for_scenario(scenario, scenario_status)
+
+    scenario_status_code = case scenario_status
+                           when :passed
+                             OK
+                           when :failed
+                             CRITICAL
+                           when :pending, :undefined
+                             WARNING
+    end
+
+    sensu_event = {
+      name: event_name,
+      handlers: [config[:handler]],
+      status: scenario_status_code,
+      output: scenario_output,
+      results: scenario_results
+    }
+
+    config[:event_data].each do |key, value|
+      if value =~ /^\A-?[0-9]+\z/
+        value = Integer(value)
+      elsif value =~ /^\A-?[0-9]+\.[0-9]+\z/
+        value = Float(value)
+      elsif value == 'true'
+        value = true
+      elsif value == 'false'
+        value = false
+      end
+      sensu_event[key] = value
+    end
+
+    sensu_event
+  end
+
+  def generate_metric_event(event_name, metrics)
+    metric_event = {
+      name: "#{event_name}.metrics",
+      type: 'metric',
+      handlers: [config[:metric_handler]],
+      output: metrics,
+      status: 0
+    }
+
+    metric_event
+  end
+
+  def get_scenario_status(scenario)
+    scenario_status = :passed
+
+    # #YELLOW
+    Array(scenario[:steps]).each do |step| # rubocop:disable Style/Next
+      if step.key? :result
+        step_status = step[:result][:status]
+
+        if %w(failed pending undefined).include? step_status
+          scenario_status = step_status.to_sym
+          break
+        end
+      end
+    end
+
+    scenario_status
+  end
+
+  def get_output_for_scenario(scenario, scenario_status) # rubocop:disable all
+    steps_output = []
+
+    Array(scenario[:steps]).each_with_index do |step, index|
+      has_result = step.key?(:result)
+      step_status = has_result ? step[:result][:status] : 'UNKNOWN'
+      step_output = {
+        'step' => "#{step_status.upcase} - #{index + 1} - #{step[:keyword]}#{step[:name]}"
+      }
+
+      if has_result && step[:result].key?(:error_message)
+        step_output['error'] = step[:result][:error_message]
+      end
+
+      steps_output << step_output
+    end
+
+    scenario_output = {
+      'status' => scenario_status.to_s,
+      'steps' => steps_output
+    }
+
+    dump_yaml(scenario_output)
+  end
+
+  def unknown_error(message)
+    data = {
+      'status' => 'unknown',
+      'errors' => [
+        {
+          'message' => message
+        }
+      ]
+    }
+    unknown dump_yaml(data)
+  end
+
+  def deep_dup(obj)
+    Marshal.load(Marshal.dump(obj))
+  end
+
+  def dump_yaml(data)
+    data.to_yaml.gsub(/^---\r?\n/, '')
+  end
+
+  def escape_unicode_characters_in_json(json)
+    json.unpack('U*').map { |i| i < 128 ? i.chr : "\\u#{i.to_s(16).rjust(4, '0')}" }.join
+  end
+end

data/bin/cucumber-example/features/failing.feature

@@ -0,0 +1,6 @@
+Feature: Failing
+
+  Scenario: Failing
+    Given a passing pre-condition
+    When a failing action is executed
+    Then a post-condition passes

data/bin/cucumber-example/features/passing.feature

@@ -0,0 +1,6 @@
+Feature: Passing
+
+  Scenario: Passing
+    Given a passing pre-condition
+    When a passing action is executed
+    Then a post-condition passes

data/bin/cucumber-example/features/step_definitions/failing.js

@@ -0,0 +1,7 @@
+module.exports = function() {
+  this.When(/^a failing action is executed$/, function(callback) {
+    if (this.isDryRun()) { return callback(); }
+
+    callback('Failed');
+  });
+};

data/bin/cucumber-example/features/step_definitions/passing.js

@@ -0,0 +1,19 @@
+module.exports = function() {
+  this.Given(/^a passing pre-condition$/, function(callback) {
+    if (this.isDryRun()) { return callback(); }
+
+    callback();
+  });
+
+  this.When(/^a passing action is executed$/, function(callback) {
+    if (this.isDryRun()) { return callback(); }
+
+    callback();
+  });
+
+  this.Then(/^a post-condition passes$/, function(callback) {
+    if (this.isDryRun()) { return callback(); }
+
+    callback();
+  });
+};

data/bin/cucumber-example/features/support/hooks.js

@@ -0,0 +1,12 @@
+module.exports = function() {
+  this.After(function (scenario, callback) {
+    if (scenario.isFailed()) {
+      scenario.attach(create1MegabyteBuffer(), 'text/plain');
+    }
+    callback();
+  });
+
+  function create1MegabyteBuffer() {
+    return new Buffer(1024 * 1024);
+  }
+};

data/bin/cucumber-example/features/support/world.js

@@ -0,0 +1,11 @@
+module.exports = function() {
+  this.World = function(callback) {
+    var world = {};
+
+    world.isDryRun = function() {
+      return process.argv.indexOf('--dry-run') !== -1 || process.env.PARALLEL_CUCUMBER_DRY_RUN === 'true';
+    };
+
+    callback(world);
+  };
+};

data/bin/cucumber-example/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "cucumber": ">=0.4.2",
+    "parallel-cucumber": ">=0.1.7"
+  }
+}

data/lib/sensu-plugins-cucumber.rb

@@ -0,0 +1,7 @@
+#
+# Set gem version
+#
+module SensuPluginsCucumber
+  # Gem version
+  VERSION = '0.0.1.alpha.1'
+end

metadata

@@ -0,0 +1,278 @@
+--- !ruby/object:Gem::Specification
+name: sensu-plugins-cucumber
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha.1
+platform: ruby
+authors:
+- Yieldbot, Inc. and contributors
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDgDCCAmigAwIBAgIBATANBgkqhkiG9w0BAQUFADBDMRIwEAYDVQQDDAltYXR0
+  am9uZXMxGDAWBgoJkiaJk/IsZAEZFgh5aWVsZGJvdDETMBEGCgmSJomT8ixkARkW
+  A2NvbTAeFw0xNTAxMjgyMTAyNTFaFw0xNjAxMjgyMTAyNTFaMEMxEjAQBgNVBAMM
+  CW1hdHRqb25lczEYMBYGCgmSJomT8ixkARkWCHlpZWxkYm90MRMwEQYKCZImiZPy
+  LGQBGRYDY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyTSzVYnO
+  CLgyrIyT1mBQakArQyW8xhi6MlDqyzXHJGeERT790U6EgoBVeS4XoK0ptFZNR8Tf
+  zko0w+Nv47TarSCgkPOaxY+mxWnAVR10dOmfeLr7huiMyps+YD56/EF2FqQ3jf/+
+  qohENfKD91qy1ieEy+Fn7Pf74ltbNKUdkb9a9eFXQ0DQ4ip5vik7DzjQkUTj4lca
+  k6ArwnmHX4YDhZoYtrQJ8jVktN0/+NtA40M5qkCYHNe5tUW25b/tKVYuioxG6b2Z
+  oIzaZxRLxf6HVAWpCVRT/F5+/yjigkX4u++eYacfLGleXQzoK7BL65vHGMJygWEE
+  0TKGqFOrl/L0AQIDAQABo38wfTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNV
+  HQ4EFgQUEf6a8Td7MrSZc8ImbLFZAENPbz0wIQYDVR0RBBowGIEWbWF0dGpvbmVz
+  QHlpZWxkYm90LmNvbTAhBgNVHRIEGjAYgRZtYXR0am9uZXNAeWllbGRib3QuY29t
+  MA0GCSqGSIb3DQEBBQUAA4IBAQBbzXAYA3BVGw8DZ0YYoY1VHPNEcH5qPIApmHO8
+  rvSmuUT0yMEi7u00H/5uHRFf4LleGT/+sTdyXKsNPGT9kdRuQEgwi+vf7Zfvd8aX
+  UF/+4VkEYf/8rV8Ere6u2QaWPgApdMV6JjKr1fAwCTd8AuGXNaWItiPPMseSQzLJ
+  JKP4hVvbc1d+oS925B1lcBiqn2aYvElbyNAVmQPywNNqkWmvtlqj9ZVJfV5HQLdu
+  8sHuVruarogxxKPBzlL2is4EUb6oN/RdpGx2l4254+nyR+abg//Ed27Ym0PkB4lk
+  HP0m8WSjZmFr109pE/sVsM5jtOCvogyujQOjNVGN4gz1wwPr
+  -----END CERTIFICATE-----
+date: 2015-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: english
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: timeout
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+- !ruby/object:Gem::Dependency
+  name: sensu-plugin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Sensu plugins for cucumber
+email: "<sensu-users@googlegroups.com>"
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/README.md
+- bin/check-cucumber.rb
+- bin/cucumber-example/features/failing.feature
+- bin/cucumber-example/features/passing.feature
+- bin/cucumber-example/features/step_definitions/failing.js
+- bin/cucumber-example/features/step_definitions/passing.js
+- bin/cucumber-example/features/support/hooks.js
+- bin/cucumber-example/features/support/world.js
+- bin/cucumber-example/package.json
+- lib/sensu-plugins-cucumber.rb
+homepage: https://github.com/sensu-plugins/sensu-plugins-cucumber
+licenses:
+- MIT
+metadata:
+  maintainer: ''
+  development_status: unmaintained
+  production_status: unstable - testing recommended
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Sensu plugins for cucumber
+test_files: []
+has_rdoc: