train 1.4.25 → 1.4.29

data/test/integration/tests/path_pipe_test.rb

@@ -18,11 +18,6 @@ describe 'file interface' do
       file.type.must_equal(:pipe)
     end
 
-    # # TODO add back content
-    # it 'has no content' do
-    #   file.content.must_be_nil
-    # end
-
     it 'has owner name root' do
       file.owner.must_equal('root')
     end
@@ -43,16 +38,6 @@ describe 'file interface' do
       file.link_path.must_be_nil
     end
 
-    # # TODO add back content
-    # it 'has no md5sum' do
-    #   file.md5sum.must_be_nil
-    # end
-    #
-    # # TODO add back content
-    # it 'has no sha256sum' do
-    #   file.sha256sum.must_be_nil
-    # end
-
     it 'has a modified time' do
       file.mtime.must_be_close_to(Time.now.to_i - Test.mtime/2, Test.mtime)
     end

data/test/unit/file/local/unix_test.rb

@@ -143,4 +143,82 @@ describe Train::File::Local::Unix do
       file_tester.unix_mode_mask('all', 'r').must_equal 0444
     end
   end
-end
+
+  describe '#md5sum' do
+    let(:md5_checksum) { '57d4c6f9d15313fd5651317e588c035d' }
+
+    let(:ruby_md5_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(md5_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('md5sum /tmp/testfile', '', '', 1)
+      Digest::MD5.expects(:new).returns(ruby_md5_mock)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `linux` platform family' do
+      output = "#{md5_checksum} /tmp/testfile"
+      backend.mock_command('md5sum /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `darwin` platform family' do
+      output = "#{md5_checksum} /tmp/testfile"
+      backend.mock_os(family: 'darwin')
+      backend.mock_command('md5 -r /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `solaris` platform family' do
+      # The `digest` command doesn't output the filename by default
+      output = "#{md5_checksum}"
+      backend.mock_os(family: 'solaris')
+      backend.mock_command('digest -a md5 /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+  end
+
+  describe '#sha256sum' do
+    let(:sha256_checksum) {
+      '491260aaa6638d4a64c714a17828c3d82bad6ca600c9149b3b3350e91bcd283d'
+    }
+
+    let(:ruby_sha256_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('sha256sum /tmp/testfile', '', '', 1)
+      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `linux` platform family' do
+      output = "#{sha256_checksum} /tmp/testfile"
+      backend.mock_command('sha256sum /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `darwin` platform family' do
+      output = "#{sha256_checksum} /tmp/testfile"
+      backend.mock_os(family: 'darwin')
+      backend.mock_command('shasum -a 256 /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `solaris` platform family' do
+      # The `digest` command doesn't output the filename by default
+      output = "#{sha256_checksum}"
+      backend.mock_os(family: 'solaris')
+      backend.mock_command('digest -a sha256 /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+  end
+end

data/test/unit/file/local/windows_test.rb

@@ -38,4 +38,64 @@ describe 'file common' do
     backend.mock_command('Get-Acl "path" | select -expand Owner', out)
     cls.new(backend, 'path').owner.must_equal out
   end
+
+  describe '#md5sum' do
+    let(:md5_checksum) { '4ce0c733cdcf1d2f78532bbd9ce3441d' }
+    let(:filepath) { 'C:\Windows\explorer.exe' }
+
+    let(:ruby_md5_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(md5_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command("CertUtil -hashfile #{filepath} MD5", '', '', 1)
+      Digest::MD5.expects(:new).returns(ruby_md5_mock)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `windows` platform family' do
+      output = <<-EOC
+        MD5 hash of file C:\\Windows\\explorer.exe:\r
+        4c e0 c7 33 cd cf 1d 2f 78 53 2b bd 9c e3 44 1d\r
+        CertUtil: -hashfile command completed successfully.\r
+      EOC
+
+      backend.mock_command("CertUtil -hashfile #{filepath} MD5", output)
+      cls.new(backend, filepath).md5sum.must_equal md5_checksum
+    end
+  end
+
+  describe '#sha256sum' do
+    let(:sha256_checksum) {
+      '85270240a5fd51934f0627c92b2282749d071fdc9ac351b81039ced5b10f798b'
+    }
+    let(:filepath) { 'C:\Windows\explorer.exe' }
+
+    let(:ruby_sha256_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('CertUtil -hashfile #{filepath} SHA256', '', '', 1)
+      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `windows` platform family' do
+      output = <<-EOC
+        SHA256 hash of file C:\\Windows\\explorer.exe:\r
+        85 27 02 40 a5 fd 51 93 4f 06 27 c9 2b 22 82 74 9d 07 1f dc 9a c3 51 b8 10 39 ce d5 b1 0f 79 8b\r
+        CertUtil: -hashfile command completed successfully.\r
+      EOC
+
+      backend.mock_command("CertUtil -hashfile #{filepath} SHA256", output)
+      cls.new(backend, filepath).sha256sum.must_equal sha256_checksum
+    end
+  end
 end

data/test/unit/file/remote/aix_test.rb

@@ -30,4 +30,52 @@ describe Train::File::Remote::Aix do
     backend.mock_command("perl -e 'print readlink shift' path", 'our_link_path')
     file.link_path.must_equal 'our_link_path'
   end
+
+  describe '#md5sum' do
+    let(:md5_checksum) { '57d4c6f9d15313fd5651317e588c035d' }
+
+    let(:ruby_md5_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(md5_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('md5sum /tmp/testfile', '', '', 1)
+      Digest::MD5.expects(:new).returns(ruby_md5_mock)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `aix` platform family' do
+      output = "#{md5_checksum} /tmp/testfile"
+      backend.mock_command('md5sum /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+  end
+
+  describe '#sha256sum' do
+    let(:sha256_checksum) {
+      '491260aaa6638d4a64c714a17828c3d82bad6ca600c9149b3b3350e91bcd283d'
+    }
+
+    let(:ruby_sha256_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('sha256sum /tmp/testfile', '', '', 1)
+      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `aix` platform family' do
+      output = "#{sha256_checksum} /tmp/testfile"
+      backend.mock_command('sha256sum /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+  end
 end

data/test/unit/file/remote/linux_test.rb

@@ -9,7 +9,7 @@ describe Train::File::Remote::Linux do
     backend = Train::Transports::Mock.new.connection
     backend.mock_os({ name: 'linux', family: 'unix' })
     backend
-  }  
+  }
 
   def mock_stat(args, out, err = '', code = 0)
     backend.mock_command(
@@ -170,4 +170,52 @@ describe Train::File::Remote::Linux do
       f.selinux_label.must_equal 'labels'
     end
   end
+
+  describe '#md5sum' do
+    let(:md5_checksum) { '57d4c6f9d15313fd5651317e588c035d' }
+
+    let(:ruby_md5_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(md5_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('md5sum /tmp/testfile', '', '', 1)
+      Digest::MD5.expects(:new).returns(ruby_md5_mock)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `linux` platform family' do
+      output = "#{md5_checksum} /tmp/testfile"
+      backend.mock_command('md5sum /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+  end
+
+  describe '#sha256sum' do
+    let(:sha256_checksum) {
+      '491260aaa6638d4a64c714a17828c3d82bad6ca600c9149b3b3350e91bcd283d'
+    }
+
+    let(:ruby_sha256_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('sha256sum /tmp/testfile', '', '', 1)
+      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `linux` platform family' do
+      output = "#{sha256_checksum} /tmp/testfile"
+      backend.mock_command('sha256sum /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+  end
 end

data/test/unit/file/remote/qnx_test.rb

@@ -7,7 +7,7 @@ describe Train::File::Remote::Qnx do
   let(:cls) { Train::File::Remote::Qnx }
   let(:backend) {
     backend = Train::Transports::Mock.new.connection
-    backend.mock_os({ name: 'qnx', family: 'unix' })
+    backend.mock_os({ family: 'qnx' })
     backend
   }
 
@@ -41,4 +41,40 @@ describe Train::File::Remote::Qnx do
       proc { file.send(m) }.must_raise NotImplementedError
     end
   end
+
+  describe '#md5sum' do
+    let(:md5_checksum) { '17404a596cbd0d1e6c7d23fcd845ab82' }
+
+    let(:ruby_md5_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(md5_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('md5sum /tmp/testfile', '', '', 1)
+      Digest::MD5.expects(:new).returns(ruby_md5_mock)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+  end
+
+  describe '#sha256sum' do
+    let(:sha256_checksum) {
+      'ec864fe99b539704b8872ac591067ef22d836a8d942087f2dba274b301ebe6e5'
+    }
+
+    let(:ruby_sha256_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('sha256sum /tmp/testfile', '', '', 1)
+      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+  end
 end

data/test/unit/file/remote/unix_test.rb

@@ -1,8 +1,15 @@
 require 'helper'
+require 'train/transports/mock'
 require 'train/file/remote/unix'
 
 describe Train::File::Remote::Unix do
-  let(:cls) { Train::File::Remote::Unix }  
+  let(:cls) { Train::File::Remote::Unix }
+
+  let(:backend) {
+    backend = Train::Transports::Mock.new.connection
+    backend.mock_os({ family: 'linux' })
+    backend
+  }
 
   def mockup(stubs)
     Class.new(cls) do
@@ -41,4 +48,72 @@ describe Train::File::Remote::Unix do
       fc.unix_mode_mask('all', 'r').must_equal 0444
     end
   end
-end  
+
+  describe '#md5sum' do
+    let(:md5_checksum) { '57d4c6f9d15313fd5651317e588c035d' }
+
+    let(:ruby_md5_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(md5_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('md5 -r /tmp/testfile', '', '', 1)
+      Digest::MD5.expects(:new).returns(ruby_md5_mock)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+
+    it 'calculates the correct md5sum on the `darwin` platform family' do
+      output = "#{md5_checksum} /tmp/testfile"
+      backend.mock_os(family: 'darwin')
+      backend.mock_command('md5 -r /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `solaris` platform family' do
+      # The `digest` command doesn't output the filename by default
+      output = "#{md5_checksum}"
+      backend.mock_os(family: 'solaris')
+      backend.mock_command('digest -a md5 /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+  end
+
+  describe '#sha256sum' do
+    let(:sha256_checksum) {
+      '491260aaa6638d4a64c714a17828c3d82bad6ca600c9149b3b3350e91bcd283d'
+    }
+
+    let(:ruby_sha256_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command('shasum -a 256 /tmp/testfile', '', '', 1)
+      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+
+    it 'calculates the correct sha256sum on the `darwin` platform family' do
+      output = "#{sha256_checksum} /tmp/testfile"
+      backend.mock_os(family: 'darwin')
+      backend.mock_command('shasum -a 256 /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `solaris` platform family' do
+      # The `digest` command doesn't output the filename by default
+      output = "#{sha256_checksum}"
+      backend.mock_os(family: 'solaris')
+      backend.mock_command('digest -a sha256 /tmp/testfile', output)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+  end
+end

data/test/unit/file/remote/windows_test.rb

@@ -0,0 +1,72 @@
+require 'helper'
+require 'train/transports/mock'
+require 'train/file/remote/windows'
+
+describe Train::File::Remote::Windows do
+  let(:cls) { Train::File::Remote::Windows }
+  let(:backend) {
+    backend = Train::Transports::Mock.new.connection
+    backend.mock_os({ family: 'windows' })
+    backend
+  }
+
+  describe '#md5sum' do
+    let(:md5_checksum) { '4ce0c733cdcf1d2f78532bbd9ce3441d' }
+    let(:filepath) { 'C:\Windows\explorer.exe' }
+
+    let(:ruby_md5_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(md5_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command("CertUtil -hashfile #{filepath} MD5", '', '', 1)
+      Digest::MD5.expects(:new).returns(ruby_md5_mock)
+      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
+    end
+
+    it 'calculates the correct md5sum on the `windows` platform family' do
+      output = <<-EOC
+        MD5 hash of file C:\\Windows\\explorer.exe:\r
+        4c e0 c7 33 cd cf 1d 2f 78 53 2b bd 9c e3 44 1d\r
+        CertUtil: -hashfile command completed successfully.\r
+      EOC
+
+      backend.mock_command("CertUtil -hashfile #{filepath} MD5", output)
+      cls.new(backend, filepath).md5sum.must_equal md5_checksum
+    end
+  end
+
+  describe '#sha256sum' do
+    let(:sha256_checksum) {
+      '85270240a5fd51934f0627c92b2282749d071fdc9ac351b81039ced5b10f798b'
+    }
+    let(:filepath) { 'C:\Windows\explorer.exe' }
+
+    let(:ruby_sha256_mock) do
+      checksum_mock = mock
+      checksum_mock.expects(:update).returns('')
+      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
+      checksum_mock
+    end
+
+    it 'defaults to a Ruby based checksum if other methods fail' do
+      backend.mock_command("CertUtil -hashfile #{filepath} SHA256", '', '', 1)
+      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
+      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
+    end
+
+    it 'calculates the correct sha256sum on the `windows` platform family' do
+      output = <<-EOC
+        SHA256 hash of file C:\\Windows\\explorer.exe:\r
+        85 27 02 40 a5 fd 51 93 4f 06 27 c9 2b 22 82 74 9d 07 1f dc 9a c3 51 b8 10 39 ce d5 b1 0f 79 8b\r
+        CertUtil: -hashfile command completed successfully.\r
+      EOC
+
+      backend.mock_command("CertUtil -hashfile #{filepath} SHA256", output)
+      cls.new(backend, filepath).sha256sum.must_equal sha256_checksum
+    end
+  end
+end