activeldap 1.0.2 → 1.0.9

data/rails/README

@@ -32,8 +32,8 @@ Here is some examples.
 app/model/member.rb:
   class Member < ActiveLdap::Base
     ldap_mapping :dn_attribute => 'uid',
-                  :classes => ['person', 'posixAccount']
-    belongs_to :primary_group, :class => "Group",
+                 :classes => ['person', 'posixAccount']
+    belongs_to :primary_group, :class_name => "Group",
                :foreign_key => "gidNumber", :primary_key => "gidNumber"
     belongs_to :groups, :many => 'memberUid'
   end

data/rails/init.rb

@@ -1,7 +1,7 @@
 require_library_or_gem 'active_ldap'
 ActiveLdap::Base.logger ||= RAILS_DEFAULT_LOGGER
 
-required_version = ["1", "0", "0"]
+required_version = ["1", "1", "0"]
 if (ActiveLdap::VERSION.split(".") <=> required_version) < 0
   ActiveLdap::Base.class_eval do
     format = _("You need ActiveLdap %s or later")
@@ -13,7 +13,7 @@ ldap_configuration_file = File.join(RAILS_ROOT, 'config', 'ldap.yml')
 if File.exist?(ldap_configuration_file)
   configurations = YAML.load(ERB.new(IO.read(ldap_configuration_file)).result)
   ActiveLdap::Base.configurations = configurations
-  ActiveLdap::Base.establish_connection
+  ActiveLdap::Base.setup_connection
 else
   ActiveLdap::Base.class_eval do
     format = _("You should run 'script/generator scaffold_active_ldap' to make %s.")

data/test/al-test-utils.rb

@@ -80,7 +80,7 @@ module AlTestUtils
     def certificate
       return @@certificate if @@certificate
       if File.exists?(certificate_path)
-        @@certificate = File.read(certificate_path)
+        @@certificate = read_binary_file(certificate_path)
         return @@certificate
       end
 
@@ -123,14 +123,21 @@ module AlTestUtils
     end
 
     def jpeg_photo
-      File.open(jpeg_photo_path, "rb") {|f| f.read}
+      read_binary_file(jpeg_photo_path)
+    end
+
+    def read_binary_file(path)
+      File.open(path, "rb") do |input|
+        input.set_encoding("ascii-8bit") if input.respond_to?(:set_encoding)
+        input.read
+      end
     end
   end
 
   module Connection
     def setup
       super
-      ActiveLdap::Base.establish_connection
+      ActiveLdap::Base.setup_connection
     end
 
     def teardown
@@ -153,7 +160,7 @@ module AlTestUtils
 
     def teardown
       if @dumped_data
-        ActiveLdap::Base.establish_connection
+        ActiveLdap::Base.setup_connection
         ActiveLdap::Base.delete_all(nil, :scope => :sub)
         ActiveLdap::Base.load(@dumped_data)
       end

data/test/run-test.rb

@@ -2,7 +2,7 @@
 
 $VERBOSE = true
 
-$KCODE = 'u'
+$KCODE = 'u' if RUBY_VERSION < "1.9"
 
 require 'yaml'
 
@@ -20,7 +20,11 @@ Dir.glob(test_file) do |file|
   require file
 end
 
-[nil, "ldap", "net-ldap"].each do |adapter|
+target_adapters = [nil]
+# target_adapters << "ldap"
+# target_adapters << "net-ldap"
+# target_adapters << "jndi"
+target_adapters.each do |adapter|
   ENV["ACTIVE_LDAP_TEST_ADAPTER"] = adapter
   puts "using adapter: #{adapter ? adapter : 'default'}"
   args = [File.dirname($0), ARGV.dup]

data/test/test_associations.rb

@@ -225,12 +225,12 @@ class TestAssociations < Test::Unit::TestCase
     mod = Module.new
     mod.__send__(:mattr_accessor, :called)
     mod.__send__(:define_method, :replace) do |entries|
-      super
+      super(entries)
       mod.called = true
     end
     mod.called = false
 
-    @group_class.send(:undef_method, :members, :members=)
+    @group_class.send(:undef_method, :members, :members=, :__make_members)
     @group_class.has_many :members, :wrap => "memberUid",
                           :extend => mod
     @group_class.set_associated_class(:members, @user_class)
