puppet 4.0.0 → 4.5.0

data/spec/unit/type/file_spec.rb

@@ -418,7 +418,7 @@ describe Puppet::Type.type(:file) do
     it "should not copy values to the child which were set by the source" do
       source = File.expand_path(__FILE__)
       file[:source] = source
-      metadata = stub 'metadata', :owner => "root", :group => "root", :mode => '0755', :ftype => "file", :checksum => "{md5}whatever", :source => source
+      metadata = stub 'metadata', :owner => "root", :group => "root", :mode => '0755', :ftype => "file", :checksum => "{md5}whatever", :checksum_type => "md5", :source => source
       file.parameter(:source).stubs(:metadata).returns metadata
 
       file.parameter(:source).copy_source_values
@@ -518,19 +518,6 @@ describe Puppet::Type.type(:file) do
 
   end
 
-  describe "#remove_less_specific_files" do
-    it "should remove any nested files that are already in the catalog" do
-      foo = described_class.new :path => File.join(file[:path], 'foo')
-      bar = described_class.new :path => File.join(file[:path], 'bar')
-      baz = described_class.new :path => File.join(file[:path], 'baz')
-
-      catalog.add_resource(foo)
-      catalog.add_resource(bar)
-
-      expect(file.remove_less_specific_files([foo, bar, baz])).to eq([baz])
-    end
-  end
-
   describe "#remove_less_specific_files" do
     it "should remove any nested files that are already in the catalog" do
       foo = described_class.new :path => File.join(file[:path], 'foo')
@@ -720,6 +707,13 @@ describe Puppet::Type.type(:file) do
       file.recurse_remote("first" => @resource)
     end
 
+    it "should set the checksum parameter based on the metadata" do
+      file.stubs(:perform_recursion).returns [@first]
+      @resource.stubs(:[]=)
+      @resource.expects(:[]=).with(:checksum, "md5")
+      file.recurse_remote("first" => @resource)
+    end
+
     it "should store the metadata in the source property for each resource so the source does not have to requery the metadata" do
       file.stubs(:perform_recursion).returns [@first]
       @resource.expects(:parameter).with(:source).returns @parameter
@@ -747,6 +741,16 @@ describe Puppet::Type.type(:file) do
       file.recurse_remote("first" => @resource)
     end
 
+    it "should update the main file's checksum parameter if the relative path is '.'" do
+      @first.stubs(:relative_path).returns "."
+      file.stubs(:perform_recursion).returns [@first]
+
+      file.stubs(:[]=)
+      file.expects(:[]=).with(:checksum, "md5")
+
+      file.recurse_remote("first" => @resource)
+    end
+
     describe "and multiple sources are provided" do
       let(:sources) do
         h = {}
@@ -1070,11 +1074,13 @@ describe Puppet::Type.type(:file) do
       it "should fail if the checksum parameter and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b', :sum_file => 'checksum_b')
         file.stubs(:parameter).with(:checksum).returns(checksum)
+        file.stubs(:parameter).with(:source).returns(nil)
+
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         file.stubs(:property).with(:content).returns(property)
 
-        expect { file.write :NOTUSED }.to raise_error(Puppet::Error)
+        expect { file.write property }.to raise_error(Puppet::Error)
       end
     end
 
@@ -1084,11 +1090,12 @@ describe Puppet::Type.type(:file) do
       it "should not fail if the checksum property and content checksums do not match" do
         checksum = stub('checksum_parameter',  :sum => 'checksum_b')
         file.stubs(:parameter).with(:checksum).returns(checksum)
+        file.stubs(:parameter).with(:source).returns(nil)
 
         property = stub('content_property', :actual_content => "something", :length => "something".length, :write => 'checksum_a')
         file.stubs(:property).with(:content).returns(property)
 
-        expect { file.write :NOTUSED }.to_not raise_error
+        expect { file.write property }.to_not raise_error
       end
     end
 
