puppetlabs-onceover 5.0.3

data/features/support/controlrepo_helper.rb

@@ -0,0 +1,36 @@
+class ControlRepo_Helper
+  attr_reader :tmp_folder
+
+  def initialize( name )
+    @name       = name
+    @tmp_folder = '.cucumber/tmp/'
+  end
+
+  def root_folder
+    @tmp_folder + @name + '/'
+  end
+
+  def puppetfile
+    root_folder + "Puppetfile"
+  end
+
+  def onceover_temp_root_folder
+    root_folder + '.onceover/etc/puppetlabs/code/environments/production/'
+  end
+
+  def onceover_temp_puppetfile
+    onceover_temp_root_folder + "Puppetfile"
+  end
+
+  def config_file
+    root_folder + 'spec/onceover.yaml'
+  end
+
+  def config_file_contents
+    File.read(config_file)
+  end
+
+  def add_line_to_puppetfile( line )
+    open(puppetfile, 'a') { |f| f.puts line }
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,2 @@
+
+

data/features/windows.feature

@@ -0,0 +1,35 @@
+@windows
+Feature: Run onceover with windows 
+  Onceover should allow to run rspec and acceptance test for all profvile and role classes
+  or for any part of them. Use should set if he wants to see only summary of tests or full
+  log info.
+
+  Background:
+    Given onceover executable
+
+  Scenario: Run with common Windows code
+    Given control repo "windows"
+    When I run onceover command "run spec" with class "role::users"
+    Then I should not see any errors
+
+  Scenario: Run with common Windows code without workarounds
+    Given existing control repo "windows"
+    When I run onceover command "run spec --no_workarounds" with class "role::users"
+    And test osfamily is not "windows"
+    Then Onceover should exit 1
+
+  Scenario: Compiling a windows role with groups that is valid should compile
+    Given control repo "windows"
+    When I run onceover command "run spec" with class "role::groups"
+    Then I should not see any errors
+  
+  Scenario: Compiling a windows role with users that is valid should compile
+    Given control repo "windows"
+    When I run onceover command "run spec" with class "role::users"
+    Then I should not see any errors
+  
+  Scenario: Compiling a windows role with chocolatey that is valid should compile
+    Given control repo "windows"
+    When I run onceover command "run spec" with class "role::choco"
+    Then I should not see any errors
+  

data/features/zzz_run.feature

