net-ldap 0.15.0 → 0.19.0

data/test/integration/test_return_codes.rb

@@ -1,38 +0,0 @@
-require_relative '../test_helper'
-
-# NOTE: These tests depend on the OpenLDAP retcode overlay.
-# See: section 12.12 http://www.openldap.org/doc/admin24/overlays.html
-
-class TestReturnCodeIntegration < LDAPIntegrationTestCase
-  def test_operations_error
-    refute @ldap.search(filter: "cn=operationsError", base: "ou=Retcodes,dc=rubyldap,dc=com")
-    assert result = @ldap.get_operation_result
-
-    assert_equal Net::LDAP::ResultCodeOperationsError, result.code
-    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeOperationsError], result.message
-  end
-
-  def test_protocol_error
-    refute @ldap.search(filter: "cn=protocolError", base: "ou=Retcodes,dc=rubyldap,dc=com")
-    assert result = @ldap.get_operation_result
-
-    assert_equal Net::LDAP::ResultCodeProtocolError, result.code
-    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeProtocolError], result.message
-  end
-
-  def test_time_limit_exceeded
-    assert @ldap.search(filter: "cn=timeLimitExceeded", base: "ou=Retcodes,dc=rubyldap,dc=com")
-    assert result = @ldap.get_operation_result
-
-    assert_equal Net::LDAP::ResultCodeTimeLimitExceeded, result.code
-    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeTimeLimitExceeded], result.message
-  end
-
-  def test_size_limit_exceeded
-    assert @ldap.search(filter: "cn=sizeLimitExceeded", base: "ou=Retcodes,dc=rubyldap,dc=com")
-    assert result = @ldap.get_operation_result
-
-    assert_equal Net::LDAP::ResultCodeSizeLimitExceeded, result.code
-    assert_equal Net::LDAP::ResultStrings[Net::LDAP::ResultCodeSizeLimitExceeded], result.message
-  end
-end

data/test/integration/test_search.rb

@@ -1,77 +0,0 @@
-require_relative '../test_helper'
-
-class TestSearchIntegration < LDAPIntegrationTestCase
-  def test_search
-    entries = []
-
-    result = @ldap.search(base: "dc=rubyldap,dc=com") do |entry|
-      assert_kind_of Net::LDAP::Entry, entry
-      entries << entry
-    end
-
-    refute entries.empty?
-    assert_equal entries, result
-  end
-
-  def test_search_without_result
-    entries = []
-
-    result = @ldap.search(base: "dc=rubyldap,dc=com", return_result: false) do |entry|
-      assert_kind_of Net::LDAP::Entry, entry
-      entries << entry
-    end
-
-    assert result
-    refute_equal entries, result
-  end
-
-  def test_search_filter_string
-    entries = @ldap.search(base: "dc=rubyldap,dc=com", filter: "(uid=user1)")
-    assert_equal 1, entries.size
-  end
-
-  def test_search_filter_object
-    filter = Net::LDAP::Filter.eq("uid", "user1") | Net::LDAP::Filter.eq("uid", "user2")
-    entries = @ldap.search(base: "dc=rubyldap,dc=com", filter: filter)
-    assert_equal 2, entries.size
-  end
-
-  def test_search_constrained_attributes
-    entry = @ldap.search(base: "uid=user1,ou=People,dc=rubyldap,dc=com", attributes: ["cn", "sn"]).first
-    assert_equal [:cn, :dn, :sn], entry.attribute_names.sort  # :dn is always included
-    assert_empty entry[:mail]
-  end
-
-  def test_search_attributes_only
-    entry = @ldap.search(base: "uid=user1,ou=People,dc=rubyldap,dc=com", attributes_only: true).first
-
-    assert_empty entry[:cn], "unexpected attribute value: #{entry[:cn]}"
-  end
-
-  def test_search_timeout
-    entries = []
-    events = @service.subscribe "search.net_ldap_connection"
-
-    result = @ldap.search(base: "dc=rubyldap,dc=com", time: 5) do |entry|
-      assert_kind_of Net::LDAP::Entry, entry
-      entries << entry
-    end
-
-    payload, = events.pop
-    assert_equal 5, payload[:time]
-    assert_equal entries, result
-  end
-
-  # http://tools.ietf.org/html/rfc4511#section-4.5.1.4
-  def test_search_with_size
-    entries = []
-
-    result = @ldap.search(base: "dc=rubyldap,dc=com", size: 1) do |entry|
-      assert_kind_of Net::LDAP::Entry, entry
-      entries << entry
-    end
-
-    assert_equal 1, result.size
-    assert_equal entries, result
-  end
-end

