sheffield_ldap_lookup 0.0.4 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f1fb61d37a5823114d379ab1a345d184b1c35b17
-  data.tar.gz: 86156649e10b28a2ff876a165a86eb15ca25b97c
+SHA256:
+  metadata.gz: 3090dd3270a42985506f6077318966d175fb5460a058f397b71f1f70577e283e
+  data.tar.gz: 60717cc86c1e4302bc2d559678cac466a8fde864f716749f9729cef676a29116
 SHA512:
-  metadata.gz: 080c9715362eb34846ec609100cfc7ba7936caa346d8ad99f6a0d9d45d03823a171b245d03f1646a3e3417b7d28ac3feff62d3976e9a889f7ed718950ea33051
-  data.tar.gz: 0116b41bd5caa1e52ced95c481721c1641669af4838b76207ba581a1d5234b725db5e0fc709568f2fa6f592b280cc5c8665d082e365d2935944f5f76f586023f
+  metadata.gz: 0cd3d1d61454854acee77fd4ce9e508596f2f5b915dd55cc1a8ca72812154e0e23da960c0c0abf0d4d51364146261fc46f4f17215e2e0bd62e704fb47aa4c52f
+  data.tar.gz: 229b7266dd482ef161b6544906d1c51847ddc7b28bd027687d295e28474d7fa9a8006386c3bd83d3e032beb1445d6d6400a5fd781f2b947626955605bb973e73

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

data/lib/sheffield_ldap_lookup/ldap_finder.rb

@@ -2,16 +2,18 @@ require 'net/ldap'
 module SheffieldLdapLookup
   class LdapFinder
     attr_accessor :keyword
-    
-    def initialize(keyword = nil, config_prefix = nil)
+    attr_accessor :custom_search_attribute
+
+    def initialize(keyword = nil, config_prefix = nil, custom_search_attribute = nil)
       self.keyword   = keyword
       @config_prefix = config_prefix
+      self.custom_search_attribute = custom_search_attribute
     end
-    
+
     class << self
       attr_accessor :ldap_config
     end
-    
+
     def lookup
       begin
         @lookup ||= connection.search(filter: ldap_filter)[0]
@@ -25,6 +27,7 @@ module SheffieldLdapLookup
     end
 
     def search_attribute
+      return custom_search_attribute if custom_search_attribute
       keyword =~ /\A[^@]+@[^@]+\z/ ? 'mail' : 'uid'
     end
 
@@ -35,12 +38,14 @@ module SheffieldLdapLookup
     def connection(ldap_class = Net::LDAP)
       @connection ||= ldap_class.new(connection_settings)
     end
-    
+
     def connection_settings
       base_settings = {
-        host: ldap_config["#{@config_prefix}host"], port: ldap_config["#{@config_prefix}port"], base: ldap_config["#{@config_prefix}base"]
+        host: ldap_config["#{@config_prefix}host"],
+        port: ldap_config["#{@config_prefix}port"],
+        base: ldap_config["#{@config_prefix}base"]
       }
-      
+
       if ldap_config.key?("#{@config_prefix}username") && ldap_config.key?("#{@config_prefix}password")
         base_settings[:auth] = {
           method: :simple,
@@ -48,8 +53,14 @@ module SheffieldLdapLookup
           password: ldap_config["#{@config_prefix}password"]
         }
       end
+
+      if ldap_config["#{@config_prefix}ssl"] == true
+        base_settings[:port] ||= 636
+        base_settings[:encryption] = :simple_tls
+      end
+
       base_settings
     end
-    
+
   end
-end
+end

data/lib/sheffield_ldap_lookup/version.rb

@@ -1,3 +1,3 @@
 module SheffieldLdapLookup
-  VERSION = "0.0.4"
+  VERSION = "0.0.7"
 end

data/sheffield_ldap_lookup.gemspec

@@ -6,20 +6,20 @@ require 'sheffield_ldap_lookup/version'
 Gem::Specification.new do |gem|
   gem.name          = "sheffield_ldap_lookup"
   gem.version       = SheffieldLdapLookup::VERSION