@@ -1101,13 +1108,13 @@ describe Puppet::Type.type(:file) do
         it "should convert symbolic mode to int" do
           file[:mode] = 'oga=r'
           Puppet::Util.expects(:replace_file).with(file[:path], 0444)
-          file.write :NOTUSED
+          file.write
         end
 
         it "should support int modes" do
           file[:mode] = '0444'
           Puppet::Util.expects(:replace_file).with(file[:path], 0444)
-          file.write :NOTUSED
+          file.write
         end
       end
 
@@ -1117,19 +1124,19 @@ describe Puppet::Type.type(:file) do
         it "should set a umask of 0" do
           file[:mode] = 'oga=r'
           Puppet::Util.expects(:withumask).with(0)
-          file.write :NOTUSED
+          file.write
         end
 
         it "should convert symbolic mode to int" do
           file[:mode] = 'oga=r'
           File.expects(:open).with(file[:path], anything, 0444)
-          file.write :NOTUSED
+          file.write
         end
 
         it "should support int modes" do
           file[:mode] = '0444'
           File.expects(:open).with(file[:path], anything, 0444)
-          file.write :NOTUSED
+          file.write
         end
       end
     end
@@ -1139,7 +1146,7 @@ describe Puppet::Type.type(:file) do
         it "should default to 0644 mode" do
           file = described_class.new(:path => path, :content => "file content")
 
-          file.write :NOTUSED
+          file.write file.parameter(:content)
 
           expect(File.stat(file[:path]).mode & 0777).to eq(0644)
         end
@@ -1151,7 +1158,7 @@ describe Puppet::Type.type(:file) do
 
           umask_from_the_user = 0777
           Puppet::Util.withumask(umask_from_the_user) do
-            file.write :NOTUSED
+            file.write
           end
 
           expect(File.stat(file[:path]).mode & 0777).to eq(0644)
@@ -1189,16 +1196,6 @@ describe Puppet::Type.type(:file) do
     end
   end
 
-  describe "#write_content" do
-    it "should delegate writing the file to the content property" do
-      io = stub('io')
-      file[:content] = "some content here"
-      file.property(:content).expects(:write).with(io)
-
-      file.send(:write_content, io)
-    end
-  end
-
   describe "#write_temporary_file?" do
     it "should be true if the file has specified content" do
       file[:content] = 'some content'
@@ -1393,7 +1390,18 @@ describe Puppet::Type.type(:file) do
   describe "when using source" do
     before do
       file[:source] = File.expand_path('/one')
+      @checksum_values = {
+        :md5 => 'd41d8cd98f00b204e9800998ecf8427e',
+        :md5lite => 'd41d8cd98f00b204e9800998ecf8427e',
+        :sha256 => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha256lite => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha1 => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :sha1lite => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :mtime => 'Jan 26 13:59:49 2016',
+        :ctime => 'Jan 26 13:59:49 2016'
+      }
     end
+
     Puppet::Type::File::ParameterChecksum.value_collection.values.reject {|v| v == :none}.each do |checksum_type|
       describe "with checksum '#{checksum_type}'" do
         before do
@@ -1401,12 +1409,66 @@ describe Puppet::Type.type(:file) do
         end
 
         it 'should validate' do
+          expect { file.validate }.to_not raise_error
+        end
+
+        it 'should fail on an invalid checksum_value' do
+          file[:checksum_value] = ''
+          expect { file.validate }.to raise_error(Puppet::Error, "Checksum value '' is not a valid checksum type #{checksum_type}")
+        end
 
+        it 'should validate a valid checksum_value' do
+          file[:checksum_value] = @checksum_values[checksum_type]
           expect { file.validate }.to_not raise_error
         end
       end
     end
 