data/test/support/vm/openldap/.gitignore

@@ -1 +0,0 @@
-/.vagrant

data/test/support/vm/openldap/README.md

@@ -1,32 +0,0 @@
-# Local OpenLDAP Integration Testing
-
-Set up a [Vagrant](http://www.vagrantup.com/) VM to run integration tests against OpenLDAP locally.
-
-To run integration tests locally:
-
-``` bash
-# start VM (from the correct directory)
-$ cd test/support/vm/openldap/
-$ vagrant up
-
-# get the IP address of the VM
-$ ip=$(vagrant ssh -- "ifconfig eth1 | grep -o -E '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | head -n1")
-
-# change back to root project directory
-$ cd ../../../..
-
-# run all tests, including integration tests
-$ time INTEGRATION=openldap INTEGRATION_HOST=$ip bundle exec rake
-
-# run a specific integration test file
-$ time INTEGRATION=openldap INTEGRATION_HOST=$ip bundle exec ruby test/integration/test_search.rb
-
-# run integration tests by default
-$ export INTEGRATION=openldap
-$ export INTEGRATION_HOST=$ip
-
-# now run tests without having to set ENV variables
-$ time bundle exec rake
-```
-
-You may need to `gem install vagrant` first in order to provision the VM.

data/test/support/vm/openldap/Vagrantfile

@@ -1,33 +0,0 @@
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
-VAGRANTFILE_API_VERSION = "2"
-
-Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
-  config.vm.hostname = "rubyldap.com"
-
-  config.vm.box = "hashicorp/precise64"
-
-  config.vm.network "private_network", type: :dhcp
-
-  config.ssh.forward_agent = true
-
-  config.vm.provision "shell", inline: "apt-get update; exec env /vagrant_data/script/install-openldap"
-
-  config.vm.synced_folder "../../../..", "/vagrant_data"
-
-  config.vm.provider "vmware_fusion" do |vb, override|
-    override.vm.box = "hashicorp/precise64"
-    vb.memory = 4596
-    vb.vmx["displayname"] = "integration tests vm"
-    vb.vmx["numvcpus"] = "2"
-  end
-
-  config.vm.provider "virtualbox" do |vb, override|
-    vb.memory = 4096
-    vb.customize ["modifyvm", :id, "--nicpromisc2", "allow-all"]
-    vb.customize ["modifyvm", :id, "--chipset", "ich9"]
-    vb.customize ["modifyvm", :id, "--vram", "16"]
-  end
-end

data/test/test_auth_adapter.rb

@@ -1,15 +0,0 @@
-require 'test_helper'
-
-class TestAuthAdapter < Test::Unit::TestCase
-  class FakeSocket
-    def initialize(*args)
-    end
-  end
-
-  def test_undefined_auth_adapter
-    conn = Net::LDAP::Connection.new(host: 'ldap.example.com', port: 379, :socket_class => FakeSocket)
-    assert_raise Net::LDAP::AuthMethodUnsupportedError, "Unsupported auth method (foo)" do
-      conn.bind(method: :foo)
-    end
-  end
-end

data/test/test_dn.rb

@@ -1,44 +0,0 @@
-require_relative 'test_helper'
-require 'net/ldap/dn'
-
-class TestDN < Test::Unit::TestCase
-  def test_escape
-    assert_equal '\\,\\+\\"\\\\\\<\\>\\;', Net::LDAP::DN.escape(',+"\\<>;')
-  end
-
-  def test_escape_on_initialize
-    dn = Net::LDAP::DN.new('cn', ',+"\\<>;', 'ou=company')
-    assert_equal 'cn=\\,\\+\\"\\\\\\<\\>\\;,ou=company', dn.to_s
-  end
-
-  def test_to_a
-    dn = Net::LDAP::DN.new('cn=James, ou=Company\\,\\20LLC')
-    assert_equal ['cn', 'James', 'ou', 'Company, LLC'], dn.to_a
-  end
-
-  def test_to_a_parenthesis
-    dn = Net::LDAP::DN.new('cn =  \ James , ou  =  "Comp\28ny"  ')
-    assert_equal ['cn', ' James', 'ou', 'Comp(ny'], dn.to_a
-  end
-
-  def test_to_a_hash_symbol
-    dn = Net::LDAP::DN.new('1.23.4=  #A3B4D5  ,ou=Company')
-    assert_equal ['1.23.4', '#A3B4D5', 'ou', 'Company'], dn.to_a
-  end
-
-  # TODO: raise a more specific exception than RuntimeError
-  def test_bad_input_raises_error
-    [
-      'cn=James,',
-      'cn=#aa aa',
-      'cn="James',
-      'cn=J\ames',
-      'cn=\\',
-      '1.2.d=Value',
-      'd1.2=Value',
-    ].each do |input|
-      dn = Net::LDAP::DN.new(input)
-      assert_raises(RuntimeError) { dn.to_a }
-    end
-  end
-end

data/test/test_entry.rb

@@ -1,65 +0,0 @@
-require_relative 'test_helper'
-
-class TestEntry < Test::Unit::TestCase
-  def setup
-    @entry = Net::LDAP::Entry.new 'cn=Barbara,o=corp'
-  end
-
-  def test_dn
-    assert_equal 'cn=Barbara,o=corp', @entry.dn
-  end
-
-  def test_empty_array_when_accessing_nonexistent_attribute
-    assert_equal [], @entry['sn']
-  end
-
-  def test_attribute_assignment
-    @entry['sn'] = 'Jensen'
-    assert_equal ['Jensen'], @entry['sn']
-    assert_equal ['Jensen'], @entry.sn
-    assert_equal ['Jensen'], @entry[:sn]
-
-    @entry[:sn] = 'Jensen'
-    assert_equal ['Jensen'], @entry['sn']
-    assert_equal ['Jensen'], @entry.sn
-    assert_equal ['Jensen'], @entry[:sn]
-
-    @entry.sn = 'Jensen'
-    assert_equal ['Jensen'], @entry['sn']
-    assert_equal ['Jensen'], @entry.sn
-    assert_equal ['Jensen'], @entry[:sn]
-  end
-
-  def test_case_insensitive_attribute_names
-    @entry['sn'] = 'Jensen'
-    assert_equal ['Jensen'], @entry.sn
-    assert_equal ['Jensen'], @entry.Sn
-    assert_equal ['Jensen'], @entry.SN
-    assert_equal ['Jensen'], @entry['sn']
-    assert_equal ['Jensen'], @entry['Sn']
-    assert_equal ['Jensen'], @entry['SN']
-  end
-end
-
-class TestEntryLDIF < Test::Unit::TestCase
-  def setup
-    @entry = Net::LDAP::Entry.from_single_ldif_string(
-      %Q{dn: something
-foo: foo
-barAttribute: bar
-      })
-  end
-
-  def test_attribute
-    assert_equal ['foo'], @entry.foo
-    assert_equal ['foo'], @entry.Foo
-  end
-
-  def test_modify_attribute
-    @entry.foo = 'bar'
-    assert_equal ['bar'], @entry.foo
-
-    @entry.fOo= 'baz'
-    assert_equal ['baz'], @entry.foo
-  end
-end

data/test/test_filter.rb

@@ -1,223 +0,0 @@
-require_relative 'test_helper'
-
-class TestFilter < Test::Unit::TestCase
-  Filter = Net::LDAP::Filter
-
-  def test_bug_7534_rfc2254
-    assert_equal("(cn=Tim Wizard)",
-                 Filter.from_rfc2254("(cn=Tim Wizard)").to_rfc2254)
-  end
-
-  def test_invalid_filter_string
-    assert_raises(Net::LDAP::FilterSyntaxInvalidError) { Filter.from_rfc2254("") }
-  end
-
-  def test_invalid_filter
-    assert_raises(Net::LDAP::OperatorError) do
-      # This test exists to prove that our constructor blocks unknown filter
-      # types. All filters must be constructed using helpers.
-      Filter.__send__(:new, :xx, nil, nil)
-    end
-  end
-
-  def test_to_s
-    assert_equal("(uid=george *)", Filter.eq("uid", "george *").to_s)
-  end
-
-  def test_convenience_filters
-    assert_equal("(uid=\\2A)", Filter.equals("uid", "*").to_s)
-    assert_equal("(uid=\\28*)", Filter.begins("uid", "(").to_s)
-    assert_equal("(uid=*\\29)", Filter.ends("uid", ")").to_s)
-    assert_equal("(uid=*\\5C*)", Filter.contains("uid", "\\").to_s)
-  end
-
-  def test_c2
-    assert_equal("(uid=george *)",
-                 Filter.from_rfc2254("uid=george *").to_rfc2254)
-    assert_equal("(uid:=george *)",
-                 Filter.from_rfc2254("uid:=george *").to_rfc2254)
-    assert_equal("(uid=george*)",
-                 Filter.from_rfc2254(" ( uid =  george*   ) ").to_rfc2254)
-    assert_equal("(!(uid=george*))",
-                 Filter.from_rfc2254("uid!=george*").to_rfc2254)
-    assert_equal("(uid<=george*)",
-                 Filter.from_rfc2254("uid <= george*").to_rfc2254)
-    assert_equal("(uid>=george*)",
-                 Filter.from_rfc2254("uid>=george*").to_rfc2254)
-    assert_equal("(&(uid=george*)(mail=*))",
-                 Filter.from_rfc2254("(& (uid=george* ) (mail=*))").to_rfc2254)
-    assert_equal("(|(uid=george*)(mail=*))",
-                 Filter.from_rfc2254("(| (uid=george* ) (mail=*))").to_rfc2254)
-    assert_equal("(!(mail=*))",
-                 Filter.from_rfc2254("(! (mail=*))").to_rfc2254)
-  end
-
-  def test_filter_with_single_clause
-    assert_equal("(cn=name)", Net::LDAP::Filter.construct("(&(cn=name))").to_s)
-  end
-
-  def test_filters_from_ber
-    [
-      Net::LDAP::Filter.eq("objectclass", "*"),
-      Net::LDAP::Filter.pres("objectclass"),
-      Net::LDAP::Filter.eq("objectclass", "ou"),
-      Net::LDAP::Filter.ge("uid", "500"),
-      Net::LDAP::Filter.le("uid", "500"),
-      (~ Net::LDAP::Filter.pres("objectclass")),
-      (Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou")),
-      (Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou") & Net::LDAP::Filter.pres("sn")),
-      (Net::LDAP::Filter.pres("objectclass") | Net::LDAP::Filter.pres("ou") | Net::LDAP::Filter.pres("sn")),
-
-      Net::LDAP::Filter.eq("objectclass", "*aaa"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc"),
-      Net::LDAP::Filter.eq("objectclass", "abc*def*1111*22*g"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc*"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc*"),
-    ].each do |ber|
-      f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
-      assert(f == ber)
-      assert_equal(f.to_ber, ber.to_ber)
-    end
-  end
-
-  def test_ber_from_rfc2254_filter
-    [
-      Net::LDAP::Filter.construct("objectclass=*"),
-      Net::LDAP::Filter.construct("objectclass=ou"),
-      Net::LDAP::Filter.construct("uid >= 500"),
-      Net::LDAP::Filter.construct("uid <= 500"),
-      Net::LDAP::Filter.construct("(!(uid=*))"),
-      Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*))"),
-      Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*)(sn=*))"),
-      Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*))"),
-      Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*)(sn=*))"),
-
-      Net::LDAP::Filter.construct("objectclass=*aaa"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb"),
-      Net::LDAP::Filter.construct("objectclass=*aaa bbb"),
-      Net::LDAP::Filter.construct("objectclass=*aaa  bbb"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc"),
-      Net::LDAP::Filter.construct("objectclass=abc*def*1111*22*g"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc*"),
-      Net::LDAP::Filter.construct("objectclass=aaa*"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb*"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc*"),
-    ].each do |ber|
-      f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
-      assert(f == ber)
-      assert_equal(f.to_ber, ber.to_ber)
-    end
-  end
-end
-
-# tests ported over from rspec. Not sure if these overlap with the above
-# https://github.com/ruby-ldap/ruby-net-ldap/pull/121
-class TestFilterRSpec < Test::Unit::TestCase
-  def test_ex_convert
-    assert_equal '(foo:=bar)', Net::LDAP::Filter.ex('foo', 'bar').to_s
-  end
-
-  def test_ex_rfc2254_roundtrip
-    filter = Net::LDAP::Filter.ex('foo', 'bar')
-    assert_equal filter, Net::LDAP::Filter.from_rfc2254(filter.to_s)
-  end
-
-  def test_ber_conversion
-    filter = Net::LDAP::Filter.ex('foo', 'bar')
-    ber = filter.to_ber
-    assert_equal filter, Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax))
-  end
-
-  [
-    '(o:dn:=Ace Industry)',
-    '(:dn:2.4.8.10:=Dino)',
-    '(cn:dn:1.2.3.4.5:=John Smith)',
-    '(sn:dn:2.4.6.8.10:=Barbara Jones)',
-    '(&(sn:dn:2.4.6.8.10:=Barbara Jones))',
-  ].each_with_index do |filter_str, index|
-    define_method "test_decode_filter_#{index}" do
-      filter = Net::LDAP::Filter.from_rfc2254(filter_str)
-      assert_kind_of Net::LDAP::Filter, filter
-    end
-
-    define_method "test_ber_conversion_#{index}" do
-      filter = Net::LDAP::Filter.from_rfc2254(filter_str)
-      ber = Net::LDAP::Filter.from_rfc2254(filter_str).to_ber
-      assert_equal filter, Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax))
-    end
-  end
-
-  def test_apostrophes
-    assert_equal "(uid=O'Keefe)", Net::LDAP::Filter.construct("uid=O'Keefe").to_rfc2254
-  end
-
-  def test_equals
-    assert_equal Net::LDAP::Filter.eq('dn', 'f\2Aoo'), Net::LDAP::Filter.equals('dn', 'f*oo')
-  end
-
-  def test_begins
-    assert_equal Net::LDAP::Filter.eq('dn', 'f\2Aoo*'), Net::LDAP::Filter.begins('dn', 'f*oo')
-  end
-
-  def test_ends
-    assert_equal Net::LDAP::Filter.eq('dn', '*f\2Aoo'), Net::LDAP::Filter.ends('dn', 'f*oo')
-  end
-
-  def test_contains
-    assert_equal Net::LDAP::Filter.eq('dn', '*f\2Aoo*'), Net::LDAP::Filter.contains('dn', 'f*oo')
-  end
-
-  def test_escape
-    # escapes nul, *, (, ) and \\
-    assert_equal "\\00\\2A\\28\\29\\5C", Net::LDAP::Filter.escape("\0*()\\")
-  end
-
-  def test_well_known_ber_string
-    ber = "\xa4\x2d" \
-      "\x04\x0b" "objectclass" \
-      "\x30\x1e" \
-      "\x80\x08" "foo" "*\\" "bar" \
-      "\x81\x08" "foo" "*\\" "bar" \
-      "\x82\x08" "foo" "*\\" "bar".b
-
-    [
-      "foo" "\\2A\\5C" "bar",
-      "foo" "\\2a\\5c" "bar",
-      "foo" "\\2A\\5c" "bar",
-      "foo" "\\2a\\5C" "bar",
-    ].each do |escaped|
-      # unescapes escaped characters
-      filter = Net::LDAP::Filter.eq("objectclass", "#{escaped}*#{escaped}*#{escaped}")
-      assert_equal ber, filter.to_ber
-    end
-  end
-
-  def test_parse_ber_escapes_characters
-    ber = "\xa4\x2d" \
-      "\x04\x0b" "objectclass" \
-      "\x30\x1e" \
-      "\x80\x08" "foo" "*\\" "bar" \
-      "\x81\x08" "foo" "*\\" "bar" \
-      "\x82\x08" "foo" "*\\" "bar".b
-
-    escaped = Net::LDAP::Filter.escape("foo" "*\\" "bar")
-    filter = Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax))
-    assert_equal "(objectclass=#{escaped}*#{escaped}*#{escaped})", filter.to_s
-  end
-
-  def test_unescape_fixnums
-    filter = Net::LDAP::Filter.eq("objectclass", 3)
-    assert_equal "\xA3\x10\x04\vobjectclass\x04\x013".b, filter.to_ber
-  end
-end

