pdqtest 1.4.1 → 1.9.9beta2

data/lib/pdqtest/docker.rb

@@ -6,23 +6,101 @@ module PDQTest
     OUT = 0
     ERR = 1
     STATUS = 2
-    ENV='export TERM=xterm LC_ALL=C PATH=/usr/local/bats/bin:/opt/puppetlabs/puppet/bin:$PATH;'
+    REAL_CMD = 3
     IMAGES = {
-     :DEFAULT => 'declarativesystems/pdqtest-1x-centos:2019-04-01-0',
-     :UBUNTU  => 'declarativesystems/pdqtest-ubuntu:2018-08-29-0',
+     :DEFAULT => 'declarativesystems/pdqtest-centos:2018-09-15-0',
+     :UBUNTU  => 'declarativesystems/pdqtest-ubuntu:2018-09-15-0',
+     :WINDOWS => 'declarativesystems/pdqtest-windows:2018-09-18-0',
     }
-    HIERA_YAML_CONTAINER = '/etc/puppetlabs/puppet/hiera.yaml'
-    HIERA_YAML_HOST = '/spec/fixtures/hiera.yaml'
-    HIERA_DIR  = '/spec/fixtures/hieradata'
-    YUM_CACHE_CONTAINER = "/var/cache/yum"
-    YUM_CACHE_HOST    = "#{Util::app_dir_expanded}/cache/yum"
-
-    def self.wrap_cmd(cmd)
-      ['bash',  '-c', "#{ENV} #{cmd}"]
+
+    # volume paths are different for windows containers
+    # https://superuser.com/questions/1051520/docker-windows-container-how-to-mount-a-host-folder-as-data-volume-on-windows
+    # path for common things *inside* the container
+    #
+    # Also... bind mounting _files_ is impossible on windows in docker right now:
+    # * https://github.com/docker/for-win/issues/376
+    # * https://github.com/moby/moby/issues/30555
+    # * https://github.com/opctl/opctl/issues/207
+    # * https://docs.docker.com/engine/reference/commandline/run/#capture-container-id---cidfile
+    CONTAINER_PATHS = {
+        :windows => {
+            :testcase   => 'C:\\testcase',
+        },
+        :linux => {
+            :yum_cache => "/var/cache/yum",
+            :testcase  => '/testcase',
+        }
+    }
+
+    # path for common things on the *host* computer running pdqtest (vm, laptop, etc)
+    HOST_PATHS = {
+        :windows => {
+        },
+        :linux => {
+            :yum_cache  => "#{Util::app_dir_expanded}/cache/yum",
+        }
+    }
+
+    # convenience lookup for container testcase dir since its used all over the
+    # place
+    def self.test_dir
+      CONTAINER_PATHS[Util.host_platform][:testcase]
     end
 
