puppet 8.4.0-x64-mingw32 → 8.5.0-x64-mingw32

data/spec/unit/provider/package/sun_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:sun) do
-  let(:resource) { Puppet::Type.type(:package).new(:name => 'dummy', :ensure => :installed, :provider => :sun) }
-  let(:provider) { resource.provider }
-
-  describe 'provider features' do
-    it { is_expected.to be_installable }
-    it { is_expected.to be_uninstallable }
-    it { is_expected.to be_upgradeable }
-    it { is_expected.not_to be_versionable }
-  end
-
-  [:install, :uninstall, :latest, :query, :update].each do |method|
-    it "should have a #{method} method" do
-      expect(provider).to respond_to(method)
-    end
-  end
-
-  context '#install' do
-    it "should install a package" do
-      resource[:ensure] = :installed
-      resource[:source] = '/cdrom'
-      expect(provider).to receive(:pkgadd).with(['-d', '/cdrom', '-n', 'dummy'])
-      provider.install
-    end
-
-    it "should install a package if it is not present on update" do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_return(File.read(my_fixture('dummy.server')))
-      expect(provider).to receive(:pkgrm).with(['-n', 'dummy'])
-      expect(provider).to receive(:install)
-      provider.update
-    end
-
-     it "should install a package on global zone if -G specified" do
-      resource[:ensure] = :installed
-      resource[:source] = '/cdrom'
-      resource[:install_options] = '-G'
-      expect(provider).to receive(:pkgadd).with(['-d', '/cdrom', '-G', '-n', 'dummy'])
-      provider.install
-    end
-  end
-
-  context '#uninstall' do
-    it "should uninstall a package" do
-      expect(provider).to receive(:pkgrm).with(['-n','dummy'])
-      provider.uninstall
-    end
-  end
-
-  context '#update' do
-    it "should call uninstall if not :absent on info2hash" do
-      allow(provider).to receive(:info2hash).and_return({:name => 'SUNWdummy', :ensure => "11.11.0,REV=2010.10.12.04.23"})
-      expect(provider).to receive(:uninstall)
-      expect(provider).to receive(:install)
-      provider.update
-    end
-
-    it "should not call uninstall if :absent on info2hash" do
-      allow(provider).to receive(:info2hash).and_return({:name => 'SUNWdummy', :ensure => :absent})
-      expect(provider).to receive(:install)
-      provider.update
-    end
-  end
-
-  context '#query' do
-    it "should find the package on query" do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_return(File.read(my_fixture('dummy.server')))
-      expect(provider.query).to eq({
-        :name     => 'SUNWdummy',
-        :category=>"system",
-        :platform=>"i386",
-        :ensure   => "11.11.0,REV=2010.10.12.04.23",
-        :root=>"/",
-        :description=>"Dummy server (9.6.1-P3)",
-        :vendor => "Oracle Corporation",
-      })
-    end
-
-    it "shouldn't find the package on query if it is not present" do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_raise(Puppet::ExecutionFailure, "Execution of 'pkginfo -l dummy' returned 3: ERROR: information for \"dummy\" not found.")
-      expect(provider.query).to eq({:ensure => :absent})
-    end
-
-    it "unknown message should raise error." do
-      expect(provider).to receive(:pkginfo).with('-l', 'dummy').and_return('RANDOM')
-      expect { provider.query }.to raise_error Puppet::Error
-    end
-  end
-
-  context '#instance' do
-    it "should list instances when there are packages in the system" do
-      expect(described_class).to receive(:pkginfo).with('-l').and_return(File.read(my_fixture('simple')))
-      instances = provider.class.instances.map { |p| {:name => p.get(:name), :ensure => p.get(:ensure)} }
-      expect(instances.size).to eq(2)
-      expect(instances[0]).to eq({
-        :name     => 'SUNWdummy',
-        :ensure   => "11.11.0,REV=2010.10.12.04.23",
-      })
-      expect(instances[1]).to eq({
-        :name     => 'SUNWdummyc',
-        :ensure   => "11.11.0,REV=2010.10.12.04.24",
-      })
-    end
-
-    it "should return empty if there were no packages" do
-      expect(described_class).to receive(:pkginfo).with('-l').and_return('')
-      instances = provider.class.instances
-      expect(instances.size).to eq(0)
-    end
-  end
-end

