cookbook_sdk 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c80a28ba6401d141a2ca1bea0df40521ae9b69f
-  data.tar.gz: de10b825bfd323009a9ef816bda208d895d3713d
+  metadata.gz: db20953f625842a05cb9c9b4052ba82f6130ddbe
+  data.tar.gz: c7959d2a228be21d3bb71005afa87728d582f061
 SHA512:
-  metadata.gz: 320961d47ae94f7a36e6b42a88d048f5b93310eaa79464e2f707275c5d6ad7c0533bc1b3f26867e15332b4ca1a727172c70d55725286d5d62aeb20be7c151559
-  data.tar.gz: 061e1e29a110d101241289c3c0ca6dbf82d4242322ddde86bb2d32d50051f666950042d8bcde9789305b7c3cbe1857c0fe8eca48f72b7e4ee52385b43576df38
+  metadata.gz: e59c713b5aeddaa4cef7563a45ea2b87184d936e1bd17771dcee3c25250de2c624ea91d21c75cc9e031d80c4238da0f5100f675b4de9fb176c353c47941c09c1
+  data.tar.gz: a5175b5ff37fd4e5bca2a7788c5ed9e01598d31dcad145be7450bd8768ef7d27daad5d287bf28e8d7558a82ed6e238c67c6483fecf882bc3c68bbf1d01cbd235

data/.rubocop.yml

@@ -14,3 +14,11 @@ Metrics/AbcSize:
 
 Metrics/PerceivedComplexity:
   Max: 15
+
+HashSyntax:
+  EnforcedStyle: hash_rockets
+  Exclude:
+    - Rakefile
+    - Berksfile
+    - Gemfile
+    - Policyfile.rb

data/.travis.yml

@@ -14,5 +14,5 @@ script:
   - /opt/chefdk/embedded/bin/chef --version
   - /opt/chefdk/embedded/bin/rubocop --version
   - /opt/chefdk/embedded/bin/foodcritic --version
-  - chef exec bundle exec rake install
-  - chef exec rake test:rubocop
+  - chef exec bundle install
+  - chef exec rake test:ci

data/README.md

@@ -1,5 +1,7 @@
 # cookbook_sdk
 
