sorcery 0.3.1 → 0.4.2

data/lib/sorcery/test_helpers/sinatra.rb

@@ -1,130 +1,84 @@
 module Sorcery
   module TestHelpers
     module Sinatra
-      
-      class MyApp
-        class << self
-          def new
-            return this
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.send(:include, CookieSessionMethods)
+        ::Sinatra::Base.class_eval do
+          class << self
+            attr_accessor :rack_test_session
           end
-        end
-      end
-      
-      class ::Sinatra::Application
-        class << self
-          attr_accessor :sorcery_vars
-        end
-        @sorcery_vars = {}
 
-        # NOTE: see before and after test filters in filters.rb
-        
-        def save_instance_vars
-          instance_variables.each do |var|
-            self.class.sorcery_vars[:"#{var.to_s.delete("@")}"] = instance_variable_get(var)
+          def self.inherited(subclass)
+            super
+            subclass.class_eval do
+              class << self
+                attr_accessor :rack_test_session
+              end
+            end
+          end
+
+          include CookieSessionMethods
+
+          def rack_test_session
+            self.class.rack_test_session
           end
         end
       end
-                    
-      ::RSpec::Matchers.define :redirect_to do |expected|
-        match do |actual|
-          actual.status == 302 && actual.location == expected
-        end
-      end
-      
-      def get_sinatra_app(app)
-        while app.class != ::Sinatra::Application do
-          app = app.instance_variable_get(:@app)
-        end
-        app
-      end
-      
-      def login_user(user=nil)
-        user ||= @user
-        get_sinatra_app(subject).send(:login_user,user)
-        get_sinatra_app(subject).send(:after_login!,user,[user.username,'secret'])
-      end
-      
-      def logout_user
-        get_sinatra_app(subject).send(:logout)
-      end
 
-      def clear_user_without_logout
-        get_sinatra_app(subject).instance_variable_set(:@current_user,nil)
-      end
-        
-      def assigns
-        ::Sinatra::Application.sorcery_vars
-      end
-      
-      class SessionData
-        def initialize(cookies)
-          @cookies = cookies
-          @data = cookies['rack.session']
-          if @data
-            @data = @data.unpack("m*").first
-            @data = Marshal.load(@data)
-          else
-            @data = {}
+      module InstanceMethods
+        def get_sinatra_app(app)
+          while !app.kind_of? ::Sinatra::Base do
+            app = app.instance_variable_get(:@app)
           end
+          app
         end
 
-        def [](key)
-          @data[key]
+        def login_user(user=nil)
+          user ||= @user
+          get_sinatra_app(app).send(:login_user, user)
+          get_sinatra_app(app).send(:after_login!, user, [user.send(user.sorcery_config.username_attribute_name), 'secret'])
         end
 
-        def []=(key, value)
-          @data[key] = value
-          session_data = Marshal.dump(@data)
-          session_data = [session_data].pack("m*")
-          @cookies.merge("rack.session=#{Rack::Utils.escape(session_data)}", URI.parse("//example.org//"))
-          raise "session variable not set" unless @cookies['rack.session'] == session_data
+        def logout_user
+          get_sinatra_app(app).send(:logout)
         end
       end
 
-      def session
-        SessionData.new(rack_test_session.instance_variable_get(:@rack_mock_session).cookie_jar)
-      end
-      
-      def cookies
-        rack_test_session.instance_variable_get(:@rack_mock_session).cookie_jar
-      end
-      
-      def sorcery_reload!(submodules = [], options = {})
-        reload_user_class
+      module CookieSessionMethods
+        class SessionData
+          def initialize(cookies)
+            @cookies = cookies
+            @data = cookies['rack.session']
+            if @data
+              @data = @data.unpack("m*").first
+              @data = Marshal.load(@data)
+            else
+              @data = {}
+            end
+          end
 
-        # return to no-module configuration
-        ::Sorcery::Controller::Config.init!
-        ::Sorcery::Controller::Config.reset!
+          def [](key)
+            @data[key]
+          end
 