+    describe "on Windows when source_permissions is `use`" do
+      before :each do
+        Puppet.features.stubs(:microsoft_windows?).returns true
+        file[:source_permissions] = "use"
+      end
+      let(:err_message) { "Copying owner/mode/group from the" <<
+                          " source file on Windows is not supported;" <<
+                          " use source_permissions => ignore." }
+
+      it "should issue error when retrieving" do
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue error when retrieving if only user is unspecified" do
+        file[:group] = 2
+        file[:mode] = "0003"
+
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue error when retrieving if only group is unspecified" do
+        file[:owner] = 1
+        file[:mode] = "0003"
+
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue error when retrieving if only mode is unspecified" do
+        file[:owner] = 1
+        file[:group] = 2
+
+        expect { file.retrieve }.to raise_error(err_message)
+      end
+
+      it "should issue warning when retrieve if group, owner, and mode are all specified" do
+        file[:owner] = 1
+        file[:group] = 2
+        file[:mode] = "0003"
+
+        file.parameter(:source).expects(:copy_source_values)
+        file.expects(:warning).with(err_message)
+        expect { file.retrieve }.not_to raise_error
+      end
+    end
+
     describe "with checksum 'none'" do
       before do
         file[:checksum] = :none
@@ -1421,6 +1483,14 @@ describe Puppet::Type.type(:file) do
   describe "when using content" do
     before do
       file[:content] = 'file contents'
+      @checksum_values = {
+        :md5 => 'd41d8cd98f00b204e9800998ecf8427e',
+        :md5lite => 'd41d8cd98f00b204e9800998ecf8427e',
+        :sha256 => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha256lite => 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+        :sha1 => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+        :sha1lite => 'da39a3ee5e6b4b0d3255bfef95601890afd80709',
+      }
     end
 
     (Puppet::Type::File::ParameterChecksum.value_collection.values - SOURCE_ONLY_CHECKSUMS).each do |checksum_type|
@@ -1432,6 +1502,16 @@ describe Puppet::Type.type(:file) do
         it 'should validate' do
           expect { file.validate }.to_not raise_error
         end
+
+        it 'should fail on an invalid checksum_value' do
+          file[:checksum_value] = ''
+          expect { file.validate }.to raise_error(Puppet::Error, "Checksum value '' is not a valid checksum type #{checksum_type}")
+        end
+
+        it 'should validate a valid checksum_value' do
+          file[:checksum_value] = @checksum_values[checksum_type]
+          expect { file.validate }.to_not raise_error
+        end
       end
     end
 
@@ -1446,6 +1526,26 @@ describe Puppet::Type.type(:file) do
     end
   end
 
+  describe "when checksum is none" do
+    before do
+      file[:checksum] = :none
+    end
+
+    it 'should validate' do
+      expect { file.validate }.to_not raise_error
+    end
+
+    it 'should fail on an invalid checksum_value' do
+      file[:checksum_value] = 'boo'
+      expect { file.validate }.to raise_error(Puppet::Error, "Checksum value 'boo' is not a valid checksum type none")
+    end
+
+    it 'should validate a valid checksum_value' do
+      file[:checksum_value] = ''
+      expect { file.validate }.to_not raise_error
+    end
+  end
+
   describe "when auditing" do
     before :each do
       # to prevent the catalog from trying to write state.yaml
@@ -1501,5 +1601,4 @@ describe Puppet::Type.type(:file) do
       end
     end
   end
-
 end

data/spec/unit/type/host_spec.rb

@@ -68,15 +68,15 @@ describe host do
     end
 
     it "should not accept malformed IPv4 addresses like 192.168.0.300" do
-      expect { @class.new(:name => "foo", :ip => '192.168.0.300') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '192.168.0.300') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     it "should reject over-long IPv4 addresses" do
-      expect { @class.new(:name => "foo", :ip => '10.10.10.10.10') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '10.10.10.10.10') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     it "should not accept malformed IP addresses like 2001:0dg8:85a3:08d3:1319:8a2e:0370:7344" do
-      expect { @class.new(:name => "foo", :ip => '2001:0dg8:85a3:08d3:1319:8a2e:0370:7344') }.to raise_error
+      expect { @class.new(:name => "foo", :ip => '2001:0dg8:85a3:08d3:1319:8a2e:0370:7344') }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
     end
 
     # Assorted, annotated IPv6 passes.