data/test/test_filter_parser.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-require_relative 'test_helper'
-
-class TestFilterParser < Test::Unit::TestCase
-  def test_ascii
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(cn=name)")
-  end
-
-  def test_multibyte_characters
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(cn=名前)")
-  end
-
-  def test_brackets
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(cn=[{something}])")
-  end
-
-  def test_slash
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(departmentNumber=FOO//BAR/FOO)")
-  end
-
-  def test_colons
-    assert_kind_of Net::LDAP::Filter, Net::LDAP::Filter::FilterParser.parse("(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)")
-  end
-end

data/test/test_helper.rb

@@ -1,66 +0,0 @@
-# Add 'lib' to load path.
-require 'test/unit'
-require 'net/ldap'
-require 'flexmock/test_unit'
-
-# Whether integration tests should be run.
-INTEGRATION = ENV.fetch("INTEGRATION", "skip") != "skip"
-
-# The CA file to verify certs against for tests.
-# Override with CA_FILE env variable; otherwise checks for the VM-specific path
-# and falls back to the test/fixtures/cacert.pem for local testing.
-CA_FILE =
-  ENV.fetch("CA_FILE") do
-    if File.exist?("/etc/ssl/certs/cacert.pem")
-      "/etc/ssl/certs/cacert.pem"
-    else
-      File.expand_path("fixtures/cacert.pem", File.dirname(__FILE__))
-    end
-  end
-
-if RUBY_VERSION < "2.0"
-  class String
-    def b
-      self
-    end
-  end
-end
-
-class MockInstrumentationService
-  def initialize
-    @events = {}
-  end
-
-  def instrument(event, payload)
-    result = yield(payload)
-    @events[event] ||= []
-    @events[event] << [payload, result]
-    result
-  end
-
-  def subscribe(event)
-    @events[event] ||= []
-    @events[event]
-  end
-end
-
-class LDAPIntegrationTestCase < Test::Unit::TestCase
-  # If integration tests aren't enabled, noop these tests.
-  if !INTEGRATION
-    def run(*)
-      self
-    end
-  end
-
-  def setup
-    @service = MockInstrumentationService.new
-    @ldap = Net::LDAP.new \
-      host:           ENV.fetch('INTEGRATION_HOST', 'localhost'),
-      port:           ENV.fetch('INTEGRATION_PORT', 389),
-      admin_user:     'uid=admin,dc=rubyldap,dc=com',
-      admin_password: 'passworD1',
-      search_domains: %w(dc=rubyldap,dc=com),
-      uid:            'uid',
-      instrumentation_service: @service
-  end
-end