class KolabEmailSendAndReceiveEmail(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_send_and_receive_email(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_send_and_receive_email")
        
        # login Directory Manager, create 2 users
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")
        username1, emailLogin1, password1 = kolabWAPhelper.create_user()
        username2, emailLogin2, password2 = kolabWAPhelper.create_user()
        kolabWAPhelper.logout_kolab_wap()

        # login user1 to roundcube and send email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin1, password1)
        emailSubjectLine = kolabWAPhelper.send_email(emailLogin2)
        kolabWAPhelper.logout_roundcube()
        kolabWAPhelper.wait_loading(5)

        # login user2 to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin2, password2)
        kolabWAPhelper.check_email_received(emailSubjectLine=emailSubjectLine)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
class KolabWAPDomainAdmin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_domain_admin_default_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_domain_admin")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin",
            default_quota = "100mb",
            overall_quota = "300mb")

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        
        # create user accounts
        # test if default quota is set properly for a new user
        kolabWAPhelper.create_user(default_quota_verify = "100mb")
        kolabWAPhelper.create_user(mail_quota = "150mb")
        kolabWAPhelper.create_user(default_quota_verify = "100mb", expected_message_contains = "mailquota of the domain admin has been exceeded")

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
class KolabEmailCatchAll(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_catch_all(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_catch_all")
        
        # login Directory Manager, create a domain and a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")
        domainname = kolabWAPhelper.create_domain()

        # add the user
        username, emailLogin, password = kolabWAPhelper.create_user(alias="@" + domainname)
        kolabWAPhelper.logout_kolab_wap()

        # send email to catch all alias address from command line
        print "sending email..."
        subject = 'subject ' + domainname
        subprocess.call(['/bin/bash', '-c', 'echo "test" | mail -s "' + subject + '" alias' + domainname + '@' + domainname])
        kolabWAPhelper.wait_loading(2.0)

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.check_email_received(subject)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.close()
class KolabEmailSendAndReceiveEmail(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_send_and_receive_email(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_send_and_receive_email")

        # login Directory Manager, create 2 users
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")
        username1, emailLogin1, password1 = kolabWAPhelper.create_user()
        username2, emailLogin2, password2 = kolabWAPhelper.create_user()
        kolabWAPhelper.logout_kolab_wap()

        # login user1 to roundcube and send email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin1,
                                       password1)
        emailSubjectLine = kolabWAPhelper.send_email(emailLogin2)
        kolabWAPhelper.logout_roundcube()
        kolabWAPhelper.wait_loading(5)

        # login user2 to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin2,
                                       password2)
        kolabWAPhelper.check_email_received(emailSubjectLine=emailSubjectLine)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
Esempio n. 5
0
class KolabAutoCreateFolders(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def helper_modify_autocreate_folders(self):
        # read kolab.conf
        fo = open("/etc/kolab/kolab.conf", "r+")
        content = fo.read()
        fo.close()
        
        newContactsFolderName = "Contacts" + datetime.datetime.now().strftime("%H%M%S")

        # find [kolab], find line starting with 'Contacts, replace with 'Contacts125559': {
        pos = content.index("[kolab]")
        pos = content.index("'Contacts", pos)
        posAfter = content.index(": {", pos)
        
        content = content[:pos] + "'" + newContactsFolderName + "'" + content[posAfter:]
        
        # write kolab.conf
        fo = open("/etc/kolab/kolab.conf", "wb")
        fo.write(content)
        fo.close()
        
        self.kolabWAPhelper.log("kolab.conf has been changed, autocreate_folders now contains " + newContactsFolderName)
        
        return newContactsFolderName

    def test_modified_foldername_in_new_domain(self):

        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log ("Running test: test_modified_foldername_in_new_domain")
        
        # login
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        domainname = kolabWAPhelper.create_domain()

        #modify the default folders in /etc/kolab/kolab.conf
        newContactsFolderName = self.helper_modify_autocreate_folders()

        username, emailLogin, password = kolabWAPhelper.create_user()

        kolabWAPhelper.logout_kolab_wap()

        # check if mailbox has been created, with the modified folder name
        p = subprocess.Popen("kolab lm | grep " + username + " | grep " + newContactsFolderName, shell=True, stdout=subprocess.PIPE)
        out, err = p.communicate()
        if newContactsFolderName not in out:
            self.assertTrue(False, "kolab lm cannot find mailbox with folder " + newContactsFolderName + " for new user " + username)

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.close()
class KolabEmailSharedFolders(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_shared_folder(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_shared_folder")

        # login Directory Manager, create 2 users
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")
        username1, emailLogin1, password1 = kolabWAPhelper.create_user()
        #username2, emailLogin2, password2 = kolabWAPhelper.create_user()

        # create shared folder
        # could use delegates=[emailLogin1, emailLogin2], but this is not tested at the moment
        emailSharedFolder, foldername = kolabWAPhelper.create_shared_folder()
        kolabWAPhelper.logout_kolab_wap()

        # need to give everyone permission to send to this folder
        # need to wait some seconds, otherwise the permissions will be reset to lrs, probably by kolabd???
        kolabWAPhelper.wait_loading(20.0)
        subprocess.call([
            '/bin/bash', '-c',
            "kolab sam shared/" + emailSharedFolder + " anyone lrsp"
        ])
        kolabWAPhelper.wait_loading(20.0)
        subprocess.call(
            ['/bin/bash', '-c', "kolab lam shared/" + emailSharedFolder])

        # login user to roundcube to send and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin1,
                                       password1)

        # TODO: why can I see and subscribe to all folders in the domain?
        # can we set permissions who can read the folder? Recipient Access list?
        # solution: http://lists.kolab.org/pipermail/users/2013-December/016161.html
        #           quote: Shared folders are created with the ACL "anyone lrs" (anyone read) per default.
        #                  After creating them you'll likely adjust the ACLs based on your needs.

        print "sending email to " + emailSharedFolder
        emailSubjectLine = kolabWAPhelper.send_email(emailSharedFolder)
        kolabWAPhelper.wait_loading(3.0)
        kolabWAPhelper.check_email_received(
            emailSubjectLineDoesNotContain="Undelivered Mail Returned to Sender"
        )
        # no need to subscribe the folder, because we are using the direct url to load the folder in Roundcube
        kolabWAPhelper.check_email_received(
            folder="Shared+Folders%2Fshared%2F" + foldername,
            emailSubjectLine=emailSubjectLine)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
Esempio n. 7
0
class KolabEmailCatchAllAcrossDomains(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_catch_all_across_domains(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_catch_all_across_domains")

        # login Directory Manager, create a domain and a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")
        # important: alias domain must be set in the domain names, otherwise: email address not in local domain
        domainname = kolabWAPhelper.create_domain(withAliasDomain=True)
        aliasdomainname = string.replace(domainname, "domain", "alias")

        username = "******" + datetime.datetime.now().strftime("%Y%m%d%H%M%S")
        # what happens if we have not added the alias domain yet to postfix config?
        kolabWAPhelper.create_user(
            username=username,
            alias="catchall@" + aliasdomainname,
            expected_message_contains="Alias 'catchall@" + aliasdomainname +
            "' must be configured manually")

        # add alias domain, and call postmap
        postfixfile = "/etc/postfix/virtual_alias_maps_manual.cf"
        subprocess.call([
            '/bin/bash', '-c', 'echo "@' + aliasdomainname + ' ' + username +
            '.' + username + '@' + domainname + '" >> ' + postfixfile
        ])
        subprocess.call(['postmap', postfixfile])
        subprocess.call(['service', 'postfix', 'restart'])

        # now add user for real
        username, emailLogin, password = kolabWAPhelper.create_user(
            username=username, alias="catchall@" + aliasdomainname)
        kolabWAPhelper.logout_kolab_wap()

        # send email to catch all alias address from command line
        print "sending email..."
        subprocess.call([
            '/bin/bash', '-c', 'echo "test" | mail -s "subject ' +
            aliasdomainname + '" test@' + aliasdomainname
        ])
        kolabWAPhelper.wait_loading(10.0)

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.check_email_received(emailSubjectLine="subject " +
                                            aliasdomainname)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
class KolabWAPDomainAdmin(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_enabled_groupware_features(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_enabled_groupware_features")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix="admin")
        # enabled by default: allow_groupware = True

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)

        # create user account. role enable-groupware-features should be set by default
        kolabWAPhelper.create_user(
            default_role_verify="enable-groupware-features")

        kolabWAPhelper.logout_kolab_wap()

    def test_disabled_groupware_features(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_disabled_groupware_features")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix="admin", allow_groupware=False)

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)

        # create user account. role enable-groupware-features should not be set
        kolabWAPhelper.create_user(default_role_verify="")

        # TODO: create role enable-groupware-features for the domain
        # TODO: create a new user with role enable-groupware-features, should fail!

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.close()
class KolabWAPDomainAdmin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_enabled_groupware_features(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_enabled_groupware_features")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin")
            # enabled by default: allow_groupware = True

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        
        # create user account. role enable-groupware-features should be set by default
        kolabWAPhelper.create_user(default_role_verify = "enable-groupware-features")

        kolabWAPhelper.logout_kolab_wap()

    def test_disabled_groupware_features(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_disabled_groupware_features")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin",
            allow_groupware = False)

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        
        # create user account. role enable-groupware-features should not be set
        kolabWAPhelper.create_user(default_role_verify = "")

        # TODO: create role enable-groupware-features for the domain
        # TODO: create a new user with role enable-groupware-features, should fail!

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.close()
Esempio n. 10
0
class KolabWAPLastLogin(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_last_login(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_last_login")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password = kolabWAPhelper.create_user()
        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.logout_roundcube()

        # check that the last login timestamp is greater than 1 January 2014
        value = kolabWAPhelper.getLDAPValue(
            "uid=" + username + ",ou=People," + kolabWAPhelper.getConf("ldap", "base_dn"), "tbitsKolabLastLogin"
        )
        self.assertTrue(int(value) > 1388534400, "login date should be after 1 January 2014")

        # last login time will only be updated after an hour, so we cannot test that here. see pykolab/auth/ldap/auth_cache.py purge_entries

    def test_last_login_in_other_domain(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_last_login")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        domainname = kolabWAPhelper.create_domain()

        username, emailLogin, password = kolabWAPhelper.create_user()
        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.logout_roundcube()

        # check that the last login timestamp is greater than 1 January 2014
        value = kolabWAPhelper.getLDAPValue(
            "uid=" + username + ",ou=People,dc=" + ",dc=".join(domainname.split(".")), "tbitsKolabLastLogin"
        )
        self.assertTrue(int(value) > 1388534400, "login date should be after 1 January 2014")

        # last login time will only be updated after an hour, so we cannot test that here. see pykolab/auth/ldap/auth_cache.py purge_entries

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
Esempio n. 11
0
class KolabWAPLastLogin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_last_login(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_last_login")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password, uid = kolabWAPhelper.create_user()
        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.logout_roundcube()

        # check that the last login timestamp is greater than 1 January 2014
        value = kolabWAPhelper.getLDAPValue("uid="+username+",ou=People," + kolabWAPhelper.getConf('ldap', 'base_dn'), 'tbitsKolabLastLogin')
        self.assertTrue(int(value) > 1388534400, "login date should be after 1 January 2014")

        # last login time will only be updated after an hour, so we cannot test that here. see pykolab/auth/ldap/auth_cache.py purge_entries

    def test_last_login_in_other_domain(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_last_login_in_other_domain")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        domainname = kolabWAPhelper.create_domain()

        username, emailLogin, password, uid = kolabWAPhelper.create_user()
        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.logout_roundcube()

        # check that the last login timestamp is greater than 1 January 2014
        value = kolabWAPhelper.getLDAPValue("uid="+username+",ou=People,dc=" + ",dc=".join(domainname.split(".")), 'tbitsKolabLastLogin')
        self.assertTrue(int(value) > 1388534400, "login date should be after 1 January 2014")

        # last login time will only be updated after an hour, so we cannot test that here. see pykolab/auth/ldap/auth_cache.py purge_entries

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
class KolabEmailSharedFolders(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_shared_folder(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_shared_folder")
        
        # login Directory Manager, create 2 users
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")
        username1, emailLogin1, password1 = kolabWAPhelper.create_user()
        #username2, emailLogin2, password2 = kolabWAPhelper.create_user()

        # create shared folder
        # could use delegates=[emailLogin1, emailLogin2], but this is not tested at the moment
        emailSharedFolder, foldername = kolabWAPhelper.create_shared_folder()
        kolabWAPhelper.logout_kolab_wap()
        
        # need to give everyone permission to send to this folder
        # need to wait some seconds, otherwise the permissions will be reset to lrs, probably by kolabd???
        kolabWAPhelper.wait_loading(20.0)
        subprocess.call(['/bin/bash', '-c', "kolab sam shared/" + emailSharedFolder + " anyone full"])
        kolabWAPhelper.wait_loading(20.0)
        subprocess.call(['/bin/bash', '-c', "kolab lam shared/" + emailSharedFolder])

        # login user to roundcube to send and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin1, password1)
        
        # TODO: why can I see and subscribe to all folders in the domain?
        # can we set permissions who can read the folder? Recipient Access list?
        # solution: http://lists.kolab.org/pipermail/users/2013-December/016161.html
        #           quote: Shared folders are created with the ACL "anyone lrs" (anyone read) per default.  
        #                  After creating them you'll likely adjust the ACLs based on your needs.
        
        print "sending email to " + emailSharedFolder
        emailSubjectLine = kolabWAPhelper.send_email(emailSharedFolder)
        kolabWAPhelper.wait_loading(3.0)
        kolabWAPhelper.check_email_received(emailSubjectLineDoesNotContain="Undelivered Mail Returned to Sender")
        # no need to subscribe the folder, because we are using the direct url to load the folder in Roundcube
        kolabWAPhelper.check_email_received(
                        folder="Shared+Folders%2Fshared%2F"+foldername, 
                        emailSubjectLine=emailSubjectLine)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
Esempio n. 13
0
class KolabUserMailhostLocalhost(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def modify_mailhost_default(self):
        driver = self.driver
        driver.get(driver.current_url)

        elem = driver.find_element_by_link_text("Settings")
        elem.click()
        self.kolabWAPhelper.wait_loading()
        elem = self.driver.find_element_by_id("searchinput")
        elem.send_keys("Kolab User")
        elem.send_keys(Keys.ENTER)
        self.kolabWAPhelper.wait_loading(initialwait = 2)
        elem = self.driver.find_element_by_xpath("//table[@id='settingstypelist']/tbody/tr/td")
        self.assertEquals("Kolab User", elem.text, "Expected to select Kolab User but was " + elem.text)
        elem.click()
        self.kolabWAPhelper.wait_loading(initialwait = 1)
        elem = driver.find_element_by_link_text("Attributes")
        elem.click()
        elem = driver.find_element_by_xpath("//tr[@id='attr_table_row_mailhost']/td[@class='actions']/a[@href='#edit']").click()
        self.kolabWAPhelper.wait_loading(0.5)
        driver.find_element_by_xpath("//tr[@id='attr_form_row_value']/td[@class='value']/select/option[@value='normal']").click()
        elem = driver.find_element_by_xpath("//tr[@id='attr_form_row_default']/td[@class='value']/input")
        elem.send_keys("localhost")
        driver.find_element_by_xpath("//input[@value='Save']").click()
        
        elem = driver.find_element_by_xpath("//input[@value=\"Submit\"]").click()
        self.kolabWAPhelper.wait_loading()
        elem = driver.find_element_by_xpath("//div[@id=\"message\"]")
        self.assertEquals("Object type updated successfully.", elem.text, "object type was not updated successfully, message: " + elem.text)

    def test_modify_mailhost_default(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_modify_mailhost_default")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        self.modify_mailhost_default()

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
class KolabEmailCatchAllAcrossDomains(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_catch_all_across_domains(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_catch_all_across_domains")
        
        # login Directory Manager, create a domain and a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")
        # important: alias domain must be set in the domain names, otherwise: email address not in local domain
        domainname = kolabWAPhelper.create_domain(withAliasDomain=True)
        aliasdomainname = string.replace(domainname, "domain", "alias")

        username = "******" + datetime.datetime.now().strftime("%Y%m%d%H%M%S")
        # what happens if we have not added the alias domain yet to postfix config?
        kolabWAPhelper.create_user(
            username=username,
            alias="catchall@" + aliasdomainname,
            expected_message_contains="Alias 'catchall@" + aliasdomainname +"' must be configured manually")

        # add alias domain, and call postmap
        postfixfile="/etc/postfix/virtual_alias_maps_manual.cf"
        subprocess.call(['/bin/bash', '-c', 'echo "@' + aliasdomainname + ' ' + username + '.' + username +'@' + domainname + '" >> ' + postfixfile])
        subprocess.call(['postmap', postfixfile])
        subprocess.call(['service', 'postfix', 'restart'])
        
        # now add user for real
        username, emailLogin, password = kolabWAPhelper.create_user(username=username, alias="catchall@" + aliasdomainname)
        kolabWAPhelper.logout_kolab_wap()

        # send email to catch all alias address from command line
        print "sending email..."
        subprocess.call(['/bin/bash', '-c', 'echo "test" | mail -s "subject ' + aliasdomainname + '" test@' + aliasdomainname])
        kolabWAPhelper.wait_loading(10.0)

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.check_email_received(emailSubjectLine="subject " + aliasdomainname)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
class KolabWAPDomainAdmin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_max_accounts(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_max_accounts")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password, domainname = kolabWAPhelper.create_domainadmin(
            max_accounts = 3)

        # create another domain, with domain admin
        domainname2 = kolabWAPhelper.create_domain(username)

        # create user accounts
        kolabWAPhelper.select_domain(domainname)
        kolabWAPhelper.create_user()
        kolabWAPhelper.create_user()
        kolabWAPhelper.select_domain(domainname2)
        username2, emailLogin2, password2, uid2 = kolabWAPhelper.create_user()
        # should fail, only 3 accounts allowed, excluding the domain admin
        kolabWAPhelper.create_user(expected_message_contains = "Cannot create another account")

        # create another domain admin, for the same domains, but with higher max_accounts
        username2, emailLogin2, password2, uid2 = kolabWAPhelper.create_domainadmin(
            max_accounts = 7)
        kolabWAPhelper.link_admin_to_domain(username2, domainname)
        # should still fail, because only one admin can have a max account number
        kolabWAPhelper.select_domain(domainname)
        kolabWAPhelper.create_user(expected_message_contains =
            "only one domainadmin can have a maximum account number specified")

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
Esempio n. 16
0
class KolabWAPDomainAdmin(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_max_accounts(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_max_accounts")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix="admin", max_accounts=3)

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        domainname2 = kolabWAPhelper.create_domain(username)

        # create user accounts
        kolabWAPhelper.select_domain(domainname)
        kolabWAPhelper.create_user()
        kolabWAPhelper.create_user()
        kolabWAPhelper.select_domain(domainname2)
        kolabWAPhelper.create_user()
        # should fail, only 3 accounts allowed
        kolabWAPhelper.create_user(
            expected_message_contains="Cannot create another account")

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.close()
class KolabWAPDomainAdmin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_max_accounts(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_max_accounts")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin",
            max_accounts = 3)

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        domainname2 = kolabWAPhelper.create_domain(username)
        
        # create user accounts
        kolabWAPhelper.select_domain(domainname)
        kolabWAPhelper.create_user()
        kolabWAPhelper.create_user()
        kolabWAPhelper.select_domain(domainname2)
        kolabWAPhelper.create_user()
        # should fail, only 3 accounts allowed
        kolabWAPhelper.create_user(expected_message_contains = "Cannot create another account")

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.close()
class KolabWAPDomainAdmin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_max_accounts(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_max_accounts")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password, domainname = kolabWAPhelper.create_domainadmin(
            max_accounts = 4)

        # create another domain, with domain admin
        domainname2 = kolabWAPhelper.create_domain(username)

        # create user accounts
        kolabWAPhelper.select_domain(domainname)
        kolabWAPhelper.create_user()
        kolabWAPhelper.create_user()
        kolabWAPhelper.select_domain(domainname2)
        username2, emailLogin2, password2 = kolabWAPhelper.create_user()
        # should fail, only 4 accounts allowed, including the domain admin
        kolabWAPhelper.create_user(expected_message_contains = "Cannot create another account")

        kolabWAPhelper.upgrade_user_to_domainadmin(username2, domainname, max_accounts = 7)
        # should still fail, because the minimum is used
        kolabWAPhelper.create_user(expected_message_contains = "Cannot create another account")

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
class KolabEmailCatchAll(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_catch_all(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_catch_all")

        # login Directory Manager, create a domain and a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")
        domainname = kolabWAPhelper.create_domain()

        # add the user
        username, emailLogin, password = kolabWAPhelper.create_user(alias="@" +
                                                                    domainname)
        kolabWAPhelper.logout_kolab_wap()

        # send email to catch all alias address from command line
        print "sending email..."
        subject = 'subject ' + domainname
        subprocess.call([
            '/bin/bash', '-c', 'echo "test" | mail -s "' + subject +
            '" alias' + domainname + '@' + domainname
        ])
        kolabWAPhelper.wait_loading(2.0)

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.check_email_received(subject)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.close()
class KolabWAPDomainAdmin(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_domain_admin_default_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_domain_admin")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix="admin", default_quota="100mb", overall_quota="300mb")

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)

        # create user accounts
        # test if default quota is set properly for a new user
        kolabWAPhelper.create_user(default_quota_verify="100mb")
        kolabWAPhelper.create_user(mail_quota="150mb")
        kolabWAPhelper.create_user(
            default_quota_verify="100mb",
            expected_message_contains=
            "mailquota of the domain admin has been exceeded")

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.close()
class KolabWAPCreateUserAndEditSelf(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    # edit yourself; testing bug https://issues.kolab.org/show_bug.cgi?id=2414
    def helper_user_edits_himself(self):
        driver = self.driver
        elem = driver.find_element_by_xpath("//div[@class=\"settings\"]")
        elem.click()
        self.kolabWAPhelper.wait_loading(1.0)
        elem = driver.find_element_by_name("initials")
        elem.send_keys("T")
        elem = driver.find_element_by_xpath("//input[@value=\"Submit\"]")
        elem.click()
        self.kolabWAPhelper.wait_loading()
        elem = driver.find_element_by_xpath("//div[@id=\"message\"]")
        self.assertEquals("User updated successfully.", elem.text, "User was not saved successfully, message: " + elem.text)
        
        self.kolabWAPhelper.log("User has updated his own data successfully")


    def test_edit_user_himself(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_edit_user_himself")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password = kolabWAPhelper.create_user()

        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", emailLogin, password)

        self.helper_user_edits_himself()
        
        kolabWAPhelper.logout_kolab_wap()

    def test_edit_user_himself_multi_domain_with_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_edit_user_himself_multi_domain_with_quota")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        domainname = kolabWAPhelper.create_domain()

        username, emailLogin, password = kolabWAPhelper.create_user(mail_quota="20kb")

        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", emailLogin, password)

        self.helper_user_edits_himself()
        
        kolabWAPhelper.logout_kolab_wap()

    def test_edit_user_himself_multi_domain(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_edit_user_himself_multi_domain")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        domainname = kolabWAPhelper.create_domain()

        username, emailLogin, password = kolabWAPhelper.create_user()

        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", emailLogin, password)

        self.helper_user_edits_himself()
        
        kolabWAPhelper.logout_kolab_wap()


    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
Esempio n. 22
0
class KolabWAPCreateUserAndEditSelf(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    # edit yourself; testing bug https://issues.kolab.org/show_bug.cgi?id=2414
    def helper_user_edits_himself(self):
        driver = self.driver
        elem = driver.find_element_by_xpath("//div[@class=\"settings\"]")
        elem.click()
        self.kolabWAPhelper.wait_loading(1.0)
        elem = driver.find_element_by_name("initials")
        elem.send_keys("T")
        elem = driver.find_element_by_xpath("//input[@value=\"Submit\"]")
        elem.click()
        self.kolabWAPhelper.wait_loading()
        elem = driver.find_element_by_xpath("//div[@id=\"message\"]")
        self.assertEquals(
            "User updated successfully.", elem.text,
            "User was not saved successfully, message: " + elem.text)

        self.kolabWAPhelper.log("User has updated his own data successfully")

    def test_edit_user_himself(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_edit_user_himself")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        username, emailLogin, password, uid = kolabWAPhelper.create_user()

        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", emailLogin, password)

        self.helper_user_edits_himself()

        kolabWAPhelper.logout_kolab_wap()

    def test_edit_user_himself_multi_domain_with_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log(
            "Running test: test_edit_user_himself_multi_domain_with_quota")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        domainname = kolabWAPhelper.create_domain()

        username, emailLogin, password, uid = kolabWAPhelper.create_user(
            mail_quota="20kb")

        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", emailLogin, password)

        self.helper_user_edits_himself()

        kolabWAPhelper.logout_kolab_wap()

    def test_edit_user_himself_multi_domain(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_edit_user_himself_multi_domain")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        domainname = kolabWAPhelper.create_domain()

        username, emailLogin, password, uid = kolabWAPhelper.create_user()

        kolabWAPhelper.logout_kolab_wap()

        # login the new user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", emailLogin, password)

        self.helper_user_edits_himself()

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
class KolabWAPDomainAdmin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    # test if correct user type is used in a normal domain
    def test_default_user_type_in_normal_domain(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_default_user_type_in_normal_domain")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "user")

        # now edit the user
        elem = self.driver.find_element_by_id("searchinput")
        elem.send_keys(username)
        elem.send_keys(Keys.ENTER)
        kolabWAPhelper.wait_loading(initialwait = 2)

        elem = self.driver.find_element_by_xpath("//table[@id='userlist']/tbody/tr/td")
        self.assertEquals(username + ", " + username, elem.text, "Expected to select user " + username + " but was " + elem.text)
        elem.click()

        kolabWAPhelper.wait_loading(initialwait = 1)

        # check if the user type is actually a normal kolab user
        elem = self.driver.find_element_by_xpath("//form[@id='user-form']/fieldset/table/tbody/tr/td[@class='value']")
        self.assertEquals("Kolab User", elem.text, "user type should be Kolab User, but was " + elem.text)

        kolabWAPhelper.logout_kolab_wap()

    # test if correct user type is used when not many attributes are set which are specific for domain admins
    def test_domain_admin_user_type(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_domain_admin_user_type")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin")

        # now edit the user
        elem = self.driver.find_element_by_id("searchinput")
        elem.send_keys(username)
        elem.send_keys(Keys.ENTER)
        kolabWAPhelper.wait_loading(initialwait = 2)

        elem = self.driver.find_element_by_xpath("//tbody/tr/td[@class=\"name\"]")
        self.assertEquals(username + ", " + username, elem.text, "Expected to select user " + username + " but was " + elem.text)
        elem.click()
        
        kolabWAPhelper.wait_loading(initialwait = 1)

        # check if the user type is actually a domain admin
        elem = self.driver.find_element_by_xpath("//form[@id='user-form']/fieldset/table/tbody/tr/td[@class='value']")
        self.assertEquals("Domain Administrator", elem.text, "user type should be Domain Administrator, but was " + elem.text)

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.close()
Esempio n. 24
0
class KolabUniqueIDAcrossDomains(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def enable_editable_uid(self):
        driver = self.driver
        driver.get(driver.current_url)

        elem = driver.find_element_by_link_text("Settings")
        elem.click()
        self.kolabWAPhelper.wait_loading()
        elem = self.driver.find_element_by_id("searchinput")
        elem.send_keys("Kolab User")
        elem.send_keys(Keys.ENTER)
        self.kolabWAPhelper.wait_loading(initialwait=2)
        elem = self.driver.find_element_by_xpath(
            "//table[@id='settingstypelist']/tbody/tr/td")
        self.assertEquals("Kolab User", elem.text,
                          "Expected to select Kolab User but was " + elem.text)
        elem.click()
        self.kolabWAPhelper.wait_loading(initialwait=1)
        elem = driver.find_element_by_link_text("Attributes")
        elem.click()
        elem = driver.find_element_by_xpath(
            "//tr[@id='attr_table_row_uid']/td[@class='actions']/a[@href='#edit']"
        ).click()
        self.kolabWAPhelper.wait_loading(0.5)
        driver.find_element_by_xpath(
            "//tr[@id='attr_form_row_value']/td[@class='value']/select/option[@value='auto']"
        ).click()
        driver.find_element_by_xpath("//input[@value='Save']").click()

        elem = driver.find_element_by_xpath(
            "//input[@value=\"Submit\"]").click()
        self.kolabWAPhelper.wait_loading()
        elem = driver.find_element_by_xpath("//div[@id=\"message\"]")
        self.assertEquals(
            "Object type updated successfully.", elem.text,
            "object type was not updated successfully, message: " + elem.text)

    def test_unique_id_across_domains(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_unique_id_across_domains")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        # create a user in the primary domain
        username = "******" + datetime.datetime.now().strftime(
            "%Y%m%d%H%M%S") + "uid"
        self.enable_editable_uid()
        username, emailLogin, password, uid = kolabWAPhelper.create_user(
            username=username, uid=username)

        # create a domain and select it
        domainname = kolabWAPhelper.create_domain()

        # attempt to create a user with the same username as in the primary domain, should result in a uid with digit 2 attached
        username, emailLogin, password, uid = kolabWAPhelper.create_user(
            username=username)
        self.assertEquals(
            username + "2", uid,
            "generate_uid should create a unique id across domains for same surname, expected "
            + username + "2, but got: " + uid)

        # attempt to create a user with the same uid as in the primary domain
        kolabWAPhelper.create_user(
            username=username,
            uid=username,
            expected_message_contains=("Error: The unique identity (UID) " +
                                       username + " is already in use."))

        # create a new user
        username = "******" + datetime.datetime.now().strftime("%Y%m%d%H%M%S")
        username, emailLogin, password, uid = kolabWAPhelper.create_user(
            username=username)
        kolabWAPhelper.logout_kolab_wap()

        # test kolab-saslauthd from the commandline
        print("testsaslauthd with " + emailLogin)
        p = subprocess.Popen("/usr/sbin/testsaslauthd -u " + emailLogin +
                             " -p '" + password + "'",
                             shell=True,
                             stdout=subprocess.PIPE)
        out, err = p.communicate()
        self.assertTrue('0: OK "Success."' in out,
                        "login did not work, it shows " + out)

        print("testsaslauthd with " + username)
        p = subprocess.Popen("/usr/sbin/testsaslauthd -u " + username +
                             " -p '" + password + "'",
                             shell=True,
                             stdout=subprocess.PIPE)
        out, err = p.communicate()
        self.assertTrue('0: OK "Success."' in out,
                        "login did not work, it shows " + out)

        print("testsaslauthd with wrong password")
        p = subprocess.Popen("/usr/sbin/testsaslauthd -u " + username +
                             " -p '" + password + "fail'",
                             shell=True,
                             stdout=subprocess.PIPE)
        out, err = p.communicate()
        self.assertTrue(
            '0: NO "authentication failed"' in out,
            "login should not work with wrong password, but it shows " + out)

        # login user to kolab webadmin with wrong password should fail
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", username,
                                       password + "fail",
                                       "Incorrect username or password!")

        # login user to kolab webadmin with the email login
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", emailLogin, password)
        kolabWAPhelper.logout_kolab_wap()

        # login user to kolab webadmin with just the uid
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", username, password)
        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
Esempio n. 25
0
class KolabWAPDomainAdmin(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    # check that domain admin cannot assign too much quota to the user accounts
    def test_overall_quota_limit(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_overall_quota_limit")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        username, emailLogin, password, uid = kolabWAPhelper.create_user(
            prefix="admin", overall_quota="800mb")

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        domainname2 = kolabWAPhelper.create_domain(username)

        # create user accounts
        kolabWAPhelper.select_domain(domainname)
        # test if no account has been created yet, validation will still kick in
        kolabWAPhelper.create_user(
            mail_quota="2gb",
            expected_message_contains=
            "mailquota of the domain admin has been exceeded")
        kolabWAPhelper.create_user(mail_quota="200mb")
        kolabWAPhelper.select_domain(domainname2)
        # should fail, exceeding the overall quota of the domain admin
        kolabWAPhelper.create_user(
            mail_quota="900mb",
            expected_message_contains=
            "mailquota of the domain admin has been exceeded")
        kolabWAPhelper.create_user(mail_quota="600mb")

        kolabWAPhelper.logout_kolab_wap()

    # test that a domain admin with a mail quota cannot create user mailboxes with no quota specified
    def test_unlimited_user_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_unlimited_user_quota")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        username, emailLogin, password, uid = kolabWAPhelper.create_user(
            prefix="admin", overall_quota="1gb")

        # create domain, with domain admin
        domainname = kolabWAPhelper.create_domain(username)

        # create user account
        kolabWAPhelper.create_user(
            expected_message_contains="must specify a mailquota for the user")

        kolabWAPhelper.logout_kolab_wap()

    # test that a domain admin with no mail quota can create user mailboxes with as much quota as he wants
    def test_no_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_no_quota")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        username, emailLogin, password, uid = kolabWAPhelper.create_user(
            prefix="admin")

        # create domain, with domain admin
        domainname = kolabWAPhelper.create_domain(username)

        # create user account with a quota
        kolabWAPhelper.create_user(mail_quota="100mb")
        # without any quota for the user
        kolabWAPhelper.create_user()

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
Esempio n. 26
0
class KolabEmailMailForwarding(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_mail_forwarding(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_mail_forwarding")
        
        # login Directory Manager, create a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        # add the user
        username, emailLogin, password = kolabWAPhelper.create_user()
        
        # create a forward address
        username2, emailForwardAddress, password2 = kolabWAPhelper.create_user(forward_to=emailLogin)
        # wait a few seconds for the change to take effect
        time.sleep(10)
        
        kolabWAPhelper.logout_kolab_wap()

        # send email to the forward address from command line
        print "sending email to " + emailForwardAddress
        subject = 'for ' + username
        subprocess.call(['/bin/bash', '-c', 'echo "test" | mail -s "' + subject + '" ' + emailForwardAddress])
        time.sleep(10)

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.check_email_received(emailSubjectLine=subject)
        kolabWAPhelper.logout_roundcube()

    def test_mail_forwarding_external(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_mail_forwarding_external")

        # login Directory Manager, create a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        # please modify following line to add a domain that actually can receive emails, ie. has a valid MX record
        enabled_maildomain="soliderp.net"
        # quit the test if that domain does not exist in the current setup
        kolabWAPhelper.select_domain(enabled_maildomain);

        # add the user
        username, emailLogin, password = kolabWAPhelper.create_user()

        # create a forward address
        # using an external echo address (see https://de.wikipedia.org/wiki/Echo-Mailer)
        username2, emailForwardAddress, password2 = kolabWAPhelper.create_user(forward_to="*****@*****.**")
        time.sleep(10)

        kolabWAPhelper.logout_kolab_wap()

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        print "sending email to " + emailForwardAddress
        emailSubjectLine = kolabWAPhelper.send_email(emailForwardAddress)
        kolabWAPhelper.wait_loading(5.0)
        kolabWAPhelper.check_email_received(emailSubjectLine="Re: " + emailSubjectLine)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.quit()
class KolabWAPDomainAdmin(unittest.TestCase):

    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    # check that domain admin cannot assign too much quota to the user accounts
    def test_overall_quota_limit(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_overall_quota_limit")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin",
            overall_quota = "800mb")

        # create domains, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        domainname2 = kolabWAPhelper.create_domain(username)
        
        # create user accounts
        kolabWAPhelper.select_domain(domainname)
        # test if no account has been created yet, validation will still kick in
        kolabWAPhelper.create_user(mail_quota = "2gb", expected_message_contains = "mailquota of the domain admin has been exceeded")
        kolabWAPhelper.create_user(mail_quota = "200mb")
        kolabWAPhelper.select_domain(domainname2)
        # should fail, exceeding the overall quota of the domain admin
        kolabWAPhelper.create_user(mail_quota = "900mb", expected_message_contains = "mailquota of the domain admin has been exceeded")
        kolabWAPhelper.create_user(mail_quota = "600mb")

        kolabWAPhelper.logout_kolab_wap()

    # test that a domain admin with a mail quota cannot create user mailboxes with no quota specified
    def test_unlimited_user_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_unlimited_user_quota")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin",
            overall_quota = "1gb")

        # create domain, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        
        # create user account
        kolabWAPhelper.create_user(expected_message_contains = "must specify a mailquota for the user")

        kolabWAPhelper.logout_kolab_wap()

    # test that a domain admin with no mail quota can create user mailboxes with as much quota as he wants
    def test_no_quota(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_no_quota")
        
        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(
            prefix = "admin")

        # create domain, with domain admin
        domainname = kolabWAPhelper.create_domain(username)
        
        # create user account with a quota
        kolabWAPhelper.create_user(mail_quota = "100mb")
        # without any quota for the user
        kolabWAPhelper.create_user()

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):
        
        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()
        
        self.driver.close()
Esempio n. 28
0
class KolabEmailMailForwarding(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    def test_mail_forwarding(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_mail_forwarding")

        # login Directory Manager, create a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        # add the user
        username, emailLogin, password = kolabWAPhelper.create_user()

        # create a forward address
        username2, emailForwardAddress, password2 = kolabWAPhelper.create_user(
            forward_to=emailLogin)
        # wait a few seconds for the change to take effect
        time.sleep(10)

        kolabWAPhelper.logout_kolab_wap()

        # send email to the forward address from command line
        print "sending email to " + emailForwardAddress
        subject = 'for ' + username
        subprocess.call([
            '/bin/bash', '-c',
            'echo "test" | mail -s "' + subject + '" ' + emailForwardAddress
        ])
        time.sleep(10)

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        kolabWAPhelper.check_email_received(emailSubjectLine=subject)
        kolabWAPhelper.logout_roundcube()

    def test_mail_forwarding_external(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_mail_forwarding_external")

        # login Directory Manager, create a user
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin",
                                       "cn=Directory Manager", "test")

        # please modify following line to add a domain that actually can receive emails, ie. has a valid MX record
        enabled_maildomain = "soliderp.net"
        # quit the test if that domain does not exist in the current setup
        kolabWAPhelper.select_domain(enabled_maildomain)

        # add the user
        username, emailLogin, password = kolabWAPhelper.create_user()

        # create a forward address
        # using an external echo address (see https://de.wikipedia.org/wiki/Echo-Mailer)
        username2, emailForwardAddress, password2 = kolabWAPhelper.create_user(
            forward_to="*****@*****.**")
        time.sleep(10)

        kolabWAPhelper.logout_kolab_wap()

        # login user to roundcube and check for email
        kolabWAPhelper.login_roundcube("/roundcubemail", emailLogin, password)
        print "sending email to " + emailForwardAddress
        emailSubjectLine = kolabWAPhelper.send_email(emailForwardAddress)
        kolabWAPhelper.wait_loading(5.0)
        kolabWAPhelper.check_email_received(emailSubjectLine="Re: " +
                                            emailSubjectLine)
        kolabWAPhelper.logout_roundcube()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.quit()
class KolabWAPDomainAdmin(unittest.TestCase):
    def setUp(self):
        self.kolabWAPhelper = KolabWAPTestHelpers()
        self.driver = self.kolabWAPhelper.init_driver()

    # test if correct user type is used in a normal domain
    def test_default_user_type_in_normal_domain(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_default_user_type_in_normal_domain")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        username, emailLogin, password = kolabWAPhelper.create_user(prefix="user")

        # now edit the user
        elem = self.driver.find_element_by_id("searchinput")
        elem.send_keys(username)
        elem.send_keys(Keys.ENTER)
        kolabWAPhelper.wait_loading(initialwait=2)

        elem = self.driver.find_element_by_xpath("//table[@id='userlist']/tbody/tr/td")
        self.assertEquals(
            username + ", " + username, elem.text, "Expected to select user " + username + " but was " + elem.text
        )
        elem.click()

        kolabWAPhelper.wait_loading(initialwait=1)

        # check if the user type is actually a normal kolab user
        elem = self.driver.find_element_by_xpath("//form[@id='user-form']/fieldset/table/tbody/tr/td[@class='value']")
        self.assertEquals("Kolab User", elem.text, "user type should be Kolab User, but was " + elem.text)

        kolabWAPhelper.logout_kolab_wap()

    # test if correct user type is used when not many attributes are set which are specific for domain admins
    def test_domain_admin_user_type(self):
        kolabWAPhelper = self.kolabWAPhelper
        kolabWAPhelper.log("Running test: test_domain_admin_user_type")

        # login Directory Manager
        kolabWAPhelper.login_kolab_wap("/kolab-webadmin", "cn=Directory Manager", "test")

        kolabWAPhelper.select_domain("administrators.org")

        username, emailLogin, password = kolabWAPhelper.create_user(prefix="admin")

        # now edit the user
        elem = self.driver.find_element_by_id("searchinput")
        elem.send_keys(username)
        elem.send_keys(Keys.ENTER)
        kolabWAPhelper.wait_loading(initialwait=2)

        elem = self.driver.find_element_by_xpath('//tbody/tr/td[@class="name"]')
        self.assertEquals(
            username + ", " + username, elem.text, "Expected to select user " + username + " but was " + elem.text
        )
        elem.click()

        kolabWAPhelper.wait_loading(initialwait=1)

        # check if the user type is actually a domain admin
        elem = self.driver.find_element_by_xpath("//form[@id='user-form']/fieldset/table/tbody/tr/td[@class='value']")
        self.assertEquals(
            "Domain Administrator", elem.text, "user type should be Domain Administrator, but was " + elem.text
        )

        kolabWAPhelper.logout_kolab_wap()

    def tearDown(self):

        # write current page for debugging purposes
        self.kolabWAPhelper.log_current_page()

        self.driver.close()