shield 0.0.0 → 0.0.1

data/README.markdown

@@ -1,5 +1,36 @@
 # Shield
 
-See the [one file tutorial][tut] for info on getting started.
+Shield
 
-[tut]: http://cyx.github.com/shield
+_n. A solid piece of metal code used to protect your application._
+
+## Why another authentication library?
+
+1. Because most of the other libraries are too huge.
+2. Extending other libraries is a pain.
+3. Writing code is fun :-)
+
+## Description of Shield
+
+1. Simple
+2. Doesn't get in the way
+3. Extensible (see [shield-contrib][shield-contrib]).
+
+## Getting started
+
+The fastest way to get started is by using one of the drop-in solutions
+in [shield-contrib][shield-contrib].
+
+## Tutorials
+
+You can learn more by reading through some of our tutorials:
+
+1. [Sinatra & OHM][sin-ohm]
+2. [Sinatra & Sequel][sin-sequel]
+
+
+[sin]: http://sinatrarb.com
+[ohm]: http://ohm.keyvalue.org
+[shield-contrib]: http://github.com/cyx/shield-contrib
+[sin-ohm]: http://cyx.github.com/shield/sinatra-ohm.html
+[sin-sequel]: http://cyx.github.com/shield/sinatra-sequel.html

data/lib/shield.rb

@@ -1,18 +1,7 @@
 module Shield
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 
-  autoload :BasicUser, "shield/template/basic_user"
-  autoload :User,      "shield/template/user"
-  autoload :FlexiUser, "shield/template/flexi_user"
   autoload :Password,  "shield/password"
-  autoload :Login,     "shield/login"
   autoload :Helpers,   "shield/helpers"
-
-  def self.registered(app)
-    app.helpers Helpers
-
-    app.use Login do |m|
-      m.settings.set :views, app.views if app.views
-    end
-  end
-end
+  autoload :Model,     "shield/model"
+end

data/lib/shield/helpers.rb

@@ -1,22 +1,41 @@
 module Shield
   module Helpers
-    def ensure_authenticated
-      return if logged_in?
+    def ensure_authenticated(model)
+      return if authenticated(model)
 
       session[:return_to] = request.fullpath
-      redirect "/login"
+      redirect_to_login
     end
 
-    def logged_in?
-      !! current_user
+    def authenticated(model)
+      @_authenticated ||= {}
+      @_authenticated[model] ||= model[session[model.to_s]]
     end
 
-    def current_user
-      @_current_user ||= ::User[session[:user]]
+    def redirect_to_login
+      redirect "/login"
     end
 
     def redirect_to_stored(default = "/")
       redirect(session.delete(:return_to) || default)
     end
+
+    def login(model, username, password)
+      instance = model.authenticate(username, password)
+
+      if instance
+        session[model.to_s] = instance.id
+        return true
+      else
+        return false
+      end
+    end
+
+    def logout(model)
+      session.delete(model.to_s)
+      session.delete(:return_to)
+
+      @_authenticated.delete(model) if defined?(@_authenticated)
+    end
   end
 end

data/lib/shield/model.rb

@@ -0,0 +1,35 @@
+module Shield
+  module Model
+    def authenticate(username, password)
+      user = fetch(username)
+
+      if user and is_valid_password?(user, password)
+        return user
+      end
+    end
+
+    def fetch(login)
+      raise FetchMissing
+    end
+
+    def is_valid_password?(user, password)
+      Shield::Password.check(password, user.crypted_password)
+    end
+
+    class FetchMissing < Class.new(StandardError)
+      def message
+        %{
+          !! You need to implement `fetch`.
+          Below is a quick example implementation (in Ohm):
+
+            def fetch(email)
+              find(:email => email).first
+            end
+
+          For more example implementations, check out
+          http://github.com/cyx/shield-contrib
+        }.gsub(/^ {10}/, "")
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -4,12 +4,6 @@ require "shield"
 require "cutest"
 require "rack/test"
 require "sinatra/base"
-require "nokogiri"
-require "haml"
-require "ohm"
-require "ohm/contrib"
-
-prepare { Ohm.flush }
 
 class Cutest::Scope
   include Rack::Test::Methods