+    # Map the testcase and any OS specific volumes we would always want, eg
+    # yum cache, random crap for systemd, etc
+    def self.supporting_volumes
+      pwd = Dir.pwd
+      platform = Util.host_platform
+      if Util.is_windows
+        # normalise output for windows
+        pwd = pwd.gsub(/\//, '\\')
+      end
+      test_dir = CONTAINER_PATHS[platform][:testcase]
+      volumes = {test_dir => {pwd => 'rw'}}
+
+      if ! Util.is_windows
+        volumes['/sys/fs/cgroup']                      = {'/sys/fs/cgroup'                 => 'ro'}
+        volumes[CONTAINER_PATHS[platform][:yum_cache]] = {HOST_PATHS[platform][:yum_cache] => 'rw'}
+      end
+
+      volumes
+    end
+
+
     def self.exec(container, cmd)
-      container.exec(wrap_cmd(cmd), tty: true)
+      status = 0
+      res = []
+
+      res[OUT]=[]
+      res[ERR]=[]
+      res[STATUS]=0
+      res[REAL_CMD]=[]
+
+      Array(cmd).each do |c|
+        real_c = Util.wrap_cmd(c)
+        res[REAL_CMD] << real_c
+        $logger.debug "Executing: #{real_c}"
+        _res = container.exec(real_c, tty: true)
+
+        if c =~ /robocopy/
+          # robocopy exit codes break the status check we do later on - we have
+          # to manually 'fix' them here
+          if _res[STATUS] < 4
+            _res[STATUS] = 0
+          end
+        end
+        res[STATUS] += _res[STATUS]
+        res[OUT]    += _res[OUT]
+        res[ERR]    += _res[ERR]
+
+        # non zero status from something thats not puppet apply is probably an error
+        if _res[STATUS] != 0 && !(c =~ /pupet apply|bats/)
+          $logger.warn "non-zero exit status: #{_res[STATUS]} from #{real_c}: #{_res[OUT]} #{_res[ERR]}"
+        end
+      end
+
+      res
     end
 
     # detect the image to use based on metadata.json
@@ -50,7 +128,7 @@ module PDQTest
             when "ubuntu"
               supported_images << IMAGES[:UBUNTU]
             when "windows"
-              Escort::Logger.output.puts "Windows acceptance testing not supported yet... any ideas?"
+              supported_images << IMAGES[:WINDOWS]
             else
               supported_images << IMAGES[:DEFAULT]
           end
@@ -60,10 +138,15 @@ module PDQTest
       supported_images.uniq
     end
 
-    def self.new_container(test_dir, image_name, privileged)
-      pwd = Dir.pwd
-      hiera_yaml_host = File.join(pwd, HIERA_YAML_HOST)
-      hiera_dir = File.join(pwd, HIERA_DIR)
+
+    def self.new_container(image_name, privileged)
+
+      if Util.is_windows
+        ::Docker.url = "tcp://127.0.0.1:2375"
+        # nasty hack for https://github.com/swipely/docker-api/issues/441
+        ::Docker.send(:remove_const, 'API_VERSION')
+        ::Docker.const_set('API_VERSION', '1.24')
+      end
 
       # security options seem required on OSX to allow SYS_ADMIN capability to
       # work - without this container starts fine with no errors but the CAP is
@@ -76,47 +159,56 @@ module PDQTest
           []
         end
 
-      if ! Dir.exists?(YUM_CACHE_HOST)
-        FileUtils.mkdir_p(YUM_CACHE_HOST)
+      if ! Util.is_windows
+        if ! Dir.exists?(HOST_PATHS[Util.host_platform][:yum_cache])
+          FileUtils.mkdir_p(HOST_PATHS[Util.host_platform][:yum_cache])
+        end
       end
 
-      # hiera.yaml *must* exist on the host or we will get errors from Docker
-      if ! File.exists?(hiera_yaml_host)
-        File.write(hiera_yaml_host, '# hiera configuration for testing')
+      #
+      #  volumes (container -> host)
+      #
+      volumes = supporting_volumes
+
+      #
+      # binds (host -> container)
+      #
+      binds = Util.volumes2binds(volumes)
+
+      #
+      # hostconfig->tmpfs (linux)
+      #
+      if Util.is_windows
+        start_body = {}
+        if privileged
+          $logger.error "--privileged has no effect on windows"
+        end
+      else
+        start_body = {
+            'HostConfig' => {
+                'Tmpfs': {
+                    '/run'      => '',
+                    '/run/lock' => '',
+                },
+                CapAdd: [ 'SYS_ADMIN'],
+                Privileged: privileged,
+            }
+        }
       end
+
+      #
+      # container
+      #
+
       container = ::Docker::Container.create(
         'Image'   => image_name,
-        'Volumes' => {
-          test_dir              => {pwd               => 'rw'},
-          HIERA_YAML_CONTAINER  => {hiera_yaml_host   => 'rw'},
-          HIERA_DIR             => {hiera_dir         => 'rw'},
-          '/sys/fs/cgroup'      => {'/sys/fs/cgroup'  => 'ro'},
-          YUM_CACHE_CONTAINER   => {YUM_CACHE_HOST    => 'rw'},
-        },
+        'Volumes' => volumes,
         'HostConfig' => {
           "SecurityOpt" => security_opt,
-          "Binds": [
-            "/sys/fs/cgroup:/sys/fs/cgroup:ro",
-            "#{pwd}:#{test_dir}:rw",
-            "#{hiera_yaml_host}:#{HIERA_YAML_CONTAINER}:rw",
-            "#{hiera_dir}:#{HIERA_DIR}:rw",
-            "#{YUM_CACHE_HOST}:#{YUM_CACHE_CONTAINER}:rw",
-          ],
+          "Binds": binds,
         },
       )
-      container.start(
-        {
-          #'Binds' => [ pwd +':'+ test_dir,],
-          'HostConfig' => {
-            'Tmpfs': {
-              '/run'      => '',
-              '/run/lock' => '',
-            },
-            CapAdd: [ 'SYS_ADMIN'],
-            Privileged: privileged,
-          },
-        }
-      )
+      container.start(start_body)
 
       container
     end
@@ -149,7 +241,7 @@ module PDQTest
       exec_out(res).each { |l|
         # Output comes back as an array and needs to be iterated or we lose our
         # ansi formatting
-        Escort::Logger.output << l
+        $logger.info l.chomp
       }
     end
 
@@ -162,7 +254,7 @@ module PDQTest
       exec_err(res).each { |l|
         # Output comes back as an array and needs to be iterated or we lose our
         # ansi formatting
-        Escort::Logger.error << l
+        $logger.error l.chomp
       }
     end
 

data/lib/pdqtest/emoji.rb

@@ -1,17 +1,43 @@
 module PDQTest
   module Emoji
+
+    # windows can only output emojii characters in powershell ISE *but* ISE
+    # causes PDK to crash, so we need special lame emoji's for our windows users
+    EMOJIS = {
+        :windows => {
+            :pass => ":-)",
+            :fail => "●~*",
+            :overall_pass => "=D",
+            :overall_fail => "><(((*>",
+            :slow => "(-_-)zzz",
+            :shame => "(-_-)",
+        },
+        :linux => {
+            :pass => "😬",
+            :fail => "💣",
+            :overall_pass => "😎",
+            :overall_fail => "💩",
+            :slow => "🐌",
+        }
+    }
+
+
     @@disable = false
 
     def self.disable(disable)
       @@disable = disable
     end
 
+    def self.emoji(key)
+      EMOJIS[Util.host_platform][key] || raise("missing emoji #{key}")
+    end
+
     # Print a message prefixed with optional emoji to the STDOUT logger
-    def self.emoji_message(emoji, message)
+    def self.emoji_message(key, message, level=::Logger::INFO)
       if ! @@disable
-        message = "#{message} #{emoji}"
+        message = "#{message} #{emoji(key)}"
       end
-      Escort::Logger.output.puts message
+      $logger.add(level) { message }
     end
 
     # print cool emoji based on status
@@ -20,22 +46,22 @@ module PDQTest
       if ! @@disable
         if status
           # cool bananas
-          Escort::Logger.output.puts lable_string + emoji_pass
+          $logger.info lable_string + emoji_pass
         else
           # boom! crappy code
-          Escort::Logger.error.error lable_string + emoji_fail
+          $logger.error lable_string + emoji_fail
         end
       end
     end
 
     # partial status when lots to do
     def self.partial_status(status, label)
-      emoji_status(status, "😬", "💣", label)
+      emoji_status(status, emoji(:pass), emoji(:fail), label)
     end
 
     # Overall program exit status
     def self.final_status(status)
-      emoji_status(status, "😎", "💩", 'Overall')
+      emoji_status(status, emoji(:overall_pass), emoji(:overall_fail), 'Overall')
     end
   end
 end

data/lib/pdqtest/fastcheck.rb

@@ -0,0 +1,19 @@
+require 'pdqtest/emoji'
+module PDQTest
+
+  # Faster version of syntax and lint checks
+  module Fastcheck
+
+    def self.run
+      status = system("bundle exec puppet-lint manifests")
+
+      if status
+        status = system("bundle exec rake syntax")
+      end
+
+      PDQTest::Emoji.partial_status(status, "fastcheck (syntax+lint)")
+      status
+    end
+
+  end
+end

data/lib/pdqtest/instance.rb

@@ -5,7 +5,6 @@ require 'escort'
 
 module PDQTest
   module Instance
-    TEST_DIR='/testcase'
     @@keep_container = false
     @@active_container = nil
     @@image_name = false
@@ -50,29 +49,29 @@ module PDQTest
       @@active_container = nil
 
       if PDQTest::Puppet::find_examples().empty?
-        Escort::Logger.output.puts "No acceptance tests found, annotate examples with #{PDQTest::Puppet::MAGIC_MARKER} to make some"
+        $logger.info "No acceptance tests found, annotate examples with #{PDQTest::Puppet.setting(:magic_marker)} to make some"
       else
         # process each supported OS
         test_platforms = @@image_name || Docker::acceptance_test_images
-        Escort::Logger.output.puts "Acceptance test on #{test_platforms}..."
+        $logger.info "Acceptance test on #{test_platforms}..."
         test_platforms.each { |image_name|
-          Escort::Logger.output.puts "--- start test with #{image_name} ---"
-          @@active_container = PDQTest::Docker::new_container(TEST_DIR, image_name, @@privileged)
-          Escort::Logger.output.puts "alive, running tests"
+          $logger.info "--- start test with #{image_name} ---"
+          @@active_container = PDQTest::Docker::new_container(image_name, @@privileged)
+          $logger.info "alive, running tests"
           status &= PDQTest::Puppet.run(@@active_container, example)
 
           if @@keep_container
-            Escort::Logger.output.puts "finished build, container #{@@active_container.id} left on system"
-            Escort::Logger.output.puts "  docker exec -ti #{@@active_container.id} bash "
+            $logger.info "finished build, container #{@@active_container.id} left on system"
+            $logger.info "  docker exec -ti #{@@active_container.id} #{Util.shell} "
           else
             PDQTest::Docker.cleanup_container(@@active_container)
             @@active_container = nil
           end
 
-          Escort::Logger.output.puts "--- end test with #{image_name} (status: #{status})---"
+          $logger.info "--- end test with #{image_name} (status: #{status})---"
         }
       end
-      Escort::Logger.output.puts "overall acceptance test status=#{status}"
+      $logger.info "overall acceptance test status=#{status}"
       status
     end
 
@@ -80,8 +79,10 @@ module PDQTest
       # pick the first test platform to test on as our shell - want to do a specific one
       # just list it with --image-name
       image_name = (@@image_name || Docker::acceptance_test_images).first
-      Escort::Logger.output.puts "Opening a shell in #{image_name}"
-      @@active_container = PDQTest::Docker::new_container(TEST_DIR, image_name, @@privileged)
+      $logger.info "Opening a shell in #{image_name}"
+      @@active_container = PDQTest::Docker::new_container(image_name, @@privileged)
+
+      PDQTest::Docker.exec(@@active_container, PDQTest::Puppet.setup)
 
       # In theory I should be able to get something like the code below to
       # redirect all input streams and give a makeshift interactive shell, howeve
@@ -93,10 +94,10 @@ module PDQTest
       #   puts out
       #   puts err
       # }
-      system("docker exec -ti #{@@active_container.id} bash")
+      system("docker exec -ti #{@@active_container.id} #{Util.shell}")
       if @@keep_container
-        Escort::Logger.output.puts "finished build, container #{@@active_container.id} left on system"
-        Escort::Logger.output.puts "  docker exec -ti #{@@active_container.id} bash "
+        $logger.info "finished build, container #{@@active_container.id} left on system"
+        $logger.info "  docker exec -ti #{@@active_container.id} #{Util.shell} "
       else
           PDQTest::Docker.cleanup_container(@@active_container)
           @@active_container = nil

data/lib/pdqtest/logger.rb

@@ -0,0 +1,35 @@
+require 'logging'
+
+# Fixme - this should be in escort...
+# credit: Dylan Ratcliffe
+module PDQTest
+  module Logger
+    def self.logger
+      if ! $logger
+        # here we setup a color scheme called 'bright'
+        Logging.color_scheme('bright',
+          :lines => {
+            :debug => :blue,
+            :info  => :white,
+            :warn  => :yellow,
+            :error => :red,
+            :fatal => [:white, :on_red]
+          }
+        )
+
+        Logging.appenders.stdout(
+            'stdout',
+            :layout => Logging.layouts.pattern(
+                :pattern      => '%m\n',
+                :color_scheme => 'bright'
+            )
+        )
+
+        $logger = Logging.logger['Colors']
+        $logger.add_appenders 'stdout'
+        $logger.level = :info
+      end
+      $logger
+    end
+  end
+end

data/lib/pdqtest/pdk.rb

@@ -0,0 +1,98 @@
+require 'pdqtest/emoji'
+require 'pdqtest/puppet'
+require 'deep_merge'
+
+module PDQTest
+  # the main purpose of this is to add emoji after running a PDK lifecycle..
+  # There is basically no other way to do this mega-hack. while `pdk` itself is
+  # a kind of selective wrapper around ruby, I couldn't get calling `pdk` from
+  # inside `pdk bundle` to work, nor could I figure out how to load the PDK
+  # libraries from the "inside"
+  module Pdk
+    SYNC_YML    = '.sync.yaml'
+
+    # Copy these values from PDK generated metadata to module metadata
+    PDK_TAGS    = [
+      "pdk-version",
+      "template-url",
+      "template-ref",
+    ]
+
+    # Golden metadata key which proves PDK is already installed
+    PDK_VERSION_TAG = "pdk-version"
+
+    def self.run(subcommand)
+      if Util.is_windows
+        pdk = "powershell -command \"pdk #{subcommand}\" ; exit $LastExitCode"
+      else
+        pdk = "pdk #{subcommand}"
+      end
+
+      # write a .fixtures.yml for PDK test commands
+      if subcommand =~ /test/
+        PDQTest::Puppet.fixtures_yml
+      end
+
+      # on windows our environment is heavly contaminated by bundler - we have
+      # to remove it's environment or pdk command will flatout refuse to run
+      # probably doens't hurt to do this on linux too.
+      env = ENV.reject { |e|
+        [
+            "BUNDLER_ORIG_BUNDLER_ORIG_MANPATH",
+            "BUNDLER_ORIG_BUNDLER_VERSION",
+            "BUNDLER_ORIG_BUNDLE_BIN_PATH",
+            "BUNDLER_ORIG_BUNDLE_GEMFILE",
+            "BUNDLER_ORIG_GEM_HOME",
+            "BUNDLER_ORIG_GEM_PATH",
+            "BUNDLER_ORIG_MANPATH",
+            "BUNDLER_ORIG_PATH",
+            "BUNDLER_ORIG_RB_USER_INSTALL",
+            "BUNDLER_ORIG_RUBYLIB",
+            "BUNDLER_ORIG_RUBYOPT",
+            "BUNDLER_VERSION",
+            "BUNDLE_BIN_PATH",
+            "BUNDLE_GEMFILE",
+            "GEM_HOME",
+            "GEM_PATH",
+            "MANPATH",
+            "PROMPT",
+            "RUBYLIB",
+            "RUBYOPT",
+        ].include? e
+      }
+
+      status = system(env, pdk, :unsetenv_others=>true)
+
+      PDQTest::Emoji.partial_status(status, subcommand)
+      status
+    end
+
+    def self.enable_pdk(pdk_metadata)
+      if ! is_pdk_enabled
+        $logger.info("enabling PDK in metadata.json")
+        metadata = Puppet.module_metadata
+
+        PDK_TAGS.each do |pdk_tag|
+          metadata[pdk_tag] = pdk_metadata[pdk_tag]
+        end
+        PDQTest::Puppet.save_module_metadata(metadata)
+      end
+    end
+
+    def self.is_pdk_enabled
+      Puppet.module_metadata.include?(PDK_VERSION_TAG)
+    end
+
+    def self.amend_sync_yml(data)
+      if File.exist? SYNC_YML
+        sync = YAML.load_file(SYNC_YML)
+      else
+        sync = {}
+      end
+      sync.deep_merge!(data)
+      $logger.info("Updated .sync.yml with #{data}")
+
+      File.open(SYNC_YML, 'w') { |f| YAML.dump(sync, f) }
+    end
+  end
+end

data/lib/pdqtest/pdqtest1x.rb

@@ -0,0 +1,115 @@
+# Detection routines for PDQTest 1x files so that we can find and remove them
+# as part of any PDQTest 2x/PDK upgrade
+require 'digest/md5'
+
+module PDQTest
+  module PDQTest1x
+
+    # Urgh... I wish I'd put my own magic marker in these files... then I would
+    # have been able to find them easily(!)
+    # This is a list of known PDQTest integrations and their MD5 sums.
+    # Thankfully I didn't make _too many_ upgrades
+    PDQTEST_FILES = {
+        "Rakefile" => [
+          "3c65c0650e68771854036fbe67fb0f5d",
+          "0254db5d3fc38c67a2c160d7296a24f8"
+        ],
+        "spec/spec_helper.rb" => [
+          "8862eca30ed66bc71c1acc7a0da89305",
+          "0db89c9a486df193c0e40095422e19dc",
+        ],
+        ".rspec" => [
+          "c5f206a3f2387663a941cd9719e4bb00"
+        ]
+    }
+
+    # These plus the `pdqtest` gem are the _only_ gems that PDQTest 1x ever used
+    # If we only see these gems and our own, then we are almost certainly safe
+    # to replace the file with the PDK version
+    # List was extracted with some awk-foo
+    # https://gist.github.com/GeoffWilliams/21de190c5f6285b68f777885d92dba72
+    PDQTEST_RUBYGEMS = [
+      /gem 'CFPropertyList'/,
+      /gem 'facter', '>= 1.7.0'/,
+      /gem 'facter', '2.4.6'/,
+      /gem 'facter', '2.5.1'/,
+      /gem 'metadata-json-lint'/,
+      /gem 'puppet'/,
+      /gem 'puppetlabs_spec_helper', '>= 1.0.0'/,
+      /gem 'puppet-lint', '>= 1.0.0'/,
+      /gem 'puppet', puppetversion/,
+      /gem 'puppet-strings'/,
+      /gem 'rake', '~> 10.0'/,
+      /gem 'rspec', '~> 2.0'/,
+      /gem 'rspec-puppet'/,
+      /gem 'rspec-puppet-facts', '1.7.0'/,
+      /gem 'rubocop'/,
+      /gem 'rubocop', '0.47.1'/,
+      /gem 'rubocop', '0.50.0'/,
+    ]
+
+    PDQTEST_GEM = /^\s*gem 'pdqtest'/
+
+    # Did PDQTest ever manage this file?
+    def self.was_pdqtest_file(f)
+      [
+          ".rspec",
+          "Gemfile",
+          "Rakefile",
+          "spec/fixtures",
+      ].include? f
+    end
+
+    def self.is_pdqtest_file(f)
+      detected = false
+
+      if PDQTEST_FILES.include?(f)
+        if File.exist? f
+          # check for known PDQTest files spanning all versions
+          project_md5 = Digest::MD5.file(f).hexdigest
+          if PDQTEST_FILES[f].include?(project_md5)
+            $logger.debug("File at #{f} matches a known PDQTest 1x file")
+            detected = true
+          end
+        else
+          $logger.debug "Missing PDQTest file #{f}"
+          detected = false
+        end
+      elsif f == "Gemfile"
+        if File.exist? f
+          # to detect if PDQTest is the Gemfile, just look for the gem itself
+          if File.readlines(f).grep(PDQTEST_GEM).any?
+            # this project previously used PDQTest, now check to see if there
+            # are any unknown gems in the file
+            $logger.debug("Detected PDQTest 1.x in your Gemfile")
+            detected = true
+            project_gems = File.readlines(f).grep(/^\s*gem /)
+            project_gems.reject { |line|
+              line =~ PDQTEST_GEM
+            }.each { |project_gem|
+              found = false
+              PDQTEST_RUBYGEMS.each { |pdqtest_gem|
+                if project_gem =~ pdqtest_gem
+                  $logger.debug "known gem detected: #{project_gem.strip}"
+                  found = true
+                end
+              }
+              if ! found
+                $logger.error("unknown gem line in your Gemfile: '#{project_gem.strip}'")
+                detected = false
+              end
+            }
+          end
+        else
+          $logger.debug("missing Gemfile: #{f}")
+          detected = false
+        end
+      else
+        raise("File #{f} was never managed by PDQTest, why are you testing it?")
+      end
+
+      detected
+    end
+
+  end
+end