puppet-retrospec 0.11.0 → 0.12.0

data/lib/retrospec/plugins/v1/plugin/generators/type_generator.rb

@@ -0,0 +1,118 @@
+require_relative 'parsers/type'
+
+module Retrospec
+  module Puppet
+    module Generators
+      class TypeGenerator < Retrospec::Plugins::V1::Plugin
+        attr_reader :template_dir, :context
+
+        # this is the list of core puppet types that cannot be recreated
+        CORE_TYPES = ["augeas", "computer", "cron", "exec", "file", "filebucket",
+           "group", "host", "interface", "k5login", "macauthorization", "mailalias",
+           "maillist", "mcx", "mount", "nagios_command", "nagios_contact",
+           "nagios_contactgroup", "nagios_host", "nagios_hostdependency",
+           "nagios_hostescalation", "nagios_hostextinfo", "nagios_hostgroup",
+           "nagios_service", "nagios_servicedependency",
+           "nagios_serviceescalation", "nagios_serviceextinfo",
+           "nagios_servicegroup", "nagios_timeperiod", "notify", "package",
+           "resources", "router", "schedule", "scheduled_task", "selboolean",
+           "selmodule", "service", "ssh_authorized_key", "sshkey", "stage",
+           "tidy", "user", "vlan", "yumrepo", "zfs", "zone", "zpool"]
+
+        # retrospec will initilalize this class so its up to you
+        # to set any additional variables you need to get the job done.
+        def initialize(module_path, spec_object = {})
+          super
+          # below is the Spec Object which serves as a context for template rendering
+          # you will need to initialize this object, so the erb templates can get the binding
+          # the SpecObject can be customized to your liking as its different for every plugin gem.
+          if CORE_TYPES.include?(spec_object[:name])
+            raise Retrospec::Puppet::Generators::CoreTypeException
+          end
+          @context = OpenStruct.new(:type_name => spec_object[:name], :parameters => spec_object[:parameters],
+                                    :properties => spec_object[:properties], :providers => spec_object[:providers])
+        end
+
+        def template_dir
+            external_templates = File.expand_path(File.join(config_data[:template_dir], 'types', 'type_template.rb.retrospec.erb'))
+            if File.exist?(external_templates)
+              File.join(config_data[:template_dir], 'types')
+            else
+              File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'templates', 'types'))
+            end
+        end
+        # used to display subcommand options to the cli
+        # the global options are passed in for your usage
+        # http://trollop.rubyforge.org
+        # all options here are available in the config passed into config object
+        # returns the parameters
+        def self.run_cli(global_opts, args=ARGV)
+          sub_command_opts = Trollop.options(args) do
+            banner <<-EOS
+Generates a new type with the given name, parameters, and properties.
+
+            EOS
+            opt :name, 'The name of the type you wish to create', :type => :string, :required => true, :short => '-n'
+            opt :parameters, 'A list of parameters to initialize your type with', :type => :strings, :required => false,
+                                                                                  :short => '-p', :default => ['name']
+            opt :properties, 'A list of properties to initialize your type with', :type => :strings, :required => false,
+                                                                                  :short => '-a', :default => []
+            opt :providers, 'A list of providers to create and associate with this type', :type => :strings,
+                                                                                          :default => ['default'], :required => false
+          end
+          unless sub_command_opts[:name]
+            Trollop.educate
+            exit 1
+          end
+          plugin_data = global_opts.merge(sub_command_opts)
+          plugin_data
+        end
+
+        def type_dir
+          @type_dir ||= File.join(module_path, 'lib', 'puppet', 'type')
+        end
+
+        def type_spec_dir
+          @type_spec_dir ||= File.join(module_path, 'spec', 'unit', 'puppet', 'type')
+        end
+
+        def type_name_path
+          File.join(type_dir, "#{type_name}.rb")
+        end
+
+        def type_name
+          context.type_name
+        end
+
+        def generate_provider_files
+          providers = context.providers
+          providers.each do |provider|
+            plugin_data = { :name => provider, :type => type_name, :template_dir => config_data[:template_dir] }
+            p = Retrospec::Puppet::Generators::ProviderGenerator.new(module_path, plugin_data)
+            p.generate_provider_files
+          end
+        end
+
+        def generate_type_files
+          safe_create_template_file(type_name_path, File.join(template_dir, 'type_template.rb.retrospec.erb'), context)
+          generate_provider_files
+          type_name_path
+        end
+
+        # this will look through all
+        def generate_type_spec_files
+          type_files = Dir.glob(File.join(type_dir, '**', '*.rb')).sort
+          spec_files = []
+          type_files.each do |type_file|
+            type_file_data = Retrospec::Puppet::Type.load_type(type_file)
+            # because many facts can be in a single file we want to create a unique file for each fact
+            type_spec_path = File.join(type_spec_dir, "#{type_file_data.name}_spec.rb")
+            spec_files << type_spec_path
+            safe_create_template_file(type_spec_path, File.join(template_dir, 'type_spec.rb.retrospec.erb'), type_file_data)
+          end
+          spec_files
+        end
+      end
+    end
+  end
+end

