rrba 1.0.0

data/lib/rrba.rb

@@ -0,0 +1,3 @@
+class rrba
+VERSION =  '1.0.0'
+end

data/lib/rrba/error.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# Error -- rrba -- 04.02.2005 -- rwaltert@ywesee.com
+
+module RRBA
+	class AuthenticationError < RuntimeError; end
+end

data/lib/rrba/server.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# Server -- rrba -- 10.11.2004 -- hwyss@ywesee.com
+
+require 'rrba/user'
+require 'rrba/error'
+require 'openssl'
+require 'digest/md5'
+
+module RRBA
+	class Server
+		attr_writer :root, :anonymous
+		def initialize
+			@users = []
+		end
+		def add_user(user)
+			id = user.unique_id
+			if(@users.any? { |usr| usr.unique_id == id })
+				raise "Duplicate ID #{id}"
+			end
+			@users.push(user).last
+		end
+		def authenticate(id=nil, &block)
+			challenge = Digest::MD5.hexdigest(rand(2**32).to_s)[0,20]
+			signature = block.call(challenge)
+			if(@anonymous && signature == :anonymous)
+				return @anonymous.new_session
+			end
+			if(@root && @root.authenticate(challenge, signature))
+				return @root.new_session
+			end
+			begin
+				if(id)
+					if((user = user(id)) \
+						&& user.authenticate(challenge, signature))
+						return user.new_session
+					end
+				else
+					@users.each { |user|
+						if(user.authenticate(challenge, signature))
+							return user.new_session
+						end
+					}
+				end
+			rescue RuntimeError
+			end
+			raise AuthenticationError, 'Authentication failed'
+		end
+		def user(id)
+			@users.select { |user|  
+				user.unique_id == id 
+			}.first or raise "Unknown User: #{id}"
+		end
+		def unique_ids
+			@users.collect { |user|
+				user.unique_id
+			}
+		end
+	end
+end

data/lib/rrba/user.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# User -- rrba -- 01.11.2004 -- hwyss@ywesee.com
+
+module RRBA
+	class User
+		attr_reader :name, :email, :short_name, :unique_id, :public_key
+		def initialize(unique_id)
+			@unique_id = unique_id or raise "Invalid ID #{unique_id}"
+		end
+		def authenticate(challenge, signature)
+			# enable lazy initializing 
+			# (for subclasses that can be persisted)
+			public_key.sysverify(challenge, signature)
+		end
+		def email=(email)
+			email = email.to_s.strip
+			raise "Invalid Email #{email}" if(email.empty?)
+			@email = email
+		end
+		def name=(name)
+			name = name.to_s.strip
+			raise "Invalid Username #{name}" if(name.empty?)
+			@name = name
+		end
+		def new_session
+			raise NotImplementedError, 
+				"no predefined behavior for RRBA::User#new_session"
+		end
+		def public_key=(key)
+			@public_key = key.public_key
+		end
+		def short_name=(short_name)
+			short_name = short_name.to_s.strip
+			raise "Invalid Short Name #{short_name}" if(short_name.empty?)
+			@short_name = short_name
+		end
+	end
+end

data/test/mock.rb

