cfacter 3.11.0.rc.20180314

data/ext/facter/facter/acceptance/bin/ci-bootstrap-from-artifacts.sh

@@ -0,0 +1,55 @@
+#! /usr/bin/env bash
+
+###############################################################################
+# Initial preparation for a ci acceptance job in Jenkins.  Crucially, it
+# handles the untarring of the build artifact and bundle install, getting us to
+# a state where we can then bundle exec rake the particular ci:test we want to
+# run.
+#
+# Having this checked in in a script makes it much easier to have multiple
+# acceptance jobs.  It must be kept agnostic between Linux/Solaris/Windows
+# builds, however.
+
+set -x
+
+# If $GEM_SOURCE is not set, fall back to rubygems.org
+if [ -z $GEM_SOURCE ]; then
+  export GEM_SOURCE='https://rubygems.org'
+fi
+
+echo "SHA: ${SHA}"
+echo "FORK: ${FORK}"
+echo "BUILD_SELECTOR: ${BUILD_SELECTOR}"
+echo "PACKAGE_BUILD_STATUS: ${PACKAGE_BUILD_STATUS}"
+
+rm -rf acceptance
+tar -xzf acceptance-artifacts.tar.gz
+cd acceptance
+
+mkdir -p log/latest
+
+echo "===== This artifact is from ====="
+cat creator.txt
+
+bundle install --without=development --path=.bundle/gems
+
+if [[ "${platform}" =~ 'solaris' ]]; then
+  repo_proxy="  :repo_proxy => false,"
+fi
+
+# If the platform is Windows, append $ruby_arch
+if [[ "${platform}" =~ 'win' ]]; then
+    platform="${platform}-${ruby_arch}"
+fi
+
+cat > local_options.rb <<-EOF
+{
+  :hosts_file => 'config/nodes/${platform}.yaml',
+  :ssh => {
+    :keys => ["${HOME}/.ssh/id_rsa-acceptance"],
+  },
+${repo_proxy}
+}
+EOF
+
+[[ (-z "${PACKAGE_BUILD_STATUS}") || ("${PACKAGE_BUILD_STATUS}" = "success") ]] || exit 1

data/ext/facter/facter/acceptance/config/aio/options.rb

@@ -0,0 +1,9 @@
+{
+  :type => 'aio',
+  :pre_suite => [
+    'setup/common/pre-suite/000-delete-puppet-when-none.rb',
+    'setup/aio/pre-suite/010_Install.rb',
+    'setup/aio/pre-suite/021_InstallAristaModule.rb',
+    'setup/aio/pre-suite/022_Remove_LD_PRELOAD.rb',
+  ],
+}

data/ext/facter/facter/acceptance/config/git/options.rb

@@ -0,0 +1,7 @@
+{
+  :pre_suite => [
+    'setup/common/pre-suite/000-delete-puppet-when-none.rb',
+    'setup/common/00_EnvSetup.rb',
+    'setup/git/pre-suite/01_TestSetup.rb',
+  ],
+}

data/ext/facter/facter/acceptance/config/nodes/aix-53-power.yaml

@@ -0,0 +1,7 @@
+---
+HOSTS:
+  pe-aix-53-acceptance:
+    roles:
+      - agent
+    platform: aix-5.3-power
+    hypervisor: none

data/ext/facter/facter/acceptance/config/nodes/aix-61-power.yaml

@@ -0,0 +1,7 @@
+---
+HOSTS:
+  pe-aix-61-acceptance:
+    roles:
+      - agent
+    platform: aix-6.1-power
+    hypervisor: none

data/ext/facter/facter/acceptance/config/nodes/aix-71-power.yaml

@@ -0,0 +1,7 @@
+---
+HOSTS:
+  pe-aix-71-acceptance:
+    roles:
+      - agent
+    platform: aix-7.1-power
+    hypervisor: none

data/ext/facter/facter/acceptance/config/nodes/huaweios-6-powerpc.yaml

@@ -0,0 +1,7 @@
+---
+HOSTS:
+  huawei-ce6850-2-debian-vm-eth0.ops.puppetlabs.net:
+    roles:
+      - agent
+    platform: huaweios-6-powerpc
+    hypervisor: none

data/ext/facter/facter/acceptance/config/nodes/solaris-10-sparc.yaml

@@ -0,0 +1,9 @@
+---
+HOSTS:
+  solaris-10-sparc:
+    roles:
+      - agent
+    platform: solaris-10-sparc
+    hypervisor: none
+    ip: 10.32.121.124
+    vmhostname: sol10-1.delivery.puppetlabs.net