data/lib/retrospec/plugins/v1/plugin/helpers.rb

@@ -1,10 +1,9 @@
 require 'fileutils'
 
 class Helpers
-
   def self.get_module_name
     module_name = nil
-    Dir["manifests/*.pp"].entries.each do |manifest|
+    Dir['manifests/*.pp'].entries.each do |manifest|
       module_name = get_module_name_from_file(manifest)
       break unless module_name.nil?
     end
@@ -18,15 +17,12 @@ class Helpers
     tokens = p.fullscan
 
     i = tokens.index { |token| [:CLASS, :DEFINE].include? token.first }
-    unless i.nil?
-      module_name = tokens[i + 1].last[:value].split('::').first
-    end
+    module_name = tokens[i + 1].last[:value].split('::').first unless i.nil?
 
     module_name
   end
 
   def self.is_module_dir?(dir)
-    Dir[File.join(dir,"*")].entries.include? "manifests"
+    Dir[File.join(dir, '*')].entries.include? 'manifests'
   end
-
 end

data/lib/retrospec/plugins/v1/plugin/puppet.rb

@@ -1,8 +1,8 @@
 require 'retrospec/plugins/v1/module_helpers'
 require 'retrospec/plugins/v1'
 require 'retrospec/config'
-require_relative 'generators/fact_generator'
-require_relative 'generators/module_generator'
+require_relative 'generators'
+require_relative 'exceptions'
 require_relative 'spec_object'
 require 'erb'
 require_relative 'template_helpers'
@@ -21,11 +21,12 @@ module Retrospec
     module V1
       class Puppet < Retrospec::Plugins::V1::Plugin
         include Retrospec::Puppet::TemplateHelpers
-        attr_reader :template_dir, :context, :manifest_dir, :manifest_files
+        attr_reader :template_dir, :context, :manifest_files
+        attr_accessor :manifest_dir
 
-        def initialize(supplied_module_path=nil,config={})
+        def initialize(supplied_module_path = nil, config = {})
           super
-          @manifest_dir = File.join(supplied_module_path,'manifests')
+          @manifest_dir = File.join(supplied_module_path, 'manifests')
           Utilities::PuppetModule.instance.future_parser = config_data[:enable_future_parser]
           # user supplied a template path or user wants to use local templates
           @template_dir = setup_user_template_dir(config_data[:template_dir], config_data[:scm_url], config_data[:ref])
@@ -34,9 +35,12 @@ module Retrospec
         def post_init
           # before we validate the module directory we should ensure the module exists by creating it
           # validation also occurs when setting the module path
+          # these are required because the puppet module creates a singleton with some cached values
+          Utilities::PuppetModule.instance.module_dir_name = File.basename(module_path)
+          Utilities::PuppetModule.instance.module_name = File.basename(module_path)
           Utilities::PuppetModule.instance.module_path = module_path
           Utilities::PuppetModule.create_tmp_module_path # this is required to finish initialization
-          # setting the context is require to make other methods below work.  #TODO lazy create the context
+          # setting the context is required to make other methods below work.  #TODO lazy create the context
           @context = ::Retrospec::Puppet::SpecObject.new(module_path, Utilities::PuppetModule.instance, config_data)
         end
 
@@ -46,8 +50,22 @@ module Retrospec
         # anything since it is not mandatory
         # I thought about using the the module face to perform this generation but it seems like its not
         # supported at this time, and you can't specify the path to generate the module in