@@ -0,0 +1,93 @@
+@run
+Feature: Run rspec and acceptance test suites
+  Onceover should allow to run rspec and acceptance test for all profile and role classes
+  or for any part of them. Use should set if he wants to see only summary of tests or full
+  log info.
+
+  Background:
+    Given onceover executable
+
+  Scenario: Run without a Puppetfile
+    Given initialized control repo "minimal"
+    When I run onceover command "run spec"
+    Then I should not see any errors
+
+  Scenario: Run correct spec tests
+    Given initialized control repo "basic"
+    When I run onceover command "run spec"
+    Then I should not see any errors
+
+  Scenario: Run correct spec tests in parallel
+    Given initialized control repo "basic"
+    When I run onceover command "run spec --parallel"
+    Then I should not see any errors
+
+  Scenario: Using regexes to define tests
+    Given initialized control repo "caching"
+    When I run onceover command "run spec"
+    Then I should see message pattern "apache::params"
+
+  Scenario: Checking that r10k config works
+    Given initialized control repo "caching"
+    When I run onceover command "run spec --debug"
+    Then I should see message pattern "r10k.yaml"
+
+  Scenario: Run spec tests with misspelled module in Puppetfile
+    Given initialized control repo "basic"
+    And in Puppetfile is misspelled module's name
+    When I run onceover command "run spec"
+    Then I should see error with message pattern "The module acme-not_exists does not exist"
+
+  @skip_on_windows
+  Scenario: Force overwrite local modifications
+    Given initialized control repo "basic"
+    When I run onceover command "run spec"
+    And I make local modifications
+    And I run onceover command "run spec --force"
+    Then I should see message pattern "Overwriting local modifications"
+
+  Scenario: When using an alternate manifests directory
+    Given initialized control repo "basic"
+    When I run onceover command "run spec --manifest manifests_alternate"
+    Then I should see error with message pattern "Using alternate site.pp"
+
+  Scenario: Check that control_branch functionality works
+    Given initialized control repo "control_branch"
+    When I run onceover command "run spec"
+    Then the temporary Puppetfile should contain the git branch
+
+  Scenario: Mocking functions should work and return the correct data types
+    Given control repo "function_mocking"
+    When I run onceover command "run spec" with class "role::test_data_return"
+    Then I should not see any errors
+
+  Scenario: Mocking functions that use the new :: pathing
+    Given control repo "function_mocking"
+    When I run onceover command "run spec" with class "role::test_new_functions"
+    Then I should not see any errors
+
+  Scenario: Running tests that fail to compile
+    Given control repo "function_mocking"
+    When I run onceover command "run spec" with class "role::fail"
+    Then I should see message pattern "Syntax error at 'is'"
+    And Onceover should exit 1
+
+  Scenario: Run with a custom Puppetfile
+    Given initialized control repo "custom_puppetfile"
+    When I run onceover command "run spec" with --puppetfile Puppetfile.custom
+    Then Puppetfile.custom should be copied to Puppetfile
+    And I should see message pattern "Using Puppetfile .*Puppetfile"
+    And I should see message pattern ".*extlib"
+
+  Scenario: Testing that --tags works with native rspec tags
+    Given control repo "puppet_controlrepo"
+    When I run onceover command "run spec --tags syntax"
+    Then I should not see any errors
+    And I should see message pattern "When checking Puppet syntax"
+    And I should not see message pattern "role::"
+
+  # This test is a full test using my controlrepo. It should remain at the end because it takes ages
+  Scenario: Run advanced spec tests
+    Given control repo "puppet_controlrepo"
+    When I run onceover command "run spec -p --force"
+    Then I should not see any errors

data/lib/puppetlabs-onceover/beaker/spec_helper.rb

@@ -0,0 +1,71 @@
+# This has all been hacked out of the beaker-rspec gem. The reason I have
+# hacked it out instead of just using it the way it was intended is that
+# it is very stuck in its ways around how it spins up all the servers
+# first, then goes ahead and runs the tests. Because I don't want to do this
+# I have had to replicate MOST of the functionality, EXCEPT the stuff I don't
+# want. This is annoying but as far as I can tell this is the only way to do
+# it
+
+require 'beaker'
+require 'beaker-rspec/beaker_shim' # This overloads Rspec's methods and provides the interface between beaker and RSpec
+require "beaker-rspec/helpers/serverspec"
+include BeakerRSpec::BeakerShim
+
+require 'puppetlabs-onceover/beaker'
+
+#scp_to hosts, '<%= repo.tempdir %>/etc', '/'
+
+RSpec.configure do |c|
+  # Enable color
+  c.color = true
+  c.tty = true
+
+  # Readable test descriptions
+  c.formatter = :documentation
+
+  # Define persistant hosts setting
+  c.add_setting :hosts, :default => []
+  # Define persistant options setting
+  c.add_setting :options, :default => {}
+  # Define persistant metadata object
+  c.add_setting :metadata, :default => {}
+  # Define persistant logger object
+  c.add_setting :logger, :default => nil
+  # Define persistant default node
+  c.add_setting :default_node, :default => nil
+
+  #default option values
+  defaults = {
+    :nodeset => 'onceover-nodes',
+  }
+  #read env vars
+  env_vars = {
+    :color => ENV['BEAKER_color'] || ENV.fetch('RS_COLOR', nil),
+    :nodeset => ENV['BEAKER_set'] || ENV.fetch('RS_SET', nil),
+    :nodesetfile => ENV['BEAKER_setfile'] || ENV.fetch('RS_SETFILE', nil),
+    :provision => ENV['BEAKER_provision'] || ENV.fetch('RS_PROVISION', nil),
+    :keyfile => ENV['BEAKER_keyfile'] || ENV.fetch('RS_KEYFILE', nil),
+    :debug => ENV['BEAKER_debug'] || ENV.fetch('RS_DEBUG', nil),
+    :destroy => ENV['BEAKER_destroy'] || ENV.fetch('RS_DESTROY', nil),
+  }.compact
+  #combine defaults and env_vars to determine overall options
+  options = defaults.merge(env_vars)
+
+  # process options to construct beaker command string
+  nodesetfile = options[:nodesetfile] || File.join('spec/acceptance/nodesets',"#{options[:nodeset]}.yml")
+  fresh_nodes = options[:provision] == 'no' ? '--no-provision' : nil
+  keyfile = options[:keyfile] ? ['--keyfile', options[:keyfile]] : nil
+  debug = options[:debug] ? ['--log-level', 'debug'] : nil
+  color = options[:color] == 'no' ? ['--no-color'] : nil
+
+  # Configure all nodes in nodeset
+  c.setup([fresh_nodes, '--hosts', nodesetfile, keyfile, debug, color].flatten.compact)
+  #c.provision
+  #c.validate
+  #c.configure
+end
+
+# Set the number of lines it will print
+options[:trace_limit] = 1000
+
+OPTIONS = options