-  gem.authors       = ["Shuo Chen"]
-  gem.email         = ["s.chen@epigenesys.co.uk"]
+  gem.authors       = ["James Gregory-Monk", "Shuo Chen"]
+  gem.email         = ["james.gregory@epigenesys.org.uk", "shuo.chen@epigenesys.org.uk"]
   gem.description   = "A gem to fetch information from University of Sheffield LDAP server based on username or email address."
   gem.summary       = "LDAP lookup"
-  gem.homepage      = "http://www.epigenesys.org.uk"
+  gem.homepage      = "https://www.epigenesys.org.uk"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-  
+
   gem.add_dependency('net-ldap')
-  
+
   gem.add_development_dependency('rake')
   gem.add_development_dependency('rails', '>= 3.2')
   gem.add_development_dependency('rspec')
-end
+end

data/spec/lib/ldap_finder_spec.rb

@@ -2,68 +2,127 @@ require 'spec_helper'
 require 'sheffield_ldap_lookup/ldap_finder.rb'
 
 describe SheffieldLdapLookup::LdapFinder do
-  LDAP_CONFIG = { 'host' => 'localhost', 'port' => '389', 'base' => 'ou=Users' }
+  let(:ldap_config) { { 'host' => 'localhost', 'port' => '389', 'base' => 'ou=Users' } }
+
   describe "#connection" do
     it "should create a new LDAP connection" do
-      subject.stub(ldap_config: LDAP_CONFIG)
+      allow(subject).to receive(:ldap_config).and_return(ldap_config)
       ldap_class = double
-      ldap_class.should_receive(:new).with(host: LDAP_CONFIG['host'], port: LDAP_CONFIG['port'], base: LDAP_CONFIG['base'])
+      expect(ldap_class).to receive(:new).with(host: ldap_config['host'], port: ldap_config['port'], base: ldap_config['base'])
       subject.connection(ldap_class)
     end
   end
-  
+
   describe "#ldap_config" do
     it "should load the LDAP configuration" do
-      SheffieldLdapLookup::LdapFinder.ldap_config = LDAP_CONFIG
-      subject.ldap_config.should == LDAP_CONFIG
+      SheffieldLdapLookup::LdapFinder.ldap_config = ldap_config
+      expect(subject.ldap_config).to eq ldap_config
     end
   end
-  
+
   describe "#search_attribute" do
     describe "determine to search against uid or email based on the format of the keyword" do
       it "should use 'uid' attribute for username" do
         finder = SheffieldLdapLookup::LdapFinder.new('username')
-        finder.search_attribute.should == 'uid'
+        expect(finder.search_attribute).to eq 'uid'
       end
-      
+
       it "should use 'mail' attribute for email" do
         finder = SheffieldLdapLookup::LdapFinder.new('test@test.com')
-        finder.search_attribute.should == 'mail'
+        expect(finder.search_attribute).to eq 'mail'
       end
     end
   end
-  
+
   describe "#ldap_filter" do
     it "should create a LDAP filter for the attribute and keyword" do
       finder = SheffieldLdapLookup::LdapFinder.new('username')
-      finder.stub(search_attribute: 'uid')
+      allow(finder).to receive(:search_attribute).and_return('uid')
       filter_class = double
-      filter_class.should_receive(:eq).with('uid', 'username')
+      expect(filter_class).to receive(:eq).with('uid', 'username')
       finder.ldap_filter filter_class
     end
   end