-        def new_module(plugin_data)
-          f = Retrospec::Puppet::Generators::ModuleGenerator.run_cli(plugin_data)
+        def new_module(plugin_data, args)
+          plugin_data = Retrospec::Puppet::Generators::ModuleGenerator.run_cli(plugin_data, args)
+          # the user passed in /tmp/test1 and the name is irrelevent
+          if ! File.exists?(plugin_data[:module_path])
+            plugin_data[:module_path] = File.join(plugin_data[:module_path])
+          # if the module path basename is the same as the module name
+          # this is a parent directory or the module already exists
+          elsif File.basename(plugin_data[:module_path]) != plugin_data[:name]
+            plugin_data[:module_path] = File.join(plugin_data[:module_path], plugin_data[:name])
+          end
+          # we need to set this because the this class is created before we created the new module directory
+          # so we now have to set the manifests and module directory
+          self.module_path = plugin_data[:module_path]
+          config_data[:module_path] = plugin_data[:module_path]
+          self.manifest_dir = File.join(plugin_data[:module_path], 'manifests')
+          f = Retrospec::Puppet::Generators::ModuleGenerator.new(plugin_data[:module_path], plugin_data)
           f.run(manifest_dir)
         end
 
@@ -57,65 +75,127 @@ module Retrospec
         # all options here are available in the config passed into the initialize code
         # this is the only entry point into the plugin
         def self.run_cli(global_opts, global_config, plugin_config, args=ARGV)
-          template_dir = plugin_config['plugins::puppet::template_dir'] || File.expand_path('~/.retrospec/repos/retrospec-puppet-templates')
+          template_dir = ENV['RETROSPEC_TEMPLATES_DIR'] || plugin_config['plugins::puppet::template_dir'] || File.expand_path('~/.retrospec/repos/retrospec-puppet-templates')
           scm_url = ENV['RETROSPEC_PUPPET_SCM_URL'] || plugin_config['plugins::puppet::templates::url']
           scm_branch = ENV['RETROSPEC_PUPPET_SCM_BRANCH'] || plugin_config['plugins::puppet::templates::ref'] || 'master'
           future_parser = plugin_config['plugins::puppet::enable_future_parser'] || false
           beaker_tests  = plugin_config['plugins::puppet::enable_beaker_tests'] || false
           # a list of subcommands for this plugin
-          sub_commands  = ['new_module', 'new_fact']
+          sub_commands  = %w(new_module new_fact new_type new_provider new_function)
           if sub_commands.count > 0
             sub_command_help = "Subcommands:\n#{sub_commands.join("\n")}\n"
           else
-            sub_command_help = ""
+            sub_command_help = ''
           end
-          plugin_opts = Trollop::options do
+          plugin_opts = Trollop.options(args) do
             version "Retrospec puppet plugin: #{Retrospec::Puppet::VERSION} (c) Corey Osman"
             banner <<-EOS
 Generates puppet rspec test code based on the classes and defines inside the manifests directory.\n
 #{sub_command_help}
 
             EOS
-            opt :template_dir, "Path to templates directory (only for overriding Retrospec templates)", :type => :string,
+            opt :template_dir, 'Path to templates directory (only for overriding Retrospec templates)', :type => :string,
                 :required => false, :default => template_dir
-            opt :scm_url, "SCM url for retrospec templates", :type => :string, :required => false,
+            opt :scm_url, 'SCM url for retrospec templates', :type => :string, :required => false,
                 :default => scm_url
-            opt :branch, "Branch you want to use for the retrospec template repo", :type => :string, :required => false,
+            opt :branch, 'Branch you want to use for the retrospec template repo', :type => :string, :required => false,
                 :default => scm_branch
-            opt :enable_beaker_tests, "Enable the creation of beaker tests", :require => false, :type => :boolean, :default => beaker_tests
-            opt :enable_future_parser, "Enables the future parser only during validation", :default => future_parser, :require => false, :type => :boolean
+            opt :enable_beaker_tests, 'Enable the creation of beaker tests', :require => false, :type => :boolean, :default => beaker_tests
+            opt :enable_future_parser, 'Enables the future parser only during validation', :default => future_parser, :require => false, :type => :boolean
             stop_on sub_commands
           end
           # the passed in options will always override the config file
-          plugin_data = plugin_opts.merge(global_config).merge(global_opts).merge(plugin_opts)
+          plugin_data = plugin_opts.merge(global_config).merge(global_opts).merge(plugin_opts).merge(plugin_config)
           # define the default action to use the plugin here, the default is run
           sub_command = (args.shift || :run).to_sym
           # create an instance of this plugin
-          plugin = self.new(plugin_data[:module_path],plugin_data)
+          plugin = new(plugin_data[:module_path], plugin_data)
           # check if the plugin supports the sub command
-          if plugin.respond_to?(sub_command)
-            case sub_command
+          begin
+            if plugin.respond_to?(sub_command)
+              case sub_command
               when :new_module
-                plugin.send(sub_command, plugin_data)
-                plugin.post_init   # finish initialization
+                plugin.send(sub_command, plugin_data, args)
+                plugin.post_init # finish initialization
               when :run
                 plugin.post_init   # finish initialization
