omniauth-aleph 0.1.0

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# Ignore the Gemfile.lock
+/Gemfile.lock
+
+# Ignore .ruby-version
+.ruby-version

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx

data/Gemfile

@@ -0,0 +1,16 @@
+source 'http://rubygems.org'
+gemspec
+
+gem "coveralls", "~> 0.7.0", require: false, group: :test
+gem "pry-debugger", group: :development, platform: :mri
+gem "pry", group: :development, platforms: [:jruby, :rbx]
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0' # if using anything in the ruby standard library
+  gem 'json', '~> 1.8.1'
+  gem 'rubinius-coverage'
+end
+
+# XML parsing
+gem 'ox', '~> 2.0.0', platform: :ruby
+gem 'nokogiri', '~> 1.6.1', platform: :jruby

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Scot Dalton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# OmniAuth Aleph
+[![Build Status](https://api.travis-ci.org/scotdalton/omniauth-aleph.png?branch=master)](https://travis-ci.org/scotdalton/omniauth-aleph)
+[![Dependency Status](https://gemnasium.com/scotdalton/omniauth-aleph.png)](https://gemnasium.com/scotdalton/omniauth-aleph)
+[![Code Climate](https://codeclimate.com/github/scotdalton/omniauth-aleph.png)](https://codeclimate.com/github/scotdalton/omniauth-aleph)
+[![Coverage Status](https://coveralls.io/repos/scotdalton/omniauth-aleph/badge.png?branch=master)](https://coveralls.io/r/scotdalton/omniauth-aleph)
+
+Aleph patron login strategy for OmniAuth.
+
+## Installation
+Add to your Gemfile:
+
+    gem 'omniauth-aleph'
+
+Then `bundle install`.
+
+## Usage
+`OmniAuth::Strategies::Aleph` simply makes a call to the Aleph bor_auth X-Service and
+returns the attributes from the returned XML.
+
+Use the Aleph strategy as a middleware in your application:
+
+    use OmniAuth::Strategies::Aleph, title: 'My Library's Aleph', 
+      host: 'aleph.library.edu', port: 80, library: 'ADM50', sub_library: 'SUB'
+

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new

data/lib/omniauth-aleph.rb

@@ -0,0 +1 @@
+require "omniauth/aleph"

data/lib/omniauth/aleph.rb

@@ -0,0 +1,3 @@
+require 'omniauth/aleph/version'
+require 'omniauth/aleph/adaptor'
+require 'omniauth/strategies/aleph'

data/lib/omniauth/aleph/adaptor.rb

@@ -0,0 +1,57 @@
+module OmniAuth
+  module Aleph
+    require 'faraday'
+    require 'multi_xml'
+    class Adaptor
+      class AlephError < StandardError; end
+
+      # List of keys, all are required.
+      KEYS = [:scheme, :host, :port, :library, :sub_library]
+
+      def self.validate(configuration={})
+        message = []
+        KEYS.each do |key|
+          message << key if(configuration[key].nil?)
+        end
+        unless message.empty?
+          raise ArgumentError.new(message.join(",") +" MUST be provided")
+        end
+      end
+
+      def initialize(configuration={})
+        self.class.validate(configuration)
+        @configuration = configuration.dup
+        @logger = @configuration.delete(:logger)
+        KEYS.each do |key|
+          instance_variable_set("@#{key}", @configuration[key])
+        end
+      end
+
+      def authenticate(username, password)
+        url = bor_auth_url + "&bor_id=#{username}&verification=#{password}"
+        response = Faraday.get url
+        # If we get a successful response AND we are looking at XML and we have a body
+        if response.status == 200 && response.headers["content-type"] == 'text/xml' && response.body
+          json = MultiXml.parse(response.body)
+          if json["bor_auth"] && (error = json["bor_auth"]["error"]).nil?
+            return json
+          elsif json["bor_auth"].nil?
+            raise AlephError.new("Aleph responded, but it's not a response I understand.")
+          else
+            raise AlephError.new(error)
+          end
+        else
+          raise AlephError.new("Aleph response:\n\t #{@response.inspect}.")
+        end
+      rescue Faraday::ConnectionFailed => e
+        raise AlephError.new("Couldn't connect to Aleph.")
+      end
+
+      def bor_auth_url
+        @bor_auth_url ||= "#{@scheme}://#{@host}:#{@port}"+
+          "/X?op=bor-auth&library=#{@library}&sub_library=#{@sub_library}"
+      end
+      private :bor_auth_url
+    end
+  end
+end

data/lib/omniauth/aleph/version.rb

@@ -0,0 +1,5 @@
+module OmniAuth
+  module Aleph
+    VERSION = "0.1.0"
+  end
+end

data/lib/omniauth/strategies/aleph.rb

@@ -0,0 +1,61 @@
+require 'omniauth'
+
+module OmniAuth
+  module Strategies
+    class Aleph
+      include OmniAuth::Strategy
+
+      # Set defaults for options
+      option :title, "Aleph Authentication"
+      option :scheme, 'http'
+      option :port, 80
+
+      uid { @raw_info["bor_auth"]["z303"]["z303_id"] }
+
+      info do
+        {
+          'name' => @raw_info["bor_auth"]["z303"]["z303_name"],
+          'nickname' => @raw_info["bor_auth"]["z303"]["z303_id"],
+          'email' => @raw_info["bor_auth"]["z304"]["z304_email_address"],
+          'phone' => @raw_info["bor_auth"]["z304"]["z304_telephone"]
+        }
+      end
+
+      extra do
+        (skip_info?) ? {} : { 'raw_info' => @raw_info }
+      end
+
+      def request_phase
+        OmniAuth::Aleph::Adaptor.validate @options
+        OmniAuth::Form.build(title: options[:title], url: callback_path) do |f|
+          f.text_field 'Login', 'username'
+          f.password_field 'Password', 'password'
+        end.to_response
+      end
+
+      def callback_phase
+        return fail!(:missing_credentials) if missing_credentials?
+        adaptor = OmniAuth::Aleph::Adaptor.new(@options)
+        @raw_info = adaptor.authenticate(username, password)
+        super
+      rescue OmniAuth::Aleph::Adaptor::AlephError => e
+        fail!(e.message)
+      end
+
+      def username
+        @username ||= request['username']
+      end
+      private :username
+
+      def password
+        @password ||= request['password']
+      end
+      private :password
+
+      def missing_credentials?
+        username.nil? || username.empty? || password.nil? || password.empty?
+      end
+      private :missing_credentials?
+    end
+  end
+end

data/omniauth-aleph.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/omniauth/aleph/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name     = 'omniauth-aleph'
+  gem.version  = OmniAuth::Aleph::VERSION
+  gem.authors  = ['Scot Dalton']
+  gem.email    = ['scotdalton@gmail.com']
+  gem.summary  = 'Aleph Patron Login Strategy for OmniAuth'
+  gem.homepage = 'https://github.com/scotdalton/omniauth-aleph'
+  gem.license  = 'MIT'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'omniauth', '~> 1.2.0'
+  gem.add_runtime_dependency 'faraday', '~> 0.9.0'
+  gem.add_runtime_dependency 'multi_xml', '~> 0.5.0'
+
+  gem.add_development_dependency 'rake', '~> 10.1.0'
+  gem.add_development_dependency 'rspec', '~> 2.14.0'
+  gem.add_development_dependency 'rack-test', '~> 0.6.2'
+  gem.add_development_dependency 'webmock', '~> 1.17.0'
+  gem.add_development_dependency 'vcr', '~> 2.8.0'
+end

data/spec/omniauth/aleph/adaptor_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+describe "OmniAuth::Aleph::Adaptor" do
+  context 'when the configuration is missing :scheme' do
+    let(:config) do
+      { host: 'aleph.library.edu', port: 80, library: 'ADM50', sub_library: 'SUB' }
+    end
+
+    describe '.validate' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.validate config }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '.new' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.new config }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'when the configuration is missing :host' do
+    let(:config) do
+      { scheme: 'http', port: 80, library: 'ADM50', sub_library: 'SUB' }
+    end
+
+    describe '.validate' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.validate config }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '.new' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.new config }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'when the configuration is missing :port' do
+    let(:config) do
+      { scheme: 'http', host: 'aleph.library.edu', library: 'ADM50', sub_library: 'SUB' }
+    end
+
+    describe '.validate' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.validate config }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '.new' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.new config }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'when the configuration is missing :library' do
+    let(:config) do
+      { scheme: 'http', host: 'aleph.library.edu', port: 80, sub_library: 'SUB' }
+    end
+
+    describe '.validate' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.validate config }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '.new' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.new config }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'when the configuration is missing :sub_library' do
+    let(:config) do
+      { scheme: 'http', host: 'aleph.library.edu', port: 80, library: 'ADM50' }
+    end
+
+    describe '.validate' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.validate config }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe '.new' do
+      it "should raise an ArgumentError" do
+        expect{ OmniAuth::Aleph::Adaptor.new config }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context 'when the configuration has all required fields' do
+    let(:config) do
+      { scheme: 'http', host: aleph_host, 
+        port: 80, library: aleph_library,
+        sub_library: aleph_sub_library }
+    end
+
+    subject(:adaptor) { OmniAuth::Aleph::Adaptor.new(config) }
+
+    describe '.validate' do
+      it "shouldn't raise an error" do
+        expect{ OmniAuth::Aleph::Adaptor.validate config }.not_to raise_error
+      end
+    end
+
+    context 'when the username and password are correct' do
+      describe '#authenticate', vcr: { cassette_name: "valid" } do
+        it "shouldn't raise an error" do
+          expect{ adaptor.authenticate(aleph_username, aleph_password) }.not_to raise_error
+        end
+
+        let(:user_info) { adaptor.authenticate(aleph_username, aleph_password) }
+        it "should return a hash" do
+          expect(user_info).to be_a(Hash)
+        end
+        
+        it "should return 'USERNAME' as the username" do
+          expect(user_info["bor_auth"]["z303"]["z303_id"]).to eql("USERNAME")
+        end
+        
+        it "should return 'username@library.nyu.edu' as the email" do
+          expect(user_info["bor_auth"]["z304"]["z304_email_address"]).to eql("username@library.edu")
+        end
+        
+        it "should return 'USERNAME, TEST-RECORD' as the name" do
+          expect(user_info["bor_auth"]["z303"]["z303_name"]).to eql("USERNAME, TEST-RECORD")
+        end
+      end
+    end
+
+    context 'when the password is invalid' do
+      describe '#authenticate', vcr: { cassette_name: "invalid password" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate(aleph_username, "INVALID") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+    end
+
+    context 'when the password is nil' do
+      describe '#authenticate', vcr: { cassette_name: "nil password" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate(aleph_username, nil) }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+    end
+
+    context 'when the password is empty' do
+      describe '#authenticate', vcr: { cassette_name: "empty password" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate(aleph_username, "") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+    end
+
+    context 'when the user is does not exist' do
+      describe '#authenticate', vcr: { cassette_name: "nonexistent user" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate("NONEXISTENTUSER", "NONEXISTENTPASSWORD") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+    end
+  end
+
+  context 'when the aleph host doesn\'t connect' do
+    let(:config) do
+      { scheme: 'http', host: "aleph.library.edu", 
+        port: 80, library: "ADM50",
+        sub_library: "SUB" }
+    end
+
+    subject(:adaptor) { OmniAuth::Aleph::Adaptor.new(config) }
+
+    describe '#authenticate', :vcr do
+      it "should raise an Aleph error" do
+        expect{ adaptor.authenticate("USERNAME", "PASSWORD") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+      end
+    end
+  end
+
+  context 'when the aleph host is not actually Aleph' do
+    let(:config) do
+      { scheme: 'http', host: "example.com", 
+        port: 80, library: "ADM50",
+        sub_library: "SUB" }
+    end
+
+    subject(:adaptor) { OmniAuth::Aleph::Adaptor.new(config) }
+
+    describe '#authenticate' do
+      context 'when the host returns HTML', vcr: { cassette_name: "aleph host returns html" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate("USERNAME", "PASSWORD") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+
+      context 'when the host returns an empty body', vcr: { cassette_name: "aleph host returns an empty body" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate("USERNAME", "PASSWORD") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+
+      context 'when the host returns with status not found', vcr: { cassette_name: "aleph host returns with status not found" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate("USERNAME", "PASSWORD") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+
+      context 'when the host returns non bor auth xml', vcr: { cassette_name: "aleph host returns non bor auth xml" } do
+        it "should raise an Aleph error" do
+          expect{ adaptor.authenticate("USERNAME", "PASSWORD") }.to raise_error(OmniAuth::Aleph::Adaptor::AlephError)
+        end
+      end
+    end
+  end
+end