tilia-dav 3.1.0.pre.alpha2

data/test/dav/auth/backend/abstract_basic_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        class AbstractBasicTest < Minitest::Test
+          def test_check_no_headers
+            request = Http::Request.new
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractBasicMock.new
+
+            refute(backend.check(request, response)[0])
+          end
+
+          def test_check_unknown_user
+            request = Http::Sapi.create_from_server_array(
+              'PHP_AUTH_USER' => 'username',
+              'PHP_AUTH_PW' => 'wrongpassword'
+            )
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractBasicMock.new
+
+            refute(backend.check(request, response)[0])
+          end
+
+          def test_check_success
+            request = Http::Sapi.create_from_server_array(
+              'PHP_AUTH_USER' => 'username',
+              'PHP_AUTH_PW' => 'password'
+            )
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractBasicMock.new
+            assert_equal(
+              [true, 'principals/username'],
+              backend.check(request, response)
+            )
+          end
+
+          def test_require_auth
+            request = Http::Request.new
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractBasicMock.new
+            backend.realm = 'writing unittests on a saturday night'
+            backend.challenge(request, response)
+
+            assert_equal(
+              'Basic realm="writing unittests on a saturday night"',
+              response.header('WWW-Authenticate')
+            )
+          end
+        end
+
+        class AbstractBasicMock < AbstractBasic
+          # Validates a username and password
+          #
+          # This method should return true or false depending on if login
+          # succeeded.
+          #
+          # @param string username
+          # @param string password
+          # @return bool
+          def validate_user_pass(username, password)
+            username == 'username' && password == 'password'
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/auth/backend/abstract_digest_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        class AbstractDigestTest < Minitest::Test
+          def test_check_no_headers
+            request = Http::Request.new
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractDigestMock.new
+            refute(backend.check(request, response)[0])
+          end
+
+          def test_check_bad_get_user_info_response
+            header = 'username=null, realm=myRealm, nonce=12345, uri=/, response=HASH, opaque=1, qop=auth, nc=1, cnonce=1'
+            request = Http::Sapi.create_from_server_array(
+              'PHP_AUTH_DIGEST' => header
+            )
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractDigestMock.new
+            refute(backend.check(request, response)[0])
+          end
+
+          def test_check_bad_get_user_info_response2
+            header = 'username=array, realm=myRealm, nonce=12345, uri=/, response=HASH, opaque=1, qop=auth, nc=1, cnonce=1'
+            request = Http::Sapi.create_from_server_array(
+              'PHP_AUTH_DIGEST' => header
+            )
+
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractDigestMock.new
+            assert_raises(Exception) { backend.check(request, response) }
+          end
+
+          def test_check_unknown_user
+            header = 'username=false, realm=myRealm, nonce=12345, uri=/, response=HASH, opaque=1, qop=auth, nc=1, cnonce=1'
+            request = Http::Sapi.create_from_server_array(
+              'PHP_AUTH_DIGEST' => header
+            )
+
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractDigestMock.new
+            refute(backend.check(request, response)[0])
+          end
+
+          def test_check_bad_password
+            header = 'username=user, realm=myRealm, nonce=12345, uri=/, response=HASH, opaque=1, qop=auth, nc=1, cnonce=1'
+            request = Http::Sapi.create_from_server_array(
+              'PHP_AUTH_DIGEST' => header,
+              'REQUEST_METHOD'  => 'PUT'
+            )
+
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractDigestMock.new
+            refute(backend.check(request, response)[0])
+          end
+
+          def test_check
+            digest_hash = Digest::MD5.hexdigest("HELLO:12345:1:1:auth:#{Digest::MD5.hexdigest('GET:/')}")
+            header = "username=user, realm=myRealm, nonce=12345, uri=/, response=#{digest_hash}, opaque=1, qop=auth, nc=1, cnonce=1"
+            request = Http::Sapi.create_from_server_array(
+              'REQUEST_METHOD'  => 'GET',
+              'PHP_AUTH_DIGEST' => header,
+              'REQUEST_PATH'    => '/'
+            )
+
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractDigestMock.new
+            assert_equal(
+              [true, 'principals/user'],
+              backend.check(request, response)
+            )
+          end
+
+          def test_require_auth
+            request = Http::Request.new
+            response = Http::Response.new
+
+            backend = Auth::Backend::AbstractDigestMock.new
+            backend.realm = 'writing unittests on a saturday night'
+            backend.challenge(request, response)
+
+            assert_equal(
+              'Digest realm="writing unittests on a saturday night"',
+              response.header('WWW-Authenticate')[0..51]
+            )
+          end
+        end
+
+        class AbstractDigestMock < AbstractDigest
+          def digest_hash(_realm, user_name)
+            case user_name
+            when 'null'
+              nil
+            when 'false'
+              false
+            when 'array'
+              []
+            when 'user'
+              'HELLO'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/auth/backend/abstract_sequel_test.rb

