puppet-retrospec 0.12.2 → 1.0.0

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

@@ -0,0 +1,36 @@
+require_relative 'resource_base_generator'
+require_relative 'serializers/rspec_dumper'
+require 'puppet'
+require 'puppet/pops'
+
+module Retrospec
+  module Puppet
+    module Generators
+      class HostClassGenerator < Retrospec::Puppet::Generators::ResourceBaseGenerator
+        # 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
+          @singular_name = 'class'
+          @plural_name = 'classes'
+        end
+
+        def spec_template_file
+          'hostclass_spec.rb.retrospec.erb'
+        end
+
+        def self.generate_spec_files(module_path, config_data)
+          files = []
+          manifest_files(module_path).each do |file|
+            hostclass = new(module_path, config_data.merge({:manifest_file => file}))
+            next unless hostclass.resource_type == ::Puppet::Pops::Model::HostClassDefinition
+            files << hostclass.generate_spec_file
+          end
+          files
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative 'serializers/rspec_dumper'
+require 'puppet'
+require 'puppet/pops'
+
+module Retrospec
+  module Puppet
+    module Generators
+      class NodeGenerator < Retrospec::Puppet::Generators::ResourceBaseGenerator
+        # 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
+          @singular_name = 'node'
+          @plural_name = 'nodes'
+        end
+
+        def spec_template_file
+          'node_spec.rb.retrospec.erb'
+        end
+
+        def self.generate_spec_files(module_path, config_data)
+          files = []
+          manifest_files(module_path).each do |file|
+            nodedef = new(module_path, config_data.merge({:manifest_file => file}))
+            next unless nodedef.resource_type == ::Puppet::Pops::Model::NodeDefinition
+            files << nodedef.generate_spec_file
+          end
+          files
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require_relative 'base_generator'
+
+module Retrospec
+  module Puppet
+    module Generators
+      class ReportGenerator < Retrospec::Puppet::Generators::BaseGenerator
+        # 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
+          @plural_name = 'reports'
+          @singular_name = 'report'
+        end
+
+        def run
+          files = []
+          files << generate_lib_files
+          files << generate_spec_files
+          files
+        end
+
+        def generate_lib_files
+          template_file = File.join(template_dir, 'report.rb.retrospec.erb')
+          safe_create_template_file(item_path, template_file, context)
+          item_path
+        end
+
+        def generate_spec_files
+          template_file = File.join(template_dir, 'report_spec.rb.retrospec.erb')
+          safe_create_template_file(item_spec_path, template_file, context)
+          item_spec_path
+        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
+Creates a new puppet report
+            EOS
+            opt :name, "The name of the report you wish to create", :type => :string, :required => true, :short => '-n'
+          end
+          unless sub_command_opts[:name]
+            Trollop.educate
+            exit 1
+          end
+          plugin_data = global_opts.merge(sub_command_opts)
+          plugin_data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+require_relative 'base_generator'
+require_relative 'serializers/rspec_dumper'
+require_relative 'serializers/rspec_dumper_full'
+
+require 'puppet'
+require 'puppet/pops'
+
+module Retrospec
+  module Puppet
+    module Generators
+      class ResourceBaseGenerator < Retrospec::Puppet::Generators::BaseGenerator
+        # 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
+          raise "NoManifestFileError" unless spec_object[:manifest_file]
+          @context = OpenStruct.new(:manifest_file => spec_object[:manifest_file], :content => nil)
+        end
+
+        def singular_name
+          unless @singular_name
+            raise NotImplementedError
+          end
+          @singular_name
+        end
+
+        def plural_name
+          unless @plural_name
+            raise NotImplementedError
+          end
+          @plural_name
+        end
+
+        def spec_template_file
+          NotImplementedError
+        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
+            ""
+            EOS
+          end
+          unless sub_command_opts[:manifest_file]
+            Trollop.educate
+            exit 1
+          end
+          plugin_data = global_opts.merge(sub_command_opts)
+          plugin_data
+        end
+
+        def self.manifest_files(module_path)
+          Dir.glob(File.join(module_path, 'manifests', '*.pp'))
+        end
+
+        def self.generate_spec_files(module_path, config_data)
+          manifests = manifest_files(module_path)
+          files = Retrospec::Puppet::Generators::HostClassGenerator.generate_spec_files(module_path, config_data)
+          files << Retrospec::Puppet::Generators::DefinitionGenerator.generate_spec_files(module_path, config_data)
+          files.flatten
+        end
+
+        def load_context_data
+          context.content = generate_content
+          context.parameters = parameters
+          context.type_name = type_name
+          context.resources = resources
+          context.resource_type = resource_type
+          context.resource_type_name = resource_type_name
+          context
+        end
+
+        def generate_spec_file
+          template_file = File.join(template_dir,spec_template_file )
+          context = load_context_data
+          logger.debug("\nUsing template #{template_file}\n")
+          safe_create_template_file(item_spec_path, template_file, context)
+          item_spec_path
+        end
+
+        def manifest_file
+          context.manifest_file
+        end
+
+        # return a manifest body object
+        def manifest_body
+          ast.body.body || ast.body
+        end
+
+        def find_all_resources
+          res = manifest_body.eAllContents.find_all do |p|
+            p.class.to_s == 'Puppet::Pops::Model::ResourceExpression'
+          end
+        end
+
+        # returns all the found resources
+        def resources
+          @resources ||= find_all_resources.map {|p| dumper.dump(p)}
+        end
+
+        def dumper
+          @dumper ||= Retrospec::Puppet::RspecDumper.new
+        end
+
+        # this produces the content that will later be rendered in the template
+        def generate_content
+          content = dumper.dump(ast)
+        end
+
+        def parameters
+          if ast.body.respond_to?(:parameters)
+            args = ast.body.parameters || []
+            dumper.dump(args)
+          else
+            []
+          end
+        end
+
+        # run is the main method that gets called automatically
+        def run
+          generate_spec_file
+        end
+
+        def item_path
+          File.join(lib_path, "#{item_name}.pp")
+        end
+
+        def spec_path
+          File.join(module_path, 'spec', plural_name)
+        end
+
+        def lib_path
+          File.join(module_path, 'manifests')
+        end
+
+        def resource_type
+          ast.eContents.first.class
+        end
+
+        # returns the type of resource either the define, type, or class
+        def resource_type_name
+          case ast.eContents.first
+          when ::Puppet::Pops::Model::HostClassDefinition
+            'class'
+          when ::Puppet::Pops::Model::ResourceTypeDefinition
+            type_name
+          else
+            resource_type
+          end
+        end
+
+        # returns the name of the first type found in the file
+        # for files that have multiple types, we just don't care since it doesn't
+        # follow the style guide
+        def type_name
+          if ast.eContents.first.respond_to?(:name)
+            ast.eContents.first.name
+          else
+            #ast.eContents.first.host_matches.first
+          end
+        end
+
+        # returns the filename of the type
+        def generate_file_name(type_name)
+          tokens = type_name.split('::')
+          file_name = tokens.pop
+          "#{file_name}_spec.rb"
+        end
+
+        # generates a file path for spec tests based on the resource name.  An added option
+        # is to generate directory names for each parent resource as a default option
+        def item_spec_path
+          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 > 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(spec_path, dir_name, file_name) # spec/classes/tomcat/config/server
+          else
+            dir_name = File.join(spec_path, file_name)
+          end
+          dir_name
+        end
+
+        def ast
+          unless @ast
+            parser = ::Puppet::Pops::Parser::EvaluatingParser.new
+            result = parser.parse_file(manifest_file)
+            @ast = result.current
+          end
+          @ast
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'yaml'
+require_relative 'serializers/schema_dumper'
 
 module Retrospec
   module Puppet
