train 0.29.2 → 0.30.0

data/test/unit/platforms/detect/scanner_test.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'helper'
+require 'train/platforms/detect/scanner'
+require 'train/transports/mock'
+
+describe 'scanner' do
+  let(:backend) { Train::Transports::Mock::Connection.new }
+  let(:scanner) { Train::Platforms::Detect::Scanner.new(backend) }
+
+  describe 'scan family children' do
+    it 'return child' do
+      family = Train::Platforms.family('linux')
+      scanner.scan_family_children(family).name.must_equal('linux')
+      scanner.instance_variable_get(:@family_hierarchy).must_equal(['linux'])
+    end
+
+    it 'return nil' do
+      family = Train::Platforms.family('fake-fam')
+      scanner.scan_family_children(family).must_be_nil
+      scanner.instance_variable_get(:@family_hierarchy).must_be_empty
+    end
+  end
+
+  describe 'check condition' do
+    it 'return true equal' do
+      scanner.instance_variable_set(:@platform, { arch: 'x86_64' })
+      scanner.check_condition({ arch: '= x86_64' }).must_equal(true)
+    end
+
+    it 'return true greater then' do
+      scanner.instance_variable_set(:@platform, { release: '8.2' })
+      scanner.check_condition({ release: '>= 7' }).must_equal(true)
+    end
+
+    it 'return false greater then' do
+      scanner.instance_variable_set(:@platform, { release: '2.2' })
+      scanner.check_condition({ release: '> 7' }).must_equal(false)
+    end
+  end
+
+  describe 'get platform' do
+    it 'return empty platform' do
+      plat = Train::Platforms.name('linux')
+      plat = scanner.get_platform(plat)
+      plat.platform.must_equal({})
+      plat.backend.must_equal(backend)
+      plat.family_hierarchy.must_equal([])
+    end
+
+    it 'return full platform' do
+      scanner.instance_variable_set(:@platform, { family: 'linux' })
+      scanner.instance_variable_set(:@family_hierarchy, [ 'linux', 'unix' ])
+      plat = Train::Platforms.name('linux')
+      plat = scanner.get_platform(plat)
+      plat.platform.must_equal({ family: 'linux' })
+      plat.backend.must_equal(backend)
+      plat.family_hierarchy.must_equal([ 'linux', 'unix' ])
+    end
+  end
+end

data/test/unit/platforms/family_test.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'helper'
+
+describe 'platform family' do
+  def mock_family(x)
+    Train::Platforms.families[x] = nil if x == 'mock'
+    Train::Platforms.family(x)
+  end
+
+  it 'set family title' do
+    plat = mock_family('mock')
+    plat.title.must_equal('Mock Family')
+    plat.title('The Best Mock Family')
+    plat.title.must_equal('The Best Mock Family')
+  end
+
+  it 'set family in a family' do
+    plat = mock_family('family1')
+    plat.in_family('family2')
+    plat.families.keys[0].name.must_equal('family2')
+
+    plat = mock_family('family2')
+    plat.children.keys[0].name.must_equal('family1')
+  end
+
+  it 'set family in a family with condition' do
+    plat = Train::Platforms.family('family4', arch: '= x68_64').in_family('family5')
+    plat.families.keys[0].name.must_equal('family5')
+    plat.families.values[0].must_equal({ arch: '= x68_64' })
+  end
+end