@@ -598,7 +598,7 @@ describe host do
      "::2222:3333:4444:5555:6666:7777:8888:",
     ].each do |ip|
       it "should reject #{ip.inspect} as an IPv6 address" do
-        expect { @class.new(:name => "foo", :ip => ip) }.to raise_error
+        expect { @class.new(:name => "foo", :ip => ip) }.to raise_error(Puppet::ResourceError, /Parameter ip failed/)
       end
     end
 

data/spec/unit/type/interface_spec.rb

@@ -67,6 +67,38 @@ describe Puppet::Type.type(:interface) do
       end
     end
 
+    describe "interface mode" do
+      it "should allow :access" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => :access)
+      end
+
+      it "should allow :trunk" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => :trunk)
+      end
+
+      it "should allow 'dynamic auto'" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => 'dynamic auto')
+      end
+
+      it "should allow 'dynamic desirable'" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :mode => 'dynamic desirable')
+      end
+    end
+
+    describe "interface encapsulation" do
+      it "should allow :dot1q" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :encapsulation => :dot1q)
+      end
+
+      it "should allow :isl" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :encapsulation => :isl)
+      end
+
+      it "should allow :negotiate" do
+        Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :encapsulation => :negotiate)
+      end
+    end
+
     describe "especially ipaddress" do
       it "should allow ipv4 addresses" do
         Puppet::Type.type(:interface).new(:name => "FastEthernet 0/1", :ipaddress => "192.168.0.1/24")

data/spec/unit/type/macauthorization_spec.rb

@@ -1,6 +1,9 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
+module Puppet::Util::Plist
+end
+
 macauth_type = Puppet::Type.type(:macauthorization)
 
 describe Puppet::Type.type(:macauthorization), "when checking macauthorization objects" do
@@ -10,7 +13,7 @@ describe Puppet::Type.type(:macauthorization), "when checking macauthorization o
     authplist["rules"] = { "foorule" => "foo" }
     authplist["rights"] = { "fooright" => "foo" }
     provider_class = macauth_type.provider(macauth_type.providers[0])
-    Plist.stubs(:parse_xml).with("/etc/authorization").returns(authplist)
+    Puppet::Util::Plist.stubs(:parse_plist).with("/etc/authorization").returns(authplist)
     macauth_type.stubs(:defaultprovider).returns provider_class
     @resource = macauth_type.new(:name => 'foo')
   end

data/spec/unit/type/mount_spec.rb

@@ -197,6 +197,10 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       it "should not support whitespace in fstype" do
         expect { described_class.new(:name => "/foo", :ensure => :present, :fstype => 'ext 3') }.to raise_error Puppet::Error, /fstype.*whitespace/
       end
+
+      it "should not support an empty string in fstype" do
+        expect { described_class.new(:name => "/foo", :ensure => :present, :fstype => "") }.to raise_error Puppet::Error, /fstype.*empty string/
+      end
     end
 
     describe "for options" do
@@ -211,6 +215,10 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       it "should not support whitespace in options" do
         expect { described_class.new(:name => "/foo", :ensure => :present, :options => ['ro','foo bar','intr']) }.to raise_error Puppet::Error, /option.*whitespace/
       end
+
+      it "should not support an empty string in options" do
+        expect { described_class.new(:name => "/foo", :ensure => :present, :options => "") }.to raise_error Puppet::Error, /option.*empty string/
+      end
     end
 
     describe "for pass" do
@@ -537,15 +545,23 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
     end
   end
 
-  describe "establishing autorequires" do
+  describe "establishing autorequires and autobefores" do
 
-    def create_resource(path)
+    def create_mount_resource(path)
       described_class.new(
         :name => path,
         :provider => providerclass.new(path)
       )
     end
 
+    def create_file_resource(path)
+      file_class = Puppet::Type.type(:file)
+      file_class.new(
+        :path => path,
+        :provider => file_class.new(:path => path).provider
+      )
+    end
+
     def create_catalog(*resources)
       catalog = Puppet::Resource::Catalog.new
       resources.each do |resource|