data/test/model_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class User < Struct.new(:crypted_password)
+  extend Shield::Model
+end
+
+test "fetch" do
+  ex = nil
+
+  begin
+    User.fetch("quentin")
+  rescue Exception => e
+    ex = e
+  end
+
+  assert ex.kind_of?(Shield::Model::FetchMissing)
+  assert Shield::Model::FetchMissing.new.message == ex.message
+end
+
+test "is_valid_password?" do
+  user = User.new(Shield::Password.encrypt("password"))
+
+  assert User.is_valid_password?(user, "password")
+  assert ! User.is_valid_password?(user, "password1")
+end
+
+class User
+  class << self
+    attr_accessor :fetched
+  end
+
+  def self.fetch(username)
+    return fetched if username == "quentin"
+  end
+end
+
+test "authenticate" do
+  user = User.new(Shield::Password.encrypt("pass"))
+
+  User.fetched = user
+
+  assert user == User.authenticate("quentin", "pass")
+  assert nil == User.authenticate("unknown", "pass")
+  assert nil == User.authenticate("quentin", "wrongpass")
+end

data/test/shield_test.rb

@@ -1 +1,114 @@
-require File.expand_path("helper", File.dirname(__FILE__))
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class User < Struct.new(:id)
+  extend Shield::Model
+
+  def self.[](id)
+    User.new(1) unless id.to_s.empty?
+  end
+
+  def self.authenticate(username, password)
+    User.new(1001) if username == "quentin" && password == "password"
+  end
+end
+
+class Context
+  def initialize(path)
+    @path = path
+  end
+
+  def session
+    @session ||= {}
+  end
+
+  class Request < Struct.new(:fullpath)
+  end
+
+  def request
+    Request.new(@path)
+  end
+
+  def redirect(redirect = nil)
+    @redirect = redirect if redirect
+    @redirect
+  end
+
+  include Shield::Helpers
+end
+
+setup do
+  Context.new("/events/1")
+end
+
+test "ensure_authenticated when logged out" do |context|
+  context.ensure_authenticated(User)
+  assert "/events/1" == context.session[:return_to]
+  assert "/login" == context.redirect
+end
+
+test "ensure_authenticated when logged in" do |context|
+  context.session["User"] = 1
+  assert nil == context.ensure_authenticated(User)
+  assert nil == context.redirect
+  assert nil == context.session[:return_to]
+end
+
+class Admin < Struct.new(:id)
+  def self.[](id)
+    new(id) unless id.to_s.empty?
+  end
+end
+
+test "authenticated" do |context|
+  context.session["User"] = 1
+
+  assert User.new(1) == context.authenticated(User)
+  assert nil == context.authenticated(Admin)
+end
+
+test "caches authenticated in @_authenticated" do |context|
+  context.session["User"] = 1
+  context.authenticated(User)
+
+  assert User.new(1) == context.instance_variable_get(:@_authenticated)[User]
+end
+
+test "redirect to stored when :return_to is set" do |context|
+  context.session[:return_to] = "/private"
+  context.redirect_to_stored
+
+  assert "/private" == context.redirect
+  assert nil == context.session[:return_to]
+end
+
+test "redirect to stored when no return to" do |context|
+  context.redirect_to_stored
+  assert "/" == context.redirect
+
+  context.redirect_to_stored("/custom")
+  assert "/custom" == context.redirect
+end
+
+test "login success" do |context|
+  assert context.login(User, "quentin", "password")
+  assert 1001 == context.session["User"]
+end
+
+test "login failure" do |context|
+  assert false == context.login(User, "wrong", "creds")
+  assert nil == context.session["User"]
+end
+
+test "logout" do |context|
+  context.session["User"] = 1001
+  context.session[:return_to] = "/foo"
+
+  # Now let's make it memoize the User
+  context.authenticated(User)
+
+  context.logout(User)
+
+  assert nil == context.session["User"]
+  assert nil == context.session[:return_to]
+  assert nil == context.authenticated(User)
+end

data/test/sinatra_test.rb

@@ -1,21 +1,47 @@
 require File.expand_path("helper", File.dirname(__FILE__))
 
-class User < Shield::User
+class User < Struct.new(:id)
+  extend Shield::Model
+
+  def self.[](id)
+    User.new(1) unless id.to_s.empty?
+  end
+
+  def self.authenticate(username, password)
+    User.new(1001) if username == "quentin" && password == "password"
+  end
 end
 
 class SinatraApp < Sinatra::Base
   enable :sessions
