ladle 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 113aa33cc9b1acbde8511373ad24bab37cb50062
-  data.tar.gz: 467022513e3987d166c66aaa9f9c668fe896d354
+  metadata.gz: ad18110ea93dd232ca300c7309251b5ba187d0ba
+  data.tar.gz: 822a0d244ee10817ac5af600ed6688a25a61d222
 SHA512:
-  metadata.gz: bfd21fd2ae5f8bdda7dc56a40d345f41451ab09f8c906c54446bb907df7eec2eacf8aae126ebcfc60f9965de7c126f208abdb97491b728ccf51da758eb8cf00c
-  data.tar.gz: 5e50a8547b9de3ce3738cf9666529208129983358435c165e4c6730d0fbcec5de34778099624f3fdf95ee048821e35cebbb06a6606ba39c2ce3c030b2fee2f37
+  metadata.gz: 5a82d005b523b57c8e2c57359cba87dd5ba656a334294fcce93ee686640d852a78ecb192bb30e06e211e94fc45f6a0d384cbc21755eaa4eece4d778f7afc239b
+  data.tar.gz: aaf25e22714ec321985d575d70a3c23e828c9129fe95124f0eb765fd63a6427f82b5df35bbf36b0bb52871f58dcedd11ad4d053bf90aaf36237ae688cdc6db24

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+1.0.1
+=====
+
+- Use the more thorough tmpdir detection provided by `Dir.tmpdir`. (#21, @pirj)
+- Treat unrecognized attributeType as bogus warning. (#25, @mtodd)
+
+
 1.0.0
 =====
 

data/lib/ladle/server.rb

@@ -1,4 +1,5 @@
 require 'ladle'
+require 'tmpdir'
 
 module Ladle
   ##
@@ -90,7 +91,7 @@ module Ladle
       @quiet = opts[:quiet]
       @verbose = opts[:verbose]
       @timeout = opts[:timeout] || 60
-      @tmpdir = opts[:tmpdir] || ENV['TMPDIR'] || ENV['TEMPDIR']
+      @tmpdir = opts[:tmpdir] || ENV['TEMPDIR'] || Dir.tmpdir
       @java_bin = opts[:java_bin] ||
         (ENV['JAVA_HOME'] ? File.join(ENV['JAVA_HOME'], "bin", "java") : "java")
       @custom_schemas = opts[:custom_schemas] ? [*opts[:custom_schemas]] : []
@@ -105,9 +106,7 @@ module Ladle
         raise "The domain component must start with 'dc='.  '#{@domain}' does not."
       end
 
-      if tmpdir.nil?
-        raise "Cannot guess tmpdir from the environment.  Please specify it."
-      elsif !File.directory?(tmpdir)
+      unless File.directory?(tmpdir)
         raise "Tmpdir #{tmpdir.inspect} does not exist."
       end
 
@@ -375,7 +374,8 @@ module Ladle
           %r{attributeType w/ OID 2.5.4.16 not registered},
           %r{default.*?cache size},
           %r{change the admin password},
-          %r{Attribute \S+ does not have normalizer}
+          %r{Attribute \S+ does not have normalizer},
+          %r{attribute \S+ was not recognized as a valid attributeType}
         ].detect { |re| line =~ re }
       end
     end

data/lib/ladle/version.rb

@@ -1,5 +1,5 @@
 module Ladle
   ##
   # The current version number for Ladle.
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/ladle/server_spec.rb

@@ -11,15 +11,15 @@ describe Ladle, "::Server" do
 
   def should_be_running
     s = nil
-    lambda { s = TCPSocket.new('localhost', @server.port) }.
-      should_not raise_error
+    expect { s = TCPSocket.new('localhost', @server.port) }.
+      not_to raise_error
     s.close if s
   end
 
   def should_not_be_running
     s = nil
-    lambda { s = TCPSocket.new('localhost', @server.port) }.
-      should raise_error(/Connection refused/)
+    expect { s = TCPSocket.new('localhost', @server.port) }.
+      to raise_error(/Connection refused/)
     s.close if s
   end
 
@@ -37,7 +37,7 @@ describe Ladle, "::Server" do
       $stderr.puts "Killing leftover process #{pid}"
       Process.kill 15, pid
     }
-    left_over_pids.should be_empty
+    expect(left_over_pids).to be_empty
   end
 
   describe "initialization of" do
