train 1.5.11 → 1.6.3

data/test/unit/file/local_test.rb

@@ -1,121 +0,0 @@
-require 'helper'
-require 'train/transports/local'
-
-describe Train::File::Local do
-  let(:transport) { Train::Transports::Local.new }
-  let(:connection) { transport.connection }
-
-  it 'gets file contents' do
-    res = rand.to_s
-    File.stub :read, res do
-      connection.file(rand.to_s).content.must_equal(res)
-    end
-  end
-
-  {
-    exist?:            :exist?,
-    file?:             :file?,
-    socket?:           :socket?,
-    directory?:        :directory?,
-    symlink?:          :symlink?,
-    pipe?:             :pipe?,
-    character_device?: :chardev?,
-    block_device?:     :blockdev?,
-  }.each do |method, file_method|
-    it "checks if file is a #{method}" do
-      File.stub file_method.to_sym, true do
-        connection.file(rand.to_s).method(method.to_sym).call.must_equal(true)
-      end
-    end
-  end
-
-  describe '#type' do
-    it 'returns the type block_device if it is block device' do
-      File.stub :ftype, "blockSpecial" do
-        connection.file(rand.to_s).type.must_equal :block_device
-      end
-    end
-
-    it 'returns the type character_device if it is character device' do
-      File.stub :ftype, "characterSpecial" do
-        connection.file(rand.to_s).type.must_equal :character_device
-      end
-    end
-
-    it 'returns the type symlink if it is symlink' do
-      File.stub :ftype, "link" do
-        connection.file(rand.to_s).type.must_equal :symlink
-      end
-    end
-
-    it 'returns the type file if it is file' do
-      File.stub :ftype, "file" do
-        connection.file(rand.to_s).type.must_equal :file
-      end
-    end
-
-    it 'returns the type directory if it is block directory' do
-      File.stub :ftype, "directory" do
-        connection.file(rand.to_s).type.must_equal :directory
-      end
-    end
-
-    it 'returns the type pipe if it is pipe' do
-      File.stub :ftype, "fifo" do
-        connection.file(rand.to_s).type.must_equal :pipe
-      end
-    end
-
-    it 'returns the type socket if it is socket' do
-      File.stub :ftype, "socket" do
-        connection.file(rand.to_s).type.must_equal :socket
-      end
-    end
-
-    it 'returns the unknown if not known' do
-      File.stub :ftype, "unknown" do
-        connection.file(rand.to_s).type.must_equal :unknown
-      end
-    end
-  end
-
-  describe '#path' do
-    it 'returns the path if it is not a symlink' do
-      File.stub :symlink?, false do
-        filename = rand.to_s
-        connection.file(filename).path.must_equal filename
-      end
-    end
-
-    it 'returns the link_path if it is a symlink' do
-      File.stub :symlink?, true do
-        file_obj = connection.file(rand.to_s)
-        file_obj.stub :link_path, '/path/to/resolved_link' do
-          file_obj.path.must_equal '/path/to/resolved_link'
-        end
-      end
-    end
-  end
-
-  describe '#link_path' do
-    it 'returns file\'s link path' do
-      out = rand.to_s
-      File.stub :realpath, out do
-        File.stub :symlink?, true do
-          connection.file(rand.to_s).link_path.must_equal out
-        end
-      end
-    end
-  end
-
-  describe '#shallow_shlink_path' do
-    it 'returns file\'s direct link path' do
-      out = rand.to_s
-      File.stub :readlink, out do
-        File.stub :symlink?, true do
-          connection.file(rand.to_s).shallow_link_path.must_equal out
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-require 'helper'
-require 'train/transports/local'
-require 'train/file/remote/aix'
-require 'train/transports/mock'
-
-describe Train::File::Remote::Aix do
-  let(:cls) { Train::File::Remote::Aix }
-  let(:backend) {
-    backend = Train::Transports::Mock.new.connection
-    backend.mock_os({ name: 'aix', family: 'unix' })
-    backend
-  }
-
-  it 'returns a nil link_path if the object is not a symlink' do
-    file = cls.new(backend, 'path')
-    file.stubs(:symlink?).returns(false)
-    file.link_path.must_be_nil
-  end
-
-  it 'returns a correct link_path' do
-    file = cls.new(backend, 'path')
-    file.stubs(:symlink?).returns(true)
-    backend.mock_command("perl -e 'print readlink shift' path", 'our_link_path')
-    file.link_path.must_equal 'our_link_path'
-  end
-
-  it 'returns a correct shallow_link_path' do
-    file = cls.new(backend, 'path')
-    file.stubs(:symlink?).returns(true)
-    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