data/test/unit/platforms/os_detect_test.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+require 'helper'
+require 'train/transports/mock'
+
+class OsDetectLinuxTester
+  include Train::Platforms::Detect::Helpers::OSCommon
+end
+
+describe 'os_detect' do
+  let(:detector) { OsDetectLinuxTester.new }
+
+  def scan_with_files(uname, files)
+    mock = Train::Transports::Mock::Connection.new
+    mock.mock_command('uname -s', uname)
+    mock.mock_command('uname -r', 'test-release')
+    files.each do |path, data|
+      mock.mock_command("test -f #{path}")
+      mock.mock_command("test -f #{path} && cat #{path}", data)
+    end
+    Train::Platforms::Detect.scan(mock)
+  end
+
+  ## Detect all linux distros
+  describe '/etc/enterprise-release' do
+    it 'sets the correct family/release for oracle' do
+      path = '/etc/enterprise-release'
+      platform = scan_with_files('linux', { path => 'release 7' })
+
+      platform[:name].must_equal('oracle')
+      platform[:family].must_equal('redhat')
+      platform[:release].must_equal('7')
+    end
+  end
+
+  describe '/etc/redhat-release' do
+    describe 'and /etc/os-release' do
+      it 'sets the correct family, name, and release on centos' do
+        files = {
+          '/etc/redhat-release' => "CentOS Linux release 7.2.1511 (Core) \n",
+          '/etc/os-release' => "NAME=\"CentOS Linux\"\nVERSION=\"7 (Core)\"\nID=\"centos\"\nID_LIKE=\"rhel fedora\"\n",
+        }
+        platform = scan_with_files('linux', files)
+        platform[:name].must_equal('centos')
+        platform[:family].must_equal('redhat')
+        platform[:release].must_equal('7.2.1511')
+      end
+    end
+  end
+
+  describe 'darwin' do
+    describe 'mac_os_x' do
+      it 'sets the correct family, name, and release on os_x' do
+        files = {
+          '/System/Library/CoreServices/SystemVersion.plist' => '<string>Mac OS X</string>',
+        }
+        platform = scan_with_files('darwin', files)
+        platform[:name].must_equal('mac_os_x')
+        platform[:family].must_equal('darwin')
+        platform[:release].must_equal('test-release')
+      end
+    end
+
+    describe 'generic darwin' do
+      it 'sets the correct family, name, and release on darwin' do
+        files = {
+          '/usr/bin/sw_vers' => "ProductVersion: 17.0.1\nBuildVersion: alpha.x1",
+        }
+        platform = scan_with_files('darwin', files)
+        platform[:name].must_equal('darwin')
+        platform[:family].must_equal('darwin')
+        platform[:release].must_equal('17.0.1')
+        platform[:build].must_equal('alpha.x1')
+      end
+    end
+  end
+
+  describe '/etc/debian_version' do
+    def debian_scan(id, version)
+      lsb_release = "DISTRIB_ID=#{id}\nDISTRIB_RELEASE=#{version}"
+      files = {
+        '/etc/lsb-release' => lsb_release,
+        '/etc/debian_version' => 'data',
+      }
+      scan_with_files('linux', files)
+    end
+
+    describe 'ubuntu' do
+      it 'sets the correct family/release for ubuntu' do
+        platform = debian_scan('ubuntu', '16.04')
+
+        platform[:name].must_equal('ubuntu')
+        platform[:family].must_equal('debian')
+        platform[:release].must_equal('16.04')
+      end
+    end
+
+    describe 'linuxmint' do
+      it 'sets the correct family/release for linuxmint' do
+        platform = debian_scan('linuxmint', '12')
+
+        platform[:name].must_equal('linuxmint')
+        platform[:family].must_equal('debian')
+        platform[:release].must_equal('12')
+      end
+    end
+
+    describe 'raspbian' do
+      it 'sets the correct family/release for raspbian ' do
+        files = {
+          '/usr/bin/raspi-config' => 'data',
+          '/etc/debian_version' => '13.6',
+        }
+        platform = scan_with_files('linux', files)
+
+        platform[:name].must_equal('raspbian')
+        platform[:family].must_equal('debian')
+        platform[:release].must_equal('13.6')
+      end
+    end
+
+    describe 'everything else' do
+      it 'sets the correct family/release for debian ' do
+        platform = debian_scan('some_debian', '12.99')
+
+        platform[:name].must_equal('debian')
+        platform[:family].must_equal('debian')
+        platform[:release].must_equal('12.99')
+      end
+    end
+  end
+
+  describe '/etc/coreos/update.conf' do
+    it 'sets the correct family/release for coreos' do
+      lsb_release = "DISTRIB_ID=Container Linux by CoreOS\nDISTRIB_RELEASE=27.9"
+      files = {
+        '/etc/lsb-release' => lsb_release,
+        '/etc/coreos/update.conf' => 'data',
+      }
+      platform = scan_with_files('linux', files)
+
+      platform[:name].must_equal('coreos')
+      platform[:family].must_equal('linux')
+      platform[:release].must_equal('27.9')
+    end
+  end
+
+  describe '/etc/os-release' do
+    describe 'when not on a wrlinux build' do
+      it 'fail back to genaric linux' do
+        os_release = "ID_LIKE=cisco-unkwown\nVERSION=unknown"
+        files = {
+          '/etc/os-release' => os_release,
+        }
+        platform = scan_with_files('linux', files)
+
+        platform[:name].must_equal('linux')
+        platform[:family].must_equal('linux')
+      end
+    end
+
+    describe 'when on a wrlinux build' do
+      it 'sets the correct family/release for wrlinux' do
+        os_release = "ID_LIKE=cisco-wrlinux\nVERSION=cisco123"
+        files = {
+          '/etc/os-release' => os_release,
+        }
+        platform = scan_with_files('linux', files)
+
+        platform[:name].must_equal('wrlinux')
+        platform[:family].must_equal('redhat')
+        platform[:release].must_equal('cisco123')
+      end
+    end
+  end
+end