@@ -52,74 +52,74 @@ describe Ladle, "::Server" do
 
     describe ":port" do
       it "defaults to 3897" do
-        Ladle::Server.new.port.should == 3897
+        expect(Ladle::Server.new.port).to eq(3897)
       end
 
       it "can be overridden" do
-        Ladle::Server.new(:port => 4200).port.should == 4200
+        expect(Ladle::Server.new(:port => 4200).port).to eq(4200)
       end
     end
 
     describe ":domain" do
       it "defaults to dc=example,dc=org" do
-        Ladle::Server.new.domain.should == "dc=example,dc=org"
+        expect(Ladle::Server.new.domain).to eq("dc=example,dc=org")
       end
 
       it "can be overridden" do
-        Ladle::Server.new(:domain => "dc=northwestern,dc=edu").domain.
-          should == "dc=northwestern,dc=edu"
+        expect(Ladle::Server.new(:domain => "dc=northwestern,dc=edu").domain).
+          to eq("dc=northwestern,dc=edu")
       end
 
       it "rejects a domain that doesn't start with 'dc='" do
-        lambda { Ladle::Server.new(:domain => "foo") }.
-          should raise_error("The domain component must start with 'dc='.  'foo' does not.")
+        expect { Ladle::Server.new(:domain => "foo") }.
+          to raise_error("The domain component must start with 'dc='.  'foo' does not.")
       end
     end
 
     describe ":ldif" do
       it "defaults to lib/ladle/default.ldif" do
-        Ladle::Server.new.ldif.should =~ %r{lib/ladle/default.ldif$}
+        expect(Ladle::Server.new.ldif).to match(%r{lib/ladle/default.ldif$})
       end
 
       it "can be overridden" do
         ldif_file = "#{tmpdir}/foo.ldif"
         FileUtils.touch ldif_file
-        Ladle::Server.new(:ldif => ldif_file).ldif.should == ldif_file
+        expect(Ladle::Server.new(:ldif => ldif_file).ldif).to eq(ldif_file)
       end
 
       it "fails if the file can't be read" do
-        lambda { Ladle::Server.new(:ldif => "foo/bar.ldif") }.
-          should raise_error("Cannot read specified LDIF file foo/bar.ldif.")
+        expect { Ladle::Server.new(:ldif => "foo/bar.ldif") }.
+          to raise_error("Cannot read specified LDIF file foo/bar.ldif.")
       end
     end
 
     describe ":verbose" do
       it "defaults to false" do
-        Ladle::Server.new.verbose?.should be_false
+        expect(Ladle::Server.new.verbose?).to be_falsey
       end
 
       it "can be overridden" do
-        Ladle::Server.new(:verbose => true).verbose?.should be_true
+        expect(Ladle::Server.new(:verbose => true).verbose?).to be_truthy
       end
     end
 
     describe ":quiet" do
       it "defaults to false" do
-        Ladle::Server.new.quiet?.should be_false
+        expect(Ladle::Server.new.quiet?).to be_falsey
       end
 
       it "can be overridden" do
-        Ladle::Server.new(:quiet => true).quiet?.should be_true
+        expect(Ladle::Server.new(:quiet => true).quiet?).to be_truthy
       end
     end
 
     describe ":timeout" do
       it "defaults to 60 seconds" do
-        Ladle::Server.new.timeout.should == 60
+        expect(Ladle::Server.new.timeout).to eq(60)
       end
 
       it "can be overridden" do
-        Ladle::Server.new(:timeout => 87).timeout.should == 87
+        expect(Ladle::Server.new(:timeout => 87).timeout).to eq(87)
       end
     end
 
@@ -134,29 +134,28 @@ describe Ladle, "::Server" do
 
       it "defaults to TMPDIR if set" do
         ENV["TMPDIR"] = tmpdir('foo')
-        Ladle::Server.new.tmpdir.should == tmpdir('foo')
+        expect(Ladle::Server.new.tmpdir).to eq(tmpdir('foo'))
       end
 
       it "defaults to TEMPDIR if set" do
         ENV["TEMPDIR"] = tmpdir('baz')
-        Ladle::Server.new.tmpdir.should == tmpdir('baz')
+        expect(Ladle::Server.new.tmpdir).to eq(tmpdir('baz'))
       end
 
       it "prefers the explicitly provided value" do
         ENV["TMPDIR"] = tmpdir('quux')
         ENV["TEMPDIR"] = tmpdir('bar')
-        Ladle::Server.new(:tmpdir => tmpdir('zap')).tmpdir.
-          should == tmpdir('zap')
+        expect(Ladle::Server.new(:tmpdir => tmpdir('zap')).tmpdir).
+          to eq(tmpdir('zap'))
       end
 
-      it "must exist" do
-        lambda { Ladle::Server.new(:tmpdir => 'whatever') }.
-          should raise_error(/Tmpdir "whatever" does not exist./)
+      it "must be specified somehow" do
+        expect(Ladle::Server.new.tmpdir).to eq(Dir.tmpdir)
       end
 
-      it "must be specified somehow" do
-        lambda { Ladle::Server.new }.
-          should raise_error(/Cannot guess tmpdir from the environment.  Please specify it./)
+      it "must exist" do
+        expect { Ladle::Server.new(:tmpdir => 'whatever') }.
+          to raise_error(/Tmpdir "whatever" does not exist./)
       end
     end
 
@@ -170,59 +169,59 @@ describe Ladle, "::Server" do
       end
 
       it "relies on the path with no JAVA_HOME" do
-        Ladle::Server.new.java_bin.should == "java"
+        expect(Ladle::Server.new.java_bin).to eq("java")
       end
 
       it "defaults to JAVA_HOME/bin/java if available" do
         ENV["JAVA_HOME"] = tmpdir('myjdk')
-        Ladle::Server.new.java_bin.should == "#{tmpdir}/myjdk/bin/java"
+        expect(Ladle::Server.new.java_bin).to eq("#{tmpdir}/myjdk/bin/java")
       end
 
       it "can be overridden" do
-        Ladle::Server.new(:java_bin => File.join(tmpdir('openjdk'), "jre")).java_bin.
-          should == "#{tmpdir}/openjdk/jre"
+        expect(Ladle::Server.new(:java_bin => File.join(tmpdir('openjdk'), "jre")).java_bin).
+          to eq("#{tmpdir}/openjdk/jre")
       end
     end
 
     describe ":allow_anonymous" do
       it "defaults to true" do
-        Ladle::Server.new.allow_anonymous?.should be_true
+        expect(Ladle::Server.new.allow_anonymous?).to be_truthy
       end
 
       it "can be overridden" do
-        Ladle::Server.new(:allow_anonymous => false).allow_anonymous?.should be_false
+        expect(Ladle::Server.new(:allow_anonymous => false).allow_anonymous?).to be_falsey
       end
     end
 
     describe ":custom_schemas" do
       it "defaults to an empty list" do
-        Ladle::Server.new.custom_schemas.should == []
+        expect(Ladle::Server.new.custom_schemas).to eq([])
       end
 
       it "can be set from one file name" do
-        Ladle::Server.new(:custom_schemas => "net.example.HappySchema").
-          custom_schemas.should == %w(net.example.HappySchema)
+        expect(Ladle::Server.new(:custom_schemas => "net.example.HappySchema").
+          custom_schemas).to eq(%w(net.example.HappySchema))
       end
 
       it "can be set from a list" do
-        Ladle::Server.new(:custom_schemas => ["net.example.HappySchema", "net.example.SadSchema"]).
-          custom_schemas.should == %w(net.example.HappySchema net.example.SadSchema)
+        expect(Ladle::Server.new(:custom_schemas => ["net.example.HappySchema", "net.example.SadSchema"]).
+          custom_schemas).to eq(%w(net.example.HappySchema net.example.SadSchema))
       end
     end
 
     describe ":additional_classpath" do
       it "defaults to an empty list" do
-        Ladle::Server.new.additional_classpath.should == []
+        expect(Ladle::Server.new.additional_classpath).to eq([])
       end
 
       it "can be set from one entry" do
-        Ladle::Server.new(:additional_classpath => "foo").
-          additional_classpath.should == %w(foo)
+        expect(Ladle::Server.new(:additional_classpath => "foo").
+          additional_classpath).to eq(%w(foo))
       end
 
       it "can be set from a list" do
-        Ladle::Server.new(:additional_classpath => ["bar", "baz"]).
-          additional_classpath.should == %w(bar baz)
+        expect(Ladle::Server.new(:additional_classpath => ["bar", "baz"]).
+          additional_classpath).to eq(%w(bar baz))
       end
     end
   end
@@ -234,12 +233,12 @@ describe Ladle, "::Server" do
     end
 
     it "returns the server object" do
-      @server.start.should be(@server)
+      expect(@server.start).to be(@server)
     end
 
     it "is safe to invoke twice (in the same thread)" do
       @server.start
-      lambda { @server.start }.should_not raise_error
+      expect { @server.start }.not_to raise_error
     end
 
     it "can be stopped then started again" do
@@ -253,16 +252,16 @@ describe Ladle, "::Server" do
       old_stderr, $stderr = $stderr, StringIO.new
 
       @server = create_server(:more_args => ["--fail", "before_start"])
-      lambda { @server.start }.should raise_error(/LDAP server failed to start/)
-      $stderr.string.should == "ApacheDS process failed: FATAL: Expected failure for testing\n"
+      expect { @server.start }.to raise_error(/LDAP server failed to start/)
+      expect($stderr.string).to eq("ApacheDS process failed: FATAL: Expected failure for testing\n")
 
       $stderr = old_stderr
     end
 
     it "times out after the specified interval" do
       @server = create_server(:timeout => 3, :more_args => %w(--fail hang))
-      lambda { @server.start }.
-        should raise_error(/LDAP server startup did not complete within 3 seconds/)
+      expect { @server.start }.
+        to raise_error(/LDAP server startup did not complete within 3 seconds/)
     end
 
     it "should use the specified port" do
@@ -273,14 +272,14 @@ describe Ladle, "::Server" do
     it "uses the specified tmpdir" do
       target = tmpdir('baz')
       @server = create_server(:tmpdir => target).start
-      Dir["#{target}/ladle-server-*"].size.should == 1
+      expect(Dir["#{target}/ladle-server-*"].size).to eq(1)
     end
 
     it "cleans up the tmpdir afterward" do
       target = tmpdir('quux')
       @server = create_server(:tmpdir => target).start
       @server.stop
-      Dir["#{target}/ladle-server-*"].size.should == 0
+      expect(Dir["#{target}/ladle-server-*"].size).to eq(0)
     end
   end
 
@@ -302,7 +301,7 @@ describe Ladle, "::Server" do
           :base => base || 'dc=example,dc=org',
           :filter => filter
         ).tap {
-          ldap.get_operation_result.code.should == 0 # success
+          expect(ldap.get_operation_result.code).to eq(0) # success
         }
       }
     end
@@ -310,26 +309,26 @@ describe Ladle, "::Server" do
     describe "data" do
       describe "the default set" do
         it "has 26 people" do
-          ldap_search(Net::LDAP::Filter.pres('uid')).should have(26).people
+          expect(ldap_search(Net::LDAP::Filter.pres('uid')).size).to eq(26)
         end
 
         it "has 1 group" do
-          ldap_search(Net::LDAP::Filter.pres('ou')).should have(1).group
+          expect(ldap_search(Net::LDAP::Filter.pres('ou')).size).to eq(1)
         end
 
         it "has given names" do
-          ldap_search(Net::LDAP::Filter.pres('uid')).
-            select { |res| !res[:givenname] || res[:givenname].empty? }.should == []
+          expect(ldap_search(Net::LDAP::Filter.pres('uid')).
+            select { |res| !res[:givenname] || res[:givenname].empty? }).to eq([])
         end
 
         it "has e-mail addresses" do
-          ldap_search(Net::LDAP::Filter.pres('uid')).
-            select { |res| !res[:mail] || res[:mail].empty? }.should == []
+          expect(ldap_search(Net::LDAP::Filter.pres('uid')).
+            select { |res| !res[:mail] || res[:mail].empty? }).to eq([])
         end
 
         it "can be searched by value" do
-          ldap_search(Net::LDAP::Filter.eq(:givenname, 'Josephine')).
-            collect { |res| res[:uid].first }.should == %w(jj243)
+          expect(ldap_search(Net::LDAP::Filter.eq(:givenname, 'Josephine')).
+            collect { |res| res[:uid].first }).to eq(%w(jj243))
         end
       end
 