-  
+
+  context "load config prefix" do
+    let(:ldap_config) { { 'host' => 'localhost', 'port' => '389', 'base' => 'ou=Users',
+      'prefix_host' => 'prefix_localhost', 'prefix_port' => '400', 'prefix_base' => 'ou=BigUsers' } }
+    subject { SheffieldLdapLookup::LdapFinder.new('123', 'prefix_') }
+
+    it "should create a new LDAP connection" do
+      allow(subject).to receive(:ldap_config).and_return(ldap_config)
+      ldap_class = double
+      expect(ldap_class).to receive(:new).with(host: ldap_config['prefix_host'], port: ldap_config['prefix_port'], base: ldap_config['prefix_base'])
+      subject.connection(ldap_class)
+    end
+  end
+
+  context 'with an ssl config' do
+    let(:ldap_config) { { 'host' => 'localhost', 'port' => '389', 'base' => 'ou=Users', 'ssl' => true } }
+
+    it "should create a new secure LDAP connection" do
+      allow(subject).to receive(:ldap_config).and_return(ldap_config)
+      ldap_class = double
+      expect(ldap_class).to receive(:new).with(host: ldap_config['host'],
+        port: ldap_config['port'], base: ldap_config['base'],
+        encryption: :simple_tls)
+      subject.connection(ldap_class)
+    end
+  end
+
+  context 'with a username and password config' do
+    let(:ldap_config) { { 'host' => 'localhost', 'port' => '389', 'base' => 'ou=Users',
+      'username' => 'ldapusername', 'password' => 'ldappassword' } }
+
+    it "should create a new secure LDAP connection" do
+      allow(subject).to receive(:ldap_config).and_return(ldap_config)
+      ldap_class = double
+      expect(ldap_class).to receive(:new).with(host: ldap_config['host'],
+        port: ldap_config['port'], base: ldap_config['base'],
+        auth: { method: :simple, username: 'ldapusername', password: 'ldappassword' } )
+      subject.connection(ldap_class)
+    end
+  end
+
+  context 'with a username, password and ssl config' do
+    let(:ldap_config) { { 'host' => 'localhost', 'port' => '389', 'base' => 'ou=Users',
+      'username' => 'ldapusername', 'password' => 'ldappassword', 'ssl' => true } }
+
+    it "should create a new secure LDAP connection" do
+      allow(subject).to receive(:ldap_config).and_return(ldap_config)
+      ldap_class = double
+      expect(ldap_class).to receive(:new).with(host: ldap_config['host'],
+        port: ldap_config['port'], base: ldap_config['base'], encryption: :simple_tls,
+        auth: { method: :simple, username: 'ldapusername', password: 'ldappassword' } )
+      subject.connection(ldap_class)
+    end
+  end
+
   describe "#lookup" do
     describe "use the LDAP filter to search for the entity and return the first result" do
       let(:ldap_filter) { double }
       let(:connection)  { double }
-      before { subject.stub(ldap_filter: ldap_filter, connection: connection) }
-      
+
+      before do
+        allow(subject).to receive(:ldap_filter).and_return(ldap_filter)
+        allow(subject).to receive(:connection).and_return(connection)
+      end
+
       it "should search the LDAP connection using the filter" do
-        connection.should_receive(:search).with(filter: ldap_filter).and_return([])
+        expect(connection).to receive(:search).with(filter: ldap_filter).and_return([])
         subject.lookup
       end
-      
+
       it "should return the first result" do
         result = double
-        connection.stub(search: [result])
-        subject.lookup.should == result
+        allow(connection).to receive(:search).and_return([result])
+        expect(subject.lookup).to eq result
       end
-      
+
       it "should return an empty hash if cannot connect to LDAP" do
-        connection.stub(search: ->{raise})
-        subject.lookup.should == {}
+        allow(connection).to receive(:search).and_return(->{raise})
+        expect(subject.lookup).to eq({})
       end
     end
   end
-end
+end

metadata

@@ -1,81 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: sheffield_ldap_lookup
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.7
 platform: ruby
 authors:
+- James Gregory-Monk
 - Shuo Chen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2023-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ldap
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A gem to fetch information from University of Sheffield LDAP server based
   on username or email address.
 email:
-- s.chen@epigenesys.co.uk
+- james.gregory@epigenesys.org.uk
+- shuo.chen@epigenesys.org.uk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rvmrc
+- ".gitignore"
+- ".ruby-version"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -88,7 +90,7 @@ files:
 - sheffield_ldap_lookup.gemspec
 - spec/lib/ldap_finder_spec.rb
 - spec/spec_helper.rb
-homepage: http://www.epigenesys.org.uk
+homepage: https://www.epigenesys.org.uk
 licenses: []
 metadata: {}
 post_install_message: 
@@ -97,17 +99,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: LDAP lookup

data/.rvmrc

@@ -1 +0,0 @@
-rvm use --create @sheffield_ldap_lookup