data/test/unit/{extras/os_common_test.rb → platforms/platform_test.rb}

@@ -1,30 +1,102 @@
 # encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
 
 require 'helper'
-require 'train/extras'
 
-describe 'os common plugin' do
-  let(:cls) {
-    Class.new(Train::Extras::OSCommon) do
-      def detect_family; end
+describe 'platform' do
+  def mock_platform(x)
+    plat = Train::Platforms.name(x)
+    plat.family_hierarchy = mock_os_hierarchy(plat).flatten
+    plat.platform[:family] = plat.family_hierarchy[0]
+    plat.add_platform_methods
+    plat
+  end
+
+  def mock_platform_family(x)
+    Train::Platforms.list[x] = nil if x == 'mock'
+    plat = Train::Platforms.name(x).in_family(x)
+    plat.family_hierarchy = mock_os_hierarchy(plat).flatten
+    plat.platform[:family] = plat.family_hierarchy[0]
+    plat.add_platform_methods
+    plat
+  end
+
+  def mock_os_hierarchy(plat)
+    plat.families.each_with_object([]) do |(k, _v), memo|
+      memo << k.name
+      memo << mock_os_hierarchy(k) unless k.families.empty?
     end
-  }
+  end
 
-  def mock_platform(x)
-    cls.new(nil, { family: x })
+  it 'set platform title' do
+    plat = mock_platform_family('mock')
+    plat.title.must_equal('Mock')
+    plat.title('The Best Mock')
+    plat.title.must_equal('The Best Mock')
+  end
+
+  it 'set name and name override' do
+    plat = mock_platform_family('mock')
+    plat.name.must_equal('mock')
+    plat[:name].must_equal('mock')
+    plat.platform[:name] = 'mock2020'
+    plat.name.must_equal('mock2020')
+    plat[:name].must_equal('mock2020')
+  end
+
+  it 'check families' do
+    plat = mock_platform_family('mock')
+    plat.families.keys[0].name.must_equal('mock')
+  end
+
+  it 'check families with condition' do
+    Train::Platforms.list['mock'] = nil
+    plat = Train::Platforms.name('mock', arch: '= x86_64').in_family('linux')
+    plat.families.keys[0].name.must_equal('linux')
+    plat.families.values[0].must_equal({ arch: '= x86_64' })
+  end
+
+  it 'return direct families' do
+    plat = mock_platform_family('mock')
+    plat.in_family('mock2')
+    plat.in_family('mock3')
+    plat.direct_families.must_equal(["mock", "mock2", "mock3"])
+  end
+
+  it 'return to_hash' do
+    plat = mock_platform_family('mock')
+    plat.to_hash.must_equal({ family: "mock" })
+  end
+
+  it 'return unknown release' do
+    plat = mock_platform_family('mock')
+    plat[:release].must_equal('unknown')
+  end
+
+  it 'return name?' do
+    plat = Train::Platforms.name('windows_rc1')
+    defined?(plat.windows_rc1?).must_be_nil
+    plat.add_platform_methods
+    plat.windows_rc1?.must_equal(true)
+  end
+
+  it 'add platform methods' do
+    Train::Platforms.list['mock'] = nil
+    plat = Train::Platforms.name('mock').in_family('linux')
+    defined?(plat.linux?).must_be_nil
+    plat.family_hierarchy = mock_os_hierarchy(plat).flatten
+    plat.add_platform_methods
+    plat.linux?.must_equal(true)
   end
 
   it 'provides a method to access platform data' do
