train 0.28.0 → 0.29.0

data/test/unit/{extras/linux_file_test.rb → file/remote/linux_test.rb}

@@ -1,15 +1,15 @@
-# encoding: utf-8
 require 'helper'
+require 'train/transports/local'
+require 'train/file/remote/linux'
 require 'train/transports/mock'
-require 'train/extras'
 
-describe 'file common' do
-  let(:cls) { Train::Extras::LinuxFile }
+describe Train::File::Remote::Linux do
+  let(:cls) { Train::File::Remote::Linux }
   let(:backend) {
     backend = Train::Transports::Mock.new.connection
     backend.mock_os({ family: 'linux' })
     backend
-  }
+  }  
 
   def mock_stat(args, out, err = '', code = 0)
     backend.mock_command(
@@ -39,7 +39,7 @@ describe 'file common' do
   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_equal nil
+    cls.new(backend, 'path').content.must_be_nil
   end
 
   it 'checks for file existance' do
@@ -164,4 +164,4 @@ describe 'file common' do
       f.selinux_label.must_equal 'labels'
     end
   end
-end
+end

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

@@ -0,0 +1,44 @@
+require 'helper'
+require 'train/file/remote/unix'
+
+describe Train::File::Remote::Unix do
+  let(:cls) { Train::File::Remote::Unix }  
+
+  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
+end  

data/test/unit/file/remote_test.rb

@@ -0,0 +1,62 @@
+require 'helper'
+require 'train/file/remote'
+
+describe Train::File::Remote do
+  let(:cls) { Train::File::Remote }  
+
+  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 'basename helper' do
+    def fc(path)
+      mockup(type: :file, path: path)
+    end
+
+    it 'works with an empty path' do
+      fc('').basename.must_equal ''
+    end
+
+    it 'separates a simple path (defaults to unix mode)' do
+      fc('/dir/file').basename.must_equal 'file'
+    end
+
+    it 'separates a simple path (Unix mode)' do
+      fc('/dir/file').basename(nil, '/').must_equal 'file'
+    end
+
+    it 'separates a simple path (Windows mode)' do
+      fc('C:\dir\file').basename(nil, '\\').must_equal 'file'
+    end
+
+    it 'identifies a folder name (Unix mode)' do
+      fc('/dir/file/').basename(nil, '/').must_equal 'file'
+    end
+
+    it 'identifies a folder name (Windows mode)' do
+      fc('C:\dir\file\\').basename(nil, '\\').must_equal 'file'
+    end
+
+    it 'ignores tailing separators (Unix mode)' do
+      fc('/dir/file///').basename(nil, '/').must_equal 'file'
+    end
+
+    it 'ignores tailing separators (Windows mode)' do
+      fc('C:\dir\file\\\\\\').basename(nil, '\\').must_equal 'file'
+    end
+
+    it 'doesnt work with backward slashes (Unix mode)' do
+      fc('C:\dir\file').basename(nil, '/').must_equal 'C:\\dir\file'
+    end
+
+    it 'doesnt work with forward slashes (Windows mode)' do
+      fc('/dir/file').basename(nil, '\\').must_equal '/dir/file'
+    end
+  end
+end  

data/test/unit/file_test.rb

@@ -0,0 +1,156 @@
+require 'helper'
+
+describe Train::File do
+  let(:cls) { Train::File }
+  let(:new_cls) { cls.new(nil, '/temp/file', false) }
+
+  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
+
+  it 'has the default type of unknown' do
+    new_cls.type.must_equal :unknown
+  end
+
+  it 'calculates md5sum from content' do
+    content = 'hello world'
+    new_cls.stub :content, content do |i|
+      i.md5sum.must_equal '5eb63bbbe01eeed093cb22bb8f5acdc3'
+    end
+  end
+
+  it 'sets md5sum of nil content to nil' do
+    new_cls.stub :content, nil do |i|
+      i.md5sum.must_be_nil
+    end
+  end
+
+  it 'calculates sha256sum from content' do
+    content = 'hello world'
+    new_cls.stub :content, content do |i|
+      i.sha256sum.must_equal 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'
+    end
+  end
+
+  it 'sets sha256sum of nil content to nil' do
+    new_cls.stub :content, nil do |i|
+      i.sha256sum.must_be_nil
+    end
+  end
+
+  it 'throws Not implemented error for exist?' do
+    # proc { Train.validate_backend({ host: rand }) }.must_raise Train::UserError
+    proc { new_cls.exist?}.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for mode' do
+    proc { new_cls.mode }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for owner' do
+    proc { new_cls.owner }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for group' do
+    proc { new_cls.group }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for uid' do
+    proc { new_cls.uid }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for gid' do
+    proc { new_cls.gid }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for content' do
+    proc { new_cls.content }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for mtime' do
+    proc { new_cls.mtime }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for size' do
+    proc { new_cls.size }.must_raise NotImplementedError
+  end
+
+  it 'throws Not implemented error for selinux_label' do
+    proc { new_cls.selinux_label }.must_raise NotImplementedError
+  end
+
+  it 'return path of file' do
+    new_cls.path.must_equal('/temp/file')
+  end
+
+  it 'set product_version to nil' do
+    new_cls.product_version.must_be_nil
+  end  
+
+  it 'set product_version to nil' do
+    new_cls.file_version.must_be_nil
+  end
+
+
+  describe 'type' do
+    it 'recognized type == file' do
+      fc = mockup(type: :file)
+      fc.file?.must_equal true
+    end
+
+    it 'recognized type == block_device' do
+      fc = mockup(type: :block_device)
+      fc.block_device?.must_equal true
+    end
+
+    it 'recognized type == character_device' do
+      fc = mockup(type: :character_device)
+      fc.character_device?.must_equal true
+    end
+
+    it 'recognized type == socket' do
+      fc = mockup(type: :socket)
+      fc.socket?.must_equal true
+    end
+
+    it 'recognized type == directory' do
+      fc = mockup(type: :directory)
+      fc.directory?.must_equal true
+    end
+
+    it 'recognized type == pipe' do
+      fc = mockup(type: :pipe)
+      fc.pipe?.must_equal true
+    end
+
+    it 'recognized type == symlink' do
+      fc = mockup(type: :symlink)
+      fc.symlink?.must_equal true
+    end
+  end
+
+  describe 'version' do
+    it 'recognized wrong version' do
+      fc = mockup(product_version: rand, file_version: rand)
+      fc.version?(rand).must_equal false
+    end
+
+    it 'recognized product_version' do
+      x = rand
+      fc = mockup(product_version: x, file_version: rand)
+      fc.version?(x).must_equal true
+    end
+
+    it 'recognized file_version' do
+      x = rand
+      fc = mockup(product_version: rand, file_version: x)
+      fc.version?(x).must_equal true
+    end
+  end
+end  

data/test/unit/plugins/transport_test.rb

@@ -86,7 +86,7 @@ describe 'v1 Transport Plugin' do
 
     it 'default option must not be required' do
       name, plugin = train_class
-      plugin.default_options[name][:required].must_equal nil
+      plugin.default_options[name][:required].must_be_nil
     end
 
     it 'can include options from another module' do

data/test/unit/transports/mock_test.rb

@@ -94,11 +94,11 @@ describe 'mock transport' do
 
     # tests if all fields between the local json and resulting mock file
     # are equal
-    JSON = Train.create('local').connection.file(__FILE__).to_json
-    RES = Train::Transports::Mock::Connection::File.from_json(JSON)
+    JSON_DATA = Train.create('local').connection.file(__FILE__).to_json
+    RES = Train::Transports::Mock::Connection::File.from_json(JSON_DATA)
     %w{ content mode owner group }.each do |f|
       it "can be initialized from json (field #{f})" do
-        RES.method(f).call.must_equal JSON[f]
+        RES.method(f).call.must_equal JSON_DATA[f]
       end
     end
   end

data/test/windows/local_test.rb

@@ -6,6 +6,7 @@ require 'minitest/autorun'
 require 'minitest/spec'
 require 'mocha/setup'
 require 'train'
+require 'tempfile'
 
 describe 'windows local command' do
   let(:conn) {
@@ -39,6 +40,111 @@ describe 'windows local command' do
     cmd.stderr.must_equal ''
   end
 
+  describe 'file' do
+    before do
+      @temp = Tempfile.new('foo')
+      @temp.write("hello world")
+      @temp.rewind
+    end
+
+    let(:file) { conn.file(@temp.path) }
+
+    it 'exists' do
+      file.exist?.must_equal(true)
+    end
+
+    it 'is a file' do
+      file.file?.must_equal(true)
+    end
+
+    it 'has type :file' do
+      file.type.must_equal(:file)
+    end
+
+    it 'has content' do
+      file.content.must_equal("hello world")
+    end
+
+    it 'returns basename of file' do
+      file_name = ::File.basename(@temp)
+      file.basename.must_equal(file_name)
+    end
+
+    it 'has owner name' do
+      file.owner.wont_be_nil
+    end
+
+    it 'has no group name' do
+      file.group.must_be_nil
+    end
+
+    it 'has no mode' do
+      file.mode.wont_be_nil
+    end
+
+    it 'has an md5sum' do
+      file.md5sum.wont_be_nil
+    end
+
+    it 'has an sha256sum' do
+      file.sha256sum.wont_be_nil
+    end
+
+    it 'has no modified time' do
+      file.mtime.wont_be_nil
+    end
+
+    it 'has no size' do
+      file.size.wont_be_nil
+    end
+
+    it 'has size 11' do
+      size = ::File.size(@temp)
+      file.size.must_equal size
+    end
+
+    it 'has no selinux_label handling' do
+      file.selinux_label.must_be_nil
+    end
+
+    it 'has product_version' do
+      file.product_version.wont_be_nil
+    end
+
+    it 'has file_version' do
+      file.file_version.wont_be_nil
+    end
+
+    it 'provides a json representation' do
+      j = file.to_json
+      j.must_be_kind_of Hash
+      j['type'].must_equal :file
+    end
+
+    after do
+      @temp.close
+      @temp.unlink
+    end
+  end
+
+  describe 'file' do
+    before do
+      @temp = Tempfile.new('foo bar')
+      @temp.rewind
+    end
+
+    let(:file) { conn.file(@temp.path) }
+
+    it 'provides the full path with whitespace for path #{@temp.path}' do
+      file.path.must_equal @temp.path
+    end
+
+    after do
+      @temp.close
+      @temp.unlink
+    end
+  end
+
   after do
     # close the connection
     conn.close

data/test/windows/winrm_test.rb

@@ -45,6 +45,131 @@ describe 'windows winrm command' do
     cmd.stderr.must_equal ''
   end
 
+
+  describe 'file' do
+    before do
+      @temp = Tempfile.new('foo')
+      @temp.write("hello world")
+      @temp.rewind
+    end
+
+    let(:file) { conn.file(@temp.path) }
+
+    it 'exists' do
+      file.exist?.must_equal(true)
+    end
+
+    it 'is a file' do
+      file.file?.must_equal(true)
+    end
+
+    it 'has type :file' do
+      file.type.must_equal(:file)
+    end
+
+    it 'has content' do
+      # TODO: this shouldn't include newlines that aren't in the original file
+      file.content.must_equal("hello world\r\n")
+    end
+
+    it 'has owner name' do
+      file.owner.wont_be_nil
+    end
+
+    it 'has no group name' do
+      file.group.must_be_nil
+    end
+
+    it 'has no mode' do
+      file.mode.must_be_nil
+    end
+
+    it 'has an md5sum' do
+      file.md5sum.wont_be_nil
+    end
+
+    it 'has an sha256sum' do
+      file.sha256sum.wont_be_nil
+    end
+
+    it 'has no modified time' do
+      file.mtime.must_be_nil
+    end
+
+    it 'has no size' do
+      file.size.wont_be_nil
+    end
+
+    it 'has size 11' do
+      size = ::File.size(@temp)
+      file.size.must_equal size
+    end
+
+    it 'has no selinux_label handling' do
+      file.selinux_label.must_be_nil
+    end
+
+    it 'has product_version' do
+      file.product_version.wont_be_nil
+    end
+
+    # TODO: This is not failing in manual testing
+    # it 'returns basname of file' do
+    #   basename = ::File.basename(@temp)
+    #   file.basename.must_equal basename
+    # end
+
+    it 'has file_version' do
+      file.file_version.wont_be_nil
+    end
+
+    it 'returns nil for mounted' do
+      file.mounted.must_be_nil
+    end
+
+    it 'has no link_path' do
+      file.link_path.must_be_nil
+    end
+
+    it 'has no uid' do
+      file.uid.must_be_nil
+    end
+
+    it 'has no gid' do
+      file.gid.must_be_nil
+    end
+
+    it 'provides a json representation' do
+      j = file.to_json
+      j.must_be_kind_of Hash
+      j['type'].must_equal :file
+    end
+
+    after do
+      @temp.close
+      @temp.unlink
+    end
+  end
+
+  describe 'file' do
+    before do
+      @temp = Tempfile.new('foo bar')
+      @temp.write("hello world")
+      @temp.rewind
+    end
+
+    let(:file) { conn.file(@temp.path) }
+
+    it 'provides the full path with whitespace for path #{@temp.path}' do
+      file.path.must_equal @temp.path
+    end
+
+    after do
+      @temp.close
+      @temp.unlink
+    end
+  end
+
   after do
     # close the connection
     conn.close