data/ext/facter/facter/acceptance/config/nodes/solaris-11-sparc.yaml

@@ -0,0 +1,9 @@
+---
+HOSTS:
+  solaris-11-sparc:
+    roles:
+      - agent
+    platform: solaris-11-sparc
+    hypervisor: none
+    ip: 10.32.114.245
+    vmhostname: sol11-1.delivery.puppetlabs.net

data/ext/facter/facter/acceptance/lib/facter/acceptance/base_fact_utils.rb

@@ -0,0 +1,563 @@
+module Facter
+  module Acceptance
+    module BaseFactUtils
+
+      # return a hash of expected facts for os, processors, and kernel facts
+      #
+      def os_processors_and_kernel_expected_facts(agent)
+        if agent['platform'] =~ /aix-/
+          aix_expected_facts(agent)
+        elsif agent['platform'] =~ /cisco/
+          cisco_expected_facts(agent)
+        elsif agent['platform'] =~ /cumulus-/
+          cumulus_expected_facts(agent)
+        elsif agent['platform'] =~ /debian-/
+          debian_expected_facts(agent)
+        elsif agent['platform'] =~ /el-|centos-/
+          el_expected_facts(agent)
+        elsif agent['platform'] =~ /eos-/ # arista
+          eos_expected_facts(agent)
+        elsif agent['platform'] =~ /fedora-/
+          fedora_expected_facts(agent)
+        elsif agent['platform'] =~ /huaweios-/
+          huawei_expected_facts(agent)
+        elsif agent['platform'] =~ /osx-/
+          osx_expected_facts(agent)
+        elsif agent['platform'] =~ /sles-/
+          sles_expected_facts(agent)
+        elsif agent['platform'] =~ /solaris-/
+          solaris_expected_facts(agent)
+        elsif agent['platform'] =~ /ubuntu-/
+          ubuntu_expected_facts(agent)
+        elsif agent['platform'] =~ /windows-/
+          windows_expected_facts(agent)
+        else
+          fail_test("unknown agent type being tested #{agent['platform']}")
+        end
+      end
+
+      # return the value from the facter json parsed set of results using the fact path separated using '.'s
+      #
+      def json_result_fact_by_key_path(results, fact)
+        fact.split('.').each do |key|
+          results = results[key]
+        end
+        results
+      end
+
+      # AIX
+      def aix_expected_facts(agent)
+        version = agent['platform'].match(/aix-(\d)\.(\d)/)
+        if version.nil?
+          kernel_major_version = /\d\d00/
+        else
+          kernel_major_version = /#{version[1]}#{version[2]}00/
+        end
+        kernel_release = /^#{kernel_major_version}-\d+-\d+-\d+/
+        os_arch        = /[Pp]ower[Pp][Cc]/
+        os_hardware    = /IBM/
+
+        expected_facts = {
+            'os.architecture'   => os_arch,
+            'os.family'         => 'AIX',
+            'os.hardware'       => os_hardware,
+            'os.name'           => 'AIX',
+            'os.release.full'   => kernel_release,
+            'os.release.major'  => kernel_major_version,
+            'processors.count'  => /[1-9]+/,
+            'processors.isa'    => os_arch,
+            'processors.models' => os_arch,
+            'kernel'            => 'AIX',
+            'kernelrelease'     => kernel_release,
+            'kernelversion'     => kernel_major_version,
+            'kernelmajversion'  => kernel_major_version
+        }
+        expected_facts
+      end
+
+      # Cisco
+      def cisco_expected_facts(agent)
+        os_arch                 = 'x86_64'
+        os_hardware             = 'x86_64'
+        processor_model_pattern = 'Westmere'
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.family'                => 'cisco-wrlinux',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => /ios_xr|nexus/,
+            'os.release.full'          => /\d+\.\d+(\.\d+)?/,
+            'os.release.major'         => /\d+/,
+            'os.release.minor'         => /\d+/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => /unknown|#{os_hardware}/,
+            'processors.models'        => /#{processor_model_pattern}/,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # Cumulus
+      def cumulus_expected_facts(agent)
+        os_version       = /\d+\.\d+/
+        os_release_major = /\d+/
+        os_release_minor = /\d+/
+        os_arch          = 'x86_64'
+        os_hardware      = 'x86_64'
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.distro.codename'       => /\w+/,
+            'os.distro.description'    => /#{os_version}\.\d+-/,
+            'os.distro.id'             => 'Cumulus Linux',
+            'os.distro.release.full'   => /#{os_version}\.\d+/,
+            'os.distro.release.major'  => os_release_major,
+            'os.distro.release.minor'  => os_release_minor,
+            'os.family'                => 'Debian',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'CumulusLinux',
+            'os.release.full'          => /#{os_version}\.\d+/,
+            'os.release.major'         => os_release_major,
+            'os.release.minor'         => os_release_minor,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => /unknown|#{os_hardware}/,
+            'processors.models'        => /(Intel\(R\).*)|(AMD.*)/,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # Debian
+      def debian_expected_facts(agent)
+        version = agent['platform'].match(/debian-(\d)/)
+        if version.nil?
+          os_version = /\d+/
+        else
+          os_version = /#{version[1]}/
+        end
+        if agent['platform'] =~ /amd64/
+          os_arch     = 'amd64'
+          os_hardware = 'x86_64'
+        else
+          os_arch     = 'i386'
+          os_hardware = 'i686'
+        end
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.distro.codename'       => /\w+/,
+            'os.distro.description'    => /Debian GNU\/Linux #{os_version}\.\d/,
+            'os.distro.id'             => 'Debian',
+            'os.distro.release.full'   => /#{os_version}\.\d+/,
+            'os.distro.release.major'  => os_version,
+            'os.distro.release.minor'  => /\d/,
+            'os.family'                => 'Debian',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'Debian',
+            'os.release.full'          => /#{os_version}\.\d+/,
+            'os.release.major'         => os_version,
+            'os.release.minor'         => /\d/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => /unknown|#{os_hardware}/,
+            'processors.models'        => /(Intel\(R\).*)|(AMD.*)/,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # el (RedHat, Centos)
+      def el_expected_facts(agent)
+        version = agent['platform'].match(/(el|centos)-(\d)/)
+        if version.nil?
+          os_version = /\d+/
+        else
+          os_version = /#{version[2]}/
+        end
+        release_string = on(agent, 'cat /etc/*-release').stdout.downcase
+        case release_string
+          when /amazon/
+            os_name = 'Amazon'
+            # This parses: VERSION_ID="2017.09"
+            os_version = on(agent, 'grep VERSION_ID /etc/os-release | cut --delimiter=\" --fields=2 | cut --delimiter=. --fields=1').stdout.chomp
+          when /centos/
+            os_name = 'CentOS'
+          when /oracle/
+            os_name = 'OracleLinux'
+          when /scientific/
+            os_name = 'Scientific'
+          else
+            os_name = 'RedHat'
+        end
+        if agent['platform'] =~ /x86_64/
+          os_arch                 = 'x86_64'
+          os_hardware             = 'x86_64'
+          processor_model_pattern = /(Intel\(R\).*)|(AMD.*)/
+        elsif agent['platform'] =~ /ppc|power|64le/
+          os_arch                 = 'ppc64le'
+          os_hardware             = 'ppc64le'
+          processor_model_pattern = // # facter doesn't figure out the processor type on these machines
+        elsif agent['platform'] =~ /s390x/
+          os_arch                 = 's390x'
+          os_hardware             = 's390x'
+          processor_model_pattern = // # s390x does not populate a model value in /proc/cpuinfo
+        elsif agent['platform'] =~ /aarch64/
+          os_arch                 = 'aarch64'
+          os_hardware             = 'aarch64'
+          processor_model_pattern = // # aarch64 does not populate a model value in /proc/cpuinfo
+        else
+          os_arch                 = 'i386'
+          os_hardware             = 'i686'
+          processor_model_pattern = /(Intel\(R\).*)|(AMD.*)/
+        end
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.family'                => 'RedHat',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => os_name,
+            'os.release.full'          => /#{os_version}\.\d+(\.\d+)?/,
+            'os.release.major'         => os_version,
+            'os.release.minor'         => /\d+/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => os_hardware,
+            'processors.models'        => processor_model_pattern,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # eos Arista
+      def eos_expected_facts(agent)
+        version = agent['platform'].match(/eos-(\d+)-/)
+        if version.nil?
+          os_version = /\d+/
+        else
+          os_version = /#{version[1]}/
+        end
+        os_arch                 = 'x86_64'
+        os_hardware             = 'x86_64'
+        processor_model_pattern = 'Intel\(R\)'
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.family'                => 'Linux',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'AristaEOS',
+            'os.release.full'          => /#{os_version}\.\d+(\.\dF)?/,
+            'os.release.major'         => os_version,
+            'os.release.minor'         => /\d+/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => os_hardware,
+            'processors.models'        => /#{processor_model_pattern}/,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # fedora
+      def fedora_expected_facts(agent)
+        version = agent['platform'].match(/fedora-(\d\d)-/)
+        if version.nil?
+          os_version = /\d+/
+        else
+          os_version = /#{version[1]}/
+        end
+        if agent['platform'] =~ /x86_64/
+          os_arch     = 'x86_64'
+          os_hardware = 'x86_64'
+        else
+          os_arch     = 'i386'
+          os_hardware = 'i686'
+        end
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.family'                => 'RedHat',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'Fedora',
+            'os.release.full'          => os_version,
+            'os.release.major'         => os_version,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => os_hardware,
+            'processors.models'        => /(Intel\(R\).*)|(AMD.*)/,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # huawei
+      def huawei_expected_facts(agent)
+        os_version       = /\d+\.\d+/
+        os_version_major = /\d+/
+        os_version_minor = /\d+/
+        os_arch          = 'ppc'
+        os_hardware      = 'ppc'
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.family'                => 'Debian',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'Debian',
+            'os.release.full'          => os_version,
+            'os.release.major'         => os_version_major,
+            'os.release.minor'         => os_version_minor,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => 'unknown',
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # osx
+      def osx_expected_facts(agent)
+        version = agent['platform'].match(/osx-(10\.\d+)/)
+        if version.nil?
+          os_version = /\d+\.\d+/
+        else
+          os_version = /#{version[1]}/
+        end
+
+        expected_facts = {
+            'os.architecture'          => 'x86_64',
+            'os.family'                => 'Darwin',
+            'os.hardware'              => 'x86_64',
+            'os.name'                  => 'Darwin',
+            'os.macosx.build'          => /\d+[A-Z]\d{2,4}\w?/,
+            'os.macosx.product'        => 'Mac OS X',
+            'os.macosx.version.full'   => /#{os_version}\.\d+/,
+            'os.macosx.version.major'  => os_version,
+            'os.macosx.version.minor'  => /\d+/,
+            'os.release.full'          => /\d+\.\d+\.\d+/,
+            'os.release.major'         => /\d+/,
+            'os.release.minor'         => /\d+/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => 'i386',
+            'processors.models'        => /"Intel\(R\).*"/,
+            'kernel'                   => 'Darwin',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # SLES
+      def sles_expected_facts(agent)
+        version = agent['platform'].match(/sles-(\d\d)/)
+        if version.nil?
+          os_version = /\d+/
+        else
+          os_version = /#{version[1]}/
+        end
+        if agent['platform'] =~ /x86_64/
+          os_arch                 = 'x86_64'
+          os_hardware             = 'x86_64'
+          processor_model_pattern = /(Intel\(R\).*)|(AMD.*)/
+        elsif agent['platform'] =~ /ppc|power|64le/
+          os_arch                 = 'ppc64le'
+          os_hardware             = 'ppc64le'
+          processor_model_pattern = // # facter doesn't figure out the processor type on these machines
+        elsif agent['platform'] =~ /s390x/
+          os_arch                 = 's390x'
+          os_hardware             = 's390x'
+          processor_model_pattern = // # s390x does not populate a model value in /proc/cpuinfo
+        else
+          os_arch                 = 'i386'
+          os_hardware             = 'i686'
+          processor_model_pattern = /(Intel\(R\).*)|(AMD.*)/
+        end
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.family'                => 'Suse',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'SLES',
+            'os.release.full'          => /#{os_version}\.\d+(\.\d+)?/,
+            'os.release.major'         => os_version,
+            'os.release.minor'         => /\d+/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => os_hardware,
+            'processors.models'        => processor_model_pattern,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # Solaris
+      def solaris_expected_facts(agent)
+        version = agent['platform'].match(/solaris-(\d\d)/)
+        if version.nil?
+          os_version = /\d+/
+        else
+          os_version = /#{version[1]}/
+        end
+        case agent[:platform]
+          when /solaris-10/
+            os_release_full = /#{os_version}_u\d+/
+            os_kernel       = /Generic_\d+-\d+/
+            os_kernel_major = os_kernel
+          when /solaris-11/
+            os_release_full = /#{os_version}\.\d+/
+            os_kernel       = os_release_full
+            os_kernel_major = os_version
+          else
+            fail_test("Unknown Solaris version #{agent['platform']}")
+        end
+        case agent[:platform]
+          when /sparc/
+            os_architecture = 'sun4v'
+            proc_models     = /.*SPARC.*/
+            proc_isa        = /sparc/
+          else
+            os_architecture = 'i86pc'
+            proc_models     = /(Intel.*)|(AMD.*)/
+            proc_isa        = /i386/
+        end
+
+        expected_facts = {
+            'os.architecture'          => os_architecture,
+            'os.family'                => 'Solaris',
+            'os.hardware'              => os_architecture,
+            'os.name'                  => 'Solaris',
+            'os.release.full'          => os_release_full,
+            'os.release.major'         => os_version,
+            'os.release.minor'         => /\d+/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => proc_isa,
+            'processors.models'        => proc_models,
+            'kernel'                   => 'SunOS',
+            'kernelrelease'            => /5\.#{os_version}/,
+            'kernelversion'            => os_kernel,
+            'kernelmajversion'         => os_kernel_major
+        }
+        expected_facts
+      end
+
+      # Ubuntu
+      def ubuntu_expected_facts(agent)
+        version = agent['platform'].match(/ubuntu-(\d\d\.\d\d)/)
+        if version.nil?
+          os_version = /\d+\.\d+/
+        else
+          os_version = /#{version[1]}/
+        end
+        if agent['platform'] =~ /x86_64|amd64/
+          os_arch     = 'amd64'
+          os_hardware = 'x86_64'
+          processor_model_pattern = /(Intel\(R\).*)|(AMD.*)/
+        elsif agent['platform'] =~ /ppc|power|64le/
+          os_arch                 = 'ppc64le'
+          os_hardware             = 'ppc64le'
+          processor_model_pattern = // # facter doesn't figure out the processor type on these machines
+        else
+          os_arch     = 'i386'
+          os_hardware = 'i686'
+          processor_model_pattern = /(Intel\(R\).*)|(AMD.*)/
+        end
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.distro.codename'       => /\w+/,
+            'os.distro.description'    => /Ubuntu #{os_version}/,
+            'os.distro.id'             => 'Ubuntu',
+            'os.distro.release.full'   => os_version,
+            'os.distro.release.major'  => os_version,
+            'os.family'                => 'Debian',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'Ubuntu',
+            'os.release.full'          => os_version,
+            'os.release.major'         => os_version,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => os_hardware,
+            'processors.models'        => processor_model_pattern,
+            'kernel'                   => 'Linux',
+            'kernelrelease'            => /\d+\.\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+
+      # Windows
+      def windows_expected_facts(agent)
+        # Get expected values based on platform name
+        if agent['platform'] =~ /windows-7/
+          os_version = '7'
+        elsif agent['platform'] =~ /windows-8.1/
+          os_version = '8.1'
+        elsif agent['platform'] =~ /2008/
+          os_version = '2008 R2'
+        elsif agent['platform'] =~ /2012/
+          os_version = '2012 R2'
+        elsif agent['platform'] =~ /-10/
+          os_version = '10'
+        elsif agent['platform'] =~ /2016/
+          os_version = '2016'
+        else
+          fail_test "Unknown Windows version #{agent['platform']}"
+        end
+        if agent['platform'] =~ /64/
+          os_arch     = 'x64'
+          os_hardware = 'x86_64'
+        else
+          os_arch     = 'x86'
+          os_hardware = 'i686'
+        end
+
+        expected_facts = {
+            'os.architecture'          => os_arch,
+            'os.family'                => 'windows',
+            'os.hardware'              => os_hardware,
+            'os.name'                  => 'windows',
+            'os.release.full'          => os_version,
+            'os.release.major'         => os_version,
+            'os.windows.system32'      => /C:\\(WINDOWS|Windows)\\(system32|sysnative)/,
+            'processors.count'         => /[1-9]/,
+            'processors.physicalcount' => /[1-9]/,
+            'processors.isa'           => /x86|x64/,
+            'processors.models'        => /(Intel\(R\).*)|(AMD.*)/,
+            'kernel'                   => 'windows',
+            'kernelrelease'            => /\d+\.\d+/,
+            'kernelversion'            => /\d+\.\d+/,
+            'kernelmajversion'         => /\d+\.\d+/
+        }
+        expected_facts
+      end
+    end
+  end
+end