-    family = rand
-    os = mock_platform(family)
+    family = 'test-os'
+    os = mock_platform_family(family)
     os[:family].must_equal family
   end
 
   it 'provides an accessor for the full hash' do
-    x = rand.to_s
-    os = mock_platform(x)
+    x = 'test-os'
+    os = mock_platform_family(x)
     os.to_hash.must_equal({ family: x })
   end
 
@@ -68,7 +140,7 @@ describe 'os common plugin' do
   describe 'with platform set to amazon' do
     let(:os) { mock_platform('amazon') }
     it { os.fedora?.must_equal(false) }
-    it { os.redhat?.must_equal(false) }
+    it { os.redhat?.must_equal(true) }
     it { os.debian?.must_equal(false) }
     it { os.suse?.must_equal(false) }
     it { os.linux?.must_equal(true) }
@@ -278,10 +350,10 @@ describe 'os common plugin' do
   end
 
   describe 'with platform set to esx' do
-    let(:os) { mock_platform('esx') }
+    let(:os) { mock_platform('vmkernel') }
     it { os.solaris?.must_equal(false) }
     it { os.linux?.must_equal(false) }
-    it {os[:family].must_equal('esx')}
+    it { os[:family].must_equal('esx') }
     it { os.unix?.must_equal(false) }
     it { os.esx?.must_equal(true) }
   end
@@ -290,10 +362,23 @@ describe 'os common plugin' do
     let(:os) { mock_platform('darwin') }
     it { os.solaris?.must_equal(false) }
     it { os.linux?.must_equal(false) }
-    it {os[:family].must_equal('darwin')}
+    it { os[:family].must_equal('darwin') }
+    it { os.bsd?.must_equal(true) }
+    it { os.darwin?.must_equal(true) }
     it { os.unix?.must_equal(true) }
     it { os.bsd?.must_equal(true) }
     it { os.esx?.must_equal(false) }
   end
 
+  describe 'with platform set to mac_os_x' do
+    let(:os) { mock_platform('mac_os_x') }
+    it { os.solaris?.must_equal(false) }
+    it { os.linux?.must_equal(false) }
+    it { os[:family].must_equal('darwin') }
+    it { os.bsd?.must_equal(true) }
+    it { os.darwin?.must_equal(true) }
+    it { os.unix?.must_equal(true) }
+    it { os.bsd?.must_equal(true) }
+    it { os.esx?.must_equal(false) }
+  end
 end

data/test/unit/platforms/platforms_test.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'helper'
+
+describe 'platforms' do
+
+  it 'create platform' do
+    Train::Platforms.list['mock'] = nil
+    plat = Train::Platforms.name('mock')
+    Train::Platforms.name('mock').in_family('test')
+    Train::Platforms.name('mock').detect { true }
+    plat.title.must_equal('Mock')
+    plat.detect.call.must_equal(true)
+    plat.families.keys[0].name.must_equal('test')
+  end
+
+  it 'create family' do
+    Train::Platforms.families['mock'] = nil
+    fam = Train::Platforms.family('mock')
+    Train::Platforms.family('mock').in_family('test')
+    Train::Platforms.family('mock').detect { true }
+    fam.title.must_equal('Mock Family')
+    fam.detect.call.must_equal(true)
+    fam.families.keys[0].name.must_equal('test')
+  end
+
+  it 'return top platforms empty' do
+    Train::Platforms.stubs(:list).returns({})
+    Train::Platforms.stubs(:families).returns({})
+    top = Train::Platforms.top_platforms
+    top.count.must_equal(0)
+  end
+
+  it 'return top platforms with data' do
+    plat = Train::Platforms.name('linux')
+    plat.stubs(:families).returns({})
+    Train::Platforms.stubs(:list).returns({ 'linux' => plat })
+    Train::Platforms.stubs(:families).returns({})
+    top = Train::Platforms.top_platforms
+    top.count.must_equal(1)
+  end
+end