rspec-puppet-utils 1.0.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  metadata.gz: 635a0ce9c2b54988fb7ec410b75c4c77e435ae1e80fe1b66ce5b3d1c05c4cb3a8c97b79744060e8f2589607f0efca76372b53d9104e3dcc5673f087d87b2984f
-  data.tar.gz: 98963571a4a6102963fb1fc5435b01b3ee5783e70a58fbba4944e1e8de71307be6c92e5dd3bf5ee14d0aa25f7047678991d299a02bf812495680d5d8089180d8
 SHA1: 
-  metadata.gz: 7bec66522effc527a36925023661942dbd76828e
-  data.tar.gz: 331f03f24580fdb7048c43f3e693837f7c504ba4
+  data.tar.gz: a4dd63771ed01e8d6afa8f1e971ee5d34fd5422c
+  metadata.gz: c6a81e4e44b6d5e1198e5c4d27c4d9bf3d383cec
+SHA512: 
+  data.tar.gz: f0b85634b96353cee343e2238264a90b8a03aca441125c5fe7d08b048f803c8e38fd303e5a678d0641513d1fd64f14151d03b0366b3c4db53f94dbc949f32f27
+  metadata.gz: 39365b0ebfbfa4af02a41502d0f8bfa268648dee536082f871fe2cd8d7efbe5afa35ae6fc75e483185551d9fee6d644c3de7aa51b3e93b898747b0d65eb4c205

data/README.md

@@ -1,6 +1,6 @@
 # rspec-puppet-utils
 