data/lib/puppetlabs-onceover/beaker.rb

@@ -0,0 +1,241 @@
+# rubocop:disable Style/RescueStandardError
+# ^^ I canlt be bothered fixing this because all of this code is deprecated
+
+class PuppetlabsOnceover
+  class Beaker
+    # WARNING: All of this functionality is deprecated. It will be left around
+    # until there is something to replace it, but don't rely on it
+    def self.facts_to_vagrant_box(facts)
+      warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"
+      # Gets the most similar vagrant box to the facts set provided, will accept a single fact
+      # se or an array
+
+      if facts.is_a?(Array)
+        returnval = facts.map do |fact|
+          self.facts_to_vagrant_box(fact)
+        end
+        return returnval
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Ubuntu'
+          os = 'ubuntu'
+          version = facts['os']['distro']['release']['major']
+        end
+      rescue
+        # Do nothing, this is the easiest way to handle the hash bing in different formats
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Debian'
+          os = 'Debian'
+          version = facts['os']['distro']['release']['full']
+        end
+      rescue
+        # Do nothing
+      end
+
+      begin
+        if facts['os']['family'] == "RedHat"
+          os = 'centos'
+          version = "#{facts['os']['release']['major']}.#{facts['os']['release']['minor']}"
+        end
+      rescue
+        # Do nothing
+      end
+
+      return "UNKNOWN" unless os.is_a?(String)
+
+      if facts['os']['architecture'] =~ /64/
+        arch = '64'
+      else
+        arch = '32'
+      end
+
+      "puppetlabs/#{os}-#{version}-#{arch}-puppet"
+    end
+
+    # This will take a fact set and return the beaker platform of that machine
+    # This is necissary as beaker needs the platform set up correctly to know which
+    # commands to run when we do stuff. Personally I would prefer beaker to detect the
+    # platform as it would not be that hard, especially once puppet is installed, oh well.
+    def self.facts_to_platform(facts)
+      warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"
+
+      if facts.is_a?(Array)
+        returnval = facts.map do |fact|
+          self.facts_to_platform(fact)
+        end
+        return returnval
+      end
+
+      begin
+        if facts['os']['family'] == 'RedHat'
+          platform = 'el'
+          version = facts['os']['release']['major']
+        end
+      rescue
+        # Do nothing, this is the easiest way to handle the hash being in different formats
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Ubuntu'
+          platform = 'ubuntu'
+          version = facts['os']['distro']['release']['major']
+        end
+      rescue
+        # Do nothing, this is the easiest way to handle the hash being in different formats
+      end
+
+      begin
+        if facts['os']['distro']['id'] == 'Debian'
+          platform = 'debian'
+          version = facts['os']['distro']['release']['full']
+        end
+      rescue
+        # Do nothing
+      end
+
+      if facts['os']['architecture'] =~ /64/
+        arch = '64'
+      else
+        arch = '32'
+      end
+
+      "#{platform}-#{version}-#{arch}"
+    end
+
+    # This little method will deploy a Controlrepo object to a host, just using r10k deploy
+    def self.deploy_controlrepo_on(host, repo = PuppetlabsOnceover::Controlrepo.new())
+      warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"
+
+      require 'beaker-rspec'
+      require 'puppetlabs-onceover/controlrepo'
+
+      if host.is_a?(Array)
+        hosts.each do |single_host|
+          deploy_controlrepo_on(single_host)
+        end
+      end
+
+      # Use a beaker helper to do the install (*nix only)
+      install_r10k_on(host)
+
+      # Use beaker to install git
+      host.install_package('git')
+
+      # copy the file over to the host (Maybe I should be changing the directory here??)
+      scp_to(host, repo.r10k_config_file, '/tmp/r10k.yaml')
+
+      # Do an r10k deploy
+      r10k_deploy(host, {
+                    :puppetfile => true,
+                    :configfile => '/tmp/r10k.yaml',
+                  })
+    end
+
+    # This actually provisions a node and checks that puppet will be able to run and
+    # be idempotent. It hacks the beaker NetworkManager object to do this. The reason
+    # is that beaker is designed to run in the following order:
+    #   1. Spin up nodes
+    #   2. Run all tests
+    #   3. Kill all nodes
+    #
+    # This is not helpful for us. We want to be able to test all of our classes on
+    # all of our nodes, this could be a lot of vms and having them all running at once
+    # would be a real kick in the dick for whatever system was running it.
+    def self.provision_and_test(host,puppet_class,opts = {}, repo = PuppetlabsOnceover::Controlrepo.new)
+      warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"
+
+      opts = {:runs_before_idempotency => 1}.merge(opts)
+      opts = {:check_idempotency => true}.merge(opts)
+      opts = {:deploy_controlrepo => true}.merge(opts)
+
+      raise "Hosts must be a single host object, not an array" if host.is_a?(Array)
+      raise "Class must be a single Class [String], not an array" unless puppet_class.is_a?(String)
+
+      # Create our own NWM object that we are going to interact with
+      # Note here that 'options', 'logger' and are exposed within the rspec tests
+      # if this is run outside of that context it will fail
+      network_manager = ::Beaker::NetworkManager.new(options,logger)
+
+      # Hack the network manager to smash our host in there without provisioning
+      network_manager.instance_variable_set(:@hosts,[host])
+
+      # Now that we have a working network manager object, we can provision, but only if
+      # we need to, ahhh smart...
+      unless host.up?
+        network_manager.provision
+        network_manager.proxy_package_manager
+        network_manager.validate
+        network_manager.configure
+      end
+
+      # Actually run the tests
+      manifest = "include #{puppet_class}"
+
+      opts[:runs_before_idempotency].times do
+        apply_manifest_on(host, manifest, {:catch_failures => true})
+      end
+
+      if opts[:check_idempotency]
+        apply_manifest_on(host, manifest, {:catch_changes => true})
+      end
+
+      network_manager.cleanup
+    end
+
+    def self.match_indentation(test,logger)
+      warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"
+
+      logger.line_prefix = '  ' * (test.metadata[:scoped_id].split(':').count - 1)
+    end
+
+    def self.host_create(name, nodes)
+      warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"
+
+      require 'beaker/network_manager'
+
+      current_opts = {}
+      nodes.each do |opt,val|
+        if opt == :HOSTS
+          val.each do |k,v|
+            if k == name
+              current_opts[:HOSTS] = {k => v}
+            end
+          end
+        else
+          current_opts[opt] = val
+        end
+      end
+
+      # I copied this code off the internet, basically it allows us
+      # to refer to each key as either a string or an object
+      current_opts.default_proc = proc do |h, k|
+        case k
+        when String then sym = k.to_sym; h[sym] if h.key?(sym)
+        when Symbol then str = k.to_s; h[str] if h.key?(str)
+        end
+      end
+
+      @nwm = ::Beaker::NetworkManager.new(current_opts,logger)
+      @nwm.provision
+      @nwm.proxy_package_manager
+      @nwm.validate
+      @nwm.configure
+
+      @nwm.instance_variable_get(:@hosts).each do |host|
+        host.instance_variable_set(:@nwm,@nwm)
+        host.define_singleton_method(:down!) do
+          @nwm.cleanup
+        end
+      end
+
+      raise "The networkmanager created too many machines! Only expecting one" if hosts.count > 1
+
+      @nwm.instance_variable_get(:@hosts)[0]
+    end
+  end
+end
+
+# rubocop:enable Style/RescueStandardError