+              when :new_type
+                plugin.new_type(plugin_data, args)
+              when :new_function
+                plugin.new_function(plugin_data, args)
               when :new_fact
-                plugin.new_fact(plugin_data)
+                plugin.new_fact(plugin_data, args)
+              when :new_provider
+                plugin.new_provider(plugin_data, args)
               else
                 plugin.post_init   # finish initialization
-                plugin.send(sub_command, plugin_data[:module_path], plugin_data)
+                plugin.send(sub_command, plugin_data[:module_path], plugin_data, args)
+              end
+              plugin.send(:run)
+            else
+              puts "The subcommand #{sub_command} is not supported or valid".fatal
+              exit 1
             end
-            plugin.send(:run)
-          else
-            puts "The subcommand #{sub_command} is not supported or valid"
+          rescue Retrospec::Puppet::InvalidModulePathError  => e
+            exit 1
+          rescue Retrospec::Puppet::NoManifestDirError => e
+            exit 1
+          rescue Retrospec::Puppet::ParserError => e
+            exit 1
+          rescue Retrospec::Puppet::Generators::CoreTypeException => e
+            puts e.message.fatal
+          rescue Exception => e
             exit 1
           end
+          plugin_data
+        end
+
+        def new_schema(module_path, config, args=[])
+          plugin_data = Retrospec::Puppet::Generators::SchemaGenerator.run_cli(config, args)
+          plugin_data[:puppet_context] = context
+          s = Retrospec::Puppet::Generators::SchemaGenerator.new(plugin_data[:module_path], plugin_data)
+          s.generate_schema_file
+        end
+
+        def new_function(config, args)
+          plugin_data = Retrospec::Puppet::Generators::FunctionGenerator.run_cli(config, args)
+          f = Retrospec::Puppet::Generators::FunctionGenerator.new(plugin_data[:module_path], plugin_data)
+          post_init
+          f.generate_function_file
+        end
+
+        def function_spec_files(module_path, config)
+          f = Retrospec::Puppet::Generators::FunctionGenerator.new(module_path, config)
+          f.generate_spec_files
+        end
+
+        def new_provider(config, args)
+          plugin_data = Retrospec::Puppet::Generators::ProviderGenerator.run_cli(config, args)
+          p = Retrospec::Puppet::Generators::ProviderGenerator.new(plugin_data[:module_path], plugin_data)
+          post_init
+          p.generate_provider_files
+        end
+
+        def provider_spec_files(module_path, config)
+          t = Retrospec::Puppet::Generators::ProviderGenerator.new(module_path, config)
+          t.generate_provider_spec_files
+        end
+
+        def new_type(config, args)
+          plugin_data = Retrospec::Puppet::Generators::TypeGenerator.run_cli(config, args)
+          t = Retrospec::Puppet::Generators::TypeGenerator.new(plugin_data[:module_path], plugin_data)
+          post_init
+          t.generate_type_files
         end
 
-        def new_fact(plugin_data)
-          f = Retrospec::Puppet::Generators::FactGenerator.run_cli(plugin_data)
-          post_init   # finish initialization
+        def type_spec_files(module_path, config)
+          t = Retrospec::Puppet::Generators::TypeGenerator.new(module_path, config)
+          t.generate_type_spec_files
+        end
+
+        def new_fact(plugin_data, args)
+          f = Retrospec::Puppet::Generators::FactGenerator.run_cli(plugin_data, args)
+          post_init # finish initialization
           f.generate_fact_file
         end
 
@@ -139,10 +219,10 @@ Generates puppet rspec test code based on the classes and defines inside the man
 
         # runs a user defined hook called pre-hook
         def run_pre_hook
-          hook_file = File.join(template_dir,'pre-hook')
-          if File.exists?(hook_file)
+          hook_file = File.join(template_dir, 'pre-hook')
+          if File.exist?(hook_file)
             output = `#{hook_file} #{module_path}`
-            if $?.success?
+            if $CHILD_STATUS.success?
               puts "Successfully ran hook: #{hook_file}".info
               puts output.info
             else
@@ -154,10 +234,10 @@ Generates puppet rspec test code based on the classes and defines inside the man
 
         # runs a user defined hook called post-hook
         def run_post_hook
-          hook_file = File.join(template_dir,'post-hook')
-          if File.exists?(hook_file)
+          hook_file = File.join(template_dir, 'post-hook')
+          if File.exist?(hook_file)
             output = `#{hook_file} #{module_path}`