-  register Shield
+  helpers Shield::Helpers
 
   get "/public" do
     "Public"
   end
 
   get "/private" do
-    ensure_authenticated
+    ensure_authenticated(User)
 
     "Private"
   end
+
+  get "/login" do
+    "Login"
+  end
+
+  post "/login" do
+    if login(User, params[:login], params[:password])
+      redirect_to_stored
+    else
+      redirect_to_login
+    end
+  end
+
+  get "/logout" do
+    logout(User)
+    redirect "/"
+  end
 end
 
 scope do
@@ -24,9 +50,7 @@ scope do
   end
 
   setup do
-    User.create(:email => "quentin@test.com",
-                :password => "password",
-                :password_confirmation => "password")
+    clear_cookies
   end
 
   test "public" do
@@ -34,40 +58,30 @@ scope do
     assert "Public" == last_response.body
   end
 
-  test "private" do
+  test "successful logging in" do
     get "/private"
     assert_redirected_to "/login"
     assert "/private" == session[:return_to]
 
-    post "/login", :login => "quentin@test.com", :password => "password"
+    post "/login", :login => "quentin", :password => "password"
     assert_redirected_to "/private"
-  end
 
-  test "GET /login response" do
-    get "/login"
-
-    doc = Nokogiri(%{<div>#{last_response.body}</div>})
-
-    assert 2 == doc.search("form > fieldset > label > input").size
-    assert 1 == doc.search("form > fieldset > button").size
+    assert 1001 == session["User"]
   end
-end
-
-class LoginCustomized < Sinatra::Base
-  enable :sessions
-  set :views, File.join(File.dirname(__FILE__), "fixtures", "views")
 
-  register Shield
-end
+  test "failed login" do
+    post "/login", :login => "q", :password => "p"
+    assert_redirected_to "/login"
 
-scope do
-  def app
-    LoginCustomized.new
+    assert nil == session["User"]
   end
 
-  test "login response" do
-    get "/login"
+  test "logging out" do
+    post "/login", :login => "quentin", :password => "password"
+
+    get "/logout"
 
-    assert "<h1>Login</h1>" == last_response.body.strip
+    assert nil == session["User"]
+    assert nil == session[:return_to]
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - Michel Martens
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-15 00:00:00 +08:00
+date: 2010-10-21 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,7 +46,7 @@ dependencies:
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: haml
+  name: rack-test
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
@@ -58,59 +58,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: rack-test
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: ohm
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: ohm-contrib
-  prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: nokogiri
-  prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id007
-description: "\n    Gets you 80-90% of the way regarding your authentication\n    requirements. Provides convenience helper functions which you can\n    use with your favorite web framework of choice.\n  "
+description: "\n    Provides all the protocol you need in order to do authentication on\n    your rack application. The implementation specifics can be found in\n    http://github.com/cyx/shield-contrib\n  "
 email: 
 - michel@soveran.com
 - djanowski@dimaion.com
@@ -123,26 +71,17 @@ extra_rdoc_files: []
 
 files: 
 - lib/shield/helpers.rb
-- lib/shield/login.rb
+- lib/shield/model.rb
 - lib/shield/password.rb
-- lib/shield/template/basic_user.rb
-- lib/shield/template/flexi_user.rb
-- lib/shield/template/user.rb
 - lib/shield.rb
 - README.markdown
-- README.rb
 - LICENSE
 - Rakefile
-- test/basic_user_test.rb
-- test/flexi_user_test.rb
 - test/helper.rb
-- test/login_middleware_test.rb
-- test/login_rack_mounting_test.rb
-- test/mounted_middleware_test.rb
+- test/model_test.rb
 - test/password_hash_test.rb
 - test/shield_test.rb
 - test/sinatra_test.rb
-- test/user_test.rb
 has_rdoc: true
 homepage: http://github.com/cyx/shield
 licenses: []
@@ -174,6 +113,6 @@ rubyforge_project: shield
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Ohm specific authentication solution.
+summary: Generic authentication protocol for rack applications.
 test_files: []
 

data/README.rb

@@ -1,73 +0,0 @@
-## Shield
-
-# A simple authentication framework for use with a basic Rack application.
-# It doesn't try to be generic and instead has the following assertions:
-
-# 1. You use [Ohm][ohm] for your persistence layer.
-# 2. That your app has some form of a Helper plugin system.
-
-## Usage
-
-# The fastest way to get started with `Shield` is to use it as a [Sinatra][sin]
-# extension on top of your main application.
-
-# We simply have to require sinatra, shield, and [Ohm][ohm].
-require "sinatra/base"
-require "shield"
-require "ohm"
-
-# We then define a `User` class on the top-level namespace:
-class User < Shield::User
-end
-
-# Our sinatra application can be a classic style, but for this example,
-# we'll use the more modular style extending from `Sinatra::Base`.
-class App < Sinatra::Base
-  # One very very important detail to remember is that you need to
-  # have session support for all of Shield to work.
-  enable :sessions
-
-  # Now for the main highlight: This line simply does two things:
-  #
-  # 1. It adds `Shield::Helpers` to your Sinatra app's helpers.
-  # 2. It adds `Shield::Login` as a middleware for your application.
-  #
-  register Shield
-
-  # This is a normal Sinatra route. No authentication is needed here.
-  get "/public" do
-    "Public"
-  end
-
-  # This is a private Sinatra route, which we enforce using
-  # `ensure_authenticated`. This method comes from `Shield::Helpers` along
-  # with some other helper methods:
-  #
-  # 1. `current_user`         - ain't this the standard nowadays?
-  # 2. `logged_in?`           - simple sugar to verify if the user is logged in.
-  # 3. `ensure_authenticated` - as shown here.
-  # 4. `redirect_to_stored`   - redirects to the previous url the user was
-  #                             trying to access prior to authenticating.
-  get "/private" do
-    ensure_authenticated
-
-    "Private"
-  end
-end
-
-# If this file was run directly i.e. ruby README.rb.
-if __FILE__ == $0
-  # For the purposes of this quick script, let's create a User. You'll use that
-  # to quickly verify that you can indeed login to the application.
-  if User.all.size == 0
-    User.create(:email => "quentin@test.com",
-                :password => "password",
-                :password_confirmation => "password")
-  end
-
-  # Let Sinatra take the stage.
-  App.run!
-end
-
-# [ohm]: http://ohm.keyvalue.org
-# [sin]: http://sinatrarb.com

data/lib/shield/login.rb

@@ -1,38 +0,0 @@
-require "sinatra/base"
-
-module Shield
-  class Login < Sinatra::Base
-    enable :sessions
-    helpers Helpers
-
-    set :views, File.join(File.dirname(__FILE__), "..", "..", "views")
-
-    set :auth_success_message, "You have successfully logged in."
-    set :auth_failure_message, "Wrong Username and/or Password combination."
-
-    get "/login/?" do
-      haml :login
-    end
-
-    post "/login/?" do
-      user = ::User.authenticate(params[:login], params[:password])
-
-      if user
-        session[:success] = settings.auth_success_message
-        session[:user] = user.id
-
-        redirect_to_stored
-      else
-        session[:error] = settings.auth_failure_message
-        redirect "/login"
-      end
-    end
-
-    get "/logout/?" do
-      session.delete(:user)
-      session.delete(:return_to)
-
-      redirect "/"
-    end
-  end
-end

data/lib/shield/template/basic_user.rb

@@ -1,37 +0,0 @@
-module Shield
-  class BasicUser < Ohm::Model
-    Unimplemented = Class.new(StandardError)
-
-    def self.inherited(model)
-      model.attribute :crypted_password
-    end
-
-    # TODO : change this if Ohm decides on implementing subclassing.
-    def self._copy_attributes_indices_counters(model)
-      attributes.each { |att| model.attribute(att) }
-      indices.each    { |att| model.index(att)     }
-      counters.each   { |att| model.counter(att)   }
-    end
-
-    attr_reader :password, :password_confirmation
-    attr_writer :password_confirmation
-
-    def self.authenticate(login, password)
-      user = find_by_login(login)
-
-      if user && Shield::Password.check(password, user.crypted_password)
-        return user
-      end
-    end
-
-    def self.find_by_login(login)
-      raise Unimplemented
-    end
-
-    def password=(password)
-      write_local :crypted_password, Shield::Password.encrypt(password)
-
-      @password = password
-    end
-  end
-end

data/lib/shield/template/flexi_user.rb

@@ -1,22 +0,0 @@
-module Shield
-  class FlexiUser < User
-    def self.inherited(model)
-      model.attribute :username
-      model.index :username
-
-      _copy_attributes_indices_counters(model)
-    end
-
-    def self.find_by_login(login)
-      super or find(:username => login).first
-    end
-
-    def validate
-      super
-
-      assert_present(:username) &&
-        assert_format(:username, /\A[a-z][a-z0-9\-\_\.]{2,}\z/) &&
-        assert_unique(:username)
-    end
-  end
-end

data/lib/shield/template/user.rb

@@ -1,32 +0,0 @@
-require "ohm/contrib"
-
-module Shield
-  class User < BasicUser
-    include Ohm::WebValidations
-
-    def self.inherited(model)
-      model.attribute :email
-      model.index :email
-
-      _copy_attributes_indices_counters(model)
-    end
-
-    def self.find_by_login(login)
-      find(:email => login).first
-    end
-
-    def validate
-      super
-
-      assert_present(:email) && assert_email(:email) && assert_unique(:email)
-
-      if new?
-        assert_present :password
-      end
-
-      unless password.to_s.empty?
-        assert password == password_confirmation, [:password, :not_confirmed]
-      end
-    end
-  end
-end

data/test/basic_user_test.rb

@@ -1,37 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class BasicUser < Shield::BasicUser
-end
-
-setup do
-  BasicUser.create(:password => "password")
-end
-
-test "allows password checks at the minimum" do |u|
-  assert Shield::Password.check("password", u.crypted_password)
-end
-
-test "no find_by_login" do
-  assert_raise Shield::BasicUser::Unimplemented do
-    BasicUser.authenticate("quentin", "password")
-  end
-
-  assert_raise Shield::BasicUser::Unimplemented do
-    BasicUser.find_by_login("quentin")
-  end
-end
-
-test "has password confirmation accesors" do |u|
-  u.password_confirmation = "pass"
-
-  assert "pass" == u.password_confirmation
-end
-
-test "writes the new crypted password on set" do
-  u = BasicUser.new(:password => "mypass")
-  assert Shield::Password.check("mypass", u.crypted_password)
-
-  u.save
-  u = BasicUser[u.id]
-  assert Shield::Password.check("mypass", u.crypted_password)
-end

data/test/flexi_user_test.rb

@@ -1,40 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class FlexiUser < Shield::FlexiUser
-end
-
-setup do
-  FlexiUser.create(:email => "quentin@test.com",
-                   :username => "quentin",
-                   :password => "password",
-                   :password_confirmation => "password")
-end
-
-test "find_by_login" do |u|
-  assert u == FlexiUser.find_by_login("quentin@test.com")
-  assert u == FlexiUser.find_by_login("quentin")
-end
-
-test "authenticate" do |u|
-  assert u == FlexiUser.authenticate("quentin", "password")
-  assert u == FlexiUser.authenticate("quentin@test.com", "password")
-end
-
-test "username validation" do |u|
-  u.username = nil
-  assert ! u.valid?
-  assert u.errors.include?([:username, :not_present])
-
-  ["1foo", "fo", "foo^", "foo&", "foo#"].each do |username|
-    u.username = username
-    assert ! u.valid?
-    assert u.errors.include?([:username, :format])
-  end
-
-  u.username = "foo"
-  assert u.valid?
-
-  newuser = FlexiUser.new(:username => "quentin")
-  assert ! newuser.valid?
-  assert newuser.errors.include?([:username, :not_unique])
-end

data/test/login_middleware_test.rb

@@ -1,59 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class User < Shield::User
-end
-
-class Main < Sinatra::Base
-  enable :sessions
-  helpers Shield::Helpers
-
-  get "/public" do
-    "Public"
-  end
-
-  get "/private" do
-    ensure_authenticated
-
-    "Private"
-  end
-
-  use Shield::Login do |login|
-    login.settings.auth_success_message = "Booya!"
-    login.settings.auth_failure_message = "BOOM!"
-  end
-end
-
-scope do
-  def app
-    Main.new
-  end
-
-  setup do
-    clear_cookies
-
-    User.create(:email => "quentin@test.com",
-                :password => "password",
-                :password_confirmation => "password")
-  end
-
-  test "public" do
-    get "/public"
-    assert "Public" == last_response.body
-  end
-
-  test "logging in" do
-    post "/login", :login => "quentin@test.com", :password => "password"
-
-    get "/private"
-    assert "Private" == last_response.body
-    assert "Booya!" == session[:success]
-  end
-
-  test "login, logout, login failure" do
-    post "/login", :login => "quentin@test.com", :password => "password"
-    get "/logout"
-
-    post "/login"
-    assert "BOOM!" == session[:error]
-  end
-end

data/test/login_rack_mounting_test.rb

@@ -1,63 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class User < Shield::User
-end
-
-class Main < Sinatra::Base
-  enable :sessions
-  helpers Shield::Helpers
-
-  get "/public" do
-    "Public"
-  end
-
-  get "/private" do
-    ensure_authenticated
-
-    "Private"
-  end
-end
-
-$app = Rack::Builder.app {
-  use Shield::Login
-
-  map "/" do
-    run Main
-  end
-}
-
-scope do
-  def app
-    $app
-  end
-
-  setup do
-    clear_cookies
-
-    User.create(:email => "quentin@test.com",
-                :password => "password",
-                :password_confirmation => "password")
-  end
-
-  test "public" do
-    get "/public"
-
-    assert "Public" == last_response.body
-  end
-
-  test "logging in" do
-    post "/login", :login => "quentin@test.com",
-                   :password => "password"
-
-    get "/private"
-    assert "Private" == last_response.body
-  end
-
-  test "being redirected and then logging in" do
-    get "/private"
-    assert_redirected_to "/login"
-
-    post "/login", :login => "quentin@test.com", :password => "password"
-    assert_redirected_to "/private"
-  end
-end

data/test/mounted_middleware_test.rb

@@ -1,96 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class User < Shield::User
-end
-
-class App < Sinatra::Base
-  enable :sessions
-
-  helpers Shield::Helpers
-end
-
-class Main < App
-  get "/public" do
-    "Public"
-  end
-
-  get "/private" do
-    ensure_authenticated
-
-    "Private"
-  end
-end
-
-class Admin < App
-  before do
-    ensure_authenticated unless request.fullpath == "/admin/login"
-  end
-
-  get "/events" do
-    "Events"
-  end
-
-  get "/sponsors" do
-    "Sponsors"
-  end
-
-  post "/login" do
-    user = User.authenticate(params[:login], params[:password])
-
-    if user
-      session[:success] = "Success"
-      session[:user] = user.id
-
-      redirect_to_stored
-    else
-      session[:error] = "Failure"
-      redirect "/login"
-    end
-  end
-end
-
-$app = Rack::Builder.app {
-  map "/" do
-    run Main
-  end
-
-  map "/admin" do
-    run Admin
-  end
-}
-
-scope do
-  def app
-    $app
-  end
-
-  setup do
-    User.create(:email => "quentin@test.com",
-                :password => "password",
-                :password_confirmation => "password")
-  end
-
-  test "public" do
-    get "/public"
-
-    assert "Public" == last_response.body
-  end
-
-  test "all admin routes" do
-    get "/admin/events"
-    assert_redirected_to "/login"
-    assert "/admin/events" == session[:return_to]
-
-    get "/admin/sponsors"
-    assert_redirected_to "/login"
-    assert "/admin/sponsors" == session[:return_to]
-  end
-
-  test "single sign on" do
-    post "/admin/login", :login => "quentin@test.com",
-                         :password => "password"
-
-    get "/private"
-    assert "Private" == last_response.body
-  end
-end

data/test/user_test.rb

@@ -1,33 +0,0 @@
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class User < Shield::User
-end
-
-setup do
-  User.create(:email => "quentin@email.com", :password => "password",
-              :password_confirmation => "password")
-end
-
-test "authentication default" do |u|
-  assert u == User.authenticate("quentin@email.com", "password")
-
-  assert nil == User.authenticate("quentin@email.com", "pass")
-  assert nil == User.authenticate("quentin@email.co.uk", "password")
-end
-
-test "email validation" do |u|
-  u.email = nil
-  assert ! u.valid?
-  assert u.errors.include?([:email, :not_present])
-
-  u.email = "foobar"
-  assert ! u.valid?
-  assert u.errors.include?([:email, :not_email])
-
-  u.email = "foo@bar.com"
-  u.save
-
-  foo = User.new(:email => "foo@bar.com")
-  assert ! foo.valid?
-  assert foo.errors.include?([:email, :not_unique])
-end