@@ -270,7 +270,7 @@ class TestAssociations < Test::Unit::TestCase
           group.members = [user1]
           assert_equal([user1.uid].sort,
                        group.members.collect {|x| x.uid}.sort)
-          assert_equal([user1.uid].sort, group.member_uid.sort)
+          assert_equal(user1.uid, group.member_uid)
           assert_equal(gid_number1, user1.gid_number.to_i)
         end
       end
@@ -452,7 +452,7 @@ class TestAssociations < Test::Unit::TestCase
           group.members << user1
           assert_equal([user1.uid].sort,
                        group.members.collect {|x| x.uid}.sort)
-          assert_equal([user1.uid].sort, group.member_uid.sort)
+          assert_equal(user1.uid, group.member_uid)
           assert_equal(gid_number1, user1.gid_number.to_i)
 
           assert_equal(gid_number2, user2.gid_number.to_i)

data/test/test_attributes.rb

@@ -8,9 +8,11 @@ class TestAttributes < Test::Unit::TestCase
   priority :normal
   def test_to_real_attribute_name
     user = @user_class.new("user")
-    assert_nil(user.__send__(:to_real_attribute_name, "objectclass"))
+    assert_equal("objectClass",
+                 user.__send__(:to_real_attribute_name, "objectclass"))
     assert_equal("objectClass",
                  user.__send__(:to_real_attribute_name, "objectclass", true))
+    assert_nil(user.__send__(:to_real_attribute_name, "objectclass", false))
   end
 
   def test_protect_object_class_from_mass_assignment

data/test/test_base.rb

@@ -6,12 +6,54 @@ class TestBase < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
+  def test_first
+    make_temporary_user(:simple => true) do |user1,|
+      make_temporary_user(:simple => true) do |user2,|
+        assert_equal(user1, @user_class.find(:first))
+        assert_equal(user2, @user_class.find(:first, user2.cn))
+      end
+    end
+  end
+
+  def test_last
+    make_temporary_user(:simple => true) do |user1,|
+      make_temporary_user(:simple => true) do |user2,|
+        assert_equal(user2, @user_class.find(:last))
+        assert_equal(user1, @user_class.find(:last, user1.cn))
+      end
+    end
+  end
+
+  def test_convenient_operation_methods
+    make_temporary_user(:simple => true) do |user1,|
+      make_temporary_user(:simple => true) do |user2,|
+        assert_equal(user1, @user_class.first)
+        assert_equal(user2, @user_class.last)
+        assert_equal([user1, user2], @user_class.all)
+      end
+    end
+  end
+
+  priority :normal
+  def test_set_attributes_with_a_blank_value_in_values
+    make_temporary_user(:simple => true) do |user,|
+      user.attributes = {"description" => ["a", "b", ""]}
+      assert(user.save)
+    end
+  end
+
+  def test_set_attributes_with_a_blank_value
+    make_temporary_user(:simple => true) do |user,|
+      user.attributes = {"description" => [""]}
+      assert(user.save)
+    end
+  end
+
   def test_create_invalid
     user = @user_class.create
     assert_not_predicate(user.errors, :empty?)
   end
 
-  priority :normal
   def test_id_with_invalid_dn_attribute_value
     user = @user_class.new("#")
     assert_equal("#", user.uid)
@@ -36,16 +78,18 @@ class TestBase < Test::Unit::TestCase
     end
   end
 
-  def test_destroy_with_empty_base_of_class
+  def test_destroy_with_empty_base_and_prefix_of_class
     make_temporary_user do |user,|
       base = user.class.base
+      prefix = user.class.prefix
       begin
         user.class.base = ""
-        user.prefix = ""
+        user.class.prefix = ""
         user.base = base
         user.destroy
       ensure
         user.class.base = base
+        user.class.prefix = prefix
       end
     end
   end
@@ -76,13 +120,13 @@ class TestBase < Test::Unit::TestCase
   end
 
   def test_to_s
-    make_temporary_group do |group,|
+    make_temporary_group do |group|
       assert_equal(group.to_s, group.to_ldif)
     end
   end
 
   def test_to_ldif
-    make_temporary_group do |group,|
+    make_temporary_group do |group|
       assert_to_ldif(group)
 
       group.gidNumber += 1
@@ -626,7 +670,8 @@ EOX
 EOX
 
     make_temporary_user do |user, password|