@@ -93,6 +94,10 @@ Generates a kwalify schema based off class parameters.
 
         private
 
+        def dumper
+          @dumper || Retrospec::Puppet::SchemaDumper.new
+        end
+
         # generates a class or defination map
         def generate_type_map(puppet_type)
           type_name = puppet_type.type.to_s
@@ -100,7 +105,7 @@ Generates a kwalify schema based off class parameters.
           #arg_map = {'mapping' => {}, 'required' => false, 'type' => 'map' }
           puppet_type.arguments.each do |k, _v|
             key = "#{puppet_type.name}::#{k}"
-            kwalify_type = type_map(_v.class)
+            kwalify_type = dumper.to_kwalify_type(_v)
             @parameter_count = @parameter_count + 1
             arg_map.deep_merge!(generate_map(key, _v, kwalify_type))
           end

data/lib/retrospec/plugins/v1/plugin/generators/serializers/rspec_dumper.rb

@@ -0,0 +1,436 @@
+require 'puppet'
+require 'puppet/pops/model/tree_dumper'
+# Dumps a Pops::Model in reverse polish notation; i.e. LISP style
+# The intention is to use this for debugging output
+# TODO: BAD NAME - A DUMP is a Ruby Serialization
+#
+module Retrospec
+  module Puppet
+    class RspecDumper < ::Puppet::Pops::Model::TreeDumper
+      attr_reader :var_store
+
+      def var_store
+        @var_store ||= {}
+      end
+
+      def logger
+        unless @logger
+          require 'logger'
+          @logger = Logger.new(STDOUT)
+          if ENV['RETROSPEC_LOGGER_LEVEL'] == 'debug'
+            @logger.level = Logger::DEBUG
+          else
+            @logger.level = Logger::INFO
+          end
+        end
+        @logger
+      end
+
+      def lookup_var(key)
+        # if exists, return value
+        # if it doesn't exist, store and return key
+        key = normalize_key(key)
+        other_key = key.split('::').last
+        if key != other_key
+          other_key = "$#{other_key}"
+        end
+        logger.debug("looking up #{key}".yellow)
+        if item = var_store[key]
+          value = item[:value]
+          logger.debug("Store hit: #{key} with value: #{value}")
+        elsif item = var_store[other_key] # key does not exist
+          logger.debug("looking up #{other_key}".yellow)
+          logger.debug("Store hit: #{other_key} with value: #{value}")
+          value = item[:value]
+        else
+          logger.debug("Store miss: #{key}".fatal)
+          value = false
+        end
+        value
+      end
+
+      # prepends a dollar sign if doesn't already exist
+      def normalize_key(key)
+        unless key.start_with?('$')
+          # prepend the dollar sign
+          key = "$#{key}"
+        end
+        key
+      end
+
+      # adds a variable to the store, its value and type of scope
+      def add_var_to_store(key, value, force=false, type=:scope)
+        key = normalize_key(key)
+        if var_store.has_key?(key) and !force
+          logger.debug ("Prevented from writing #{key} with value #{value}".info)
+        else
+          logger.debug("storing #{key} with value #{value}".yellow)
+          var_store[key]= {:value => value, :type => type}
+          other_key = key.split('::').last
+          if key != other_key
+            other_key = "$#{other_key}"
+            unless key.split('::').first == '$'
+              add_var_to_store(other_key, value, false, type)
+            end
+
+          end
+        end
+        value
+      end
+
+      def dump_Array o
+        o.collect {|e| do_dump(e) }
+      end
+
+      def indent
+        "  " * indent_count
+      end
+
+      def format(x)
+        result = ""
+        parts = format_r(x)
+        parts.each_index do |i|
+          if i > 0
+            # separate with space unless previous ends with whitepsace or (
+            result << ' ' if parts[i] != ")" && parts[i-1] !~ /.*(?:\s+|\()$/ && parts[i] !~ /^\s+/
+          end
+          result << parts[i].to_s
+        end
+        result
+      end
+
+      def format_r(x)
+        result = []
+        case x
+        when :break
+          result << "\n" + indent
+        when :indent_break
+          result << indent + "\n"
+        when :indent
+          @indent_count += 1
+        when :dedent
+          @indent_count -= 1
+        when :do
+          result << format_r([' ', x.to_s, :indent, :break])
+        when :indent_end
+          result << format_r([:indent, :break, 'end', :dedent])
+        when :end
+          result << format_r([:dedent, :break, x.to_s])
+        when Array
+          #result << '('
+          result += x.collect {|a| format_r(a) }.flatten
+          #result << ')'
+        when Symbol
+          result << x.to_s # Allows Symbols in arrays e.g. ["text", =>, "text"]
+        else
+          result << x
+        end
+        result
+      end
+
+      def dump_ResourceTypeDefinition o
+        result = ["describe #{o.name.inspect}", :do]
+        result << ['let(:title)', :do, 'XXreplace_meXX'.inspect, :break, :end]
+        result << [:dedent, :break]
+        result << [:indent, :break,'let(:params)', :do, '{', :break]
+        result << o.parameters.collect {|k| do_dump(k)}
+        result << ['}', :end]
+        # result << ["inherits", o.parent_class] if o.parent_class
+        # we need to process the body so that we can relize which facts are used
+        body_result = []
+        if o.body
+          body_result << [:break, do_dump(o.body)]
+        else
+          body_result << []
+        end
+        result << [:break,:break,'let(:facts)', :do, '{',:break]
+        result << dump_top_scope_vars
+        result << ['}', :end]
+        result << body_result
+        result << [:end]
+        result
+      end
+
+      def top_scope_vars
+        var_store.find_all do |k,v|
+          v[:type] == :top_scope
+        end
+      end
+
+      #
+      def dump_top_scope_vars
+        result = []
+        top_scope_vars.sort.each do |k, v|
+          result << ['  ',k.gsub('$::', '').inspect, '=>',v[:value].inspect + ',', :break ]
+        end
+        result
+      end
+
+      def dump_HostClassDefinition o
+        result = ["describe #{o.name.inspect}", :do]
+        result << ['let(:params)', :do, '{', :break]
+        result << o.parameters.collect {|k| do_dump(k)}
+        result << ['}', :end]
+        # result << ["inherits", o.parent_class] if o.parent_class
+        # we need to process the body so that we can relize which facts are used
+        body_result = []
+        if o.body
+          body_result << [do_dump(o.body)]
+        else
+          body_result << []
+        end
+        result << [:break,:break,'let(:facts)', :do, '{',:break]
+        result << dump_top_scope_vars
+        result << ['}',:end]
+        result << body_result
+        result << [:end]
+        result
+      end
+
+      # Produces parameters as name, or (= name value)
+      def dump_Parameter o
+        name_prefix = o.captures_rest ? '*' : ''
+        name_part = "#{name_prefix}#{o.name}"
+        data_type = do_dump(do_dump(o.value)).first || do_dump(o.type_expr)
+        # records what is most likely a variable of some time and its value
+        variable_value = do_dump(o.value)
+        # need a case for Puppet::Pops::Model::LambdaExpression
+        if o.eContainer.class == ::Puppet::Pops::Model::LambdaExpression
+          add_var_to_store("#{name_part}", variable_value, false, :lambda_scope)
+        else
+          parent_name = o.eContainer.name
+          add_var_to_store("#{parent_name}::#{name_part}", variable_value, false, :parameter)
+        end
+        if o.value && o.type_expr
+          value = {:type => data_type, :name => name_part, :required => false, :default_value => variable_value}
+        elsif o.value
+          value = {:type => data_type, :name => name_part, :default_value => variable_value, :required => false}
+        elsif o.type_expr
+          value = {:type => data_type, :name => name_part, :required => true,  :default_value => ''}
+        else
+          value = {:type => data_type, :name => name_part, :default_value => '', :required => true}
+        end
+        if value[:required]
+          ['  ', "#{value[:name].to_sym.inspect}", '=>', 'nil,', :break]
+        else
+          ['  ', "##{value[:name].to_sym.inspect}", '=>', value[:default_value].inspect + ',', :break]
+        end
+      end
+
+      # this will determine and dump the resource requirement by
+      # comparing itself against the resource relationship expression
+      def dump_Resource_Relationship o
+        result = []
+        id = o.eContainer.object_id # the id of this container
+        relationship = o.eContainer.eContainer.eContainer.eContents.first
+        if relationship.respond_to?(:left_expr)
+          if relationship.left_expr.object_id == id
+            type_name = dump(relationship.right_expr.type_name).capitalize
+            titles = relationship.right_expr.bodies.map{|b| dump(b.title)}
+            result << ['"that_comes_before"', '=>', "'#{type_name}#{titles}',".gsub("\"", '') ]
+          else
+            if relationship.left_expr.respond_to?(:type_name)
+              type_name = dump(relationship.left_expr.type_name).capitalize
+              titles = relationship.left_expr.bodies.map{|b| dump(b.title)}
+              result << ['"that_requires"', '=>', "'#{type_name}#{titles}',".gsub("\"", '')]
+            end
+          end
+        end
+        result
+      end
+
+      def dump_ResourceBody o
+        type_name = do_dump(o.eContainer.type_name).gsub('::', '__')
+        title = do_dump(o.title).inspect
+        #TODO remove the :: from the front of the title if exists
+        result = ['  ', :indent, :it, :do, :indent, "is_expected.to contain_#{type_name}(#{title})"]
+        # this determies if we should use the with() or not
+        if o.operations.count > 0
+          result << [ :indent, :break,'.with({', :indent, :break]
+          o.operations.each do |p|
+            result << do_dump(p) << :break
+          end
+          #result.pop  # remove last line break which is easier than using conditional in loop
+          unless [::Puppet::Pops::Model::CallNamedFunctionExpression, ::Puppet::Pops::Model::BlockExpression].include?(o.eContainer.eContainer.class)
+            result << dump_Resource_Relationship(o)
+          end
+          result << [:dedent, :dedent, '})', :dedent, :indent]
+          result << [:dedent,:end, :break]
+          result << [:dedent]
+        else
+          result << [:dedent,:dedent, :break,'end',:dedent, :break, '  ']
+        end
+        result
+      end
+
+      def method_missing(name, *args, &block)
+        logger.debug("Method #{name} called".warning)
+        []
+      end
+
+      # Interpolated strings are shown as (cat seg0 seg1 ... segN)
+      def dump_ConcatenatedString o
+        o.segments.collect {|x| do_dump(x)}.join
+      end
+
+      # Interpolation (to string) shown as (str expr)
+      def dump_TextExpression o
+        [do_dump(o.expr)]
+      end
+
+      # outputs the value of the variable
+      # @param VariableExpression
+      # @return String the value of the variable or the name if value is not found
+      def dump_VariableExpression o
+        key = dump(o.expr)
+        if value = lookup_var(key)
+          value  # return the looked up value
+        elsif [::Puppet::Pops::Model::AttributeOperation,
+           ::Puppet::Pops::Model::AssignmentExpression].include?(o.eContainer.class)
+          "$#{key}"
+        else
+          add_var_to_store(key, "$#{key}", false, :class_scope)
+        end
+      end
+
+      # this doesn't return anything as we use it to store variables
+      def dump_AssignmentExpression o
+        oper = o.operator.to_s
+        result = []
+        case oper
+        when '='
+          # we don't know the output type of a function call, so just assign nill
+          # no need to add it to the var_store since its always the same
+          # without this separation, values will get stored
+          if o.right_expr.class == ::Puppet::Pops::Model::CallNamedFunctionExpression
+            value = nil
+          else
+            value = dump(o.right_expr)
+            key = dump(o.left_expr)
+            # we dont want empty variables storing empty values
+            unless key == value
+              add_var_to_store(key, value, true)
+            end
+          end
+          result
+        else
+          [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
+        end
+      end
+
+      def dump_BlockExpression o
+        result = [:break]
+        o.statements.each {|x| result << do_dump(x) }
+        result
+      end
+
+      # this is the beginning of the resource not the body itself
+      def dump_ResourceExpression o
+        result = []
+        o.bodies.each do |b|
+          result << :break << do_dump(b)
+        end
+        result
+      end
+
+      # defines the resource expression and outputs -> when used
+      # this would be the place to insert relationsip matchers
+      def dump_RelationshipExpression o
+        [do_dump(o.left_expr), do_dump(o.right_expr)]
+      end
+
+      # Produces (name => expr) or (name +> expr)
+      def dump_AttributeOperation o
+        key = o.attribute_name
+        value = do_dump(o.value_expr) || nil
+        [key.inspect, o.operator, value.inspect + ',']
+      end
+
+      # x[y] prints as (slice x y)
+      def dump_AccessExpression o
+        "#{do_dump(o.left_expr).capitalize}" + do_dump(o.keys).to_s.gsub("\"",'')
+      end
+
+      def dump_LiteralFloat o
+        o.value.to_s
+      end
+
+      def dump_LiteralInteger o
+        case o.radix
+        when 10
+          o.value.to_s
+        when 8
+          "0%o" % o.value
+        when 16
+          "0x%X" % o.value
+        else
+          "bad radix:" + o.value.to_s
+        end
+      end
+
+      def dump_LiteralValue o
+        o.value
+      end
+
+      def dump_LiteralList o
+        o.values.collect {|x| do_dump(x)}
+      end
+
+      def dump_LiteralHash o
+        data = o.entries.collect {|x| do_dump(x)}
+        Hash[*data.flatten]
+      end
+
+      def dump_LiteralString o
+        "#{o.value}"
+      end
+
+      def dump_LiteralDefault o
+        ":default"
+      end
+
+      def dump_LiteralUndef o
+        :undef
+      end
+
+      def dump_LiteralRegularExpression o
+        "/#{o.value.source}/"
+      end
+
+      def dump_Nop o
+        ":nop"
+      end
+
+      def dump_NilClass o
+        :undef
+      end
+
+      def dump_NotExpression o
+        ['!', dump(o.expr)]
+      end
+
+      def dump_CapabilityMapping o
+        [o.kind, do_dump(o.component), o.capability, do_dump(o.mappings)]
+      end
+
+      def dump_ParenthesizedExpression o
+        do_dump(o.expr)
+      end
+
+      # Hides that Program exists in the output (only its body is shown), the definitions are just
+      # references to contained classes, resource types, and nodes
+      def dump_Program(o)
+        dump(o.body)
+      end
+
+      def dump_Object o
+        []
+      end
+
+      def is_nop? o
+        o.nil? || o.is_a?(::Puppet::Pops::Model::Nop)
+      end
+
+    end
+  end
+end