@@ -0,0 +1,149 @@
+# Ruby/Mock version 1.0
+# 
+# A class for conveniently building mock objects in RUnit test cases.
+# Copyright (c) 2001 Nat Pryce, all rights reserved
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+require 'runit/error'
+
+
+class Mock
+    # Creates a new, named mock object. The name is reported in exceptions
+    # thrown by the mock object when method invocations are incorrect.
+    # 
+    def initialize( mock_name = self.to_s )
+        @mock_calls = []
+        @next_call = 0
+        @name = mock_name
+    end
+    
+    # Mock the next method call to be made to this mock object.
+    # 
+    # A mock method is defined by the method name (a symbol) and a block
+    # that defines the arity of the method and the mocked behaviour for
+    # this call.  The mocked behaviour should assert preconditions and
+    # return a value.  Mocked behaviour should rarely be any more complex
+    # than that.  If it is,  that's probably an indication that the tests
+    # need some restructuring or that the tested code needs refactoring.
+    # 
+    # If no block is given and preconditions have been defined for the named
+    # method, a block is created for the mocked methodthat has the same arity
+    # as the precondition and returns self.
+    # 
+    def __next( name, &test )
+        if test == nil
+            if respond_to?( Mock.__pre(name) )
+                test = proc { |*args| self }
+            else
+                raise "no block given for mocked method #{name}"
+            end
+        end
+        @mock_calls.push( [name,test] )
+    end
+    
+    # Call this at the end of a test to ensure that all scheduled calls
+    # have been made to the mock
+    #
+    def __verify
+        if @next_call != @mock_calls.length
+            raise RUNIT::AssertionFailedError,
+                  "not all expected method calls were made to #{@name}",
+                  caller
+        end
+    end
+    
+    
+private
+    # Dispatches aribtrary method calls to the next mocked behaviour
+    # 
+    def method_missing( name, *args )
+        __mock_call( name, args, (block_given? ? proc : nil) )
+    end
+    
+    # Implements a method call using the next mocked behaviour and asserts
+    # that the expected method is called with the expected number of 
+    # arguments.
+    #
+    def __mock_call( name, args, block )
+        if @next_call >= @mock_calls.length
+            raise RUNIT::AssertionFailedError,
+                  "unexpected call to #{name} method of #{@name}",
+                  caller(2)
+        end
+        
+        expected_name,body = @mock_calls[@next_call]
+        @next_call += 1
+        
+        if name != expected_name
+            raise RUNIT::AssertionFailedError,
+                  "wrong method called on #{@name}; " +
+                      "expected #{expected_name}, was #{name}",
+                  caller(2)
+        end
+        
+        args_length = args.length + (block ? 1 : 0)
+        
+        if body.arity < 0
+            if (body.arity+1).abs > args_length 
+                raise RUNIT::AssertionFailedError,
+                      "too few arguments to #{name} method of #{@name}; " +
+                          "require #{(body.arity+1).abs}, got #{args.length}",
+                      caller(2)
+            end
+        else
+            if body.arity != args_length
+                raise RUNIT::AssertionFailedError,
+                      "wrong number of arguments to " +
+                          "#{name} method of #{@name}; " +
+                          "require #{body.arity}, got #{args.length}",
+                      caller(2)
+            end
+        end
+        
+        if respond_to? Mock.__pre(name)
+            if block
+                precondition_ok = __send__( Mock.__pre(name), *args, &block )
+            else
+                precondition_ok = __send__( Mock.__pre(name), *args )
+            end
+            
+            if not precondition_ok
+                raise RUNIT::AssertionFailedError,
+                    "precondition of #{name} method violated",
+                    caller(2)
+            end
+        end
+        
+        if block
+            instance_eval { body.call( block, *args ) }
+        else
+            instance_eval { body.call( *args ) }
+        end
+    end
+
+    #  The name of a precondition for a method
+    def Mock.__pre( method )
+        "__pre_#{method.to_i}".intern
+    end
+    
+		
+    def Mock.method_added( name )
+			unless(/^__pre_/.match(name.to_s))
+        pre = self.__pre(name)
+        alias_method( pre, name )
+        undef_method(name)
+			end
+    end
+end

data/test/stub/odba.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#  -- rdpm -- 21.01.2005 -- hwyss@ywesee.com
+
+require 'odba'
+
+module ODBA
+	module Persistable
+		attr_reader :odba_store_called
+		def odba_store
+			@odba_store_called = true
+		end
+	end
+end

data/test/suite.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# suite.rb -- rrba -- 20.11.2002 -- hwyss@ywesee.com 
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+Dir.foreach(File.dirname(__FILE__)) { |file|
+	require file if /^test_.*\.rb$/o.match(file)
+}

data/test/test_server.rb