-        # clear all filters
-        ::Sinatra::Application.instance_variable_set(:@filters,{:before => [],:after => []})
-        ::Sinatra::Application.class_eval do
-          load File.join(File.dirname(__FILE__),'..','..','..','spec','sinatra','filters.rb')
-        end
-        
-        # configure
-        ::Sorcery::Controller::Config.submodules = submodules
-        ::Sorcery::Controller::Config.user_class = nil
-        ::Sinatra::Application.send(:include, Sorcery::Controller::Adapters::Sinatra)
-        ::Sinatra::Application.send(:include, Sorcery::Controller)
-        
-        User.activate_sorcery! do |config|
-          options.each do |property,value|
-            config.send(:"#{property}=", value)
+          def []=(key, value)
+            @data[key] = value
+            session_data = Marshal.dump(@data)
+            session_data = [session_data].pack("m*")
+            @cookies.merge("rack.session=#{Rack::Utils.escape(session_data)}", URI.parse("//example.org//"))
+            raise "session variable not set" unless @cookies['rack.session'] == session_data
+          end
+
+          def clear
+            @data = {}
           end
         end
-      end
-      
-      def sorcery_controller_property_set(property, value)
-        ::Sinatra::Application.activate_sorcery! do |config|
-          config.send(:"#{property}=", value)
-        end
-      end
 
-      def sorcery_controller_oauth_property_set(provider, property, value)
-        ::Sinatra::Application.activate_sorcery! do |config|
-          config.send(provider).send(:"#{property}=", value)
+        def session
+          SessionData.new(rack_test_session.instance_variable_get(:@rack_mock_session).cookie_jar)
         end
+
       end
     end
   end

data/lib/sorcery/test_helpers.rb

@@ -1,40 +1,5 @@
 module Sorcery
   module TestHelpers
-    # a patch to fix a bug in testing that happens when you 'destroy' a session twice.
-    # After the first destroy, the session is an ordinary hash, and then when destroy is called again there's an exception.
-    class ::Hash
-      def destroy
-        clear
-      end
-    end
-    
-    def create_new_user(attributes_hash = nil)
-      user_attributes_hash = attributes_hash || {:username => 'gizmo', :email => "bla@bla.com", :password => 'secret'}
-      @user = User.new(user_attributes_hash)
-      @user.save!
-      @user
-    end
 
-    def create_new_external_user(provider, attributes_hash = nil)
-      user_attributes_hash = attributes_hash || {:username => 'gizmo', :authentications_attributes => [{:provider => provider, :uid => 123}]}
-      @user = User.new(user_attributes_hash)
-      @user.save!
-      @user
-    end
-    
-    def sorcery_model_property_set(property, *values)
-      User.class_eval do
-        sorcery_config.send(:"#{property}=", *values)
-      end
-    end
-    
-    private
-
-    # reload user class between specs
-    # so it will be possible to test the different submodules in isolation
-    def reload_user_class
-      Object.send(:remove_const,:User)
-      load 'user.rb'
-    end
   end
 end

data/lib/sorcery.rb

@@ -36,6 +36,7 @@ module Sorcery
     end
   end
   module CryptoProviders
+    autoload :Common, 'sorcery/crypto_providers/common'
     autoload :AES256, 'sorcery/crypto_providers/aes256'
     autoload :BCrypt, 'sorcery/crypto_providers/bcrypt'
     autoload :MD5,    'sorcery/crypto_providers/md5'
@@ -47,7 +48,14 @@ module Sorcery
   module TestHelpers
     autoload :Rails, 'sorcery/test_helpers/rails'
     autoload :Sinatra, 'sorcery/test_helpers/sinatra'
+    autoload :Internal, 'sorcery/test_helpers/internal'
+    module Internal
+      autoload :Rails, 'sorcery/test_helpers/internal/rails'
+      autoload :Sinatra, 'sorcery/test_helpers/internal/sinatra'
+    end
+
   end
+
   
   require 'sorcery/engine' if defined?(Rails) && Rails::VERSION::MAJOR == 3
   require 'sorcery/sinatra' if defined?(Sinatra)