@@ -1,221 +0,0 @@
-require 'helper'
-require 'train/transports/local'
-require 'train/file/remote/linux'
-require 'train/transports/mock'
-
-describe Train::File::Remote::Linux do
-  let(:cls) { Train::File::Remote::Linux }
-  let(:backend) {
-    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(
-      "stat #{args} 2>/dev/null --printf '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'",
-      out, err, code
-    )
-  end
-
-  it 'works on nil path' do
-    cls.new(backend, nil).path.must_equal ''
-  end
-
-  it 'provides the full path' do
-    cls.new(backend, '/dir/file').path.must_equal '/dir/file'
-  end
-
-  it 'provides the basename to a unix path' do
-    cls.new(backend, '/dir/file').basename.must_equal 'file'
-  end
-
-  it 'reads file contents' do
-    out = rand.to_s
-    backend.mock_command('cat path || echo -n', out)
-    cls.new(backend, 'path').content.must_equal out
-  end
-
-  it 'reads file contents' do
-    backend.mock_command('cat path || echo -n', '')
-    mock_stat('-L path', '', 'some error...', 1)
-    cls.new(backend, 'path').content.must_be_nil
-  end
-
-  it 'reads file contents' do
-    out = rand.to_s
-    backend.mock_command('cat /spaced\\ path || echo -n', out)
-    cls.new(backend, '/spaced path').content.must_equal out
-  end
-
-  it 'checks for file existance' do
-    backend.mock_command('test -e path', true)
-    cls.new(backend, 'path').exist?.must_equal true
-  end
-
-  it 'checks for file existance' do
-    backend.mock_command('test -e path', nil, nil, 1)
-    cls.new(backend, 'path').exist?.must_equal false
-  end
-
-  it 'retrieves the link path via #path()' do
-    out = rand.to_s
-    mock_stat('path', "13\na1ff\nz\n1001\nz\n1001\n1444573475\n1444573475\n?")
-    backend.mock_command('readlink -n path -f', out)
-    cls.new(backend, 'path').path.must_equal File.join(Dir.pwd, out)
-  end
-
-  it 'retrieves the link path' do
-    out = rand.to_s
-    mock_stat('path', "13\na1ff\nz\n1001\nz\n1001\n1444573475\n1444573475\n?")
-    backend.mock_command('readlink -n path -f', out)
-    cls.new(backend, 'path').link_path.must_equal File.join(Dir.pwd, out)
-  end
-
-  it 'provide the source path' do
-    cls.new(backend, 'path').source_path.must_equal 'path'
-  end
-
-  it 'checks a mounted path' do
-    backend.mock_command("mount | grep -- ' on /mount/path '", rand.to_s)
-    cls.new(backend, '/mount/path').mounted?.must_equal true
-  end
-
-  it 'has nil product version' do
-    cls.new(backend, 'path').product_version.must_be_nil
-  end
-
-  it 'has nil file version' do
-    cls.new(backend, 'path').file_version.must_be_nil
-  end
-
-  describe 'stat on a file' do
-    before { mock_stat('-L path', "13\na1ff\nz\n1001\nz2\n1002\n1444573475\n1444573475\nlabels") }
-    let(:f) { cls.new(backend, 'path') }
-
-    it 'retrieves the file type' do
-      f.type.must_equal :symlink
-    end
-
-    it 'retrieves the file mode' do
-      f.mode.must_equal 00777
-    end
-
-    it 'retrieves the file owner' do
-      f.owner.must_equal 'z'
-    end
-
-    it 'retrieves the file uid' do
-      f.uid.must_equal 1001
-    end
-
-    it 'retrieves the file group' do
-      f.group.must_equal 'z2'
-    end
-
-    it 'retrieves the file gid' do
-      f.gid.must_equal 1002
-    end
-
-    it 'retrieves the file mtime' do
-      f.mtime.must_equal 1444573475
-    end
-
-    it 'retrieves the file size' do
-      f.size.must_equal 13
-    end
-
-    it 'retrieves the file selinux_label' do
-      f.selinux_label.must_equal 'labels'
-    end
-  end
-
-  describe 'stat on the source file' do
-    before { mock_stat('path', "13\na1ff\nz\n1001\nz2\n1002\n1444573475\n1444573475\nlabels") }
-    let(:f) { cls.new(backend, 'path').source }
-
-    it 'retrieves the file type' do
-      f.type.must_equal :symlink
-    end
-
-    it 'retrieves the file mode' do
-      f.mode.must_equal 00777
-    end
-
-    it 'retrieves the file owner' do
-      f.owner.must_equal 'z'
-    end
-
-    it 'retrieves the file uid' do
-      f.uid.must_equal 1001
-    end
-
-    it 'retrieves the file group' do
-      f.group.must_equal 'z2'
-    end
-
-    it 'retrieves the file gid' do
-      f.gid.must_equal 1002
-    end
-
-    it 'retrieves the file mtime' do
-      f.mtime.must_equal 1444573475
-    end
-
-    it 'retrieves the file size' do
-      f.size.must_equal 13
-    end
-
-    it 'retrieves the file selinux_label' 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

@@ -1,80 +0,0 @@
-require 'helper'
-require 'train/transports/local'
-require 'train/file/remote/qnx'
-require 'train/transports/mock'
-
-describe Train::File::Remote::Qnx do
-  let(:cls) { Train::File::Remote::Qnx }
-  let(:backend) {
-    backend = Train::Transports::Mock.new.connection
-    backend.mock_os({ family: 'qnx' })
-    backend
-  }
-
-  it 'returns file contents when the file exists' do
-    out = rand.to_s
-    backend.mock_command('cat path', out)
-    file = cls.new(backend, 'path')
-    file.stubs(:exist?).returns(true)
-    file.content.must_equal out
-  end
-
-  it 'returns nil contents when the file does not exist' do
-    file = cls.new(backend, 'path')
-    file.stubs(:exist?).returns(false)
-    file.content.must_be_nil
-  end
-
-  it 'returns a file type' do
-    backend.mock_command('file path', 'blah directory blah')
-    cls.new(backend, 'path').type.must_equal :directory
-  end
-
-  it 'returns a directory type' do
-    backend.mock_command('file path', 'blah regular file blah')
-    cls.new(backend, 'path').type.must_equal :file
-  end
-
-  it 'raises exception for unimplemented methods' do
-    file = cls.new(backend, 'path')
-    %w{mode owner group uid gid mtime size selinux_label link_path mounted stat}.each do |m|
-      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,119 +0,0 @@
-require 'helper'
-require 'train/transports/mock'
-require 'train/file/remote/unix'
-
-describe Train::File::Remote::Unix do
-  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
-      stubs.each do |k,v|
-        define_method k.to_sym do
-          v
-        end
-      end
-    end.new(nil, nil, false)
-  end
-
-  describe 'unix_mode_mask' do
-    let(:fc) { mockup(type: :file) }
-
-    it 'check owner mode calculation' do
-      fc.unix_mode_mask('owner', 'x').must_equal 0100
-      fc.unix_mode_mask('owner', 'w').must_equal 0200
-      fc.unix_mode_mask('owner', 'r').must_equal 0400
-    end
-
-    it 'check group mode calculation' do
-      fc.unix_mode_mask('group', 'x').must_equal 0010
-      fc.unix_mode_mask('group', 'w').must_equal 0020
-      fc.unix_mode_mask('group', 'r').must_equal 0040
-    end
-
-    it 'check other mode calculation' do
-      fc.unix_mode_mask('other', 'x').must_equal 0001
-      fc.unix_mode_mask('other', 'w').must_equal 0002
-      fc.unix_mode_mask('other', 'r').must_equal 0004
-    end
-
-    it 'check all mode calculation' do
-      fc.unix_mode_mask('all', 'x').must_equal 0111
-      fc.unix_mode_mask('all', 'w').must_equal 0222
-      fc.unix_mode_mask('all', 'r').must_equal 0444
-    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

@@ -1,72 +0,0 @@
-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