-      assert_equal(<<-EOX, user.to_xml(:root => "user"))
+      xml = normalize_attributes_order(user.to_xml(:root => "user"))
+      assert_equal(<<-EOX, xml)
 <user>
   <dn>#{user.dn}</dn>
   <cns type="array">
@@ -652,7 +697,7 @@ EOX
   </uids>
   <uidNumber>#{user.uid_number}</uidNumber>
   <userCertificates type="array">
-    <userCertificate binary="true" base64="true">#{base64(certificate)}</userCertificate>
+    <userCertificate base64="true" binary="true">#{base64(certificate)}</userCertificate>
   </userCertificates>
   <userPasswords type="array">
     <userPassword>#{user.user_password}</userPassword>
@@ -761,13 +806,13 @@ EOX
 
   def test_have_attribute?
     make_temporary_user do |user, password|
-      assert(user.have_attribute?(:cn))
-      assert(user.have_attribute?(:commonName))
-      assert(user.have_attribute?(:common_name))
-      assert(!user.have_attribute?(:commonname))
-      assert(!user.have_attribute?(:COMMONNAME))
+      assert_true(user.have_attribute?(:cn))
+      assert_true(user.have_attribute?(:commonName))
+      assert_true(user.have_attribute?(:common_name))
+      assert_true(user.have_attribute?(:commonname))
+      assert_true(user.have_attribute?(:COMMONNAME))
 
-      assert(!user.have_attribute?(:unknown_attribute))
+      assert_false(user.have_attribute?(:unknown_attribute))
     end
   end
 
@@ -791,7 +836,7 @@ EOX
 
   def test_update_all
     make_temporary_user do |user, password|
-      make_temporary_user do |user2, password|
+      make_temporary_user do |user2, password2|
         user2_cn = user2.cn
         new_cn = "New #{user.cn}"
         @user_class.update_all({:cn => new_cn}, user.uid)
@@ -817,7 +862,7 @@ EOX
       new_user = @user_class.update(user.dn, {:cn => new_cn})
       assert_equal(new_cn, new_user.cn)
 