data/lib/puppetlabs-onceover/class.rb

@@ -0,0 +1,56 @@
+class PuppetlabsOnceover
+  class Class
+    @@all = []
+
+    attr_accessor :name
+
+    def initialize(name)
+      # if the class we are trying to create is a regex, create class objects
+      # for everything that matches.
+      if PuppetlabsOnceover::Class.name_is_regexp?(name)
+        expression = PuppetlabsOnceover::Class.string_to_regexp(name)
+        matched_classes = PuppetlabsOnceover::Controlrepo.classes.keep_if { |c| c =~ expression }
+        matched_classes.each do |c|
+          PuppetlabsOnceover::Class.new(c)
+        end
+      else
+        @name = name
+        @@all << self
+      end
+    end
+
+    # This is what is executed to see if something exists as a class. The same
+    # thing is executed for groups etc. when building up test matricies.
+    def self.find(class_name)
+      if PuppetlabsOnceover::Class.name_is_regexp?(class_name)
+        return @@all.select do |cls|
+          cls.name =~ PuppetlabsOnceover::Class.string_to_regexp(class_name)
+        end
+      else
+        @@all.each do |cls|
+          if cls.name == class_name
+            return cls
+          end
+        end
+      end
+      logger.warn "Class #{class_name} not found"
+      nil
+    end
+
+    def self.all
+      @@all
+    end
+
+    def self.string_to_regexp(string)
+      if PuppetlabsOnceover::Class.name_is_regexp?(string)
+        Regexp.new(string[1..-2])
+      else
+        raise "#{string} does not start and end with / and cannot be converted to regexp"
+      end
+    end
+
+    def self.name_is_regexp?(name)
+      name.start_with?('/') and name.end_with?('/')
+    end
+  end
+end