@@ -555,38 +571,71 @@ describe Puppet::Type.type(:mount), :unless => Puppet.features.microsoft_windows
       catalog
     end
 
-    let(:root_mount) { create_resource("/") }
-    let(:var_mount)  { create_resource("/var") }
-    let(:log_mount)  { create_resource("/var/log") }
+    let(:root_mount) { create_mount_resource("/") }
+    let(:var_mount)  { create_mount_resource("/var") }
+    let(:log_mount)  { create_mount_resource("/var/log") }
+    let(:var_file) { create_file_resource('/var') }
+    let(:log_file) { create_file_resource('/var/log') }
+    let(:puppet_file) { create_file_resource('/var/log/puppet') }
 
     before do
-      create_catalog(root_mount, var_mount, log_mount)
+      create_catalog(root_mount, var_mount, log_mount, var_file, log_file, puppet_file)
     end
 
     it "adds no autorequires for the root mount" do
       expect(root_mount.autorequire).to be_empty
     end
 
-    it "adds the parent autorequire for a mount with one parent" do
+    it "adds the parent autorequire and the file autorequire for a mount with one parent" do
       parent_relationship = var_mount.autorequire[0]
+      file_relationship = var_mount.autorequire[1]
 
-      expect(var_mount.autorequire).to have_exactly(1).item
+      expect(var_mount.autorequire).to have_exactly(2).items
 
       expect(parent_relationship.source).to eq root_mount
       expect(parent_relationship.target).to eq var_mount
+
+      expect(file_relationship.source).to eq var_file
+      expect(file_relationship.target).to eq var_mount
     end
 
-    it "adds both parent autorequires for a mount with two parents" do
+    it "adds both parent autorequires and the file autorequire for a mount with two parents" do
       grandparent_relationship = log_mount.autorequire[0]
       parent_relationship = log_mount.autorequire[1]
+      file_relationship = log_mount.autorequire[2]
 
-      expect(log_mount.autorequire).to have_exactly(2).items
+      expect(log_mount.autorequire).to have_exactly(3).items
 
       expect(grandparent_relationship.source).to eq root_mount
       expect(grandparent_relationship.target).to eq log_mount
 
       expect(parent_relationship.source).to eq var_mount
       expect(parent_relationship.target).to eq log_mount
+
+      expect(file_relationship.source).to eq log_file
+      expect(file_relationship.target).to eq log_mount
+    end
+
+    it "adds the child autobefore for a mount with one file child" do
+      child_relationship = log_mount.autobefore[0]
+
+      expect(log_mount.autobefore).to have_exactly(1).item
+
+      expect(child_relationship.source).to eq log_mount
+      expect(child_relationship.target).to eq puppet_file
+    end
+
+    it "adds both child autobefores for a mount with two file childs" do
+      child_relationship = var_mount.autobefore[0]
+      grandchild_relationship = var_mount.autobefore[1]
+
+      expect(var_mount.autobefore).to have_exactly(2).items
+
+      expect(child_relationship.source).to eq var_mount
+      expect(child_relationship.target).to eq log_file
+
+      expect(grandchild_relationship.source).to eq var_mount
+      expect(grandchild_relationship.target).to eq puppet_file
     end
   end
 end

data/spec/unit/type/package_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:package) do
   before do
+    Process.stubs(:euid).returns 0
     Puppet::Util::Storage.stubs(:store)
   end
 

data/spec/unit/type/service_spec.rb

@@ -63,6 +63,11 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
       expect(srv.should(:enable)).to eq(:false)
     end
 
+    it "should support :mask as a value" do
+      srv = Puppet::Type.type(:service).new(:name => "yay", :enable => :mask)
+      expect(srv.should(:enable)).to eq(:mask)
+    end
+
     it "should support :manual as a value on Windows" do
       Puppet.features.stubs(:microsoft_windows?).returns true
 