@@ -0,0 +1,178 @@
+#!/usr/bin/env ruby
+# TestServer -- rdpm -- 10.11.2004 -- hwyss@ywesee.com
+
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+$: << File.dirname(__FILE__)
+
+require 'test/unit'
+require 'mock'
+require 'fileutils'
+require 'rrba/server'
+
+module RRBA
+	class TestServer < Test::Unit::TestCase
+		def setup
+			@server = Server.new
+			@datadir = File.expand_path('data', File.dirname(__FILE__))
+		end
+		def test_add_user
+			user = User.new(345)
+			users = @server.instance_variable_get('@users')
+			@server.add_user(user)
+			assert_equal(user, @server.user(345))	
+		end
+		def test_add_user__duplicate_id
+			user = User.new(345)
+			users = @server.instance_variable_get('@users')
+			@server.add_user(user)
+			assert_equal(user, @server.user(345))	
+			assert_equal(345, user.unique_id)
+			user = User.new(345)
+			assert_raises(RuntimeError) { 
+				@server.add_user(user)
+			}
+		end
+		def test_authenticate__failure
+			user1 = Mock.new('User1')
+			user2 = Mock.new('User2')
+			user3 = Mock.new('User3')
+			user1.__next(:authenticate) { |chal, sig|
+				assert_equal(20, chal.size)
+				assert_equal('client-signature', sig)
+				false
+			}
+			user2.__next(:authenticate) { |chal, sig|
+				assert_equal(20, chal.size)
+				assert_equal('client-signature', sig)
+				false
+			}
+			user3.__next(:authenticate) { |chal, sig|
+				assert_equal(20, chal.size)
+				assert_equal('client-signature', sig)
+				false
+			}
+			users = [
+				user1,
+				user2,
+				user3,
+			]
+			@server.instance_variable_set('@users', users)
+			user = nil
+			assert_raises(AuthenticationError) { 
+				user = @server.authenticate { |challenge|
+					assert_equal(20, challenge.size)
+					'client-signature'
+				}
+			}
+			assert_nil(user)
+		end
+		def test_authenticate__success
+			user1 = Mock.new('User1')
+			user2 = Mock.new('User2')
+			user3 = Mock.new('User3')
+			user1.__next(:authenticate) { |challenge, sig|
+				assert_equal('client-signature', sig)
+				false
+			}
+			user2.__next(:authenticate) { |challenge, sig|
+				assert_equal('client-signature', sig)
+				true
+			}
+			user3.__next(:authenticate) { |challenge, sig|
+				assert_equal('client-signature', sig)
+				false
+			}
+			users = [
+				user1,
+				user2,
+				user3,
+			]
+			session = Mock.new('Session')
+			user2.__next(:new_session) { session }
+			@server.instance_variable_set('@users', users)
+			sess = @server.authenticate { |challenge, sig|
+				assert_equal(20, challenge.size)
+				'client-signature'
+			}
+			assert_equal(session, sess)
+			user2.__verify
+		end
+		def test_authenticate__root
+			root = Mock.new('Root')
+			user2 = Mock.new('User2')
+			user3 = Mock.new('User3')
+			root.__next(:authenticate) { |challenge, sig|
+				assert_equal('client-signature', sig)
+				true
+			}
+			users = [
+				user2,
+				user3,
+			]
+			session = Mock.new('Session')
+			root.__next(:new_session) { session }
+			@server.instance_variable_set('@root', root)
+			@server.instance_variable_set('@users', users)
+			sess = @server.authenticate { |challenge, sig|
+				'client-signature'
+			}
+			assert_equal(session, sess)
+			root.__verify
+		end
+		def test_authenticate__anonymous
+			root = Mock.new('Root')
+			user2 = Mock.new('User2')
+			user3 = Mock.new('User3')
+			anonymous = Mock.new('Anonymous')
+			users = [
+				user2,
+				user3,
+			]
+			session = Mock.new('Session')
+			anonymous.__next(:new_session) { session }
+			@server.root = root
+			@server.anonymous = anonymous
+			@server.instance_variable_set('@users', users)
+			sess = @server.authenticate { |challenge, sig|
+				:anonymous
+			}
+			assert_equal(session, sess)
+			root.__verify
+		end
+		def test_authenticate__by_id
+			user1 = Mock.new('User1')
+			user2 = Mock.new('User2')
+			user3 = Mock.new('User3')
+			user1.__next(:unique_id) { 'user1' }
+			user2.__next(:unique_id) { 'user2' }
+			user3.__next(:unique_id) { 'user3' }
+			user2.__next(:authenticate) { |challenge, sig|
+				assert_equal('client-signature', sig)
+				true
+			}
+			users = [
+				user1,
+				user2,
+				user3,
+			]
+			session = Mock.new('Session')
+			user2.__next(:new_session) { session }
+			@server.instance_variable_set('@users', users)
+			sess = @server.authenticate('user2') { |challenge, sig|
+				assert_equal(20, challenge.size)
+				'client-signature'
+			}
+			assert_equal(session, sess)
+			user2.__verify
+		end
+		def test_unique_ids
+			user = Mock.new('user')
+			user2 = Mock.new('user2')
+			user.__next(:unique_id) { 'rwaltert' }
+			user2.__next(:unique_id) { 'hwyss' }
+			users = [user, user2]
+			@server.instance_variable_set('@users', users)
+			assert_equal(["rwaltert", 'hwyss'], @server.unique_ids)
+		end
+	end
+end