data/lib/puppetlabs-onceover/cli/init.rb

@@ -0,0 +1,34 @@
+require 'cri'
+require 'puppetlabs-onceover/controlrepo'
+require 'puppetlabs-onceover/cli'
+require 'puppetlabs-onceover/runner'
+require 'puppetlabs-onceover/testconfig'
+require 'puppetlabs-onceover/logger'
+
+class PuppetlabsOnceover
+  class CLI
+    class Init
+      def self.command
+        @command ||= Cri::Command.define do
+          name 'init'
+          usage 'init'
+          summary 'Sets up a controlrepo for testing from scratch'
+          description <<-DESCRIPTION
+This will generate all of the config files required for the onceover
+tool to work.
+          DESCRIPTION
+
+          run do |opts, args, cmd|
+            PuppetlabsOnceover::Controlrepo.init(PuppetlabsOnceover::Controlrepo.new(opts))
+            # Would it make sense for #init to be a class instance method of Controlrepo ? Then you could:
+            # cp = PuppetlabsOnceover::Controlrepo.new(opts)
+            # cp.init
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register itself
+PuppetlabsOnceover::CLI.command.add_command(PuppetlabsOnceover::CLI::Init.command)

data/lib/puppetlabs-onceover/cli/plugins.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+# Get all of the gems that start with onceover-
+plugins = Gem::Specification.group_by{ |g| g.name }.keep_if do |name, details|
+  name =~ /^onceover-.*$/
+end.keys
+
+plugins.each do |plugin|
+  require plugin.gsub('-', '/')
+end