-            if $?.success?
+            if $CHILD_STATUS.success?
               puts "Successfully ran hook: #{hook_file}".info
               puts output.info
             else
@@ -172,15 +252,17 @@ Generates puppet rspec test code based on the classes and defines inside the man
           types = context.types
           safe_create_module_files
           fact(module_path, config_data)
+          type_spec_files(module_path, config_data)
+          provider_spec_files(module_path, config_data)
+          function_spec_files(module_path, config_data)
+          new_schema(module_path, config_data)
           Retrospec::Puppet::Generators::ModuleGenerator.generate_metadata_file(context.module_name, config_data)
           # 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.
           types.each do |type|
             safe_create_resource_spec_files(type)
-            if context.enable_beaker_tests?
-              safe_create_acceptance_tests(type)
-            end
+            safe_create_acceptance_tests(type) if context.enable_beaker_tests?
           end
           Utilities::PuppetModule.clean_tmp_modules_dir
           true
@@ -192,13 +274,13 @@ Generates puppet rspec test code based on the classes and defines inside the man
         # filenames must named how they would appear in the normal module path.  The directory
         # structure where the file is contained
         def safe_create_module_files
-          templates = Find.find(File.join(template_dir,'module_files')).sort
+          templates = Find.find(File.join(template_dir, 'module_files')).sort
           templates.each do |template|
             # need to remove the erb extension and rework the destination path
             if template =~ /nodesets|spec_helper_acceptance/ and !context.enable_beaker_tests?
               next
             else
-              dest = template.gsub(File.join(template_dir,'module_files'), module_path)
+              dest = template.gsub(File.join(template_dir, 'module_files'), module_path)
               if File.symlink?(template)
                 safe_create_symlink(template, dest)
               elsif File.directory?(template)
@@ -219,7 +301,7 @@ Generates puppet rspec test code based on the classes and defines inside the man
         end
 
         # 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=File.join(template_dir,'resource_spec_file.retrospec.erb'))
+        def safe_create_resource_spec_files(type, template = File.join(template_dir, 'resource_spec_file.retrospec.erb'))
           context.parameters = type.arguments
           context.type = type
           VariableStore.populate(type)
@@ -227,15 +309,15 @@ Generates puppet rspec test code based on the classes and defines inside the man
           # 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
           context.resources += Conditional.all(type)
-          dest = File.join(module_path,generate_file_path(type, false))
+          dest = File.join(module_path, generate_file_path(type, false))
           safe_create_template_file(dest, template, context)
           dest
         end
 
-        def safe_create_acceptance_tests(type,template=File.join(template_dir,'acceptance_spec_test.retrospec.erb'))
+        def safe_create_acceptance_tests(type, template = File.join(template_dir, 'acceptance_spec_test.retrospec.erb'))
           @parameters = type.arguments
           @type = type
-          dest = File.join(module_path,generate_file_path(type, true))
+          dest = File.join(module_path, generate_file_path(type, true))
           safe_create_template_file(dest, template, context)
           dest
         end
@@ -250,17 +332,17 @@ Generates puppet rspec test code based on the classes and defines inside the man
           hosts_dir   = 'hosts'
           acceptance_dir = 'acceptance'
           case type.type
-            when :hostclass
-              type_dir_name = classes_dir
-            when :definition
-              type_dir_name = defines_dir
-            when :node
-              type_dir_name = hosts_dir
-            else
-              raise "#{type.type} retrospec does not support this resource type yet"
+          when :hostclass
+            type_dir_name = classes_dir
+          when :definition
+            type_dir_name = defines_dir
+          when :node
+            type_dir_name = hosts_dir
+          else
+            fail "#{type.type} retrospec does not support this resource type yet"
           end
           if is_acceptance_test
-            type_dir_name = File.join('spec',acceptance_dir, type_dir_name)
+            type_dir_name = File.join('spec', acceptance_dir, type_dir_name)
           else
             type_dir_name = File.join('spec', type_dir_name)
           end
@@ -275,10 +357,10 @@ Generates puppet rspec test code based on the classes and defines inside the man
             # 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
+            dir_name = File.join(tokens) # config/server
+            dir_name = File.join(type_dir_name, dir_name, file_name) # spec/classes/tomcat/config/server
           else
-            dir_name = File.join(type_dir_name,file_name)
+            dir_name = File.join(type_dir_name, file_name)
           end
           dir_name
         end
@@ -306,8 +388,7 @@ Generates puppet rspec test code based on the classes and defines inside the man
         def self.file_type
           '.pp'
         end
-
       end
     end
   end
-end
+end