@@ -342,13 +341,13 @@ describe Ladle, "::Server" do
         end
 
         it "has the groups provided by the other LDIF" do
-          ldap_search(Net::LDAP::Filter.pres('ou'), 'dc=example,dc=net').
-            collect { |result| result[:ou].first }.should == ["animals"]
+          expect(ldap_search(Net::LDAP::Filter.pres('ou'), 'dc=example,dc=net').
+            collect { |result| result[:ou].first }).to eq(["animals"])
         end
 
         it "has the individuals provided by the other LDIF" do
-          ldap_search(Net::LDAP::Filter.pres('uid'), 'dc=example,dc=net').
-            collect { |result| result[:givenname].first }.sort.should == %w(Ada Bob)
+          expect(ldap_search(Net::LDAP::Filter.pres('uid'), 'dc=example,dc=net').
+            collect { |result| result[:givenname].first }.sort).to eq(%w(Ada Bob))
         end
       end
 
@@ -362,8 +361,8 @@ describe Ladle, "::Server" do
         end
 
         it "has the data defined in the schema" do
-          ldap_search(Net::LDAP::Filter.pres('species'), 'dc=example,dc=net').
-            collect { |r| r[:species].first }.sort.should == ["Meles meles", "Orycteropus afer"]
+          expect(ldap_search(Net::LDAP::Filter.pres('species'), 'dc=example,dc=net').
+            collect { |r| r[:species].first }.sort).to eq(["Meles meles", "Orycteropus afer"])
         end
       end
     end
@@ -372,14 +371,14 @@ describe Ladle, "::Server" do
       it "works with a valid password" do
         with_ldap do |ldap|
           ldap.authenticate("uid=hh153,ou=people,dc=example,dc=org", "hatfield".reverse)
-          ldap.bind.should be_true
+          expect(ldap.bind).to be_truthy
         end
       end
 
       it "does not work with an invalid password" do
         with_ldap do |ldap|
           ldap.authenticate("uid=hh153,ou=people,dc=example,dc=org", "mccoy".reverse)
-          ldap.bind.should be_false
+          expect(ldap.bind).to be_falsey
         end
       end
 
@@ -393,29 +392,29 @@ describe Ladle, "::Server" do
             # anonymous bind is successful even with anonymous access
             # off, but searches fail appropriately
             ldap.search(:filter => Net::LDAP::Filter.pres('uid'), :base => 'dc=example,dc=org')
-            ldap.get_operation_result.code.should == 49 # invalid credentials
+            expect(ldap.get_operation_result.code).to eq(49) # invalid credentials
           end
         end
 
         it "will bind with a username and valid password" do
           with_ldap do |ldap|
             ldap.authenticate("uid=kk891,ou=people,dc=example,dc=org", "enilk")
-            ldap.bind.should be_true
+            expect(ldap.bind).to be_truthy
           end
         end
 
         it "will not bind with a username and invalid password" do
           with_ldap do |ldap|
             ldap.authenticate("uid=kk891,ou=people,dc=example,dc=org", "kevin")
-            ldap.bind.should be_false
+            expect(ldap.bind).to be_falsey
           end
         end
 
         it "permits searches for authenticated users" do
           with_ldap do |ldap|
             ldap.authenticate("uid=kk891,ou=people,dc=example,dc=org", "enilk")
-            ldap.search(:filter => Net::LDAP::Filter.pres('uid'), :base => 'dc=example,dc=org').
-              should have(26).results
+            expect(ldap.search(:filter => Net::LDAP::Filter.pres('uid'), :base => 'dc=example,dc=org').size).
+              to eq(26)
           end
         end
       end

data/spec/ladle/version_spec.rb

@@ -2,10 +2,10 @@ require File.expand_path("../../spec_helper.rb", __FILE__)
 
 describe Ladle, "::VERSION" do
   it "exists" do
-    lambda { Ladle::VERSION }.should_not raise_error
+    expect { Ladle::VERSION }.not_to raise_error
   end
 
   it "has 3 or 4 dot separated parts" do
-    Ladle::VERSION.split('.').size.should be_between(3, 4)
+    expect(Ladle::VERSION.split('.').size).to be_between(3, 4)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ladle
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Rhett Sutphin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-24 00:00:00.000000000 Z
+date: 2015-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: open4
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -175,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Dishes out steaming helpings of LDAP for fluid testing