require File.dirname(__FILE__) + '/../test_helper'
require 'sugoi_admin_controller'
require 'pp'

class SugoiAdminController; 

    @@ask_responses = []

    def self.stuff_ask(*responses)
        @@ask_responses = responses
    end

    def ask(prompt)
        # chuck away the prompt
        return @@ask_responses.shift || "test_password"
    end

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

def stuff_ask(*responses)
    SugoiAdminController.stuff_ask(*responses)
end

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

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

    def invoke(command, *args)
        @request = ActionController::CommandlineRequest.new command, *args
        @controller.process @request, @response
    end

    # Replace this with your real tests.
    def test_truth
        assert true
    end

    def test_show_config_all_vars
        assert_nothing_raised do
            invoke "show_config"
        end

        assert_equal @loaded_fixtures["sys_configs"].length, 
            assigns["config_vars"].length
    end


    def test_show_config_one_var
        assert_nothing_raised do
            invoke "show_config", "smtpserver"
        end

        assert_equal "localhost", assigns["config_vars"][0].value
    end

    def test_set_config_existent_value
        assert_nothing_raised do
            invoke "set_config", "smtpserver", "mail.google.com" # heh
        end

        assert_equal "mail.google.com", SysConfig.smtpserver
        assert_equal assigns["config_var"].name, "smtpserver"
    end

    def test_set_config_nonexistent_value
        assert_nothing_raised do
            invoke "set_config", "scoobydoobyhoobiefloobiekerwhee", 42
        end

        assert_equal "scoobydoobyhoobiefloobiekerwhee", 
            assigns["missing_config_name"]
    end

    def test_list_domains
        assert_nothing_raised do
            invoke "list_domains"
        end
        assert_equal [ 1, 2 ], assigns["domains"].map { |d| d.id }.sort
        assert_equal [ "confirm.domain", "test.domain" ],
            assigns["domains"].map { |d| d.name }.sort
    end

    def test_list_mailinglists
        assert_nothing_raised do
            invoke "list_mailinglists", "confirm.domain"
        end
        assert_equal assigns["mailinglists"], []
        assert_nothing_raised do
            invoke "list_mailinglists", "nonexistent.domain"
        end
        assert_equal assigns["error"], "list_mailinglists: nonexistent.domain: not found"
    end

    def test_list_addresses
        assert_nothing_raised do
            invoke "list_addresses", "nonexistentml@confirm.domain"
        end
        assert_equal "list_addresses: nonexistentml@confirm.domain: not found",
            assigns["error"]
        assert_nothing_raised do
            invoke "list_addresses", "testuser@test.domain"
        end
        assert_equal [ "address1@foo.test", "address2@foo.test" ],
            assigns["addresses"].map {|a| a.address}.sort
    end

    def test_create_user_nonexistent_domain
        assert_nothing_raised do
            invoke "create_user", "nonexistent.domain", "newuser"
        end
        assert_equal "create_user: Domain \"nonexistent.domain\" does not exist.",
            assigns["error"]
    end

    def test_create_user_normally
        assert_nothing_raised do
            invoke "create_user", "test.domain", "newuser", 
                "newuser@foo.test", "New User"
        end
        assert_equal [ "create_user: User \"newuser@test.domain\" created successfully" ],
            assigns["messages"]
    end

    def test_create_user_already_exists
        assert_nothing_raised do
            invoke "create_user", "test.domain", "testuser", 
                "testuser@foo.test", "New User"
        end
        assert_equal "create_user: User \"testuser@test.domain\" was not created:\n    login: has already been taken\n", assigns["error"]
    end

    def test_create_user_interactive_description
        stuff_ask "test_password", "test_password", "New 2 User"
        assert_nothing_raised do
            invoke "create_user", "test.domain", "new2user", "new2user@foo.test"
        end
        assert_equal [ "create_user: User \"new2user@test.domain\" created successfully" ],
            assigns["messages"]
    end

    def test_create_user_interactive_email_address_and_description
        stuff_ask "test_password", "test_password", "new3user@foo.test", "New 3 User"
        assert_nothing_raised do
            invoke "create_user", "test.domain", "new3user"
        end
        assert_equal [ "create_user: User \"new3user@test.domain\" created successfully" ],
            assigns["messages"]
    end

    def test_create_domain_normally
        assert_nothing_raised do
            invoke "create_domain", "new.domain"
        end
        assert !assigns["error"]
        assert_equal [ "create_domain: Domain \"new.domain\" created successfully." ], 
            assigns["messages"]

        assert_nothing_raised do
            invoke "list_domains"
        end
        assert_equal assigns["domains"].map { |d| d.name }.sort, 
            [ "confirm.domain", "new.domain", "test.domain" ]
    end

    def test_create_domain_collision
        assert_nothing_raised do
            invoke "create_domain", "test.domain"
        end
        assert_equal "create_domain: Domain \"test.domain\" already exists.",
            assigns["error"]
    end

    def test_create_mistyped_password
        assert_nothing_raised do
            stuff_ask "test_password", "mismatch_password"
        end
        invoke "create_domain", "new.domain"
        assert_equal "create_domain: Could not create domain \"new.domain\":" +
             "\n    password: doesn't match confirmation\n", assigns["error"]
    end

    def test_list_users_no_users_in_domain
        assert_nothing_raised do
            invoke "list_users", "confirm.domain"
        end
        assert_equal [], assigns["users"]
        assert !assigns["error"]
    end

    def test_list_users_invalid_domain
        assert_nothing_raised do
            invoke "list_users", "bogus.domain"
        end
        assert assigns["error"]
        assert_equal "list_users: Domain \"bogus.domain\" does not exist.",
                     assigns["error"]
    end
    
    def test_list_users_valid_with_users
        assert_nothing_raised do
            invoke "list_users", "test.domain"
        end
        assert !assigns["error"]
        assert_equal [ "nodesc", "proxuser", "root", "testuser", "virtuser"],
            assigns["users"].map { |u| u.login }.sort
    end

    def test_list_mailinglist_classes
        assert_nothing_raised do
            invoke "list_mailinglist_classes"
        end
        assert assigns["mailinglist_classes"]
    end

    def test_list_mlclasses
        assert_nothing_raised do
            invoke "list_mlclasses"
        end
        assert assigns["mailinglist_classes"]
    end

    def test_create_list_wrong_class
        assert_nothing_raised do
            invoke "create_list", "newmailinglist", "test.domain",
                "testuser", "New Mailing List", 100
        end
        assert assigns["error"]
        assert_equal "create_list: Invalid mailing list class: 100", 
            assigns["error"]
        assert_nil Mailinglist.find_by_address("newmailinglist@test.domain")
    end

    def test_create_list_wrong_domain
        assert_nothing_raised do
            invoke "create_list", "newmailinglist", 
                "nonexistent.domain", "testuser", "New Mailing List"
        end
        assert assigns["error"]
        assert_equal "create_list: Domain \"nonexistent.domain\" not found.", 
            assigns["error"]
        assert_nil Mailinglist.find_by_address("newmailinglist@test.domain")
    end

    def test_create_Mailing_list_wrong_user
        assert_nothing_raised do
            invoke "create_list", "newmailinglist",
                "test.domain", "nonexistentuser", "New Mailing List"
        end

        assert assigns["error"]
        assert_equal "create_list: User \"nonexistentuser\" not found in domain \"test.domain\".",
            assigns["error"]
        assert_nil Mailinglist.find_by_address("newmailinglist@test.domain")
    end

    def test_create_list_normal
        assert_nothing_raised do
            invoke "create_list", "newmailinglist", "test.domain", 
                "testuser"
        end

        assert assigns["messages"]
        assert_equal ["create_list: Mailing list \"newmailinglist@test.domain\" created successfully."], 
            assigns["messages"]
        assert Mailinglist.find_by_address("newmailinglist@test.domain")
    end

    def test_subscribe_address_to_mailing_list
        assert_nothing_raised do
            invoke "subscribe", "testuser@test.domain", 
                    "newaddress@foo.test"
        end

        assert assigns["messages"]
        assert_equal [ "subscribe: Subscribed \"newaddress@foo.test\" to \"testuser@test.domain\""], assigns["messages"]
        assert_nil assigns["error"]

        a=Address.find_by_address "newaddress@foo.test"
        assert a
        assert Mailinglist.find_by_address("testuser@test.domain")[0].addresses.member?(a)
    end

    def test_subscribe_address_to_nonexistent_mailing_list
        assert_nothing_raised do
            invoke "subscribe", "nonexistent@test.domain", "newaddress@foo.test"
        end
        assert_nil assigns["messages"]
        assert assigns["error"]
        assert_equal "subscribe: Mailing list \"nonexistent@test.domain\" not found.", assigns["error"]
    end

    def test_unsubscribe_address_from_mailing_list
        assert_nothing_raised do
            invoke "unsubscribe", "testuser@test.domain", "address1@foo.test"
        end

        assert_nil assigns["error"]

        ml=Mailinglist.find_by_address("testuser@test.domain")[0]

        assert_equal ["address2@foo.test"], ml.addresses.map { |a| a.address }
    end

    def test_unsubscribe_address_from_mailing_list_that_doesnt_exist
        assert_nothing_raised do
            invoke "unsubscribe", "nonexistent@test.domain", "address1@foo.test"
        end

        assert assigns["error"]
        assert_equal "unsubscribe: Mailing list \"nonexistent@test.domain\" unknown.", assigns["error"]
    end

    def test_unsubscribe_address_not_actually_subscribed_to_a_mailing_list
        assert_nothing_raised do
            invoke "unsubscribe", "testuser@test.domain", "external@foo.test"
        end

        assert assigns["error"]
        assert_equal "unsubscribe: Address \"external@foo.test\" not in mailing list \"testuser@test.domain\"", assigns["error"]
        assert_nil assigns["removed_addresses"]
    end

    def test_unsubscribe_entirely_unknown_address_from_mailinglist
        assert_nothing_raised do
            invoke "unsubscribe", "testuser@test.domain", "nonexistent@foo.test"
        end

        assert assigns["error"]
        assert_equal "unsubscribe: Address \"nonexistent@foo.test\" unknown.", 
            assigns["error"]
        assert_nil assigns["removed_addresses"]
    end

    def test_init_collisions
        assert_nothing_raised do
            invoke "init"
        end
        assert assigns["alreadythere"]
    end

    def test_init_mailinglistclasses
        MailinglistClass.delete_all

        assert_nothing_raised do
            invoke "init"
        end

        assert assigns["alreadythere"]

        assert assigns.grep(/MailinglistClass/).length == 0

        assert_equal @loaded_fixtures["mailinglist_classes"].length, 
            MailinglistClass.find(:all).length
    end

    def test_init_sysconfigs
        SysConfig.delete_all

        assert_nothing_raised do
            invoke "init"
        end

        assert assigns["alreadythere"]

        assert assigns.grep(/SysConfig/).length == 0
        
        assert_equal @loaded_fixtures["sys_configs"].length, 
            SysConfig.find(:all).length
    end

    def test_init_adminmessages
        AdminMessage.delete_all

        assert_nothing_raised do
            invoke "init"
        end

        assert assigns["alreadythere"]

        assert assigns.grep(/AdminMessages/).length == 0

        assert_equal @loaded_fixtures["admin_messages"].length, 
            AdminMessage.find(:all).length
    end

    def test_init_all
        MailinglistClass.delete_all
        SysConfig.delete_all
        AdminMessage.delete_all
        Help.delete_all

        assert_nothing_raised do
            invoke "init"
        end

        assert_equal 0, assigns["alreadythere"].length

        assert_equal @loaded_fixtures["mailinglist_classes"].length, 
            MailinglistClass.find(:all).length
        assert_equal @loaded_fixtures["sys_configs"].length, 
            SysConfig.find(:all).length
        assert_equal @loaded_fixtures["admin_messages"].length, 
            AdminMessage.find(:all).length
        assert_equal @loaded_fixtures["helps"].length, 
            Help.find(:all).length
    end

    def test_init_no_clobber_values
        SysConfig.smtpserver="www.google.com"

        assert_nothing_raised do
            invoke "init"
        end

        assert_equal "www.google.com", SysConfig.smtpserver

        assert_equal @loaded_fixtures["sys_configs"].length +
            @loaded_fixtures["mailinglist_classes"].length +
            @loaded_fixtures["admin_messages"].length +
            @loaded_fixtures["helps"].length, 
            assigns["alreadythere"].length

    end

    def test_help_by_itself
        assert_nothing_raised do
            invoke "help"
        end

        assert Array === assigns["help"]
        assert_equal @loaded_fixtures["helps"].length, assigns["help"].length
    end
end