+[![Gem Version](https://badge.fury.io/rb/cookbook_sdk.svg)](https://badge.fury.io/rb/cookbook_sdk)
 [![Build Status](https://travis-ci.org/Mindera/cookbook_sdk.svg?branch=master)](https://travis-ci.org/Mindera/cookbook_sdk)
+[![Coverage Status](https://coveralls.io/repos/Mindera/cookbook_sdk/badge.svg?branch=master&service=github)](https://coveralls.io/github/Mindera/cookbook_sdk?branch=master)
 
 Helpers for chef cookbook development and provisioning.

data/cookbook_sdk.gemspec

@@ -21,5 +21,11 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'bundler', '~> 1.9'
   spec.add_dependency 'rake', '~> 10.4'
-  spec.add_dependency 'highline', '~> 1.6', '>= 1.6.9'
+  spec.add_dependency 'highline', '~> 1.7.8'
+
+  spec.add_development_dependency 'chef'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls'
 end

data/lib/cookbook_sdk/handlers/slack.rb

@@ -1,3 +1,4 @@
+require 'chef/exceptions'
 require 'chef/handler'
 require 'net/http'
 require 'uri'
@@ -8,18 +9,19 @@ class Chef
     # Slack Handler goal is send messages to a Slack channel with Chef run status.
     # It can be used as a start, failure or success handler.
     class Slack < Chef::Handler
+      attr_reader :token, :channel, :username, :on_start, :on_success, :on_failure
+
       def initialize(options = {})
-        @token = options[:token]
-        @channel = options[:channel] || '#chef'
-        @username = options[:username] || 'Chef'
-        @on_start = options[:on_start].nil? ? true : options[:on_start]
-        @on_success = options[:on_success].nil? ? true : options[:on_success]
-        @on_failure = options[:on_failure].nil? ? true : options[:on_failure]
+        @token = options.fetch(:token) { raise Exceptions::ConfigurationError, "Slack 'token' should be provided!" }
+        @channel = options.fetch(:channel, '#chef')
+        @username = options.fetch(:username, 'Chef')
+        @on_start = options.fetch(:on_start, true)
+        @on_success = options.fetch(:on_success, true)
+        @on_failure = options.fetch(:on_failure, true)
       end
 
       def report
-        options = {}
-        options[:pretext] = "Run at #{run_status.node.name}"
+        options = { :pretext => "Run at #{run_status.node.name}" }
 
         if !run_status.is_a?(Chef::RunStatus) || elapsed_time.nil?
           report_start(options)
@@ -30,6 +32,8 @@ class Chef
         end
       end
 
+      private
+
       def report_start(options)
         return exit_without_sending('start') unless @on_start
         options[:title] = 'Chef run started!'
@@ -51,34 +55,32 @@ class Chef
       def report_failure(options)
         return exit_without_sending('failure') unless @on_failure
 
-        options[:title] = 'Chef FAILED!'
+        options[:title] = 'Chef run FAILED!'
         options[:color] = 'danger'
         options[:body] = "Running #{node.run_list} failed in #{run_status.elapsed_time} seconds."
-        options[:fallback] = "Chef FAILED! #{run_status.node.name} failed to run #{node.run_list}." \
+        options[:fallback] = "Chef FAILED! #{run_status.node.name} failed to run #{node.run_list}" \
                                " in #{run_status.elapsed_time.to_i} seconds."
         send_attachment(options)
 
         return if run_status.exception.nil?
-
-        text = '```' + run_status.formatted_exception.encode(
+        options[:text] = '```' + run_status.formatted_exception.encode(
           'UTF-8',
-          invalid: 'replace', undef: 'replace', replace: '?'
+          :invalid => :replace, :undef => :replace, :replace => '?'
         ) + '```'
-        options[:text] = text
         send_text(options)
       end
 
       def send_attachment(options)
-        fail 'No message defined to be send to slack' if options[:body].nil?
+        raise 'No message defined to be send to slack' if options[:body].nil?
         params = {
-          color: options[:color],
-          attachments: [{
-            pretext:  options[:pretext],
-            title: options[:title],
-            title_link: options[:title_link],
-            color: options[:color],
-            text: options[:body],
-            fallback: options[:fallback]
+          :color => options[:color],
+          :attachments => [{
+            :pretext => options[:pretext],
+            :title => options[:title],
+            :title_link => options[:title_link],
+            :color => options[:color],
+            :text => options[:body],
+            :fallback => options[:fallback]
           }]
         }
         send_slack_message(params)
@@ -89,15 +91,15 @@ class Chef
       end
 
       def send_text(options)
-        fail 'No message defined to be send to slack' if options[:text].nil?
+        raise 'No message defined to be send to slack' if options[:text].nil?
         params = {
-          text: options[:text]
+          :text => options[:text]
         }
         send_slack_message(params)
       end
 
       def send_slack_message(specif_params)
-        params = { username: @username, channel: @channel, token: @token }.merge(specif_params)
+        params = { :username => @username, :channel => @channel, :token => @token }.merge(specif_params)
 
         uri = URI("https://hooks.slack.com/services/#{@token}")
         http = Net::HTTP.new(uri.host, uri.port)
@@ -105,7 +107,7 @@ class Chef
 
         begin
           req = Net::HTTP::Post.new("#{uri.path}?#{uri.query}")
-          req.set_form_data(payload: params.to_json)
+          req.set_form_data(:payload => params.to_json)
           res = http.request(req)
           if res.code != '200'
             Chef::Log.error("We got an error while posting a message to Slack: #{res.code} - #{res.msg}")

data/lib/cookbook_sdk/rake_tasks.rb

@@ -2,6 +2,8 @@ require 'cookbook_sdk/ext/string'
 require 'cookbook_sdk/rake_tasks/test_tasks'
 require 'cookbook_sdk/rake_tasks/helper_tasks'
 require 'cookbook_sdk/rake_tasks/provisioning_tasks'
+require 'cookbook_sdk/rake_tasks/jenkins_tasks'
+require 'cookbook_sdk/rake_tasks/go_tasks'
 require 'English'
 
 # Runs a shell command.

data/lib/cookbook_sdk/rake_tasks/go_tasks.rb

@@ -0,0 +1,56 @@
+require 'cookbook_sdk/rake_tasks'
+require 'json'
+
+namespace :go do
+  desc 'Generate attribute json file for image creation'
+  task :image_attr_json do
+    rpm_version_file = File.join('../rpm_version')
+
+    base_dir = Dir.pwd
+    base_dir += '/provision' if File.directory?('provision')
+    attributes_file = File.join(base_dir, 'attributes.json')
+
+    version = nil
+    File.open(rpm_version_file, 'r') do |output|
+      version = output.read.strip
+    end
+
+    raise "'rpm_version' file should have a valid rpm version" if version.nil? || version.empty?
+
+    attributes = { 'pipeline' => { 'app_version' => version } }
+
+    File.open(attributes_file, 'w') do |f|
+      f.write(attributes.to_json)
+    end
+  end
+
+  desc 'Create attribute json file for cluster deployment'
+  task :cluster_attr_json do
+    begin
+      image_output_file = File.read('../_aws_image.output.json')
+      image_output = JSON.parse(image_output_file)
+    rescue StandardError => err
+      raise err
+    end
+
+    environment = ENV['ENVIRONMENT']
+    environment = 'test' if environment.nil? || environment.empty?
+
+    action = ENV['ACTION'] || nil
+    actions = %w(create destroy update)
+    raise "'ACTION' should be one of #{actions}" unless actions.include? action
+
+    attributes_file = File.join('provision', 'attributes.json')
+    attributes = {
+      'pipeline' => {
+        'ami_id' => image_output['ami_id'],
+        'environment' => environment,
+        'action' => action
+      }
+    }
+
+    File.open(attributes_file, 'w') do |f|
+      f.write(attributes.to_json)
+    end
+  end
+end

data/lib/cookbook_sdk/rake_tasks/jenkins_tasks.rb

@@ -0,0 +1,43 @@
+require 'cookbook_sdk/rake_tasks'
+require 'json'
+
+namespace :jenkins do
+  desc 'Generate attribute json file for image creation'
+  task :pipeline_version do
+    attributes_file = File.join('provision', 'attributes.json')
+    pipeline_version = ENV['PIPELINE_VERSION']
+
+    raise '$PIPELINE_VERSION cannot be null or empty' if pipeline_version.nil? || pipeline_version.empty?
+
+    attributes = {
+      'pipeline_version' => pipeline_version
+    }
+
+    File.open(attributes_file, 'w') do |f|
+      f.write(attributes.to_json)
+    end
+  end
+
+  desc 'Create attribute json file for cluster deployment'
+  task :attributes do
+    begin
+      image_output_file = File.read(File.join('.', '_aws_image.output.json'))
+      image_output = JSON.parse(image_output_file)
+    rescue StandardError => err
+      raise err
+    end
+
+    environment = ENV['ENVIRONMENT']
+    environment = 'test' if environment.nil? || environment.empty?
+
+    attributes_file = File.join('provision', 'attributes.json')
+    attributes = {
+      'image_id' => image_output['ami_id'],
+      'environment' => environment
+    }
+
+    File.open(attributes_file, 'w') do |f|
+      f.write(attributes.to_json)
+    end
+  end
+end

data/lib/cookbook_sdk/rake_tasks/provisioning_tasks.rb

@@ -9,14 +9,14 @@ module CookbookSDK
     base_dir = Dir.pwd
     base_dir += '/provision' if File.directory?('provision')
     TARGET_FOLDER = File.join(base_dir, '.target')
-    SDK_CONFIGURATION = 'cookbook_sdk.json'
+    SDK_CONFIGURATION = 'cookbook_sdk.json'.freeze
     CUSTOM_NAMED_LIST = ENV['NAMED_RUN_LIST']
     RUN_LIST = ENV['RUN_LIST']
     DEBUG = ENV['DEBUG']
-    BERKS = ENV['BERKS'] || false
+    BERKS = ENV['BERKS'] || true
 
     desc 'Prepare chef-zero environment, and run it.'
-    task all: ['chef:prepare', 'chef:run', 'chef:clean']
+    task :all => ['chef:prepare', 'chef:run', 'chef:clean']
 
     namespace :chef do
       desc 'Prepare chef-zero environment to run.'
@@ -81,7 +81,7 @@ def read_configuration(configuration_file)
   end
   return nil if file.nil?
 
-  data_hash = JSON.parse(file, symbolize_names: true)
+  data_hash = JSON.parse(file, :symbolize_names => true)
   data_hash
 rescue Errno::ENOENT, Errno::EACCES, JSON::ParserError => e
   puts "Problem reading #{configuration_file} - #{e}"
@@ -162,22 +162,27 @@ def run_chef_zero(target_folder, custom_named_run_list = nil, run_list = nil, de
   named_run_list = custom_named_run_list.nil? ? '' : "-n #{custom_named_run_list}"
   run_list = run_list.nil? ? '' : "-o #{run_list}"
   debug = !debug ? '' : '-l debug'
+  log_format = '--force-formatter'
 
-  attributes_file = File.join(target_folder, 'attributes.json')
-  attributes = File.exist?(attributes_file) ? '-j attributes.json' : ''
+  attributes_file_path = File.join(target_folder, 'attributes.json')
+  attributes_flag = File.exist?(attributes_file_path) ? '-j attributes.json' : ''
 
   timestamp = Time.now.to_i
   cache_pid_file = "#{target_folder}/.chef/cache/chef-client-running_#{timestamp}.pid"
   lockfile = "--lockfile=#{cache_pid_file}"
 
   cmd = 'chef exec chef-client -c custom_client.rb -z '
-  cmd += "#{named_run_list} #{run_list} #{debug} #{attributes} #{lockfile}"
+  cmd += "#{named_run_list} #{run_list} #{debug} #{attributes_flag} #{lockfile} #{log_format}"
 
-  banner("Running '#{cmd}' inside folder '#{target_folder}' ...")
+  if attributes_flag != ''
+    file = File.read(attributes_file_path)
+    data_hash = JSON.pretty_generate(JSON.parse(file))
 
-  Dir.chdir target_folder do
-    run_command(cmd, true)
+    banner('Attributes are:')
+    banner(data_hash)
   end
+
+  _run_command(cmd, target_folder)
 end
 
 def clean(target_folder)

data/lib/cookbook_sdk/rake_tasks/test_tasks.rb

@@ -5,7 +5,7 @@ module CookbookSdk
     extend Rake::DSL
 
     desc 'Run all fast tests.'
-    task test: ['test:foodcritic', 'test:rubocop', 'test:rspec']
+    task :test => ['test:foodcritic', 'test:rubocop', 'test:rspec']
 
     namespace :test do
       desc 'Runs Foodcritic linting'
@@ -24,7 +24,7 @@ module CookbookSdk
       end
 
       ### Continous Integration
-      desc 'Runs all tests to be run in a CI environment'
+      desc 'Runs all tests when run in a CI environment'
       task :ci do
         error = false
         error = foodcritic(false) || error
@@ -44,8 +44,8 @@ def foodcritic(exit_on_error = true)
 end
 
 def rspec(exit_on_error = true)
-  files = FileList[File.join(Dir.pwd, 'spec', 'unit', '**/*_spec.rb')]
-  cmd = "chef exec rspec #{files}"
+  files = FileList[File.join(Dir.pwd, 'test', 'unit', '**/test_*.rb')]
+  cmd = "chef exec rspec #{files} --format doc"
   banner("Running '#{cmd}' ...")
   run_command(cmd, exit_on_error)
 end

data/lib/cookbook_sdk/version.rb

@@ -1,4 +1,4 @@
 # Define gem version
 module CookbookSDK
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'.freeze
 end

data/test/unit/handlers/test_slack.rb

@@ -0,0 +1,249 @@
+require_relative '../helpers'
+
+require 'webmock/rspec'
+require 'cookbook_sdk/handlers/slack'
+
+WebMock.disable_net_connect!(:allow_localhost => true)
+
+describe Chef::Handler::Slack do
+  let(:node) do
+    node = Chef::Node.new
+    node.name('test')
+    node.run_list('recipe[fake_cookbook::fake_recipe]')
+    node
+  end
+
+  let(:url) do
+    "https://hooks.slack.com/services/#{config[:token]}"
+  end
+
+  let(:config) do
+    {
+      :token => 'fake_token',
+      :channel => '#fake_channel',
+      :username => 'fake_user',
+      :on_start => true,
+      :on_success => true,
+      :on_failure => true
+    }
+  end
+
+  before do
+    Chef::Handler::Slack.any_instance.stubs(:node).returns(node)
+  end
+
+  it 'should read the configuration options on initialization' do
+    @slack_handler = Chef::Handler::Slack.new(config)
+    expect(@slack_handler.token).to eq(config[:token])
+    expect(@slack_handler.channel).to eq(config[:channel])
+    expect(@slack_handler.username).to eq(config[:username])
+    expect(@slack_handler.on_start).to eq(config[:on_start])
+    expect(@slack_handler.on_success).to eq(config[:on_success])
+    expect(@slack_handler.on_failure).to eq(config[:on_failure])
+  end
+
+  it 'should set configuration defaults when not provide on initialization' do
+    @slack_handler = Chef::Handler::Slack.new(:token => 'fake_token')
+    expect(@slack_handler.token).to eq('fake_token')
+    expect(@slack_handler.channel).to eq('#chef')
+    expect(@slack_handler.username).to eq('Chef')
+    expect(@slack_handler.on_start).to eq(true)
+    expect(@slack_handler.on_success).to eq(true)
+    expect(@slack_handler.on_failure).to eq(true)
+  end
+
+  it 'should throw an exception when the slack token is not provided on initialization' do
+    expect { Chef::Handler::Slack.new({}) }.to raise_error(ChefConfig::ConfigurationError)
+  end
+
+  describe '#report' do
+    before do
+      @slack_handler = Chef::Handler::Slack.new(config)
+      @run_status = Chef::RunStatus.new(node, {})
+    end
+
+    describe 'when chef run is not over' do
+      before do
+        @run_status.start_clock
+      end
+
+      it 'should call report_start function at start of the run' do
+        @slack_handler.stubs(:report_start)
+
+        expect(@slack_handler).to receive(:report_start)
+        expect(@slack_handler).not_to receive(:report_success)
+        expect(@slack_handler).not_to receive(:report_failure)
+
+        @slack_handler.run_report_unsafe(@run_status)
+      end
+
+      it 'should skip the sending of the starting message when on_start option is false' do
+        new_config = config
+        new_config[:on_start] = false
+        @slack_handler = Chef::Handler::Slack.new(new_config)
+        expect(Chef::Log).to receive(:debug).with("Slack 'start' handler is not active.")
+        expect(@slack_handler).not_to receive(:send_attachment)
+        expect(@slack_handler).not_to receive(:send_slack_message)
+
+        @slack_handler.run_report_unsafe(@run_status)
+      end
+
+      it 'should send the starting message when on_start option is true' do
+        stub_request(:post, url).to_return(:status => 200, :headers => {})
+
+        expect(@slack_handler).not_to receive(:exit_without_sending)
+        expect(Chef::Log).to receive(:debug).with("Slack handler sent a message to channel '#{config[:channel]}'")
+
+        @slack_handler.run_report_unsafe(@run_status)
+
+        payload = {
+          :username => config[:username],
+          :channel => config[:channel],
+          :token => config[:token],
+          :color => nil,
+          :attachments => [{
+            :pretext => 'Run at test',
+            :title => 'Chef run started!',
+            :title_link => nil,
+            :color => nil,
+            :text => "Will run #{node.run_list}",
+            :fallback => "Chef run started! test will run #{node.run_list}."
+          }]
+        }
+        expect(WebMock).to have_requested(:post, url).with(:body => { :payload => payload.to_json })
+      end
+    end
+
+    describe 'when chef is over' do
+      before do
+        @run_status.start_clock
+        @run_status.stop_clock
+      end
+
+      describe 'and run successfully' do
+        it 'should call report_success function at end of the run' do
+          expect(@slack_handler).not_to receive(:report_start)
+          expect(@slack_handler).to receive(:report_success)
+          expect(@slack_handler).not_to receive(:report_failure)
+
+          @slack_handler.run_report_unsafe(@run_status)
+        end
+
+        it 'should skip the sending of the success message when on_success option is false' do
+          new_config = config
+          new_config[:on_success] = false
+          @slack_handler = Chef::Handler::Slack.new(new_config)
+          expect(Chef::Log).to receive(:debug).with("Slack 'success' handler is not active.")
+          expect(@slack_handler).not_to receive(:send_attachment)
+          expect(@slack_handler).not_to receive(:send_slack_message)
+
+          @slack_handler.run_report_unsafe(@run_status)
+        end
+
+        it 'should send the success message when on_success option is true' do
+          stub_request(:post, url).to_return(:status => 200)
+
+          expect(@slack_handler).not_to receive(:exit_without_sending)
+          expect(Chef::Log).to receive(:debug).with("Slack handler sent a message to channel '#{config[:channel]}'")
+
+          @slack_handler.run_report_unsafe(@run_status)
+          payload = {
+            :username => config[:username],
+            :channel => config[:channel],
+            :token => config[:token],
+            :color => 'good',
+            :attachments => [{
+              :pretext => 'Run at test',
+              :title => 'Chef run successfully!',
+              :title_link => nil,
+              :color => 'good',
+              :text => "Just run #{node.run_list} successfully in #{@run_status.elapsed_time} seconds.",
+              :fallback => "Chef run successfully! test run #{node.run_list} successfully "\
+                           "in #{@run_status.elapsed_time.to_i} seconds."
+            }]
+          }
+          expect(WebMock).to have_requested(:post, url).with(:body => { :payload => payload.to_json })
+        end
+      end
+
+      describe 'and failed' do
+        before do
+          @run_status.start_clock
+          @run_status.stop_clock
+          @run_status.exception = ChefConfig::ConfigurationError.new('A fake error.')
+        end
+
+        it 'should call report_failed function at end of the run' do
+          expect(@slack_handler).not_to receive(:report_start)
+          expect(@slack_handler).not_to receive(:report_success)
+          expect(@slack_handler).to receive(:report_failure)
+
+          @slack_handler.run_report_unsafe(@run_status)
+        end
+
+        it 'should skip the sending of the failed message when on_failure option is false' do
+          new_config = config
+          new_config[:on_failure] = false
+          @slack_handler = Chef::Handler::Slack.new(new_config)
+          expect(Chef::Log).to receive(:debug).with("Slack 'failure' handler is not active.")
+          expect(@slack_handler).not_to receive(:send_attachment)
+          expect(@slack_handler).not_to receive(:send_slack_message)
+
+          @slack_handler.run_report_unsafe(@run_status)
+        end
+
+        it 'should send the failure message when on_failure option is true' do
+          stub_request(:post, url).to_return(:status => 200, :headers => {})
+
+          expect(@slack_handler).not_to receive(:exit_without_sending)
+          expect(Chef::Log).to receive(:debug)
+            .with("Slack handler sent a message to channel '#{config[:channel]}'").twice
+
+          @slack_handler.run_report_unsafe(@run_status)
+
+          # Message as attachment
+          payload = {
+            :username => config[:username],
+            :channel => config[:channel],
+            :token => config[:token],
+            :color => 'danger',
+            :attachments => [{
+              :pretext => 'Run at test',
+              :title => 'Chef run FAILED!',
+              :title_link => nil,
+              :color => 'danger',
+              :text => "Running #{node.run_list} failed in #{@run_status.elapsed_time} seconds.",
+              :fallback => "Chef FAILED! #{@run_status.node.name} failed to run #{node.run_list}" \
+                           " in #{@run_status.elapsed_time.to_i} seconds."
+            }]
+          }
+          expect(WebMock).to have_requested(:post, url).with(:body => { :payload => payload.to_json })
+
+          # Exception
+          payload = {
+            :username => config[:username],
+            :channel => config[:channel],
+            :token => config[:token],
+            :text => '```ChefConfig::ConfigurationError: A fake error.```'
+          }
+          expect(WebMock).to have_requested(:post, url).with(:body => { :payload => payload.to_json })
+        end
+      end
+    end
+
+    describe 'when tries to send an http request but it fails' do
+      it 'should log a error when receive a http response different than 200 OK' do
+        stub_request(:post, url).to_return(:status => 400)
+        expect(Chef::Log).to receive(:error).with('We got an error while posting a message to Slack: 400 - ')
+        @slack_handler.run_report_unsafe(@run_status)
+      end
+
+      it 'should log a error when got any exception related with the request' do
+        stub_request(:post, url).to_return(:should_timeout => true)
+        expect(Chef::Log).to receive(:error)
+          .with('An unhandled exception occurred while posting a message to Slack: execution expired')
+        @slack_handler.run_report_unsafe(@run_status)
+      end
+    end
+  end
+end

data/test/unit/helpers.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+if ENV['TRAVIS']
+  require 'coveralls'
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+end
+SimpleCov.start
+
+require 'minitest'
+require 'mocha/mini_test'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cookbook_sdk
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Mindera
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-18 00:00:00.000000000 Z
+date: 2016-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,24 +44,90 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.6.9
+        version: 1.7.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 1.7.8
+- !ruby/object:Gem::Dependency
+  name: chef
+  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: minitest
+  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: mocha
+  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: simplecov
+  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: coveralls
+  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: 1.6.9
+        version: '0'
 description: |
   # cookbook_sdk
 
+  [![Gem Version](https://badge.fury.io/rb/cookbook_sdk.svg)](https://badge.fury.io/rb/cookbook_sdk)
   [![Build Status](https://travis-ci.org/Mindera/cookbook_sdk.svg?branch=master)](https://travis-ci.org/Mindera/cookbook_sdk)
+  [![Coverage Status](https://coveralls.io/repos/Mindera/cookbook_sdk/badge.svg?branch=master&service=github)](https://coveralls.io/github/Mindera/cookbook_sdk?branch=master)
 
   Helpers for chef cookbook development and provisioning.
 email:
@@ -81,11 +147,15 @@ files:
 - lib/cookbook_sdk/ext/string.rb
 - lib/cookbook_sdk/handlers/slack.rb
 - lib/cookbook_sdk/rake_tasks.rb
+- lib/cookbook_sdk/rake_tasks/go_tasks.rb
 - lib/cookbook_sdk/rake_tasks/helper_tasks.rb
+- lib/cookbook_sdk/rake_tasks/jenkins_tasks.rb
 - lib/cookbook_sdk/rake_tasks/provisioning_tasks.rb
 - lib/cookbook_sdk/rake_tasks/test_tasks.rb
 - lib/cookbook_sdk/version.rb
 - lib/foodcritic/rules/etsy.rb
+- test/unit/handlers/test_slack.rb
+- test/unit/helpers.rb
 homepage: https://github.com/mindera/cookbook_sdk
 licenses:
 - MIT
@@ -106,9 +176,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: cookbook sdk
-test_files: []
+test_files:
+- test/unit/handlers/test_slack.rb
+- test/unit/helpers.rb
 has_rdoc: