require File.dirname(__FILE__) + '/../test_helper'
require 'mailservice_controller'
require 'net-smtp-stub'

# Re-raise errors caught by the controller.
class MailserviceController; def rescue_action(e) raise e end; end

class MailserviceControllerTest < Test::Unit::TestCase
    fixtures :domains, :users, :mailinglists, :admin_messages,
        :mailinglist_classes, :confirmationcodes, :addresses,
        :addresses_mailinglists

    def setup
        @controller = MailserviceController.new
        @request    = ActionController::TestRequest.new
        @response   = ActionController::TestResponse.new
    end

    def test_0_alive
        assert invoke(:ping)
    end
end

def get_confirmation_code(mailinglist, addr)
    Confirmationcode.find(:first, :conditions => 
        [ 'address_id = ? and mailinglist_id = ?',
            Address.find_by_address(addr).id,
            Mailinglist.find_by_name(mailinglist).id ]).code
end

class MailserviceDomainLogin < MailserviceControllerTest
    def setup
        super
        @domain_name     = @loaded_fixtures["domains"]["testdomain"]["name"]
        @domain_password = "foobar"
        invoke :domain_login,  @domain_name, @domain_password
    end

    def teardown
        invoke :domain_logout
    end

    def test_0_domain_logged_in
        assert invoke(:domain_logged_in), "Domain still logged in"
        assert_equal @domain_name, invoke(:domain_name), "Still the right domain"
    end
end

class MailserviceUserLogin < MailserviceDomainLogin
    def setup
        super
        @user_password = "foobar"
        @user_name = @loaded_fixtures["users"]["testuser"]["login"]
        invoke :user_login, @user_name, @user_password
    end
    
    def teardown
        invoke :user_logout
        super
    end

    def test_0_user_logged_in
        assert invoke(:user_logged_in), "User still logged in"
        assert_equal "testuser", invoke(:user_name), "Still the right user"
    end
end

class MailserviceDomainAdmin < MailserviceDomainLogin
    def setup
        super
        @admin_password="foobar"
        @admin_name=@loaded_fixtures["users"]["root"]["login"]
        invoke :user_login, @admin_name, @admin_password
    end

    def teardown
        invoke :user_logout
        super
    end

    def test_0_user_still_admin
        assert invoke(:user_logged_in), "User still logged in"
        assert_equal @admin_name, invoke(:user_name), "User is still root"
        assert invoke(:is_admin), "User is still administrator"
    end
end


class TC_Mailservice_DomainLogin < MailserviceControllerTest
    def setup
        super
        @domain_name     = @loaded_fixtures["domains"]["testdomain"]["name"]
        @domain_password = "foobar"
    end

    def test_baddomain
        # bad username, bad password
        assert_equal(false, invoke(:domain_login,"junkdomain", "blort"))
       
        # good username, bad password
        assert_equal(false, invoke(:domain_login,@domain_name, "blort"))
    end

    def test_loggedout
        # now once again
        assert_equal(false, invoke(:domain_logout))
    end

    def test_good_domain
        # good username, good password
        assert_equal(true, invoke(:domain_login,@domain_name, @domain_password))

        # now log out
        assert_equal(true, invoke(:domain_logout))
    end

    def test_permissions
        assert_raises RuntimeError do
            invoke :user_login, "testuser", "foobar"
        end
    end
end

class TC_Mailservice_UserLogin < MailserviceDomainLogin
    def test_baduser
        assert_equal false, invoke(:user_login,"huaglhuagl", "blort")
        assert_equal false, invoke(:user_login,"testuser", "blort")
    end

    def test_gooduser
        assert invoke(:user_login,"testuser", "foobar")
        assert_equal false, invoke(:is_admin)
    end
end


class TC_Mailservice_TroublesomeAdminTask < MailserviceDomainAdmin
    def test_userlogin
        assert_nothing_raised do
            assert invoke(:is_admin)
        end
        assert_nothing_raised do 
            assert invoke(:admin_user_signup,"newuser", "password", "password")
        end

        # user exists, login succeeds
        assert invoke(:user_login, "newuser", "password")
        assert_equal false, invoke(:is_admin)

        # let's get our session back
        assert invoke(:user_login, @admin_name, "foobar")
        assert invoke(:is_admin)
        assert_nothing_raised do
            assert invoke(:admin_user_delete, "newuser", "newuser")
        end
    end
end

class TC_Mailservice_AdminTasks_UserCreation < MailserviceDomainAdmin
    def test_passwordmismatch
        assert invoke(:is_admin)
        # password doesn't match
        assert_raises RuntimeError do
            invoke(:admin_user_signup,"newuser", "password", "drowssap")
        end
    end

    def test_usercreate
        # user doesn't exist; gets created
        assert invoke(:is_admin)
        assert invoke(:admin_user_signup,"newuser", "password", "password")
        assert_raises RuntimeError do
            assert invoke(:admin_user_delete,"newuser", "resuwen"), 
                 "login and confirmation don't match on delete"
        end
        assert_nothing_raised do
            assert invoke(:admin_user_delete,"newuser", "newuser"),
                "successful deletion"
        end
    end

    def test_usercollision
        assert_nothing_raised do
            assert invoke(:is_admin)
        end
        assert invoke(:admin_user_signup,"newuser", "password", "password")
        # user already exists; creation fails
        assert_raises RuntimeError do
            invoke(:admin_user_signup,"newuser", "password", "password")
        end
        assert invoke(:admin_user_delete,"newuser", "newuser")
    end

    def test_aaa_userlist  # force it to go first, see what happens
        assert invoke(:is_admin)
        list=nil
        assert_nothing_raised do
            list=invoke :admin_user_list
        end
        assert list
        assert_equal [ [ @admin_name, "Admin" ],
                       [ "testuser", "Test User" ],
                       [ "virtuser", "Virtual User" ],
                       [ "nodesc", nil ],
                       [ "proxuser", "Proxy Mailing List" ]
                       ].sort, list.sort
    end

end

class TC_Mailservice_AdminTasks_UserDeletion < MailserviceDomainAdmin
    def test_usernolongerexists
        assert_nothing_raised do
            assert invoke(:is_admin)
        end

        # create the user
        assert_nothing_raised do
            assert invoke(:admin_user_signup,"newuser", "password", "password")
        end

        # user exists; deletion succeeds
        assert_nothing_raised do
            assert invoke(:admin_user_delete,"newuser", "newuser")
        end

        # user doesn't exist; login fails
        assert_nothing_raised do
            assert_equal false, invoke(:user_login,"newuser", "password")
        end

        # okay, our session's just been trashed again.  Get it back.
        assert_nothing_raised do
            assert invoke(:user_login,@admin_name, "foobar")
        end

        # user doesn't exist; deletion fails
        assert_nothing_raised do
            assert_equal false, invoke(:admin_user_delete,"newuser", "newuser")
        end
    end
end

class TC_Mailservice_AdminTasks_UserPasswords < MailserviceDomainAdmin
    def test_password_reset_normal
        assert invoke(:is_admin)
        
        assert_nothing_raised do
            assert invoke(:admin_user_reset_password, "testuser", 
                          "newpassword", "newpassword")
        end
    end

    def test_password_reset_password_mismatch
        assert invoke(:is_admin)

        assert_raises RuntimeError do
            invoke(:admin_user_reset_password, "testuser",
                   "newpassword", "differentnewpassword")
        end
    end

    def test_password_reset_user_not_found
        assert invoke(:is_admin)
        
        assert_raises RuntimeError, "user: user not found" do
            invoke(:admin_user_reset_password, "nonexistentuser", "foobar", "foobar")
        end
    end
end

class TC_Mailservice_UserTasks_ChangePassword < MailserviceUserLogin
    def test_normal
        assert_nothing_raised do
            assert_equal true, invoke(:user_change_password, "foobar",
                                          "foobarquux", "foobarquux")
        end

        invoke(:user_logout)
        assert_equal false, invoke(:user_logged_in)
        assert_equal false, invoke(:user_login, "testuser", "foobar")
        assert_equal false, invoke(:user_logged_in)
        assert_equal true, invoke(:user_login, "testuser", "foobarquux")
        assert_equal true, invoke(:user_logged_in)
    end

    def test_illegal_password
        assert_raises RuntimeError, "password: is too short (minimum is 5 characters)" do
            invoke(:user_change_password, "foobar", "x", "x")
        end
    end

    def test_original_password_wrong
        assert_raises RuntimeError, "auth: original password incorrect" do
            invoke(:user_change_password, "notfoobar",
                   "foobarquux", "foobarquux")
        end
    end
end

class TC_Mailservice_UserTasks_RealName < MailserviceUserLogin
    def setup
        super
        @new_name = "Test User New"
    end

    def test_retrieve
        assert_equal "Test User", invoke(:user_real_name)
    end

    def test_change
        assert_nothing_raised do
            assert_equal @new_name, invoke(:user_change_real_name,
                                           "foobar",
                                           @new_name)
        end

        assert_equal @new_name, invoke(:user_real_name)
    end

    def test_bad_password
        assert_raises RuntimeError, "auth: password incorrect" do
            invoke(:user_change_real_name, "nofoobar", @new_name)
        end
    end
end

class TC_MailService_EmailAddresses < MailserviceUserLogin
    def test_emailaddress
        assert_equal "testuser@#{@domain_name}", invoke(:user_email_address)
    end


    def test_emailaddresses
        assert_equal [ "address1@foo.test",
                       "address2@foo.test" ], 
            invoke(:user_email_addresses).sort
        assert_equal [ "address1@foo.test" ], 
            invoke(:user_email_addresses_confirmed).sort
    end

    def test_addremove
        assert_nothing_raised do
            assert invoke(:user_email_addresses_add,"brandnewuser@foo.test")
        end

        assert_nothing_raised do 
            assert_equal [ "address1@foo.test",
                           "address2@foo.test",
                           "brandnewuser@foo.test" ], 
                invoke(:user_email_addresses).sort
        end
        assert_nothing_raised do
            assert_equal [ "address1@foo.test" ],
                invoke(:user_email_addresses_confirmed).sort
        end
        assert_nothing_raised do
            assert_equal [ "address2@foo.test", "brandnewuser@foo.test" ], 
                invoke(:user_email_addresses_unconfirmed).sort
        end

        confirmation_code=get_confirmation_code("testuser",
                                              "brandnewuser@foo.test")

        assert confirmation_code =~ /[0-9a-z]{16}/

        assert_nothing_raised do
            assert_equal false, invoke(:user_email_address_confirm,
                                      "brandnewuser@foo.test",
                                      confirmation_code+"foo")
        end

        assert_nothing_raised do
            assert_equal true, invoke(:user_email_address_confirm,
                                      "brandnewuser@foo.test",confirmation_code)
        end

        assert_nothing_raised do
            assert_equal [ "address2@foo.test" ], 
                invoke(:user_email_addresses_unconfirmed).sort
        end

        assert_nothing_raised do
            assert_equal [ "brandnewuser@foo.test" ], 
                invoke(:user_email_addresses_remove,
                       "brandnewuser@foo.test").sort
        end

        assert_nothing_raised do
            assert_equal nil,
                invoke(:user_email_addresses_remove,
                       "brandnewuser@foo.test")
        end

        assert_nothing_raised do
            assert_equal [ "address1@foo.test", 
                           "address2@foo.test" ], 
                invoke(:user_email_addresses).sort
        end
    end 
end

class TC_Mailservice_MailinglistClasses < MailserviceUserLogin

    def setup
        super
        @mailing_list = @loaded_fixtures["mailinglist_classes"]  \
                                        ["mailinglist_class_mailing_list"]
        @distribution_list = @loaded_fixtures["mailinglist_classes"] \
                                 ["mailinglist_class_distribution_list"]
    end

    def test_get_mailinglist_classes
        assert_equal [ 'Distribution List', 'Mailing List', 
                       'Proxifiable LTMA' ], 
            invoke(:mailinglist_classes).sort
    end

    def test_get_mailinglist_class 
        assert mlclass = invoke(:mailinglist_class_get_attributes,
                                "Mailing List")
        assert_equal @mailing_list["description"],  mlclass.description
        assert_equal @mailing_list["public"],       mlclass.public
        assert_equal @mailing_list["moderated"],    mlclass.moderated
        assert_equal @mailing_list["confirmation"], mlclass.confirmation
        assert_equal @mailing_list["joinable"],     mlclass.joinable
        assert_equal @mailing_list["closed"],       mlclass.closed
        assert_equal @mailing_list["archived"],     mlclass.archived

        assert dlclass = invoke(:mailinglist_class_get_attributes,
                                 "Distribution List")
        assert_equal @distribution_list["description"],  dlclass.description
        assert_equal @distribution_list["public"],       dlclass.public
        assert_equal @distribution_list["moderated"],    dlclass.moderated
        assert_equal @distribution_list["confirmation"], dlclass.confirmation
        assert_equal @distribution_list["joinable"],     dlclass.joinable
        assert_equal @distribution_list["closed"],       dlclass.closed
        assert_equal @distribution_list["archived"],     dlclass.archived
    end
end

class TC_Mailservice_UserMailingLists < MailserviceUserLogin
    def test_mailinglists
        user_mailinglists=invoke(:user_mailinglists)
        assert_equal [ 3 ],
            invoke(:user_mailinglists)
        assert_equal "testml", invoke(:mailinglist_name,3)
    end
end

class TC_Mailservice_CreateMailinglist < MailserviceUserLogin
    def test_create_mailinglist
        assert_equal "testmailinglist@test.domain",
            invoke(:mailinglist_create, "testmailinglist", "Mailing List")
        assert id = invoke(:mailinglist_find_by_name, "testmailinglist")
        assert invoke(:mailinglist_delete, id)
        assert_equal nil, invoke(:mailinglist_find_by_name, "testmailinglist")
    end
end

class MailserviceUserMailinglist < MailserviceUserLogin
    def setup
        super
        invoke(:mailinglist_create,"testmailinglist", "Mailing List") 
        @id = invoke(:mailinglist_find_by_name,"testmailinglist")
    end

    def teardown
        invoke(:mailinglist_delete,@id)
        super
    end

    def test_0_mailinglist_exists
        assert id = invoke(:mailinglist_find_by_name, "testmailinglist")
        assert_equal @id, id

        assert_equal "testmailinglist", invoke(:mailinglist_name, id)
        assert_raises RuntimeError, "Mailing list not found" do
            invoke(:mailinglist_name, 999)
        end

        assert_raises RuntimeError, "Permission denied" do
            invoke(:mailinglist_name, 2)
        end
    end
end

class TC_Mailservice_MailingListSubscribe < MailserviceUserMailinglist
    def test_mailinglist_subscribe
        assert @id

        assert_nothing_raised do
            assert_equal [ ], 
                invoke(:mailinglist_subscribers,@id).sort
        end

        assert_nothing_raised do 
            assert invoke(:mailinglist_subscribe,@id,"test@foo.test")
        end

        assert_nothing_raised do
            assert_equal [ ], 
                invoke(:mailinglist_subscribers,@id).sort
        end

        assert_nothing_raised do
            assert_equal [ "test@foo.test" ],
                invoke(:mailinglist_pending,@id)
        end

        confirmation=nil

        assert_nothing_raised do
            confirmation=get_confirmation_code("testmailinglist",
                                                "test@foo.test")
        end

        assert confirmation =~ /[0-9a-z]{16}/

        assert_nothing_raised do
            assert_equal false, invoke(:mailinglist_confirm,
                                "testmailinglist", "test@foo.test",
                                "@@@@@@@@@@@@@@@@")
        end
        
        assert_nothing_raised do
            assert_equal true, invoke(:mailinglist_confirm,
                                    "testmailinglist", "test@foo.test",
                                    confirmation)
        end

        assert_nothing_raised do
            assert_equal [ "test@foo.test" ], 
                invoke(:mailinglist_subscribers,@id).sort
        end

        assert_nothing_raised do
            assert invoke(:mailinglist_unsubscribe,@id,"test@foo.test")
        end

        assert_nothing_raised do
            assert_equal [ ], 
                invoke(:mailinglist_subscribers,@id).sort
        end
    end

    def test_mailinglist_message
        # @server.mailinglistMessages(@id)
    end
end