-      make_temporary_user do |user2, password|
+      make_temporary_user do |user2, password2|
         new_sns = ["New SN1", "New SN2"]
         new_cn2 = "New #{user2.cn}"
         new_user, new_user2 = @user_class.update([user.dn, user2.dn],
@@ -862,4 +907,19 @@ EOX
   def base64(string)
     [string].pack("m").gsub(/\n/u, "")
   end
+
+  def normalize_attributes_order(xml)
+    xml.gsub(/<(\S+) (.+?)(\/?)>/) do |matched|
+      name = $1
+      attributes = $2
+      close_mark = $3
+      attributes = attributes.scan(/(\S+)="(.+?)"/)
+      normalized_attributes = attributes.sort_by do |key, value|
+        key
+      end.collect do |key, value|
+        "#{key}=\"#{value}\""
+      end.join(' ')
+      "<#{name} #{normalized_attributes}#{close_mark}>"
+    end
+  end
 end

data/test/test_base_per_instance.rb

@@ -9,6 +9,13 @@ class TestBasePerInstance < Test::Unit::TestCase
   end
 
   priority :must
+  def test_set_base
+    guest = @user_class.new("guest")
+    guest.base = "ou=Sub"
+    assert_equal("uid=guest,ou=Sub,#{@user_class.base}", guest.dn)
+  end
+
+  priority :normal
   def test_dn_is_base
     entry_class = Class.new(ActiveLdap::Base)
     entry_class.ldap_mapping :prefix => "",
@@ -21,7 +28,6 @@ class TestBasePerInstance < Test::Unit::TestCase
     assert_equal(entry_class.base, entry.base)
   end
 
-  priority :normal
   def test_loose_dn
     user = @user_class.new("test-user , ou = Sub")
     assert_equal("uid=test-user,ou=Sub,#{@user_class.base}", user.dn)

data/test/test_bind.rb

@@ -29,9 +29,8 @@ class TestBind < Test::Unit::TestCase
     assert(!ActiveLdap::Base.connected?)
     config = ActiveLdap::Base.configurations[LDAP_ENV].symbolize_keys
     config = ActiveLdap::Base.prepare_configuration(config)
-    if config[:bind_dn].nil?
-      puts "pass this test for no user configuration"
-      return
+    if config[:bind_dn].nil? and !config[:try_sasl]
+      omit("need user configuration")
     end
     assert_nothing_raised do
       config[:allow_anonymous] = false
@@ -48,6 +47,7 @@ class TestBind < Test::Unit::TestCase
       config = ActiveLdap::Base.configurations[LDAP_ENV].symbolize_keys
       config = ActiveLdap::Base.prepare_configuration(config)
       config.delete(:bind_dn)
+      config[:try_sasl] = false
       config[:allow_anonymous] = false
       connect(config)
     end
@@ -56,7 +56,7 @@ class TestBind < Test::Unit::TestCase
 
   private
   def connect(config)
-    ActiveLdap::Base.establish_connection(config)
+    ActiveLdap::Base.setup_connection(config)
     ActiveLdap::Base.connection.connect
   end
 end

data/test/test_connection.rb

@@ -14,17 +14,33 @@ class TestConnection < Test::Unit::TestCase
   end
 
   priority :must
+  def test_retry_limit_0_with_existent_host
+    config = current_configuration.merge("retry_limit" => 0)
+    ActiveLdap::Base.setup_connection(config)
+    assert_nothing_raised do
+      ActiveLdap::Base.find(:all)
+    end
+  end
+
+  def test_retry_limit_0_with_nonexistent_host_with_timeout
+    config = current_configuration.merge("host" => "192.168.29.29",
+                                         "retry_limit" => 0,
+                                         "timeout" => 1)
+    ActiveLdap::Base.setup_connection(config)
+    assert_raise(ActiveLdap::TimeoutError) do
+      ActiveLdap::Base.find(:first)
+    end
+  end
 
-  priority :normal
   def test_bind_format_check
     connector = Class.new(ActiveLdap::Base)
     assert(!connector.connected?)
     exception = nil
     assert_raises(ArgumentError) do
       begin
-        connector.establish_connection(:adapter => adapter,
-                                       :bind_format => "uid=%s,dc=test",
-                                       :allow_anonymous => false)
+        connector.setup_connection(:adapter => adapter,
+                                   :bind_format => "uid=%s,dc=test",
+                                   :allow_anonymous => false)
         connector.connection.connect
       rescue Exception
         exception = $!
@@ -38,23 +54,29 @@ class TestConnection < Test::Unit::TestCase
     assert(!ActiveLdap::Base.connected?)
 
     config = current_configuration.merge("retry_limit" => 10)
-    ActiveLdap::Base.establish_connection(config)
+    ActiveLdap::Base.setup_connection(config)
     connection = ActiveLdap::Base.connection
-    assert(!connection.send(:can_reconnect?, :reconnect_attempts => 10))
+    assert(!connection.send(:can_reconnect?, :reconnect_attempts => 11))
 
     config = current_configuration.merge("retry_limit" => 10)
-    ActiveLdap::Base.establish_connection(config)
+    ActiveLdap::Base.setup_connection(config)
     connection = ActiveLdap::Base.connection
-    assert(!connection.send(:can_reconnect?, :reconnect_attempts => 9))
-
-    config = current_configuration.merge("retry_limit" => 10)
-    ActiveLdap::Base.establish_connection(config)
-    connection = ActiveLdap::Base.connection
-    assert(connection.send(:can_reconnect?, :reconnect_attempts => 8))
+    assert(connection.send(:can_reconnect?, :reconnect_attempts => 10))
 
     config = current_configuration.merge("retry_limit" => -1)
-    ActiveLdap::Base.establish_connection(config)
+    ActiveLdap::Base.setup_connection(config)
     connection = ActiveLdap::Base.connection
     assert(connection.send(:can_reconnect?, :reconnect_attempts => -10))
   end
+
+  priority :low
+  def test_retry_limit_0_with_nonexistent_host
+    config = current_configuration.merge("host" => "192.168.29.29",
+                                         "retry_limit" => 0)
+    ActiveLdap::Base.setup_connection(config)
+    notify("maybe take a long time")
+    assert_raise(ActiveLdap::ConnectionError) do
+      ActiveLdap::Base.find(:first)
+    end
+  end
 end

data/test/test_connection_per_class.rb

@@ -4,7 +4,7 @@ class TestConnectionPerClass < Test::Unit::TestCase
   include AlTestUtils
 
   priority :must
-  def test_multi_establish_connections_with_association
+  def test_multi_setup_connections_with_association
     make_ou("Sub,ou=Users")
     make_ou("Sub2,ou=Users")
 
@@ -30,7 +30,7 @@ class TestConnectionPerClass < Test::Unit::TestCase
   end
 
   priority :normal
-  def test_multi_establish_connections
+  def test_multi_setup_connections
     make_ou("Sub")
     make_ou("Sub2")
     sub_class = ou_class("ou=Sub")
@@ -46,9 +46,9 @@ class TestConnectionPerClass < Test::Unit::TestCase
     sub2_base = "ou=Sub2,#{current_base}"
     sub2_configuration[:base] = sub2_base
 
-    sub_class.establish_connection(sub_configuration)
+    sub_class.setup_connection(sub_configuration)
     sub_class.prefix = nil
-    sub2_class.establish_connection(sub2_configuration)
+    sub2_class.setup_connection(sub2_configuration)
     sub2_class.prefix = nil
 
     assert_equal([sub_base], sub_class.find(:all).collect(&:dn))
@@ -106,7 +106,7 @@ class TestConnectionPerClass < Test::Unit::TestCase
 
   private
   def connect(klass, config)
-    klass.establish_connection({:adapter => adapter}.merge(config))
+    klass.setup_connection({:adapter => adapter}.merge(config))
     klass.connection.connect
   end
 end

data/test/test_connection_per_dn.rb

@@ -8,12 +8,12 @@ class TestConnectionPerDN < Test::Unit::TestCase
     make_temporary_user do |user, password|
       assert_equal(user.class.connection, user.connection)
       assert_raises(ActiveLdap::AuthenticationError) do
-        user.bind("")
+        user.bind("", :try_sasl => false)
       end
       assert_equal(user.class.connection, user.connection)
 
       assert_nothing_raised do
-        user.bind("", :allow_anonymous => true)
+        user.bind("", :try_sasl => false, :allow_anonymous => true)
       end
       assert_not_equal(user.class.connection, user.connection)
     end
@@ -29,7 +29,7 @@ class TestConnectionPerDN < Test::Unit::TestCase
       assert_not_equal(user.class.connection, user.connection)
 
       assert_raises(ActiveLdap::AuthenticationError) do
-        user.bind(password + "-WRONG")
+        user.bind(password + "-WRONG", :try_sasl => false)
       end
     end
   end
@@ -39,6 +39,7 @@ class TestConnectionPerDN < Test::Unit::TestCase
       assert_equal(user.class.connection, user.connection)
       assert_raises(ActiveLdap::AuthenticationError) do
         user.bind(:bind_dn => nil,
+                  :try_sasl => false,
                   :allow_anonymous => false,
                   :retry_limit => 0)
       end
@@ -46,12 +47,17 @@ class TestConnectionPerDN < Test::Unit::TestCase
 
       assert_nothing_raised do
         user.bind(:bind_dn => nil,
+                  :try_sasl => false,
                   :allow_anonymous => true)
       end
       assert_not_equal(user.class.connection, user.connection)
 
       assert_equal(user.connection, user.class.find(user.dn).connection)
-      assert_equal(user.connection, user.find(user.dn).connection)
+      begin
+        assert_equal(user.connection, user.find(user.dn).connection)
+      rescue ActiveLdap::EntryNotFound
+        omit("requires permission for searching by 'uid' to anonymous user.")
+      end
     end
   end
 
@@ -82,7 +88,7 @@ class TestConnectionPerDN < Test::Unit::TestCase
           user.groups = [group1]
           assert_equal(group1.connection, user.connection)
 
-          user.bind(password)
+          user.bind(password, :try_sasl => false)
           assert_not_equal(user.class.connection, user.connection)
           assert_not_equal(group1.connection, user.connection)
           assert_equal(user.groups[0].connection, user.connection)

data/test/test_groupadd.rb

@@ -12,7 +12,7 @@ class TestGroupadd < Test::Unit::TestCase
 
   priority :normal
   def test_exist_group
-    make_temporary_group do |group, password|
+    make_temporary_group do |group|
       assert(@group_class.exists?(group.id))
       assert_equal([false, "Group #{group.id} already exists.\n"],
                    run_command(group.id))
@@ -21,7 +21,7 @@ class TestGroupadd < Test::Unit::TestCase
   end
 
   def test_add_group
-    ensure_delete_group("test-group") do |gid,|
+    ensure_delete_group("test-group") do |gid|
       assert_groupadd_successfully(gid)
     end
   end

data/test/test_groupdel.rb

@@ -12,7 +12,7 @@ class TestGroupdel < Test::Unit::TestCase
 
   priority :normal
   def test_non_exist_group
-    ensure_delete_group("test-group") do |name,|
+    ensure_delete_group("test-group") do |name|
       assert(!@group_class.exists?(name))
       assert_equal([false, "Group #{name} doesn't exist.\n"], run_command(name))
       assert(!@group_class.exists?(name))
@@ -20,7 +20,7 @@ class TestGroupdel < Test::Unit::TestCase
   end
 
   def test_delete_group
-    make_temporary_group do |group, password|
+    make_temporary_group do |group|
       assert_groupdel_successfully(group.id)
     end
   end

data/test/test_groupls.rb

@@ -14,7 +14,7 @@ class TestGroupls < Test::Unit::TestCase
 
   priority :normal
   def test_non_exist_group
-    ensure_delete_group("test-group") do |name,|
+    ensure_delete_group("test-group") do |name|
       assert(!@group_class.exists?(name))
       assert_equal([false, "Group #{name} doesn't exist.\n"], run_command(name))
       assert(!@group_class.exists?(name))

data/test/test_groupmod.rb

@@ -12,7 +12,7 @@ class TestGroupmod < Test::Unit::TestCase
 
   priority :normal
   def test_non_exist_group
-    ensure_delete_group("test-group") do |name,|
+    ensure_delete_group("test-group") do |name|
       assert(!@group_class.exists?(name))
       assert_equal([false, "Group #{name} doesn't exist.\n"],
                    run_command(name, 111111))
@@ -21,7 +21,7 @@ class TestGroupmod < Test::Unit::TestCase
   end
 
   def test_modify_group
-    make_temporary_group do |group, password|
+    make_temporary_group do |group|
       assert_groupmod_successfully(group.cn, group.gid_number.succ)
     end
   end

data/test/test_ldif.rb

@@ -1212,6 +1212,7 @@ uid: hjensen
 telephonenumber: +1 408 555 1212
 jpegphoto:< file://#{jpeg_photo_path}
 EOL
+    set_encoding(ldif_source, "utf-8")
 
     jpeg_photo_attribute = "jpegphoto:: "
     value = [jpeg_photo].pack("m").gsub(/\n/, '')
@@ -1295,6 +1296,7 @@ sn;lang-en: Ogasawara
 cn;lang-en: Rodney Ogasawara
 title;lang-en: Sales, Director
 EOL
+    set_encoding(ldif_source, "utf-8")
 
     record1 = {
       "dn" => "ou=営業部,o=Airius",
@@ -1422,6 +1424,7 @@ sn;lang-en: Ogasawara
 cn;lang-en: Rodney Ogasawara
 title;lang-en: Sales, Director
 EOL
+    set_encoding(ldif_source, "utf-8")
 
     assert_ldif_to_s(<<-EOL, ldif_source)
 version: 1
@@ -1833,12 +1836,15 @@ EOL
 
   private
   def assert_ldif(version, records, ldif_source)
+    encoding = ldif_source.encoding if ldif_source.respond_to?(:encoding)
     ldif = ActiveLdap::Ldif.parse(ldif_source)
     assert_equal(version, ldif.version)
     assert_equal(records,
                  ldif.records.collect {|record| record.to_hash})
 
-    reparsed_ldif = ActiveLdap::Ldif.parse(ldif.to_s)
+    regenerated_ldif = ldif.to_s
+    set_encoding(regenerated_ldif, encoding)
+    reparsed_ldif = ActiveLdap::Ldif.parse(regenerated_ldif)
     assert_equal(ldif, reparsed_ldif)
 
     ldif
@@ -1869,4 +1875,8 @@ EOL
     ldif = ActiveLdap::Ldif.parse(original_ldif_source)
     assert_equal(expected_ldif_source, ldif.to_s)
   end
+
+  def set_encoding(string, encoding)
+    string.force_encoding("utf-8") if string.respond_to?(:force_encoding)
+  end
 end