data/spec/unit/provider/package/tdnf_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-# Note that much of the functionality of the tdnf provider is already tested with yum provider tests,
-# as yum is the parent provider, via dnf
-describe Puppet::Type.type(:package).provider(:tdnf) do
-  it_behaves_like 'RHEL package provider', described_class, 'tdnf'
-
-  context 'default' do
-    it 'should be the default provider on PhotonOS' do
-      allow(Facter).to receive(:value).with('os.family').and_return(:redhat)
-      allow(Facter).to receive(:value).with('os.name').and_return("PhotonOS")
-      expect(described_class).to be_default
-    end
-  end
-end

data/spec/unit/provider/package/up2date_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'up2date package provider' do
-  # This sets the class itself as the subject rather than
-  # an instance of the class.
-  subject do
-    Puppet::Type.type(:package).provider(:up2date)
-  end
-
-  osfamilies = [ 'redhat' ]
-  releases = [ '2.1', '3', '4' ]
-
-  osfamilies.each do |osfamily|
-    releases.each do |release|
-      it "should be the default provider on #{osfamily} #{release}" do
-        allow(Facter).to receive(:value).with('os.family').and_return(osfamily)
-        allow(Facter).to receive(:value).with('os.distro.release.full').and_return(release)
-        expect(subject.default?).to be_truthy
-      end
-    end
-  end
-end

data/spec/unit/provider/package/urpmi_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:urpmi) do
-  before do
-    %w[rpm urpmi urpme urpmq].each do |executable|
-      allow(Puppet::Util).to receive(:which).with(executable).and_return(executable)
-    end
-    allow(Puppet::Util::Execution).to receive(:execute)
-      .with(['rpm', '--version'], anything)
-      .and_return(Puppet::Util::Execution::ProcessOutput.new('RPM version 4.9.1.3', 0))
-  end
-
-  let(:resource) do
-    Puppet::Type.type(:package).new(:name => 'foopkg', :provider => :urpmi)
-  end
-
-  before do
-    subject.resource = resource
-    allow(Puppet::Type.type(:package)).to receive(:defaultprovider).and_return(described_class)
-  end
-
-  describe '#install' do
-    before do
-      allow(subject).to receive(:rpm).with('-q', 'foopkg', any_args).and_return("foopkg 0 1.2.3.4 5 noarch :DESC:\n")
-    end
-
-    describe 'without a version' do
-      it 'installs the unversioned package' do
-        resource[:ensure] = :present
-        expect(Puppet::Util::Execution).to receive(:execute).with(['urpmi', '--auto', 'foopkg'], anything)
-        subject.install
-      end
-    end
-
-    describe 'with a version' do
-      it 'installs the versioned package' do
-        resource[:ensure] = '4.5.6'
-        expect(Puppet::Util::Execution).to receive(:execute).with(['urpmi', '--auto', 'foopkg-4.5.6'], anything)
-        subject.install
-      end
-    end
-
-    describe "and the package install fails" do
-      it "raises an error" do
-        allow(Puppet::Util::Execution).to receive(:execute).with(['urpmi', '--auto', 'foopkg'], anything)
-        allow(subject).to receive(:query)
-        expect { subject.install }.to raise_error Puppet::Error, /Package \S+ was not present after trying to install it/
-      end
-    end
-  end
-
-  describe '#latest' do
-    let(:urpmq_output) { 'foopkg : Lorem ipsum dolor sit amet, consectetur adipisicing elit ( 7.8.9-1.mga2 )' }
-
-    it "uses urpmq to determine the latest package" do
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['urpmq', '-S', 'foopkg'], anything)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new(urpmq_output, 0))
-      expect(subject.latest).to eq('7.8.9-1.mga2')
-    end
-
-    it "falls back to the current version" do
-      resource[:ensure] = '5.4.3'
-      expect(Puppet::Util::Execution).to receive(:execute)
-        .with(['urpmq', '-S', 'foopkg'], anything)
-        .and_return(Puppet::Util::Execution::ProcessOutput.new('', 0))
-      expect(subject.latest).to eq('5.4.3')
-    end
-  end
-
-  describe '#update' do
-    it 'delegates to #install' do
-      expect(subject).to receive(:install)
-      subject.update
-    end
-  end
-
-  describe '#purge' do
-    it 'uses urpme to purge packages' do
-      expect(Puppet::Util::Execution).to receive(:execute).with(['urpme', '--auto', 'foopkg'], anything)
-      subject.purge
-    end
-  end
-end