data/lib/puppetlabs-onceover/cli/run.rb

@@ -0,0 +1,85 @@
+require 'cri'
+require 'puppetlabs-onceover/controlrepo'
+require 'puppetlabs-onceover/cli'
+require 'puppetlabs-onceover/runner'
+require 'puppetlabs-onceover/testconfig'
+require 'puppetlabs-onceover/logger'
+require 'puppetlabs-onceover/deploy'
+
+class PuppetlabsOnceover
+  class CLI
+    class Run
+      def self.command
+        @command ||= Cri::Command.define do
+          name 'run'
+          usage 'run [spec|acceptance]'
+          summary 'Runs either the spec or acceptance tests'
+          description <<-DESCRIPTION
+This will run the full set of spec or acceptance tests.
+This includes deploying using r10k and running all custom tests.
+          DESCRIPTION
+
+          optional :t,  :tags,             'A list of tags. Only tests with these tags will be run'
+          optional :c,  :classes,          'A list of classes. Only tests with these classes will be run'
+          optional :n,  :nodes,            'A list of nodes. Only tests with these nodes will be run'
+          optional :s,  :skip_r10k,        'Skip the r10k step'
+          optional :f,  :force,            'Passes --force to r10k, overwriting modules'
+          optional :sv, :strict_variables, 'Run with strict_variables set to yes'
+
+          run do |opts, args, cmd|
+            puts cmd.help(:verbose => opts[:verbose])
+            exit 0
+          end
+        end
+      end
+
+      class Spec
+        def self.command
+          @command ||= Cri::Command.define do
+            name 'spec'
+            usage 'spec'
+            summary 'Runs spec tests'
+
+            optional :p, :parallel, 'Runs spec tests in parallel. This increases speed at the cost of poorly formatted logs and irrelevant junit output.'
+            optional nil, :format, 'Which RSpec formatter to use, valid options are: documentation, progress, FailureCollector, PuppetlabsOnceoverFormatter. You also specify this multiple times', multiple: true, default: :defaults
+            optional nil, :no_workarounds, 'Disables workarounds that have been added for convenience to get around common RSPec issues such as https://github.com/rodjek/rspec-puppet/issues/665'
+            optional :ff, :fail_fast, 'Abort the run after the first failure'
+            optional nil, :auto_vendored, 'Attempt to resolve vendored puppet modules. Ex: puppetlabs/cron_core', default: false
+
+            run do |opts, args, cmd|
+              repo = PuppetlabsOnceover::Controlrepo.new(opts)
+              PuppetlabsOnceover::Deploy.new.deploy_local(repo, opts)
+              runner = PuppetlabsOnceover::Runner.new(repo,PuppetlabsOnceover::TestConfig.new(repo.onceover_yaml, opts), :spec)
+              runner.prepare!
+              runner.run_spec!
+            end
+          end
+        end
+      end
+
+      class Acceptance
+        def self.command
+          @command ||= Cri::Command.define do
+            name 'acceptance'
+            usage 'acceptance'
+            summary 'Runs acceptance tests'
+
+            run do |opts, args, cmd|
+              warn "[DEPRECATION] Acceptance testing is deprecated due to the removal of Beaker dependencies"
+              warn "[DEPRECATION] Appeptance testing will be replaced by a more pluggable framework in the future, if you have ideas as to how this should be done please submit a ticket."
+              repo = PuppetlabsOnceover::Controlrepo.new(opts)
+              runner = PuppetlabsOnceover::Runner.new(repo,PuppetlabsOnceover::TestConfig.new(repo.onceover_yaml,opts), :acceptance)
+              runner.prepare!
+              runner.run_acceptance!
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register itself
+PuppetlabsOnceover::CLI.command.add_command(PuppetlabsOnceover::CLI::Run.command)
+PuppetlabsOnceover::CLI::Run.command.add_command(PuppetlabsOnceover::CLI::Run::Spec.command)
+PuppetlabsOnceover::CLI::Run.command.add_command(PuppetlabsOnceover::CLI::Run::Acceptance.command)