@@ -213,6 +218,22 @@ describe Puppet::Type.type(:service), "when changing the host" do
     @service.property(:enable).sync
   end
 
+  it "should always consider the enable state of a static service to be in sync" do
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    @service.provider.expects(:cached_enabled?).returns('static')
+    @service[:enable] = false
+    Puppet.expects(:debug).with("Unable to enable or disable static service yay")
+    expect(@service.property(:enable).insync?(:true)).to eq(true)
+  end
+
+  it "should determine insyncness normally when the service is not static" do
+    @service.provider.class.stubs(:supports_parameter?).returns(true)
+    @service.provider.expects(:cached_enabled?).returns('true')
+    @service[:enable] = true
+    Puppet.expects(:debug).never
+    expect(@service.property(:enable).insync?(:true)).to eq(true)
+  end
+
   it "should sync the service's enable state when changing the state of :ensure if :enable is being managed" do
     @service.provider.class.stubs(:supports_parameter?).returns(true)
     @service[:enable] = false

data/spec/unit/type/tidy_spec.rb

@@ -66,7 +66,7 @@ describe tidy do
       end
 
       it "should not allow arbitrary values" do
-        expect { @tidy[:recurse] = "whatever" }.to raise_error
+        expect { @tidy[:recurse] = "whatever" }.to raise_error(Puppet::ResourceError, /Parameter recurse failed/)
       end
     end
 
@@ -76,13 +76,13 @@ describe tidy do
       end
 
       it "should object if matches is given with recurse is not specified" do
-        expect { @tidy[:matches] = '*.doh' }.to raise_error
+        expect { @tidy[:matches] = '*.doh' }.to raise_error(Puppet::ResourceError, /Parameter matches failed/)
       end
       it "should object if matches is given and recurse is 0" do
-        expect { @tidy[:recurse] = 0; @tidy[:matches] = '*.doh' }.to raise_error
+        expect { @tidy[:recurse] = 0; @tidy[:matches] = '*.doh' }.to raise_error(Puppet::ResourceError, /Parameter matches failed/)
       end
       it "should object if matches is given and recurse is false" do
-        expect { @tidy[:recurse] = false; @tidy[:matches] = '*.doh' }.to raise_error
+        expect { @tidy[:recurse] = false; @tidy[:matches] = '*.doh' }.to raise_error(Puppet::ResourceError, /Parameter matches failed/)
       end
       it "should not object if matches is given and recurse is > 0" do
         expect { @tidy[:recurse] = 1; @tidy[:matches] = '*.doh' }.not_to raise_error

data/spec/unit/type/user_spec.rb

@@ -344,13 +344,20 @@ describe Puppet::Type.type(:user) do
     end
   end
 
-  describe "when managing comment on Ruby 1.9", :if => String.method_defined?(:encode) do
-    it "should force value encoding to ASCII-8BIT" do
-      value = 'abcd™'
-      expect(value.encoding).to eq(Encoding::UTF_8)
-      user = described_class.new(:name => 'foo', :comment => value)
-      expect(user[:comment].encoding).to eq(Encoding::ASCII_8BIT)
-      expect(user[:comment]).to eq(value.force_encoding(Encoding::ASCII_8BIT))
+  describe "when managing comment" do
+    before :each do
+      @value = 'abcd™'
+      expect(@value.encoding).to eq(Encoding::UTF_8)
+      @user = described_class.new(:name => 'foo', :comment => @value)
+    end
+
+    it "should be converted to ASCII_8BIT for ruby 1.9 / 2.0", :if => RUBY_VERSION < "2.1.0" && String.method_defined?(:encode) do
+      expect(@user[:comment].encoding).to eq(Encoding::ASCII_8BIT)
+      expect(@user[:comment]).to eq(@value.force_encoding(Encoding::ASCII_8BIT))
+    end
+
+    it "must not be converted for ruby >= 2.1", :if => RUBY_VERSION >= "2.1.0" do
+      expect(@user[:comment].encoding).to eq(Encoding::UTF_8)
     end
   end