ecomdev-chefspec 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 01543e12806b48f668ac7ad1fd5ed983ad3d0277
+  data.tar.gz: 07d25f11fc0966b44312207590c7aa81c5ec1b4c
+SHA512:
+  metadata.gz: ca516b00f234b7120a53974fd1d218fe5a82387c1e37b271c88b3cd8cc7f0e4f29012577b8c3136e2e53417e5694b7657c289905ba1889537cd19b0cd3b5a359
+  data.tar.gz: 11059f3e473023a9c6ef027e0d05560426954b8cb3bb69434f920d70c628f4e58f4ad9c09022a31058e3238d8562e81df8e7ea226d75c0934970afd0f1480b77

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ecomdev-chefspec.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ivan Chepurnyi
+
+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,79 @@
+# EcomDev::ChefSpec
+
+A set of valuable helper to make writing ChefSpecs even more easier. 
+
+Features:
+
+ * You can define matchers for your LWRP and HWRP by using DSL based file in your specs directory. 
+    * By default it looks in `spec/matchers.rb`, `spec/matchers/*.rb`,  `spec/library/matchers.rb`, `spec/library/matchers/*.rb`
+    * Example of the file DSL
+       
+      ```ruby
+      matcher :resource_name, :action
+      matcher :resource_name, [:delete, :create]
+      runner :resource_name
+      ```
+        
+    * It automatically includes matchers from other recipes, that contain such a Ruby file
+        
+ * By default it mocks any inclusion of recipes, except described one. You can specify additional one by calling `allow_recipe` in spec DSL. 
+ * Allows to supply additional cookbook directory for your specs. Just add in `spec_helper.rb` file the following code
+       
+   ```ruby
+   EcomDev::ChefSpec::Configuration.cookbook_path('path/to/your/test/cookbooks')
+   EcomDev::ChefSpec::Configuration.cookbook_path('another/path/to/your/test/cookbooks')
+   ```
+        
+    It will automatically include the following paths for cookbook search:
+
+    * Berkshelf or Librarian path if any of those was included before
+    * `path/to/your/test/cookbooks`
+    * `another/path/to/your/test/cookbooks`  
+   
+
+## Build Status
+
+[![Develop Branch](https://api.travis-ci.org/IvanChepurnyi/ecomdev-chefspec.svg?branch=develop)](https://travis-ci.org/IvanChepurnyi/ecomdev-chefspec) **Next Release Branch**
+    
+[![Master Branch](https://api.travis-ci.org/IvanChepurnyi/ecomdev-chefspec.svg)](https://travis-ci.org/IvanChepurnyi/ecomdev-chefspec) **Current Stable Release** 
+   
+
+## Installation
+
+Add this line to your application's Gemfile:
+   
+```ruby
+gem 'ecomdev-chefspec'
+```
+
+And then execute:
+   
+```bash
+bundle
+```
+
+Or install it yourself as:
+
+```bash
+gem install ecomdev-chefspec
+```
+
+## Usage
+
+Inside of your specs helper you should include this library after chefspec
+
+```ruby
+require 'ecomdev/chefspec'
+```
+
+Please note, that you should include it in the end, after all the chef spec files are included. E.g. if you use bershelf loader for your cookbooks, you should include `ecomdev/chefspec` after you've included `chefspec/berkshelf`
+
+    
+
+## Contributing
+
+1. Fork it ( https://github.com/IvanChepurnyi/ecomdev-chefspec/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:unit) do |t|
+  t.rspec_opts = [].tap do |a|
+    a.push('--color')
+    a.push('--format progress')
+  end.join(' ')
+end
+
+desc 'Run all tests'
+task :test => [:unit]
+
+task :default => [:test]

data/ecomdev-chefspec.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ecomdev/chefspec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ecomdev-chefspec'
+  spec.version       = EcomDev::ChefSpec::VERSION
+  spec.authors       = ['Ivan Chepurnyi']
+  spec.email         = ['ivan.chepurnyi@ecomdev.org']
+  spec.summary       = 'A collection of helpers for chef spec, to make easier writing recipe specs'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/IvanChepurnyi/ecomdev-chefspec'
+  spec.license       = 'GPLv3'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'chefspec', '~> 4.0'
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/ecomdev-chefspec.rb

@@ -0,0 +1,2 @@
+# Loads chefspec definition file
+require_relative 'ecomdev/chefspec'

data/lib/ecomdev/chefspec.rb

@@ -0,0 +1,9 @@
+require 'chefspec' unless defined?(ChefSpec) # Require chef spec only if it is not required before
+
+require_relative 'chefspec/version'
+require_relative 'chefspec/configuration'
+require_relative 'chefspec/resource/matcher'
+require_relative 'chefspec/api'
+
+# Registers Resource Matchers callbacks for RSpec
+EcomDev::ChefSpec::Resource::Matcher.register

data/lib/ecomdev/chefspec/api.rb

@@ -0,0 +1,3 @@
+require 'chefspec/api'
+
+require_relative 'api/include_recipe'

data/lib/ecomdev/chefspec/api/include_recipe.rb

@@ -0,0 +1,13 @@
+require_relative '../stub/include_recipe'
+
+module ChefSpec::API
+  module EcomDevIncludeRecipe
+     def allow_recipe(*recipe_name)
+       recipe_name.flatten.each do |recipe|
+          EcomDev::ChefSpec::Stub::IncludeRecipe.allow_recipe(recipe)
+       end
+     end
+  end
+end
+
+EcomDev::ChefSpec::Configuration.callback(EcomDev::ChefSpec::Stub::IncludeRecipe)

data/lib/ecomdev/chefspec/configuration.rb

@@ -0,0 +1,86 @@
+module EcomDev
+  module ChefSpec
+    class Configuration
+      class << self
+        extend Forwardable
+        def_delegators :instance, :reset, :setup!, :teardown!, :cookbook_path, :callback
+      end
+
+      include Singleton
+
+      attr_accessor :cookbook_paths
+      attr_accessor :callbacks
+
+      def initialize
+        @cookbook_paths = []
+        @callbacks = []
+      end
+
+      def setup!
+        unless cookbook_paths.empty?
+          original_path = RSpec.configuration.cookbook_path
+          if original_path.nil?
+            original_path = []
+          elsif original_path.is_a?(String)
+            original_path = [original_path]
+          end
+
+          cookbook_paths.each do |path|
+            original_path << path unless original_path.include?(path)
+          end
+
+          RSpec.configuration.cookbook_path = original_path
+        end
+
+        invoke_callbacks(__method__)
+      end
+
+      def teardown!
+        invoke_callbacks(__method__)
+      end
+
+      def reset
+         @cookbook_paths = []
+         @callbacks = []
+      end
+
+      def cookbook_path(path)
+        @cookbook_paths << path unless cookbook_paths.include?(path)
+      end
+
+      def callback(callback)
+        @callbacks << callback unless callbacks.include?(callback)
+      end
+
+      def self.register
+        if defined?(ChefSpec::Berkshelf)
+          klass = ChefSpec::Berkshelf
+        elsif defined?(ChefSpec::Librarian)
+          klass = ChefSpec::Librarian
+        else
+          klass = false
+        end
+
+        if klass
+          klass.class_exec do
+            alias_method :old_setup!, :setup!
+
+            def setup!
+              old_setup!
+              EcomDev::ChefSpec::Configuration.setup!
+            end
+          end
+        else
+          RSpec.configure do
+            before(:suite) { EcomDev::ChefSpec::Configuration.setup! }
+          end
+        end
+      end
+
+      private
+        def invoke_callbacks(method)
+          callbacks.select { |c| c.respond_to?(method) }.each { |c| c.send(method) }
+        end
+    end
+  end
+end

data/lib/ecomdev/chefspec/resource/matcher.rb

@@ -0,0 +1,126 @@
+require_relative 'matcher/dsl'
+require_relative 'matcher/helper'
+
+module EcomDev
+  module ChefSpec
+    module Resource
+      class Matcher
+        class << self
+          extend Forwardable
+          def_delegators :instance, :setup!, :teardown!, :register, :matcher, :runner
+        end
+
+        include Singleton
+
+        attr_reader :matchers, :runners
+        attr_accessor :possible_directories
+
+        def initialize
+          @matchers = {}
+          @runners = []
+          @possible_directories = [
+              File.join('spec', 'matchers.rb'),
+              File.join('spec', 'matchers', '*.rb'),
+              File.join('spec', 'libraries', 'matchers.rb'),
+              File.join('spec', 'libraries', 'matchers/*.rb')
+          ]
+        end
+
+        def setup!
+          load_matchers
+          extend_api
+        end
+
+        def teardown!
+          @matchers = {}
+          @runners = []
+          Helper.reset
+        end
+
+        def extend_api
+          matchers.each do |method, info|
+            Helper.add(method) do |identity|
+              ChefSpec::Matchers::ResourceMatcher.new(info.resource, info.action, identity)
+            end
+          end
+        end
+
+        def matcher(resource_name, action)
+          if resource_name.is_a?(Array)
+            resource_name.each do |r|
+              matcher(r, action)
+            end
+          elsif action.is_a?(Array)
+            action.each do |a|
+              matcher(resource_name, a)
+            end
+          else
+            add_matcher(resource_name, action)
+          end
+        end
+
+        def runner(resource_name)
+          if resource_name.is_a?(Array)
+            resource_name.each do |r|
+              runner(r)
+            end
+          else
+            add_runner(resource_name)
+          end
+        end
+
+        def load_matchers
+          files = search_patterns.map { |pattern| Dir.glob(pattern) }.flatten
+          files.each {|file| load_matcher_file(file) }
+        end
+
+        def load_matcher_file(file)
+           DSL.load(file)
+        end
+
+        def search_patterns
+          cookbook_path = RSpec.configuration.cookbook_path
+          if cookbook_path.nil? ||
+              cookbook_path.is_a?(String) && cookbook_path.empty?
+            return []
+          end
+
+          cookbook_path = [cookbook_path] if cookbook_path.is_a?(String)
+
+          search_patterns = []
+          possible_directories.each do |directory|
+            cookbook_path.each do |cookbook_path|
+              search_patterns << File.join(cookbook_path, '*', directory)
+            end
+          end
+          search_patterns
+        end
+
+        def register
+          EcomDev::ChefSpec::Configuration.callback(self.class.instance)
+
+          RSpec.configure do |config|
+            config.include Helper
+          end
+        end
+
+        private
+          def add_matcher(resource, action)
+            resource_name = resource.to_s
+            action_name = action.to_s
+            matcher_name = action_name + '_' + resource_name
+            matcher = matcher_name.to_sym
+            unless @matchers.key?(matcher)
+              @matchers[matcher] = {action: action_name.to_sym, resource: resource_name.to_sym}
+            end
+          end
+
+          def add_runner(resource_name)
+            resource = resource_name.to_sym
+            @runners << resource unless @runners.include?(resource)
+          end
+      end
+    end
+  end
+end
+

data/lib/ecomdev/chefspec/resource/matcher/dsl.rb

@@ -0,0 +1,23 @@
+module EcomDev
+  module ChefSpec
+    module Resource
+      class Matcher
+        class DSL
+           def matcher(resource, action)
+             EcomDev::ChefSpec::Resource::Matcher.matcher(resource, action)
+           end
+
+           def runner(resource)
+             EcomDev::ChefSpec::Resource::Matcher.runner(resource)
+           end
+
+           def self.load(filename)
+             dsl = new
+             dsl.instance_eval(File.read(filename), filename)
+             dsl
+           end
+        end
+      end
+    end
+  end
+end

data/lib/ecomdev/chefspec/resource/matcher/helper.rb

@@ -0,0 +1,17 @@
+module EcomDev
+  module ChefSpec
+    module Resource
+      class Matcher
+        module Helper
+          def self.reset
+            instance_methods.each { |method| remove_method(method) }
+          end
+
+          def self.add(method, &block)
+            define_method(method, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecomdev/chefspec/stub/include_recipe.rb

@@ -0,0 +1,71 @@
+module EcomDev::ChefSpec::Stub
+  class IncludeRecipe
+    class << self
+      extend Forwardable
+      def_delegators :instance, :teardown!, :setup!, :allow_recipe, :reset
+    end
+
+    include Singleton
+
+    attr_accessor :allowed_recipes, :loaded_recipes
+
+    def initialize
+      @allowed_recipes = []
+      @loaded_recipes = []
+    end
+
+    def allow_recipe(recipe)
+      @allowed_recipes << recipe
+    end
+
+    def reset
+      @allowed_recipes = []
+      @loaded_recipes = []
+    end
+
+    def before_example(object)
+      stub_include(object) unless allowed_recipes.empty?
+    end
+
+    def stub_include(object)
+      # Don't worry about external cookbook dependencies
+      object.allow_any_instance_of(Chef::Cookbook::Metadata).to object.receive(:depends)
+
+      # Test each recipe in isolation, regardless of includes
+      object.allow_any_instance_of(Chef::RunContext).to object.receive(:loaded_recipe?) do |run_context, recipe_name|
+        run_context.loaded_recipes.include?(recipe_name)
+      end
+
+      object.allow_any_instance_of(Chef::RunContext).to object.receive(:include_recipe) do |run_context, *recipe_names|
+        recipe_names.flatten.each do |recipe_name|
+          @loaded_recipes << recipe_name
+          if allowed_recipes.include?(recipe_name)
+            run_context.load_recipe(recipe_name)
+          end
+        end
+        loaded_recipes
+      end
+
+      object.allow_any_instance_of(Chef::RunContext).to object.receive(:loaded_recipes) do
+        loaded_recipes
+      end
+    end
+
+    def after_example(object)
+      reset
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.before(:each) do
+    if respond_to?(:described_recipe) && described_recipe.match(/^[a-z_0-9]+::[a-z_0-9]+$/)
+      EcomDev::ChefSpec::Stub::IncludeRecipe.allow_recipe described_recipe
+    end
+    EcomDev::ChefSpec::Stub::IncludeRecipe.instance.before_example(self)
+  end
+
+  c.after(:each) do
+    EcomDev::ChefSpec::Stub::IncludeRecipe.instance.after_example(self)
+  end
+end

data/lib/ecomdev/chefspec/version.rb

@@ -0,0 +1,6 @@
+
+module EcomDev
+  module ChefSpec
+    VERSION = '0.1.0'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'ecomdev-chefspec'
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.filter_run(focus: true)
+  config.run_all_when_everything_filtered = true
+end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe EcomDev::ChefSpec::Configuration do
+  before(:each) do
+    Singleton.__init__(described_class)
+  end
+
+  def callback_klass
+    Class.new
+  end
+
+  describe '#cookbook_path' do
+    it 'it adds a new cookbook path to path stack' do
+      described_class.cookbook_path('test/path')
+      expect(described_class.instance.cookbook_paths).to contain_exactly('test/path')
+    end
+
+    it 'it adds cookbook path only once' do
+      described_class.cookbook_path('test/path')
+      described_class.cookbook_path('test/path')
+      expect(described_class.instance.cookbook_paths).to contain_exactly('test/path')
+    end
+  end
+
+  describe '#callback' do
+    it 'it adds a new callback' do
+      callback = callback_klass.new
+      described_class.callback(callback)
+      expect(described_class.instance.callbacks).to contain_exactly(callback)
+    end
+
+    it 'it adds a new callback only once' do
+      callback = callback_klass.new
+      described_class.callback(callback)
+      described_class.callback(callback)
+      callback2 = callback_klass.new
+      described_class.callback(callback2)
+      expect(described_class.instance.callbacks).to contain_exactly(callback, callback2)
+    end
+  end
+
+  describe '#reset' do
+    it 'it removes all callbacks and cookbook_paths' do
+      described_class.cookbook_path('test')
+      described_class.cookbook_path('test2')
+      described_class.callback(callback_klass.new)
+      described_class.callback(callback_klass.new)
+
+      expect(described_class.instance.callbacks).not_to be_empty
+      expect(described_class.instance.cookbook_paths).not_to be_empty
+
+      described_class.reset
+
+      expect(described_class.instance.callbacks).to be_empty
+      expect(described_class.instance.cookbook_paths).to be_empty
+    end
+  end
+
+  describe '#setup!' do
+    it 'modifies cookbook path for RSpec configuration' do
+      described_class.cookbook_path('test')
+      described_class.cookbook_path('test2')
+
+      expect(RSpec.configuration).to receive(:cookbook_path).and_return(nil)
+      expect(RSpec.configuration).to receive(:cookbook_path=).with(%w(test test2))
+
+      described_class.setup!
+    end
+
+    it 'add cookbook_paths after previously defined value' do
+      described_class.cookbook_path('test')
+      described_class.cookbook_path('test2')
+
+      expect(RSpec.configuration).to receive(:cookbook_path).and_return('value')
+      expect(RSpec.configuration).to receive(:cookbook_path=).with(%w(value test test2))
+
+      described_class.setup!
+    end
+
+    it 'merges cookbook_path with previously defined values' do
+      described_class.cookbook_path('test')
+      described_class.cookbook_path('test2')
+      described_class.cookbook_path('value3')
+
+      expect(RSpec.configuration).to receive(:cookbook_path).and_return(%w(value value2 value3))
+      expect(RSpec.configuration).to receive(:cookbook_path=).with(%w(value value2 value3 test test2))
+
+      described_class.setup!
+    end
+
+
+    it 'does not modify cookbook path if it is empty' do
+      expect(RSpec.configuration).not_to receive(:cookbook_path)
+
+      described_class.setup!
+    end
+
+    it 'calls a callback method setup! if it exists' do
+      callback = double('callback')
+
+      allow(callback).to receive(:respond_to?).with(:setup!).and_return(true)
+      expect(callback).to receive(:setup!)
+      described_class.callback(callback)
+      described_class.setup!
+    end
+
+    it 'does not call a callback method setup! if it is not defined' do
+      callback = double('callback')
+
+      allow(callback).to receive(:respond_to?).with(:setup!).and_return(false)
+      expect(callback).not_to receive(:setup!)
+
+      described_class.callback(callback)
+      described_class.setup!
+    end
+  end
+
+  describe '#teardown!' do
+    it 'calls a callback method teardown! if it exists' do
+      callback = double('callback')
+
+      allow(callback).to receive(:respond_to?).with(:teardown!).and_return(true)
+      expect(callback).to receive(:teardown!)
+      described_class.callback(callback)
+      described_class.teardown!
+    end
+
+    it 'does not call a callback method teardown! if it is not defined' do
+      callback = double('callback')
+
+      allow(callback).to receive(:respond_to?).with(:teardown!).and_return(false)
+      expect(callback).not_to receive(:teardown!)
+
+      described_class.callback(callback)
+      described_class.teardown!
+    end
+  end
+end

data/spec/unit/matcher/dsl_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe EcomDev::ChefSpec::Resource::Matcher::DSL do
+  let(:instance) { described_class.new }
+  let(:matcher) { EcomDev::ChefSpec::Resource::Matcher }
+
+  describe '#matcher' do
+    it 'calls matcher method on resource matcher instance' do
+      expect_any_instance_of(matcher).to receive(:matcher).with(:my_matcher, :create)
+      instance.matcher(:my_matcher, :create)
+    end
+
+    it 'calls matcher method on resource matcher instance with array arguments' do
+      expect_any_instance_of(matcher).to receive(:matcher).with([:my_matcher, :my_matcher2], [:create, :delete])
+      instance.matcher([:my_matcher, :my_matcher2], [:create, :delete])
+    end
+  end
+
+  describe '#runner' do
+    it 'calls runner method on resource matcher instance' do
+      expect_any_instance_of(matcher).to receive(:runner).with(:my_matcher)
+      instance.runner(:my_matcher)
+    end
+
+    it 'calls runner method on resource matcher instance with array arguments' do
+      expect_any_instance_of(matcher).to receive(:runner).with([:my_matcher, :my_matcher2])
+      instance.runner([:my_matcher, :my_matcher2])
+    end
+  end
+
+  describe '#load' do
+    it 'loads file dsl content' do
+      allow(File).to receive(:read).with('file.rb').and_return('
+      runner :my_custom_runner
+      matcher :my_custom_action, :create
+      matcher :another_action, [:create, :delete]')
+
+      expect_any_instance_of(matcher).to receive(:runner).with(:my_custom_runner)
+      expect_any_instance_of(matcher).to receive(:matcher).with(:my_custom_action, :create)
+      expect_any_instance_of(matcher).to receive(:matcher).with(:another_action, [:create, :delete])
+
+      expect(described_class.load('file.rb')).to be_instance_of(described_class)
+    end
+  end
+end

data/spec/unit/matcher/helper_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe EcomDev::ChefSpec::Resource::Matcher::Helper do
+
+  def create_method_body
+    Proc.new do |argument|
+      argument*argument
+    end
+  end
+
+  describe '#add' do
+    after(:each) { described_class.reset }
+
+    it 'it adds a new method' do
+      body = create_method_body
+
+      described_class.add(:my_custom_method, &body)
+      described_class.add(:another_custom_method, &body)
+
+      expect(described_class.instance_methods).to contain_exactly(:my_custom_method, :another_custom_method)
+    end
+
+    it 'it adds a new method only once' do
+      body = create_method_body do |arg|
+        arg
+      end
+      body2 = create_method_body do |arg|
+        arg*2
+      end
+
+      described_class.add(:another_custom_method, &body)
+      described_class.add(:another_custom_method, &body2)
+
+      expect(described_class.instance_methods).to contain_exactly(:another_custom_method)
+      klass = described_class
+      callable = Class.new do
+        include klass
+      end
+      expect(callable.new.another_custom_method(1)).to equal(1)
+    end
+  end
+
+  describe '#reset' do
+    it 'it removes all defined methods for instance' do
+      body = create_method_body
+
+      expect(described_class.instance_methods).to be_empty
+
+      described_class.add(:my_custom_method, &body)
+      described_class.add(:another_custom_method, &body)
+
+      expect(described_class.instance_methods).to contain_exactly(:my_custom_method, :another_custom_method)
+
+      described_class.reset
+      expect(described_class.instance_methods).to be_empty
+    end
+  end
+end

data/spec/unit/matcher_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+describe EcomDev::ChefSpec::Resource::Matcher do
+  before(:each) do
+    Singleton.__init__(described_class)
+  end
+
+  describe '#initialize' do
+    it 'should set matchers to empty hash' do
+      expect(described_class.instance.matchers).to be_kind_of(Hash).and be_empty
+    end
+
+    it 'should set runners to empty array' do
+      expect(described_class.instance.runners).to be_kind_of(Array).and be_empty
+    end
+
+    it 'should set possible_directories to expected list' do
+      expect(described_class.instance.possible_directories)
+      .to be_kind_of(Array)
+          .and contain_exactly(
+                   File.join('spec', 'matchers.rb'),
+                   File.join('spec', 'matchers', '*.rb'),
+                   File.join('spec', 'libraries', 'matchers.rb'),
+                   File.join('spec', 'libraries', 'matchers', '*.rb')
+               )
+    end
+  end
+
+  describe '#search_patterns' do
+    it 'should include cookbook_path if it is a string' do
+      RSpec.configure do |config|
+        config.cookbook_path = File.join('test', 'directory')
+      end
+      expect(described_class.instance.search_patterns)
+      .to be_kind_of(Array)
+          .and contain_exactly(
+                   File.join('test', 'directory', '*', 'spec', 'matchers.rb'),
+                   File.join('test', 'directory', '*', 'spec', 'matchers', '*.rb'),
+                   File.join('test', 'directory', '*', 'spec', 'libraries', 'matchers.rb'),
+                   File.join('test', 'directory', '*', 'spec', 'libraries', 'matchers', '*.rb')
+               )
+    end
+
+    it 'should include cookbook_path if it is an array' do
+      RSpec.configure do |config|
+        config.cookbook_path = File.join('test', 'directory')
+      end
+      expect(described_class.instance.search_patterns)
+      .to be_kind_of(Array)
+          .and contain_exactly(
+                   File.join('test', 'directory', '*', 'spec', 'matchers.rb'),
+                   File.join('test', 'directory', '*', 'spec', 'matchers', '*.rb'),
+                   File.join('test', 'directory', '*', 'spec', 'libraries', 'matchers.rb'),
+                   File.join('test', 'directory', '*', 'spec', 'libraries', 'matchers', '*.rb')
+               )
+    end
+
+    it 'should not include any cookbook in path if it is nil' do
+      RSpec.configure do |config|
+        config.cookbook_path = nil
+      end
+      expect(described_class.instance.search_patterns)
+      .to be_kind_of(Array)
+          .and be_empty
+    end
+
+    it 'should not include any cookbook in path if it is empty string' do
+      RSpec.configure do |config|
+        config.cookbook_path = ''
+      end
+      expect(described_class.instance.search_patterns)
+      .to be_kind_of(Array)
+          .and be_empty
+    end
+  end
+
+  describe '#load_matchers' do
+    it 'loads matcher files from configured values' do
+      RSpec.configure do |config|
+        config.cookbook_path = 'test'
+      end
+
+      matcher_paths = {
+          File.join('test', '*', 'matchers.rb') => [
+              File.join('test', 'magento', 'matchers.rb'),
+              File.join('test', 'nginx', 'matchers.rb')
+          ],
+          File.join('test', '*', 'matchers', '*.rb') => [
+              File.join('test', 'custom', 'matchers', 'matcher1.rb'),
+              File.join('test', 'custom', 'matchers', 'matcher2.rb')
+          ]
+      }
+
+      matcher_paths.each_pair do |key, value|
+        allow(Dir).to receive(:glob).with(key).and_return(value)
+        value.each do |file|
+          expect_any_instance_of(described_class).to receive(:load_matcher_file).with(file).and_return(true)
+        end
+      end
+
+      described_class.instance.possible_directories = ['matchers.rb', File.join('matchers', '*.rb')]
+      described_class.instance.load_matchers
+    end
+  end
+
+  describe '#load_matcher_file' do
+    it 'loads file as matcher DSL' do
+      dsl_class = EcomDev::ChefSpec::Resource::Matcher::DSL
+      expect(dsl_class).to receive(:load).with('file.rb').and_return(dsl_class.new)
+      described_class.instance.load_matcher_file('file.rb')
+    end
+  end
+
+  describe '#setup!' do
+    it 'loads matcher files and extends api' do
+      expect(described_class.instance).to receive(:load_matchers).and_return([])
+      expect(described_class.instance).to receive(:extend_api).and_return(described_class.instance)
+      described_class.setup!
+    end
+  end
+
+  describe '#extend_api' do
+    after(:each) { EcomDev::ChefSpec::Resource::Matcher::Helper.reset }
+    it 'should add new instance methods to helper' do
+      described_class.matcher(:test, :create)
+      described_class.instance.extend_api
+
+      expect(EcomDev::ChefSpec::Resource::Matcher::Helper.instance_methods).to contain_exactly(:create_test)
+    end
+  end
+
+  describe '#teardown!' do
+    it 'clears matchers and runners' do
+      described_class.matcher(:test, :test)
+      described_class.runner(:test)
+      described_class.setup!
+      described_class.teardown!
+      expect(described_class.instance.runners).to be_empty
+      expect(described_class.instance.matchers).to be_empty
+      expect(EcomDev::ChefSpec::Resource::Matcher::Helper.instance_methods).to be_empty
+    end
+  end
+
+  describe '#matcher' do
+     it 'adds matcher if resource and action are symbols' do
+       described_class.matcher(:my_custom_matcher, :create)
+       expect(described_class.instance.matchers).to eq(create_my_custom_matcher: {action: :create, resource: :my_custom_matcher})
+     end
+
+     it 'adds matcher if resource and action are strings' do
+       described_class.matcher('my_custom_matcher', 'create')
+       expect(described_class.instance.matchers).to eq(create_my_custom_matcher: {action: :create, resource: :my_custom_matcher})
+     end
+
+     it 'adds multiple matchers if actions is an array of symbols' do
+       described_class.matcher(:my_custom_matcher, [:create, :delete])
+       expect(described_class.instance.matchers).to eq(
+                                                        create_my_custom_matcher: {
+                                                            action: :create,
+                                                            resource: :my_custom_matcher
+                                                        },
+                                                        delete_my_custom_matcher: {
+                                                            action: :delete,
+                                                            resource: :my_custom_matcher
+                                                        }
+                                                    )
+     end
+
+     it 'adds multiple matchers if actions is an array of strings' do
+       described_class.matcher(:my_custom_matcher, %w(create delete))
+       expect(described_class.instance.matchers).to eq(
+                                                        create_my_custom_matcher: {
+                                                            action: :create,
+                                                            resource: :my_custom_matcher
+                                                        },
+                                                        delete_my_custom_matcher: {
+                                                            action: :delete,
+                                                            resource: :my_custom_matcher
+                                                        }
+                                                    )
+     end
+
+     it 'adds multiple matchers if resource is an array' do
+       described_class.matcher([:my_custom_matcher, :another_matcher], %w(create delete))
+       expect(described_class.instance.matchers).to eq(
+                                                        create_my_custom_matcher: {
+                                                            action: :create,
+                                                            resource: :my_custom_matcher
+                                                        },
+                                                        delete_my_custom_matcher: {
+                                                            action: :delete,
+                                                            resource: :my_custom_matcher
+                                                        },
+                                                        create_another_matcher: {
+                                                            action: :create,
+                                                            resource: :another_matcher
+                                                        },
+                                                        delete_another_matcher: {
+                                                            action: :delete,
+                                                            resource: :another_matcher
+                                                        }
+                                                    )
+     end
+
+     it 'adds matcher only once' do
+       described_class.matcher('my_custom_matcher', 'create')
+       described_class.matcher('my_custom_matcher', 'create')
+       expect(described_class.instance.matchers).to eq(
+                                                        create_my_custom_matcher: {
+                                                            action: :create,
+                                                            resource: :my_custom_matcher
+                                                        }
+                                                    )
+     end
+  end
+
+  describe '#runner' do
+    it 'adds runner if resource is a symbol' do
+      described_class.runner(:my_custom_matcher)
+      expect(described_class.instance.runners).to contain_exactly(:my_custom_matcher)
+    end
+
+    it 'adds matcher if resource is a string' do
+      described_class.runner('my_custom_matcher')
+      expect(described_class.instance.runners).to contain_exactly(:my_custom_matcher)
+    end
+
+    it 'adds multiple runners if resource is an array of symbols' do
+      described_class.runner([:my_custom_matcher, :antoher_matcher])
+      expect(described_class.instance.runners).to contain_exactly(
+                                                       :my_custom_matcher,
+                                                       :antoher_matcher
+                                                   )
+    end
+
+    it 'adds multiple runners if resource is an array of strings' do
+      described_class.runner(%w(my_custom_matcher antoher_matcher))
+      expect(described_class.instance.runners).to contain_exactly(
+                                                       :my_custom_matcher,
+                                                       :antoher_matcher
+                                                   )
+    end
+
+    it 'adds runner only once' do
+      described_class.runner('my_custom_matcher')
+      described_class.runner('my_custom_matcher')
+      expect(described_class.instance.runners).to contain_exactly(:my_custom_matcher)
+    end
+  end
+end

data/spec/unit/stub/include_recipe/test_spec.rb

@@ -0,0 +1,33 @@
+
+describe 'test::test' do
+  let (:instance) { EcomDev::ChefSpec::Stub::IncludeRecipe.instance }
+
+  it 'should add test::test to allowed recipes' do
+    expect(instance.allowed_recipes).to contain_exactly('test::test')
+  end
+
+  it 'should have an available allow_recipe method over API' do
+    allow_recipe('my_custom::recipe')
+    expect(instance.allowed_recipes).to contain_exactly('test::test', 'my_custom::recipe')
+  end
+
+  it 'allow recipe should allow multiple arguments as recipe names' do
+    allow_recipe('my_custom::recipe', 'recipe::another')
+    expect(instance.allowed_recipes).to contain_exactly('test::test', 'my_custom::recipe', 'recipe::another')
+  end
+
+  it 'allow recipe should allow multiple arguments as recipe names' do
+    allow_recipe(%w(my_custom::recipe recipe::another), 'recipe::third')
+    expect(instance.allowed_recipes).to contain_exactly('test::test', 'my_custom::recipe', 'recipe::another', 'recipe::third')
+  end
+
+  context 'when defined in hook it' do
+    before (:each) { allow_recipe('before::recipe') }
+
+    it 'calls allow_recipe as well' do
+      expect(instance.allowed_recipes).to contain_exactly('test::test', 'before::recipe')
+    end
+  end
+
+
+end

data/spec/unit/stub/include_recipe_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe EcomDev::ChefSpec::Stub::IncludeRecipe do
+  describe '#allow_recipe' do
+    it 'should add recipe to the list of allowed' do
+       described_class.allow_recipe('test_my::test')
+       described_class.allow_recipe('test_two::test')
+       expect(described_class.instance.allowed_recipes).to contain_exactly('test_my::test', 'test_two::test')
+    end
+  end
+
+  describe '#each_exameple' do
+    context 'when there is no described recipe it' do
+      it 'does not stub any include of recipe' do
+        expect { Chef::Cookbook::Metadata.new.depends }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when there is a described recipe', :allow_recipe => true do
+      let (:runner) { ChefSpec::Runner.new }
+      let (:described_recipe) { 'test::test' }
+
+      it 'loaded recipes should be empty in the beginning' do
+        expect(described_class.instance.loaded_recipes).to be_empty
+      end
+
+      it 'should call original load method on allowed recipes' do
+        described_class.allow_recipe('test2::test')
+        expect_any_instance_of(Chef::RunContext).to receive(:load_recipe).with('test::test').exactly(1).times
+        expect_any_instance_of(Chef::RunContext).to receive(:load_recipe).with('test2::test').exactly(1).times
+        expect_any_instance_of(Chef::Client).to receive(:assert_cookbook_path_not_empty)
+
+        runner.converge
+        runner.run_context.include_recipe('test::test')
+        runner.run_context.include_recipe('test2::test')
+
+        expect(runner.run_context.loaded_recipe?('test::test')).to eq(true)
+        expect(runner.run_context.loaded_recipe?('test2::test')).to eq(true)
+      end
+
+      it 'should mark as included recipes that are not allowed, but do not load them' do
+        allow_any_instance_of(Chef::RunContext).to receive(:load_recipe).and_call_original
+        expect_any_instance_of(Chef::RunContext).not_to receive(:load_recipe).with('dummy::test')
+        expect_any_instance_of(Chef::Client).to receive(:assert_cookbook_path_not_empty)
+
+        runner.converge
+        runner.run_context.include_recipe('dummy::test')
+
+        expect(runner.run_context.loaded_recipes).to contain_exactly('dummy::test')
+        expect(runner.run_context.loaded_recipe?('dummy::test')).to eq(true)
+        expect(runner.run_context.loaded_recipe?('test::test')).to eq(false)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: ecomdev-chefspec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ivan Chepurnyi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chefspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: A collection of helpers for chef spec, to make easier writing recipe
+  specs
+email:
+- ivan.chepurnyi@ecomdev.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ecomdev-chefspec.gemspec
+- lib/ecomdev-chefspec.rb
+- lib/ecomdev/chefspec.rb
+- lib/ecomdev/chefspec/api.rb
+- lib/ecomdev/chefspec/api/include_recipe.rb
+- lib/ecomdev/chefspec/configuration.rb
+- lib/ecomdev/chefspec/resource/matcher.rb
+- lib/ecomdev/chefspec/resource/matcher/dsl.rb
+- lib/ecomdev/chefspec/resource/matcher/helper.rb
+- lib/ecomdev/chefspec/stub/include_recipe.rb
+- lib/ecomdev/chefspec/version.rb
+- spec/spec_helper.rb
+- spec/unit/configuration_spec.rb
+- spec/unit/matcher/dsl_spec.rb
+- spec/unit/matcher/helper_spec.rb
+- spec/unit/matcher_spec.rb
+- spec/unit/stub/include_recipe/test_spec.rb
+- spec/unit/stub/include_recipe_spec.rb
+homepage: https://github.com/IvanChepurnyi/ecomdev-chefspec
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.0
+signing_key: 
+specification_version: 4
+summary: A collection of helpers for chef spec, to make easier writing recipe specs
+test_files:
+- spec/spec_helper.rb
+- spec/unit/configuration_spec.rb
+- spec/unit/matcher/dsl_spec.rb
+- spec/unit/matcher/helper_spec.rb
+- spec/unit/matcher_spec.rb
+- spec/unit/stub/include_recipe/test_spec.rb
+- spec/unit/stub/include_recipe_spec.rb
+has_rdoc: