puppet-retrospec 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b5058097bcc5d5c96332495e617db07cea74805
-  data.tar.gz: 0a8f3072a91d5f72ff391c90d920336af8daa5d6
+  metadata.gz: 3132a94b4025368f76a74202f2ffacfe5906b941
+  data.tar.gz: d0adc560eb50a6a89dc3ad9810f53516cc6f2c07
 SHA512:
-  metadata.gz: c44aa9a6c8db80d14842a06662722da2a0d35c5bc1da46b843e61a71dff7222e1d13e14af74393d008ace304c9811e8e16f4b61cb8929090cd89dc61ace9200a
-  data.tar.gz: db3a54af5802009798cda488a5649e47ccf8678627e3d32f5fe064a2967108e6de90107ff61f98dfd26b7d0f04839da97f8b57d8d06a5b0f2e7a13015ce6d2e9
+  metadata.gz: e4fdd60ac3de7650f4ca6a0054fb292a9a55f25f68337d8b01b6f10e1db46915b8c6db0826f02d8ffb5447250cd4d223654a16a747653abc8c4f7303bf78fcc4
+  data.tar.gz: cce4b3c789ab9b41d16839d557ed2a83c6b2a25f062e3e4cd534ddf785e20591f157d93b59b22617b07bb556cfd553a1b85fe841a9154185483cd10f8c0f88c6

data/README.md