-This is the continuation of a previous project about [rspec-puppet unit testing](https://github.com/TomPoulton/rspec-puppet-unit-testing), it provides a more refined version of the helper method for mocking functions, plus a harness for testing templates. The motivation for mocking functions etc is provided there so I won't go over it here.
+This is a more refined version of a previous project about [rspec-puppet unit testing](https://github.com/TomPoulton/rspec-puppet-unit-testing), it provides a class for mocking functions, a harness for testing templates, and a simple tool for testing hiera data files. The motivation for mocking functions etc is provided in that project so I won't go over it here.
 
 ## Usage
 
@@ -13,49 +13,49 @@ require 'spec_helper'
 
 describe 'foo::bar' do
 
-  add_stuff = MockFunction.new(self, 'add_stuff')
-  before(:each) do
-    add_stuff.stubs(:call).with([1, 2]).returns(3)
-  end
+  let!(:add_stuff) { MockFunction.new('add_stuff') { |f|
+      f.stubs(:call).with([1, 2]).returns(3)
+    }
+  }
 
   it 'should do something with add_stuff' do
+    # Specific stub for this test
+    add_stuff.stubs(:call).with([]).returns(nil)
     ...
   end
 end
 ```
 
-You can specify a default value:
-```ruby
-func = MockFunction.new(self, 'func', {:default_value => true})
-```
-
 You can mock a function that doesn't return a value (`:rvalue` is the default):
 ```ruby
-func = MockFunction.new(self, 'func', {:type => :statement})
+MockFunction.new('func', {:type => :statement})
 ```
 
 You can mock Hiera:
 ```ruby
-hiera = MockFunction.new(self, 'hiera')
-before(:each) do
-  hiera.stubs(:call).with(['non-ex']).raises(Puppet::ParseError.new('Key not found'))
-  hiera.stubs(:call).with(['db-password']).returns('password1')
-end
+MockFunction.new('hiera') { |f|
+  f.stubs(:call).with(['non-ex']).raises(Puppet::ParseError.new('Key not found'))
+  f.stubs(:call).with(['db-password']).returns('password1')
+}
 ```
+You handle when the functions are created yourself, e.g. you can assign it to a local variable `func = MockFunction...` create it in a before block `before(:each) do MockFunction... end` or use let `let!(:func) { MockFunction... }`
 
-Note:
+If you use let, **use `let!()` and not `let()`**, this is because lets are lazy-loaded, so unless you explicitly reference your function in each test, the function won't be created and puppet won't find it. Using `let!` means that the function will be created before every test regardless.
+
+Also if you use `let` when mocking hiera, **you can't use `:hiera` as the name due to conflicts** so you have to do something like `let!(:mock_hiera) { MockFunction.new('hiera') }`
+
+Notes:
 - You always stub the `call` method as that gets called internally
 - The `call` method takes an array of arguments
-- `self` is a way of getting hold of the current `RSpec::Core::ExampleGroup` instance. If anyone knows how to do this more cleanly let me know!
 
 ### TemplateHarness
 
-If your templates have some logic in them that you want to test, and you'd ideally like to get hold of the generated template so you can inspect it programatically rather than just using a regex then use `TemplateHarness`
+If your templates have some logic in them that you want to test, you'd ideally like to get hold of the generated template so you can inspect it programmatically rather than just using a regex. In this case use `TemplateHarness`
 
 Given a basic template:
 
 
-```ruby
+```erb
 <%
     from_class = @class_var
     from_fact  = scope.lookupvar('fact-name')
@@ -91,6 +91,58 @@ end
 
 Note:
 - The path resolution is pretty simple, just pass it a normal relative path, **not** like the paths you pass into the `template` function in puppet (where you expect puppet to add the `templates` section to the path)
+ 
+### HieraData::Validator
+
+The motivation behind this is to quickly check that your hiera data files have no syntax errors without having to run all of the possible combinations of your hiera hierarchy. At the moment this only supports yaml, but other file types can be added easily.
+
+```ruby
+require 'spec_helper'
+
+describe 'YAML hieradata' do
+
+  # Files are loaded recursively
+  validator = HieraData::YamlValidator.new('spec/fixtures/hieradata')
+
+  it 'should not contain syntax errors' do
+    # Use true to ignore empty files (default false)
+    expect { validator.load true }.to_not raise_error
+  end
+
+  context 'with valid yaml' do
+
+    validator.load true
+
+    # Check types
+    it 'should use arrays for api host lists' do
+      validator.validate('my-api-hosts') { |v|
+        expect(v).to be_an Array
+      }
+    end
+
+    # Use regex to match keys
+    it 'ports should only contain digits' do
+      validator.validate(/-port$/) { |v|
+        expect(v).to match /^[0-9]+$/
+      }
+    end
+
+  end
+
+end
+```
+
+In the examples above all keys in all yaml files are searched and checked
+
+If there is an error, you'll see the inner RSpec error, as well as which key and which file is incorrect:
+
+```
+RSpecPuppetUtils::HieraData::ValidationError: mail-smtp-port is invalid in live: expected "TwoFive" to match /^[0-9]+$/
+Diff:
+@@ -1,2 +1,2 @@
+-/^[0-9]+$/
++"TwoFive"
+```
 
 ## Setup
 - Add `rspec-puppet-utils` to your Gemfile (or use `gem install rspec-puppet-utils`)

data/lib/hieradata/validator.rb

@@ -1,24 +1,44 @@
+module RSpecPuppetUtils
+  module HieraData
 
-module HieraData
+    class Validator
 
-  class Validator
+      attr_reader :data
 
-    attr_accessor :data
+      def validate(key, &block)
+        raise ValidationError, 'No data available, try #load first' if @data.nil? || @data.empty?
 
-    def validate?(key, &block)
+        found = false
+        @data.keys.each do |file|
+          keys = get_matching_keys(key, file)
+          keys.each do |matched_key|
+            found = true
+            begin
+              block.call(@data[file][matched_key])
+            rescue Exception => e
+              raise ValidationError, "#{matched_key} is invalid in #{file}: #{e.message}"
+            end
+          end
+        end
+        raise ValidationError, "No match for #{key.inspect} was not found in any files" unless found
+      end
 
-      raise StandardError, '@data is nil, try load() first' unless @data
-      raise StandardError, '@data is empty' if @data.empty?
+      private
 
-      found = false
-      @data.keys.each do |file|
-        if @data[file].has_key? key
-          found = true
-          valid = block.call(@data[file][key])
-          raise StandardError, "Key #{key} is not valid in file #{file}" unless valid
+      def get_matching_keys(key, file)
+        if key.is_a?(String) || key.is_a?(Symbol)
+          keys = @data[file].has_key?(key) ? [key] : []
+        elsif key.is_a?(Regexp)
+          keys = @data[file].keys.select { |k| k.to_s =~ key }
+        else
+          raise ValidationError, 'Search key must be a String, Symbol or a Regexp'
         end
+        keys
       end
-      raise StandardError, "Key #{key} was not found in any files" unless found
+
+    end
+
+    class ValidationError < StandardError
     end
 
   end

data/lib/hieradata/yaml_validator.rb

@@ -1,40 +1,42 @@
 require 'hieradata/validator'
 require 'yaml'
 
-module HieraData
+module RSpecPuppetUtils
+  module HieraData
 
-  class YamlValidator < Validator
+    class YamlValidator < HieraData::Validator
 
-    def initialize(directory, extensions = ['yaml', 'yml'])
-      raise ArgumentError, 'extensions should be an Array' unless extensions.is_a? Array
-      @directory = directory
-      @extensions = extensions.map {|ext| ext =~ /\..*/ ? ext : ".#{ext}" }
-    end
+      def initialize(directory, extensions = ['yaml', 'yml'])
+        raise ArgumentError, 'extensions should be an Array' unless extensions.is_a? Array
+        @directory = directory
+        @extensions = extensions.map {|ext| ext =~ /\..*/ ? ext : ".#{ext}" }
+      end
 
-    def load(ignore_empty = false)
+      def load(ignore_empty = false)
 
-      files = Dir.glob(File.join(@directory, '**', '*')).reject { |path|
-        File.directory?(path) || !@extensions.include?(File.extname path )
-      }
+        files = Dir.glob(File.join(@directory, '**', '*')).reject { |path|
+          File.directory?(path) || !@extensions.include?(File.extname path )
+        }
 
-      @data = {}
-      files.each { |file|
+        @data = {}
+        files.each { |file|
 
-        # Assume all file names are unique i.e. thing.yaml and thing.yml don't both exist
-        file_name = File.basename(file).split('.').first
+          # Assume all file names are unique i.e. thing.yaml and thing.yml don't both exist
+          file_name = File.basename(file).split('.').first
 
-        begin
-          yaml = File.open(file) { |yf|
-            YAML::load( yf )
-          }
-        rescue ArgumentError => e
-          raise StandardError, "Yaml Syntax error in file #{file}: #{e.message}"
-        end
-        raise StandardError, "Yaml file is empty: #{file}" if !yaml && !ignore_empty
+          begin
+            yaml = File.open(file) { |yf|
+              YAML::load( yf )
+            }
+          rescue ArgumentError => e
+            raise StandardError, "Yaml Syntax error in file #{file}: #{e.message}"
+          end
+          raise StandardError, "Yaml file is empty: #{file}" unless yaml || ignore_empty
 
-        @data[file_name.to_sym] = yaml
-      }
+          @data[file_name.to_sym] = yaml if yaml
+        }
 
+      end
     end
   end
 end

data/lib/mock_function.rb

@@ -1,27 +1,36 @@
-require 'rspec-puppet'
-
-class MockFunction
-
-  attr_accessor :function_type, :has_default_value, :default_value
-
-  def initialize(example_group, name, options = {})
-    opts = options.nil? ? {} : options
-
-    @function_type = opts.has_key?(:type) ? opts[:type] : :rvalue
-
-    opts[:default_value] = nil if @function_type == :statement
+require 'puppet'
+
+module RSpecPuppetUtils
+
+  class MockFunction
+
+    def initialize(name, options = {})
+      parse_options! options
+      if options[:type] == :rvalue
+        this = self
+        Puppet::Parser::Functions.newfunction(name.to_sym, options) { |args| this.call args}
+        yield self if block_given?
+      else
+        # Even though the puppet function does not return a value,
+        # this mock still needs to do something, what it returns doesn't really matter.
+        Puppet::Parser::Functions.newfunction(name.to_sym, options) { |args| args }
+      end
+    end
 
-    @has_default_value = false
-    if opts.has_key?(:default_value)
-      @has_default_value = true
-      @default_value = opts[:default_value]
+    private
+
+    def parse_options!(options)
+      unless options[:type]
+        options[:type] = :rvalue
+      end
+      unless [:rvalue, :statement].include? options[:type]
+        raise ArgumentError, "Type should be :rvalue or :statement, not #{options[:type]}"
+      end
+      unless options[:arity].nil? || options[:arity].is_a?(Integer)
+        raise ArgumentError, 'arity should be an integer'
+      end
     end
 
-    this = self
-    example_group.before(:each) {
-      Puppet::Parser::Functions.newfunction(name.to_sym, {:type => this.function_type}) { |args| this.call(args) }
-      this.stubs(:call).returns(this.default_value) if this.has_default_value
-    }
   end
 
 end

data/lib/rspec-puppet-utils.rb

@@ -1,10 +1,6 @@
-require 'rspec'
-require 'mocha'
 require 'mock_function'
 require 'template_harness'
 require 'hieradata/validator'
 require 'hieradata/yaml_validator'
 
-RSpec.configure do |c|
-  c.mock_with :mocha
-end
+include RSpecPuppetUtils

data/lib/template_harness.rb

@@ -1,33 +1,37 @@
 require 'erb'
 
-class TemplateHarness
+module RSpecPuppetUtils
 
-  def initialize(template, scope = nil)
-    @template = template
-    @isolator = Isolator.new(scope)
-  end
+  class TemplateHarness
 
-  def set(name, value)
-    var_name = name.start_with?('@') ? name : "@#{name}"
-    @isolator.instance_variable_set(var_name, value)
-  end
+    def initialize(template, scope = nil)
+      @template = template
+      @isolator = Isolator.new(scope)
+    end
 
-  def run
-    b = @isolator.get_binding
-    template = File.exists?(@template) ? File.new(@template).read : @template
-    ERB.new(template, 0, '-').result b
-  end
+    def set(name, value)
+      var_name = name.start_with?('@') ? name : "@#{name}"
+      @isolator.instance_variable_set(var_name, value)
+    end
 
-  class Isolator
-    # Isolates the binding so that only the defined set
-    # of instance variables are available to erb
-    def initialize scope
-      @scope = scope
+    def run
+      b = @isolator.get_binding
+      template = File.exists?(@template) ? File.new(@template).read : @template
+      ERB.new(template, 0, '-').result b
     end
-    def get_binding
-      scope = @scope
-      binding
+
+    class Isolator
+      # Isolates the binding so that only the defined set
+      # of instance variables are available to erb
+      def initialize scope
+        @scope = scope
+      end
+      def get_binding
+        scope = @scope
+        binding
+      end
     end
+
   end
 
 end

data/rspec-puppet-utils.gemspec

@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |gem|
   gem.name          = 'rspec-puppet-utils'
-  gem.version       = '1.0.2'
+  gem.version       = '2.0.0'
   gem.description   = 'Helper classes for mock/stub functions, templates and hierdata'
   gem.summary       = ''
   gem.author        = 'Tom Poulton'

data/spec/classes/hieradata/validator_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'lib/hieradata/validator'
 
+include RSpecPuppetUtils
+
 module HieraData
   class Test < Validator
     def load
@@ -8,11 +10,13 @@ module HieraData
           :file1 => {
               'key' => 'value',
               :other => 'other value',
-              'missmatch' => 'string'
+              'missmatch' => 'string',
+              'cat' => 'black',
           },
           :file2 => {
               'hello' => 'world',
-              'missmatch' => ['array']
+              'missmatch' => ['array'],
+              'hat' => 'fedora',
           }
       }
     end
@@ -33,39 +37,82 @@ describe HieraData::Validator do
 
   it 'should use block to validate key' do
     expect {
-      validator.validate?('key') { |v| v == 'value' }
+      validator.validate('key') { |v| expect(v).to eq 'value' }
     }.to_not raise_error
 
     expect {
-      validator.validate?('key') { |v| v == 'oooops' }
-    }.to raise_error StandardError, /Key key is not valid in file/
+      validator.validate('key') { |v| expect(v).to eq 'oooops' }
+    }.to raise_error HieraData::ValidationError
   end
 
   it 'should accept symbol as key' do
     expect {
-      validator.validate?(:other) { |v| v == 'other value' }
+      validator.validate(:other) { |v| v == 'other value' }
     }.to_not raise_error
   end
 
   it 'should validate key in all files' do
     expect {
-      validator.validate?('missmatch') { |v| v.is_a? String }
-    }.to raise_error StandardError, /Key missmatch is not valid in file file2/
+      validator.validate('missmatch') { |v| expect(v).to be_a String }
+    }.to raise_error HieraData::ValidationError
+  end
+
+  it 'should return key and file in error messages' do
+    expect {
+      validator.validate('missmatch') { |v| expect(v).to be_a String }
+    }.to raise_error HieraData::ValidationError, /missmatch is invalid in file2/
+  end
+
+  context 'when matching with regex' do
+
+    it 'should raise error if no match is found' do
+      expect {
+        validator.validate(/nonex/) { }
+      }.to raise_error HieraData::ValidationError, /No match for \/nonex\/ was not found/
+    end
+
+    it 'should not raise error if match is found' do
+      expect {
+        validator.validate(/at$/) { }
+      }.to_not raise_error
+    end
+
+    it 'should validate block against all matches' do
+      parser = mock()
+      parser.expects(:parse).with('black').once
+      parser.expects(:parse).with('fedora').once
+      validator.validate(/at$/) { |v| parser.parse v }
+    end
+
+    it 'should match symbols' do
+      expect {
+        validator.validate(/other/) { |v| expect(v).to eq 'other value' }
+      }.to_not raise_error
+    end
+
   end
 
   it 'should raise error if data is nil' do
     nil_validator = HieraData::Test.new
     expect {
-      nil_validator.validate?('meh') { }
-    }.to raise_error StandardError, /@data is nil, try load\(\) first/
+      nil_validator.validate('meh') { }
+    }.to raise_error HieraData::ValidationError, /No data available/
   end
 
   it 'should raise error if data is empty' do
     empty_validator = HieraData::Test.new
     empty_validator.load_empty
     expect {
-      empty_validator.validate?('meh') { }
-    }.to raise_error StandardError, /@data is empty/
+      empty_validator.validate('meh') { }
+    }.to raise_error HieraData::ValidationError, /No data available/
+  end
+
+end
+
+describe HieraData::Validator do
+
+  it 'should inherit from StandardError' do
+    expect(HieraData::ValidationError.ancestors).to include StandardError
   end
 
 end

data/spec/classes/hieradata/yaml_validator_spec.rb

@@ -1,5 +1,7 @@
 require 'lib/hieradata/yaml_validator'
 
+include RSpecPuppetUtils
+
 describe HieraData::YamlValidator do
 
   it 'should be of type Validator' do
@@ -67,6 +69,11 @@ describe HieraData::YamlValidator do
       expect { validator.load true }.to_not raise_error
     end
 
+    it 'should not add empty files to @data' do
+      validator.load true
+      expect(validator.data.keys).to_not include :empty
+    end
+
   end
 
 end

data/spec/classes/mock_function_spec.rb

@@ -1,83 +1,111 @@
 require 'spec_helper'
 require 'lib/mock_function'
 
+include RSpecPuppetUtils
+
 describe MockFunction do
 
   let(:scope) { PuppetlabsSpec::PuppetInternals.scope }
 
-  context 'with no options' do
+  let(:values_from_let) { [1, 2, 3] }
+
+  describe '#initialize' do
 
-    func = MockFunction.new(self, 'func')
+    func_name = 'my_func'
+    func_sym  = func_name.to_sym
 
-    it 'should return an object' do
-      expect(func).to_not eq nil
+    it 'should add new function to puppet' do
+      name = 'mock_func'
+      func = MockFunction.new name
+      expect(Puppet::Parser::Functions.function(name.to_sym)).to eq "function_#{name}"
     end
 
-    it 'should not attach stub method to object' do
-      expect { func.call 'a' }.to raise_error NoMethodError
+    it 'should default to :rvalue type' do
+      func = MockFunction.new func_name
+      expect(Puppet::Parser::Functions.rvalue?(func_sym)).to eq true
     end
 
-    it 'should set function_type to :rvalue' do
-      expect(func.function_type).to eq :rvalue
+    it 'should default to :rvalue type if missing from options' do
+      func = MockFunction.new func_name, {}
+      expect(Puppet::Parser::Functions.rvalue?(func_sym)).to eq true
     end
 
-  end
+    it 'should allow type to be set' do
+      func = MockFunction.new func_name, {:type => :statement}
+      expect(Puppet::Parser::Functions.rvalue?(func_sym)).to eq false
+    end
 
-  context 'with options set to nil' do
+    it 'should only allow :rvalue or :statement for type' do
+      expect {
+        MockFunction.new func_name, {:type => :error}
+      }.to raise_error ArgumentError, 'Type should be :rvalue or :statement, not error'
+    end
+
+    it 'should allow arity to be set' do
+      func = MockFunction.new func_name, {:arity => 3}
+      expect(Puppet::Parser::Functions.arity(func_sym)).to eq 3
+    end
 
-    it 'should not throw error creating function' do
-      expect { MockFunction.new(example.example_group, 'nil_options', nil) }.to_not raise_error
+    it 'should only allow arity to be an integer' do
+      expect {
+        MockFunction.new func_name, {:arity => 'oops'}
+      }.to raise_error ArgumentError, 'arity should be an integer'
     end
 
   end
 
-  context 'with a default value of true' do
+  describe '#call' do
 
-    default_of_true = MockFunction.new(self, 'default_of_true', {:default_value => true})
+    let(:func) { MockFunction.new('func') }
 
-    it 'function should return true' do
-      expect(default_of_true.call 'a').to eq true
+    it 'should not be defined by default' do
+      expect(func.respond_to?(:call)).to eq false
     end
 
-  end
-
-  context 'with a default value of nil' do
+    it 'should be stubable' do
+      func.stubs(:call)
+      expect(func.respond_to?(:call)).to eq true
+    end
 
-    default_of_nil = MockFunction.new(self, 'default_of_nil', {:default_value => nil})
+    it 'should be called by puppet function' do
+      func.stubs(:call).returns('penguin')
+      result = scope.function_func []
+      expect(result).to eq 'penguin'
+    end
 
-    it 'function should return true' do
-      expect(default_of_nil.call 'a').to eq nil
+    it 'should be passed puppet function args' do
+      func.expects(:call).with([1, 2, 3]).once
+      scope.function_func [1, 2, 3]
     end
 
   end
 
-  context 'with a type of :statement' do
-
-    statement = MockFunction.new(self, 'statement', {:type => :statement})
+  context 'when :type => :statement' do
 
-    it 'should set function_type to :statement' do
-      expect(statement.function_type).to eq :statement
-    end
-
-    it 'should wire up a stub call method' do
-      expect { statement.call }.to_not raise_error
+    it 'should not raise error' do
+      MockFunction.new 'statement', {:type => :statement}
+      expect {
+        scope.function_statement []
+      }.to_not raise_error
     end
 
   end
 
-  context 'when using a puppet scope' do
-
-    func = MockFunction.new(self, 'func', {:default_value => true})
+  context 'when :type => :rvalue' do
 
-    it 'puppet should be able to call function' do
-      result = scope.function_func ['a']
-      expect(result).to eq true
+    it 'should allow setup stubs' do
+      func = MockFunction.new('func') { |f| f.stubs(:call).returns('badger') }
+      result = func.call
+      expect(result).to eq 'badger'
     end
 
-    it 'should be able to stub calls' do
-      func.stubs(:call).with([1, 2]).returns(3)
-      result = scope.function_func [1, 2]
-      expect(result).to eq 3
+    it 'should return values defined by a "let"' do
+      result = []
+      expect {
+        func = MockFunction.new('func') { |f| f.stubs(:call).returns(values_from_let) }
+        result = func.call
+      }.to_not raise_error
+      expect(result).to eq [1, 2, 3]
     end
 
   end

data/spec/classes/template_harness_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'lib/template_harness'
 
+include RSpecPuppetUtils
+
 describe TemplateHarness do
 
   it 'should render template' do

data/spec/classes/utils_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 require 'rspec-puppet-utils'
 
+include RSpecPuppetUtils
+
 describe 'rspec-puppet-utils' do
 
   it 'should require MockFunction' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rspec-puppet-utils
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors: 
 - Tom Poulton
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-03-11 00:00:00 Z
+date: 2014-03-19 00:00:00 Z
 dependencies: []
 
 description: Helper classes for mock/stub functions, templates and hierdata