data/spec/unit/provider/package/windows/exe_package_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-require 'puppet/provider/package/windows/exe_package'
-require 'puppet/provider/package/windows'
-
-describe Puppet::Provider::Package::Windows::ExePackage do
-  let (:name)        { 'Git version 1.7.11' }
-  let (:version)     { '1.7.11' }
-  let (:source)      { 'E:\Git-1.7.11.exe' }
-  let (:uninstall)   { '"C:\Program Files (x86)\Git\unins000.exe" /SP-' }
-
-  context '::from_registry' do
-    it 'should return an instance of ExePackage' do
-      expect(described_class).to receive(:valid?).and_return(true)
-
-      pkg = described_class.from_registry('', {'DisplayName' => name, 'DisplayVersion' => version, 'UninstallString' => uninstall})
-      expect(pkg.name).to eq(name)
-      expect(pkg.version).to eq(version)
-      expect(pkg.uninstall_string).to eq(uninstall)
-    end
-
-    it 'should return nil if it is not a valid executable' do
-      expect(described_class).to receive(:valid?).and_return(false)
-
-      expect(described_class.from_registry('', {})).to be_nil
-    end
-  end
-
-  context '::valid?' do
-    let(:name)   { 'myproduct' }
-    let(:values) do { 'DisplayName' => name, 'UninstallString' => uninstall } end
-
-    {
-      'DisplayName'      => ['My App', ''],
-      'UninstallString'  => ['E:\uninstall.exe', ''],
-      'WindowsInstaller' => [nil, 1],
-      'ParentKeyName'    => [nil, 'Uber Product'],
-      'Security Update'  => [nil, 'KB890830'],
-      'Update Rollup'    => [nil, 'Service Pack 42'],
-      'Hotfix'           => [nil, 'QFE 42']
-    }.each_pair do |k, arr|
-      it "should accept '#{k}' with value '#{arr[0]}'" do
-        values[k] = arr[0]
-        expect(described_class.valid?(name, values)).to be_truthy
-      end
-
-      it "should reject '#{k}' with value '#{arr[1]}'" do
-        values[k] = arr[1]
-        expect(described_class.valid?(name, values)).to be_falsey
-      end
-    end
-
-    it 'should reject packages whose name starts with "KBXXXXXX"' do
-      expect(described_class.valid?('KB890830', values)).to be_falsey
-    end
-
-    it 'should accept packages whose name does not start with "KBXXXXXX"' do
-      expect(described_class.valid?('My Update (KB890830)', values)).to be_truthy
-    end
-  end
-
-  context '#match?' do
-    let(:pkg) { described_class.new(name, version, uninstall) }
-
-    it 'should match product name' do
-      expect(pkg.match?({:name => name})).to be_truthy
-    end
-
-    it 'should return false otherwise' do
-      expect(pkg.match?({:name => 'not going to find it'})).to be_falsey
-    end
-  end
-
-  context '#install_command' do
-    it 'should install using the source' do
-      allow(Puppet::FileSystem).to receive(:exist?).with(source).and_return(true)
-      cmd = described_class.install_command({:source => source})
-
-      expect(cmd).to eq(source)
-    end
-
-    it 'should raise error when URI is invalid' do
-      web_source = 'https://www.t e s t.test/test.exe'
-
-      expect do
-        described_class.install_command({:source => web_source, :name => name})
-      end.to raise_error(Puppet::Error, /Error when installing #{name}:/)
-    end
-
-    it 'should download package from source file before installing', if: Puppet::Util::Platform.windows? do
-      web_source = 'https://www.test.test/test.exe'
-      stub_request(:get, web_source).to_return(status: 200, body: 'package binaries')
-      cmd = described_class.install_command({:source => web_source})
-      expect(File.read(cmd)).to eq('package binaries')
-    end
-  end
-
-  context '#uninstall_command' do
-    ['C:\uninstall.exe', 'C:\Program Files\uninstall.exe'].each do |exe|
-      it "should quote #{exe}" do
-        expect(described_class.new(name, version, exe).uninstall_command).to eq(
-          "\"#{exe}\""
-        )
-      end
-    end
-
-    ['"C:\Program Files\uninstall.exe"', '"C:\Program Files (x86)\Git\unins000.exe" /SILENT"'].each do |exe|
-      it "should not quote #{exe}" do
-        expect(described_class.new(name, version, exe).uninstall_command).to eq(
-          exe
-        )
-      end
-    end
-  end
-end

data/spec/unit/provider/package/windows/msi_package_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-require 'puppet/provider/package/windows/msi_package'
-
-describe Puppet::Provider::Package::Windows::MsiPackage do
-  let (:name)        { 'mysql-5.1.58-win-x64' }
-  let (:version)     { '5.1.58' }
-  let (:source)      { 'E:\mysql-5.1.58-win-x64.msi' }
-  let (:productcode) { '{E437FFB6-5C49-4DAC-ABAE-33FF065FE7CC}' }
-  let (:packagecode) { '{5A6FD560-763A-4BC1-9E03-B18DFFB7C72C}' }
-
-  def expect_installer
-    inst = double()
-    expect(inst).to receive(:ProductState).and_return(5)
-    expect(inst).to receive(:ProductInfo).with(productcode, 'PackageCode').and_return(packagecode)
-    expect(described_class).to receive(:installer).and_return(inst)
-  end
-
-  context '::installer', :if => Puppet::Util::Platform.windows? do
-    it 'should return an instance of the COM interface' do
-      expect(described_class.installer).not_to be_nil
-    end
-  end
-
-  context '::from_registry' do
-    it 'should return an instance of MsiPackage' do
-      expect(described_class).to receive(:valid?).and_return(true)
-      expect_installer
-
-      pkg = described_class.from_registry(productcode, {'DisplayName' => name, 'DisplayVersion' => version})
-      expect(pkg.name).to eq(name)
-      expect(pkg.version).to eq(version)
-      expect(pkg.productcode).to eq(productcode)
-      expect(pkg.packagecode).to eq(packagecode)
-    end
-
-    it 'should return nil if it is not a valid MSI' do
-      expect(described_class).to receive(:valid?).and_return(false)
-
-      expect(described_class.from_registry(productcode, {})).to be_nil
-    end
-  end
-
-  context '::valid?' do
-    let(:values) do { 'DisplayName' => name, 'DisplayVersion' => version, 'WindowsInstaller' => 1 } end
-
-    {
-      'DisplayName'      => ['My App', ''],
-      'WindowsInstaller' => [1, nil],
-    }.each_pair do |k, arr|
-      it "should accept '#{k}' with value '#{arr[0]}'" do
-        values[k] = arr[0]
-        expect(described_class.valid?(productcode, values)).to be_truthy
-      end
-
-      it "should reject '#{k}' with value '#{arr[1]}'" do
-        values[k] = arr[1]
-        expect(described_class.valid?(productcode, values)).to be_falsey
-      end
-    end
-
-    it 'should reject packages whose name is not a productcode' do
-     expect(described_class.valid?('AddressBook', values)).to be_falsey
-   end
-
-   it 'should accept packages whose name is a productcode' do
-     expect(described_class.valid?(productcode, values)).to be_truthy
-   end
-  end
-
-  context '#match?' do
-    it 'should match package codes case-insensitively' do
-      pkg = described_class.new(name, version, productcode, packagecode.upcase)
-
-      expect(pkg.match?({:name => packagecode.downcase})).to be_truthy
-    end
-
-    it 'should match product codes case-insensitively' do
-      pkg = described_class.new(name, version, productcode.upcase, packagecode)
-
-      expect(pkg.match?({:name => productcode.downcase})).to be_truthy
-    end
-
-    it 'should match product name' do
-      pkg = described_class.new(name, version, productcode, packagecode)
-
-      expect(pkg.match?({:name => name})).to be_truthy
-    end
-
-    it 'should return false otherwise' do
-      pkg = described_class.new(name, version, productcode, packagecode)
-
-      expect(pkg.match?({:name => 'not going to find it'})).to be_falsey
-    end
-  end
-
-  context '#install_command' do
-    it 'should install using the source' do
-      cmd = described_class.install_command({:source => source})
-
-      expect(cmd).to eq(['msiexec.exe', '/qn', '/norestart', '/i', source])
-    end
-  end
-
-  context '#uninstall_command' do
-    it 'should uninstall using the productcode' do
-      pkg = described_class.new(name, version, productcode, packagecode)
-
-      expect(pkg.uninstall_command).to eq(['msiexec.exe', '/qn', '/norestart', '/x', productcode])
-    end
-  end
-end

data/spec/unit/provider/package/windows/package_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-require 'puppet/provider/package/windows/package'
-
-describe Puppet::Provider::Package::Windows::Package do
-  let(:hklm) { 'HKEY_LOCAL_MACHINE' }
-  let(:hkcu) { 'HKEY_CURRENT_USER' }
-  let(:path) { 'Software\Microsoft\Windows\CurrentVersion\Uninstall' }
-  let(:key)  { double('key', :name => "#{hklm}\\#{path}\\Google") }
-  let(:package)  { double('package') }
-
-  context '::each' do
-    it 'should generate an empty enumeration' do
-      expect(described_class).to receive(:with_key)
-
-      expect(described_class.to_a).to be_empty
-    end
-
-    it 'should yield each package it finds' do
-      expect(described_class).to receive(:with_key).and_yield(key, {})
-
-      expect(Puppet::Provider::Package::Windows::MsiPackage).to receive(:from_registry).with('Google', {}).and_return(package)
-
-      yielded = nil
-      described_class.each do |pkg|
-        yielded = pkg
-      end
-
-      expect(yielded).to eq(package)
-    end
-  end
-
-  context '::with_key', :if => Puppet::Util::Platform.windows? do
-    it 'should search HKLM (64 & 32) and HKCU (64 & 32)' do
-      expect(described_class).to receive(:open).with(hklm, path, described_class::KEY64 | described_class::KEY_READ).ordered
-      expect(described_class).to receive(:open).with(hklm, path, described_class::KEY32 | described_class::KEY_READ).ordered
-      expect(described_class).to receive(:open).with(hkcu, path, described_class::KEY64 | described_class::KEY_READ).ordered
-      expect(described_class).to receive(:open).with(hkcu, path, described_class::KEY32 | described_class::KEY_READ).ordered
-
-      described_class.with_key { |key, values| }
-    end
-
-    it 'should ignore file not found exceptions' do
-      ex = Puppet::Util::Windows::Error.new('Failed to open registry key', Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND)
-
-      # make sure we don't stop after the first exception
-      expect(described_class).to receive(:open).exactly(4).times().and_raise(ex)
-
-      keys = []
-      described_class.with_key { |key, values| keys << key }
-      expect(keys).to be_empty
-    end
-
-    it 'should raise other types of exceptions' do
-      ex = Puppet::Util::Windows::Error.new('Failed to open registry key', Puppet::Util::Windows::Error::ERROR_ACCESS_DENIED)
-      expect(described_class).to receive(:open).and_raise(ex)
-
-      expect {
-        described_class.with_key{ |key, values| }
-      }.to raise_error do |error|
-        expect(error).to be_a(Puppet::Util::Windows::Error)
-        expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
-      end
-    end
-  end
-
-  context '::installer_class' do
-    it 'should require the source parameter' do
-      expect {
-        described_class.installer_class({})
-      }.to raise_error(Puppet::Error, /The source parameter is required when using the Windows provider./)
-    end
-
-    context 'MSI' do
-      let (:klass) { Puppet::Provider::Package::Windows::MsiPackage }
-
-      it 'should accept source ending in .msi' do
-        expect(described_class.installer_class({:source => 'foo.msi'})).to eq(klass)
-      end
-
-      it 'should accept quoted source ending in .msi' do
-        expect(described_class.installer_class({:source => '"foo.msi"'})).to eq(klass)
-      end
-
-      it 'should accept source case insensitively' do
-        expect(described_class.installer_class({:source => '"foo.MSI"'})).to eq(klass)
-      end
-
-      it 'should reject source containing msi in the name' do
-        expect {
-          described_class.installer_class({:source => 'mymsi.txt'})
-        }.to raise_error(Puppet::Error, /Don't know how to install 'mymsi.txt'/)
-      end
-    end
-
-    context 'Unknown' do
-      it 'should reject packages it does not know about' do
-        expect {
-          described_class.installer_class({:source => 'basram'})
-        }.to raise_error(Puppet::Error, /Don't know how to install 'basram'/)
-      end
-    end
-  end
-
-  context '::munge' do
-    it 'should shell quote strings with spaces and fix forward slashes' do
-      expect(described_class.munge('c:/windows/the thing')).to eq('"c:\windows\the thing"')
-    end
-    it 'should leave properly formatted paths alone' do
-      expect(described_class.munge('c:\windows\thething')).to eq('c:\windows\thething')
-    end
-  end
-
-  context '::replace_forward_slashes' do
-    it 'should replace forward with back slashes' do
-      expect(described_class.replace_forward_slashes('c:/windows/thing/stuff')).to eq('c:\windows\thing\stuff')
-    end
-  end
-
-  context '::quote' do
-    it 'should shell quote strings with spaces' do
-      expect(described_class.quote('foo bar')).to eq('"foo bar"')
-    end
-
-    it 'should shell quote strings with spaces and quotes' do
-      expect(described_class.quote('"foo bar" baz')).to eq('"\"foo bar\" baz"')
-    end
-
-    it 'should not shell quote strings without spaces' do
-      expect(described_class.quote('"foobar"')).to eq('"foobar"')
-    end
-  end
-
-  context '::get_display_name' do
-    it 'should return nil if values is nil' do
-      expect(described_class.get_display_name(nil)).to be_nil
-    end
-
-    it 'should return empty if values is empty' do
-      reg_values =  {}
-      expect(described_class.get_display_name(reg_values)).to eq('')
-    end
-
-    it 'should return DisplayName when available' do
-      reg_values =  { 'DisplayName' => 'Google' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google')
-    end
-
-    it 'should return DisplayName when available, even when QuietDisplayName is also available' do
-      reg_values =  { 'DisplayName' => 'Google', 'QuietDisplayName' => 'Google Quiet' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google')
-    end
-
-    it 'should return QuietDisplayName when available if DisplayName is empty' do
-      reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'Google Quiet' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google Quiet')
-    end
-
-    it 'should return QuietDisplayName when DisplayName is not available' do
-      reg_values =  { 'QuietDisplayName' =>'Google Quiet' }
-      expect(described_class.get_display_name(reg_values)).to eq('Google Quiet')
-    end
-
-    it 'should return empty when DisplayName is empty and QuietDisplay name is not available' do
-      reg_values =  { 'DisplayName' => '' }
-      expect(described_class.get_display_name(reg_values)).to eq('')
-    end
-
-    it 'should return empty when DisplayName is empty and QuietDisplay name is empty' do
-      reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'' }
-      expect(described_class.get_display_name(reg_values)).to eq('')
-    end
-  end
-
-  it 'should implement instance methods' do
-    pkg = described_class.new('orca', '5.0')
-
-    expect(pkg.name).to eq('orca')
-    expect(pkg.version).to eq('5.0')
-  end
-end