@@ -72,7 +72,7 @@ $ retrospec
 ```
 
 Looking at the file we can see that it did a lot of work for us.  Retrospec generate three tests automatically.
-However the variable resolution isn't perfect so you will need to manually resolve all variables.  This doesn't produce
+However the variable resolution isn't perfect so you will need to manually resolve some variables.  This doesn't produce
 100% coverage but all you did was press enter to produce all this anyways.
 Below is the defines/instance_spec.rb file
    
@@ -161,7 +161,7 @@ For now you will probably want to read up on the following documentation:
 How Does it do this
 =======================
 Basically Retrospec uses the puppet lexer and parser to scan your code in order to fill out some basic templates that will retrofit
-your puppet module with unit tests.  Currently I rely on the old AST parser to generate all this
+your puppet module with unit tests.  Currently I rely on the old AST parser to generate all this.  This is why
 
 Overriding the templates
 =======================

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/bin/retrospec

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 require 'trollop'
 require 'retrospec'
-require 'retrospec/version'
 
 opts = Trollop::options do
   opt :module_path, "The path (relative or absolute) to the module directory (Defaults to current directory) " ,
@@ -11,10 +10,8 @@ opts = Trollop::options do
   opt :enable_user_templates, "Use Retrospec templates from #{File.expand_path('~/.puppet_retrospec_templates')}",
       :require => false, :type => :boolean
   opt :enable_beaker_tests, "Enable the creation of beaker tests", :require => false, :type => :boolean
-  opt :version, "The Version of the Gem", :required => false, :type => :boolean
-end
-if opts[:version]
-  puts "Puppet Retrospec Version: #{Puppet_Retrospec::VERSION}"
 end
+include Puppet_Retrospec
+
 retro = Retrospec.new(opts[:module_path], opts)
 retro.create_files

data/lib/retrospec.rb

@@ -5,20 +5,23 @@ require 'fileutils'
 require 'retrospec/resource'
 require 'retrospec/conditional'
 require 'retrospec/variable_store'
-require 'retrospec/module_utilities'
+require 'retrospec/puppet_module'
+require 'retrospec/spec_object'
+require 'retrospec/exceptions'
+require 'retrospec/version'
 
 class Retrospec
-  include PuppetModule::Utilities
 
-  attr_reader :module_path
   attr_reader :template_dir
+  attr_reader :module_path
+  attr_reader :spec_object
 
   # module path is the relative or absolute path to the module that should retro fitted
   # opts hash contains additional flags and options that can be user to control the creation of the tests
   # opts[:enable_user_templates]
   # opts[:enable_beaker_tests]
   # opts[:template_dir]
-  def initialize(module_path=nil,opts={})
+  def initialize(supplied_module_path=nil,opts={})
     # user supplied a template path or user wants to use local templates
     if opts[:template_dir] or opts[:enable_user_templates]
       @template_dir = Helpers.setup_user_template_dir(opts[:template_dir])
@@ -26,13 +29,13 @@ class Retrospec
       # if user doesn't supply template directory we assume we should use the templates in this gem
       @template_dir = Helpers.gem_template_dir
     end
-    @enable_beaker_tests = opts[:enable_beaker_tests]
-    @module_path = validate_module_dir(module_path)
-    create_tmp_module_path(module_path) # this is required to finish initialization
-  end
-
-  def enable_beaker_tests?
-    @enable_beaker_tests == true
+    begin
+      Utilities::PuppetModule.instance.module_path = supplied_module_path
+      Utilities::PuppetModule.create_tmp_module_path # this is required to finish initialization
+      @module_path = Utilities::PuppetModule.module_path
+      @spec_object = Utilities::SpecObject.new(Utilities::PuppetModule.instance)
+      spec_object.enable_beaker_tests = opts[:enable_beaker_tests]
+    end
   end
 
   def create_files
@@ -41,15 +44,19 @@ class Retrospec
     safe_create_gemfile
     safe_create_rakefile
     safe_make_shared_context
-    safe_create_acceptance_spec_helper if enable_beaker_tests?
-    safe_create_node_sets if enable_beaker_tests?
-    types.each do |type|
-      safe_create_resource_spec_files(type)
-      if enable_beaker_tests?
-        safe_create_acceptance_tests(type)
-      end
+    safe_create_ci_file
+    safe_create_acceptance_spec_helper if spec_object.enable_beaker_tests?
+    safe_create_node_sets if spec_object.enable_beaker_tests?
+    # a Type is nothing more than a defined type or puppet class
+    # we could have named this manifest but there could be multiple types
+    # in a manifest.
+    spec_object.types.each do |type|
+       safe_create_resource_spec_files(type)
+       if spec_object.enable_beaker_tests?
+         safe_create_acceptance_tests(type)
+       end
     end
-    FileUtils.remove_entry_secure tmp_modules_dir  # ensure we remove the temporary directory
+    Utilities::PuppetModule.clean_tmp_modules_dir
     true
   end
 
@@ -61,6 +68,10 @@ class Retrospec
     end
   end
 
+  def safe_create_ci_file(template='travis.yml.erb')
+     safe_create_template_file('.travis.yml.erb', template)
+  end
+
   def safe_create_acceptance_spec_helper(template='spec_helper_acceptance.rb.erb')
      safe_create_template_file(File.join('spec', 'spec_helper_acceptance.rb'), template)
   end
@@ -94,7 +105,7 @@ class Retrospec
     template_path = File.join(template_dir, template)
     File.open(template_path) do |file|
       renderer = ERB.new(file.read, 0, '-')
-      content = renderer.result binding
+      content = renderer.result spec_object.get_binding
       dest_path = File.expand_path(File.join(module_path,path))
       Helpers.safe_create_file(dest_path, content)
     end
@@ -102,12 +113,13 @@ class Retrospec
 
   # Creates an associated spec file for each type and even creates the subfolders for nested classes one::two::three
   def safe_create_resource_spec_files(type,template='resource_spec_file.erb')
-    @parameters = type.arguments
-    @type = type
-    @resources = Resource.all(type)
-    # pass the type to the variable store and it will discover all the variables and try to resolve them.
+    spec_object.parameters = type.arguments
+    spec_object.type = type
     VariableStore.populate(type)
-    @resources += Conditional.all(type)
+    spec_object.resources = Resource.all(type)
+    # pass the type to the variable store and it will discover all the variables and try to resolve them.
+    # this does not get deep nested conditional blocks
+    spec_object.resources += Conditional.all(type)
     file_path = generate_file_path(type, false)
     safe_create_template_file(file_path, template)
     file_path
@@ -146,11 +158,13 @@ class Retrospec
     file_name = generate_file_name(type.name)
     tokens = type.name.split('::')
     # if there are only two tokens ie. tomcat::params we dont need to create a subdirectory
-    if tokens.count > 1
+    if tokens.count > 2
       # this is a deep level resource ie. tomcat::config::server::connector
       # however we don't need the tomcat directory so we can just remove it
       # this should leave us with config/server/connector_spec.rb
       tokens.delete_at(0)
+      # remove the last token since its the class name
+      tokens.pop
       # so lets make a directory structure out of it
       dir_name = File.join(tokens)  # config/server
       dir_name = File.join(type_dir_name,dir_name, file_name) # spec/classes/tomcat/config/server
@@ -169,23 +183,5 @@ class Retrospec
 
   private
 
-  # processes a directory and expands to its full path, assumes './'
-  # returns the validated dir
-  def validate_module_dir(dir)
-    # first check to see if manifests directory even exists when path is nil
-    if dir.nil?
-      dir = '.'
-    elsif dir.instance_of?(Array)
-      raise "Retrospec - an array of moudule paths is not supported at this time"
-    end
-    dir = File.expand_path(dir)
-    manifest_dir = File.join(dir,'manifests')
-    if ! File.exist?(manifest_dir)
-      raise "No manifest directory in #{manifest_dir}, cannot validate this is a module"
-    else
-      files = Dir.glob("#{manifest_dir}/**/*.pp")
-      warn 'No puppet manifest files found at #' if files.length < 1
-    end
-    dir
-  end
+
 end

data/lib/retrospec/exceptions.rb

@@ -0,0 +1,4 @@
+class ParentFoundException < StandardError
+end
+class TypeNotFoundException < StandardError
+end

data/lib/retrospec/puppet_module.rb

@@ -0,0 +1,163 @@
+require 'singleton'
+
+module Utilities
+  class PuppetModule
+    attr_writer :module_path
+
+    include Singleton
+
+    def self.tmp_module_path
+      Utilities::PuppetModule.instance.tmp_module_path
+    end
+
+    def self.tmp_modules_dir
+      Utilities::PuppetModule.instance.tmp_modules_dir
+    end
+
+    def self.module_path
+      Utilities::PuppetModule.instance.module_path
+    end
+
+    def self.module_name
+      Utilities::PuppetModule.instance.module_name
+    end
+
+    def self.module_dir_name
+      Utilities::PuppetModule.instance.module_dir_name
+    end
+
+    def self.module_types
+      Utilities::PuppetModule.instance.types
+    end
+
+    # create the temporary module create, validate the
+    def self.create_tmp_module_path
+      Utilities::PuppetModule::instance.create_tmp_module_path(module_path)
+    end
+
+    def self.clean_tmp_modules_dir
+      FileUtils.remove_entry_secure instance.tmp_modules_dir  # ensure we remove the temporary directory
+    end
+
+    def module_path
+      @module_path
+    end
+
+    # validate and set the module path
+    def module_path=(path)
+      @module_path = validate_module_dir(path)
+    end
+
+    # gets an instance of the module class.  The create_tmp_module_path must first be called
+    # before instance can do anything useful.
+    def self.instance
+      @@instance ||= new
+    end
+
+    # processes a directory and expands to its full path, assumes './'
+    # returns the validated dir
+    def validate_module_dir(dir)
+      # first check to see if manifests directory even exists when path is nil
+      if dir.nil?
+        dir = '.'
+      elsif dir.instance_of?(Array)
+        puts "Retrospec - an array of module paths is not supported at this time"
+        exit 1
+      end
+      dir = File.expand_path(dir)
+      manifest_dir = File.join(dir,'manifests')
+      if ! File.exist?(manifest_dir)
+        puts "No manifest directory in #{manifest_dir}, cannot validate this is a module"
+        exit 1
+      else
+        files = Dir.glob("#{manifest_dir}/**/*.pp")
+        warn "No puppet manifest files found at #{manifest_dir}" if files.length < 1
+      end
+      dir
+    end
+
+    # puts a symlink in that module directory that points back to the user supplied module path
+    def create_tmp_module_path(module_path)
+      raise "ModulePathNotFound" unless module_path
+      path = File.join(tmp_modules_dir, module_dir_name)
+      unless File.exists?(path) # only create if it doesn't already exist
+        # create a link where source is the current repo and dest is /tmp/modules/module_name
+        FileUtils.ln_s(module_path, path)
+      end
+      path
+    end
+
+    def tmp_module_path
+      @tmp_module_path ||= File.join(tmp_modules_dir, module_dir_name)
+    end
+
+    # the directory name of the module
+    # usually this is the same as the module name but it can be namespaced sometimes
+    def module_dir_name
+      raise "ModulePathNotFound" unless module_path
+      @module_dir_name ||= File.basename(module_path)
+    end
+
+    def module_type_names
+      types.map {|x| x.name}
+    end
+
+    # returns the name of the module  ie. mysql::config  => mysql
+    def module_name
+      begin
+        @module_name ||= types.first.name.split('::').first
+      rescue
+        @module_name = module_dir_name
+      end
+    end
+
+    # creates a tmp module directory so puppet can work correctly
+    def tmp_modules_dir
+      if @tmp_modules_dir.nil? or not File.exists?(@tmp_modules_dir)
+        dir = Dir.mktmpdir
+        tmp_path = File.expand_path(File.join(dir, 'modules'))
+        FileUtils.mkdir_p(tmp_path)
+        @tmp_modules_dir = tmp_path
+      end
+      @tmp_modules_dir
+    end
+
+
+    # creates a puppet environment given a module path and environment name
+    def puppet_environment
+      @puppet_environment ||= Puppet::Node::Environment.create('production', [tmp_modules_dir])
+    end
+
+    # creates a puppet resource request to be used indirectly
+    def request(key, method)
+      instance = Puppet::Indirector::Indirection.instance(:resource_type)
+      indirection_name = 'test'
+      @request = Puppet::Indirector::Request.new(indirection_name, method, key, instance)
+      @request.environment = puppet_environment
+      @request
+    end
+
+    # creates an instance of the resource type parser
+    def resource_type_parser
+      @resource_type_parser ||= Puppet::Indirector::ResourceType::Parser.new
+    end
+
+    # returns the resource type object given a resource name ie. tomcat::connector
+    def find_resource(resource_name)
+      request = request(resource_name, 'find')
+      resource_type_parser.find(request)
+    end
+
+    # returns the resource types found in the module
+    def search_module(pattern='*')
+      request = request(pattern, 'search')
+      resource_type_parser.search(request)
+    end
+
+    # TODO we need to parse the types and find all the types that inherit other types and then order them so we can load the files first
+    def types
+      @types ||= search_module || []
+    end
+  end
+end
+

data/lib/retrospec/resource.rb

@@ -5,6 +5,7 @@ class Resource
   attr_reader :type, :title, :parameters, :scope_name
 
   def initialize(type_name,instance)
+    # we don't store the resource parameters in the variablestore because they are never referenced
     @parameters = Hash[instance.parameters.map { |k| [k.param, VariableStore.resolve(k.value).gsub("\"", '')]}]
     @type = type_name
     @title = VariableStore.resolve(instance.title).gsub("\"", '')
@@ -13,9 +14,7 @@ class Resource
   # Gets all resources in the type that are not in a code block
   def self.all(statements)
     if statements.respond_to?(:code)
-      # store the class params
-      statements.arguments.each {|k,v| VariableStore.add(k,v)}
-      # if we accidently pass a type in without specifing the code
+      # if we accidentally pass a type in without specifying the code
       statements = statements.code unless statements.nil?
     end
     a = []

data/lib/retrospec/spec_object.rb

@@ -0,0 +1,37 @@
+
+module Utilities
+  class SpecObject
+    attr_reader :instance
+    attr_accessor :enable_beaker_tests, :parameters, :types, :resources, :type
+
+    def initialize(mod_instance)
+      @instance = mod_instance
+    end
+
+    def types
+      instance.types
+    end
+
+    def module_name
+      instance.module_name
+    end
+
+    def module_path
+      instance.module_path
+    end
+
+    def get_binding
+      binding
+    end
+
+    def enable_beaker_tests?
+      @enable_beaker_tests == true
+    end
+
+    # allows the user to use the variable store to resolve the variable if it exists
+    def variable_value(key)
+      VariableStore.resolve(key)
+    end
+
+  end
+end

data/lib/retrospec/templates/gemfile.erb

@@ -2,26 +2,28 @@ source "https://rubygems.org"
 
 group :test do
   gem "rake"
-  gem "puppet", ENV['PUPPET_VERSION'] || '~> 3.7.0'
+  gem "puppet", ENV['PUPPET_VERSION'] || '~> 3.7.3'
   gem "rspec-puppet", :git => 'https://github.com/rodjek/rspec-puppet.git'
   gem "puppetlabs_spec_helper"
   gem 'rspec-puppet-utils', :git => 'https://github.com/Accuity/rspec-puppet-utils.git'
   gem 'hiera-puppet-helper', :git => 'https://github.com/bobtfish/hiera-puppet-helper.git'
-
+<%- if enable_beaker_tests? -%>
+  gem "beaker", :git => 'https://github.com/puppetlabs/beaker.git'
+  gem "beaker-rspec", :git => 'https://github.com/puppetlabs/beaker-rspec.git'
+  gem "vagrant-wrapper"
+  gem 'serverspec'
+<%- end -%>
+  # there seems to be a bug with puppet-blacksmith and metadata-json-lint
+  # removing metadata for now
+  gem "metadata-json-lint"
+  gem 'puppet-syntax'
+  gem 'puppet-lint'
 end
 
 group :development do
   gem "travis"
   gem "travis-lint"
-  <%- if enable_beaker_tests? -%>
-  gem "beaker", :git => 'https://github.com/puppetlabs/beaker.git'
-  gem "beaker-rspec", :git => 'https://github.com/puppetlabs/beaker-rspec.git'
-  gem "vagrant-wrapper"
-  <%- end -%>
   gem "puppet-blacksmith"
   gem "guard-rake"
-  gem "metadata-json-lint"
-  gem 'puppet-syntax'
-  gem 'serverspec'
 end