@@ -0,0 +1,25 @@
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        module AbstractSequelTest
+          def test_construct
+            db = sequel
+            backend = Auth::Backend::Sequel.new(db)
+            assert_kind_of(Auth::Backend::Sequel, backend)
+          end
+
+          def test_user_info
+            db = sequel
+            backend = Auth::Backend::Sequel.new(db)
+
+            assert_nil(backend.digest_hash('realm', 'blabla'))
+
+            expected = 'hash'
+            assert_equal(expected, backend.digest_hash('realm', 'user'))
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/auth/backend/apache_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        class ApacheTest < Minitest::Test
+          def test_construct
+            backend = Auth::Backend::Apache.new
+            assert_kind_of(Auth::Backend::Apache, backend)
+          end
+
+          def test_no_header
+            request = Http::Request.new
+            response = Http::Response.new
+            backend = Auth::Backend::Apache.new
+
+            refute(backend.check(request, response)[0])
+          end
+
+          def test_remote_user
+            request = Http::Sapi.create_from_server_array(
+              'REMOTE_USER' => 'username'
+            )
+            response = Http::Response.new
+            backend = Auth::Backend::Apache.new
+
+            assert_equal(
+              [true, 'principals/username'],
+              backend.check(request, response)
+            )
+          end
+
+          def test_redirect_remote_user
+            request = Http::Sapi.create_from_server_array(
+              'REDIRECT_REMOTE_USER' => 'username'
+            )
+            response = Http::Response.new
+            backend = Auth::Backend::Apache.new
+
+            assert_equal(
+              [true, 'principals/username'],
+              backend.check(request, response)
+            )
+          end
+
+          def test_require_auth
+            request = Http::Request.new
+            response = Http::Response.new
+
+            backend = Auth::Backend::Apache.new
+            backend.challenge(request, response)
+
+            assert_nil(response.header('WWW-Authenticate'))
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/auth/backend/basic_call_back_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        class BasicCallBackTest < Minitest::Test
+          def test_call_back
+            args = []
+            call_back = lambda do |user, pass|
+              args = [user, pass]
+              return true
+            end
+
+            backend = Auth::Backend::BasicCallBack.new(call_back)
+
+            request = Http::Sapi.create_from_server_array(
+              'HTTP_AUTHORIZATION' => "Basic #{Base64.strict_encode64('foo:bar')}"
+            )
+            response = Http::Response.new
+
+            assert_equal(
+              [true, 'principals/foo'],
+              backend.check(request, response)
+            )
+
+            assert_equal(['foo', 'bar'], args)
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/auth/backend/file_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        class FileTest < Minitest::Test
+          def setup
+            @temp_dir = Dir.mktmpdir
+          end
+
+          def teardown
+            FileUtils.remove_entry @temp_dir
+          end
+
+          def test_construct
+            file = Auth::Backend::File.new
+            assert_kind_of(Auth::Backend::File, file)
+          end
+
+          def test_load_file_broken
+            ::File.open("#{@temp_dir}/backend", 'w') do |f|
+              f.puts 'user:realm:hash'
+            end
+            file = Auth::Backend::File.new
+            assert_raises(Exception) { file.load_file("#{@temp_dir}/backend") }
+          end
+
+          def test_load_file
+            ::File.open("#{@temp_dir}/backend", 'w') do |f|
+              f.puts "user:realm:#{Digest::MD5.hexdigest('user:realm:password')}"
+            end
+            file = Auth::Backend::File.new
+            file.load_file("#{@temp_dir}/backend")
+
+            refute(file.digest_hash('realm', 'blabla'))
+            assert_equal(Digest::MD5.hexdigest('user:realm:password'), file.digest_hash('realm', 'user'))
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/auth/backend/mock.rb

@@ -0,0 +1,73 @@
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        class Mock
+          include BackendInterface
+
+          attr_accessor :fail
+          attr_accessor :invalid_check_response
+          attr_accessor :principal
+
+          def initialize
+            @fail = false
+            @invalid_check_response = false
+            @principal = 'principals/admin'
+          end
+
+          # When this method is called, the backend must check if authentication was
+          # successful.
+          #
+          # The returned value must be one of the following
+          #
+          # [true, "principals/username"]
+          # [false, "reason for failure"]
+          #
+          # If authentication was successful, it's expected that the authentication
+          # backend returns a so-called principal url.
+          #
+          # Examples of a principal url:
+          #
+          # principals/admin
+          # principals/user1
+          # principals/users/joe
+          # principals/uid/123457
+          #
+          # If you don't use WebDAV ACL (RFC3744) we recommend that you simply
+          # return a string such as:
+          #
+          # principals/users/[username]
+          #
+          # @param RequestInterface request
+          # @param ResponseInterface response
+          # @return array
+          def check(_request, _response)
+            return 'incorrect!' if @invalid_check_response
+            return [false, 'fail!'] if @fail
+            [true, @principal]
+          end
+
+          # This method is called when a user could not be authenticated, and
+          # authentication was required for the current request.
+          #
+          # This gives you the oppurtunity to set authentication headers. The 401
+          # status code will already be set.
+          #
+          # In this case of Basic Auth, this would for example mean that the
+          # following header needs to be set:
+          #
+          # response.add_header('WWW-Authenticate', 'Basic realm=SabreDAV')
+          #
+          # Keep in mind that in the case of multiple authentication backends, other
+          # WWW-Authenticate headers may already have been set, and you'll want to
+          # append your own WWW-Authenticate header instead of overwriting the
+          # existing one.
+          #
+          # @return void
+          def challenge(request, response)
+          end
+        end
+      end
+    end
+  end
+end

data/test/dav/auth/backend/sequel_my_sql_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module Tilia
+  module Dav
+    module Auth
+      module Backend
+        class SequelMySQLTest < Minitest::Test
+          include AbstractSequelTest
+
+          def sequel
+            db = TestUtil.mysql
+            db.run('DROP TABLE IF EXISTS users')
+            db.run(<<QUERY
+create table users (
+  id integer unsigned not null primary key auto_increment,
+  username varchar(50),
+  digesta1 varchar(32),
+  email varchar(80),
+  displayname varchar(80),
+  unique(username)
+) #{TestUtil.mysql_engine}
+QUERY
+                  )
+            db.run("INSERT INTO users (username,digesta1,email,displayname) VALUES ('user','hash','user@example.org','User')")
+
+            db
+          end
+        end
+      end
+    end
+  end
+end