def test_auth_xml(self): """ Send a configured auth request in XML format and check a successfully returned token """ config = get_config() if config.getboolean("auth_test", "enabled"): # Run only if enabled try: timestamp = config.getint("auth_test", "timestamp") except ValueError: # If timestamp is set to a none-integer, we'll just assume # that it's unset timestamp = None response = authenticate( config.get("auth_test", "url"), config.get("auth_test", "account"), config.get("auth_test", "preauthkey"), config.get("auth_test", "account_by"), config.getint("auth_test", "expires"), timestamp, ) self.assertNotEqual(response, None, "Authentication with the configured settings " "was not successful")
def test_fault_non_existing_folder_genrequest_xml(self): """ Request a non existing folder, so we get a fitting fault """ config = get_config() if config.getboolean('fault_test', 'enabled'): comm = Communication(config.get('fault_test', 'url')) token = auth.authenticate(config.get('fault_test', 'url'), config.get('fault_test', 'account'), config.get('fault_test', 'preauthkey'), config.get('fault_test', 'account_by')) request = comm.gen_request(request_type="xml", token=token) request.add_request( "GetFolderRequest", { "folder": { "path": config.get('fault_test', 'folder') } }, "urn:zimbraMail" ) response = comm.send_request(request) self.check_response( response )
def test_auth_xml(self): """ Send a configured auth request in XML format and check a successfully returned token """ config = get_config() if config.getboolean('auth_test', 'enabled'): # Run only if enabled try: timestamp = config.getint('auth_test', 'timestamp') except ValueError: # If timestamp is set to a none-integer, we'll just assume # that it's unset timestamp = None response = authenticate(config.get('auth_test', 'url'), config.get('auth_test', 'account'), config.get('auth_test', 'preauthkey'), config.get('auth_test', 'account_by'), config.getint('auth_test', 'expires'), timestamp) self.assertNotEqual( response, None, "Authentication with the configured settings " "was not successful")
def test_auth_failure_xml(self): """ Send a configured auth request with a wrong password in XML format and check the result """ config = get_config() if config.getboolean("auth_test", "enabled"): # Run only if enabled try: timestamp = config.getint("auth_test", "timestamp") except ValueError: # If timestamp is set to a none-integer, we'll just assume # that it's unset timestamp = None response = authenticate( config.get("auth_test", "url"), config.get("auth_test", "account"), config.get("auth_test", "preauthkey") + "1234", config.get("auth_test", "account_by"), config.getint("auth_test", "expires"), timestamp, ) self.assertEqual(response, None, "Authentication did not return 'None', but %s instead." % (response))
def test_fault_non_existing_folder_genrequest_invalidurl(self): """ Request a non existing folder, so we get a fitting fault """ config = get_config() if config.getboolean('fault_test', 'enabled'): comm = Communication(config.get('fault_test', 'url') + "1234") token = auth.authenticate(config.get('fault_test', 'url'), config.get('fault_test', 'account'), config.get('fault_test', 'preauthkey'), config.get('fault_test', 'account_by')) request = comm.gen_request(token=token) request.add_request( "GetFolderRequest", { "folder": { "path": config.get('fault_test', 'folder') } }, "urn:zimbraMail" ) # A 404 error should by raised as an exception. self.assertRaises( Exception, comm.send_request, request )
def test_auth_failure_xml(self): """ Send a configured auth request with a wrong password in XML format and check the result """ config = get_config() if config.getboolean('auth_test', 'enabled'): # Run only if enabled try: timestamp = config.getint('auth_test', 'timestamp') except ValueError: # If timestamp is set to a none-integer, we'll just assume # that it's unset timestamp = None response = authenticate( config.get('auth_test', 'url'), config.get('auth_test', 'account'), config.get('auth_test', 'preauthkey') + "1234", config.get('auth_test', 'account_by'), config.getint('auth_test', 'expires'), timestamp) self.assertEqual( response, None, "Authentication did not return 'None', but %s instead." % (response))
def test_genrequest_default(self): """ Create a request only using the Communication-object """ config = get_config() if config.getboolean("genrequest_test", "enabled"): # Run only if enabled comm = Communication(config.get("genrequest_test", "url")) token = authenticate(config.get("genrequest_test", "url"), config.get("genrequest_test", "account"), config.get("genrequest_test", "preauthkey")) self.assertNotEqual(token, None, "Cannot authenticate.") request = comm.gen_request(token=token) request.add_request("NoOpRequest", {}, "urn:zimbraMail") response = comm.send_request(request) if response.is_fault(): self.fail( "Reponse failed: (%s) %s" % (response.get_fault_code(), response.get_fault_message()))
def test_password_auth_xml(self): """ Send a configured auth request in xml format using password based authentication and check a successfully returned token """ config = get_config() if config.getboolean("auth_by_password_test", "enabled"): # Run only if enabled response = authenticate( config.get("auth_by_password_test", "url"), config.get("auth_by_password_test", "account"), config.get("auth_by_password_test", "password"), config.get("auth_by_password_test", "account_by"), use_password=True, request_type="xml" ) if response is None: self.fail("Authentication with the configured settings " "was not ssuccessful")
def test_admin_auth_json(self): """ Send a configured admin auth request in json format using the admin auth-method and check a successfully returned token """ config = get_config() if config.getboolean("admin_auth_test", "enabled"): # Run only if enabled response = authenticate( config.get("admin_auth_test", "url"), config.get("admin_auth_test", "account"), config.get("admin_auth_test", "password"), config.get("admin_auth_test", "account_by"), admin_auth=True, request_type="json" ) if response is None: self.fail("Authentication with the configured settings " "was not successful")
def test_auth_failure_raise(self): """ Send a configured auth request with a wrong password in json format and let it raise an exception """ config = get_config() if config.getboolean('auth_test', 'enabled'): # Run only if enabled try: timestamp = config.getint('auth_test', 'timestamp') except ValueError: # If timestamp is set to a none-integer, we'll just assume # that it's unset timestamp = None self.assertRaises(AuthenticationFailed, authenticate, config.get('auth_test', 'url'), config.get('auth_test', 'account'), config.get('auth_test', 'preauthkey') + "1234", config.get('auth_test', 'account_by'), config.getint('auth_test', 'expires'), timestamp, request_type='json', raise_on_error=True)
def test_auth_failure_raise(self): """ Send a configured auth request with a wrong password in json format and let it raise an exception """ config = get_config() if config.getboolean("auth_test", "enabled"): # Run only if enabled try: timestamp = config.getint("auth_test", "timestamp") except ValueError: # If timestamp is set to a none-integer, we'll just assume # that it's unset timestamp = None self.assertRaises( AuthenticationFailed, authenticate, config.get("auth_test", "url"), config.get("auth_test", "account"), config.get("auth_test", "preauthkey") + "1234", config.get("auth_test", "account_by"), config.getint("auth_test", "expires"), timestamp, request_type="json", raise_on_error=True, )
def generate_test(file): """ Generate a given test. """ import tests config = tests.get_config(os.path.dirname(file)) root, ext = os.path.splitext(file) if ext == config.get(get_section(os.path.basename(root), config), 'input_ext'): tests.generate(root, config) else: print test, 'does not have a valid file extension. Check config.'
def generate_test(file): """ Generate a given test. """ import sys, os sys.path.insert(0, os.path.abspath(os.path.dirname(__file__))) import tests config = tests.get_config(os.path.dirname(file)) root, ext = os.path.splitext(file) if ext == config.get(tests.get_section(os.path.basename(root), config), 'input_ext'): tests.generate(root, config) else: print file, 'does not have a valid file extension. Check config.'
def test_autoresponse_xml(self): """ Create an XML-request and pass this to send_request expection a xml response. """ config = get_config() if config.getboolean("autoresponse_test", "enabled"): # Run only if enabled token = authenticate( config.get("autoresponse_test", "url"), config.get("autoresponse_test", "account"), config.get("autoresponse_test", "preauthkey") ) self.assertNotEqual( token, None, "Cannot authenticate." ) request = RequestXml() request.set_auth_token(token) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) comm = Communication(config.get("autoresponse_test", "url")) response = comm.send_request(request) if response.is_fault(): self.fail( "Reponse failed: (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) self.assertEqual( response.response_type, "xml", "Invalid response type %s" % response.response_type )
def generate_test(file): """ Generate a given test. """ import sys, os sys.path.insert(0, os.path.abspath(os.path.dirname(__file__))) import tests config = tests.get_config(os.path.dirname(file)) root, ext = os.path.splitext(file) if ext == config.get(tests.get_section(os.path.basename(root), config), "input_ext"): tests.generate(root, config) else: print file, "does not have a valid file extension. Check config."
def test_genrequest_xml(self): """ Create a request only using the Communication-object """ config = get_config() if config.getboolean("genrequest_test", "enabled"): # Run only if enabled comm = Communication(config.get("genrequest_test", "url")) token = authenticate( config.get("genrequest_test", "url"), config.get("genrequest_test", "account"), config.get("genrequest_test", "preauthkey") ) self.assertNotEqual( token, None, "Cannot authenticate." ) request = comm.gen_request(request_type="xml", token=token) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) response = comm.send_request(request) if response.is_fault(): self.fail( "Reponse failed: (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) self.assertEqual( response.response_type, "xml", "Invalid response type %s" % response.response_type )
def test_genrequest_check_response_xml(self): """ Create a request only using the Communication-object, send it and check the response """ config = get_config() if config.getboolean("genrequest_test", "enabled"): # Run only if enabled comm = Communication(config.get("genrequest_test", "url")) token = authenticate( config.get("genrequest_test", "url"), config.get("genrequest_test", "account"), config.get("genrequest_test", "preauthkey") ) self.assertNotEqual( token, None, "Cannot authenticate." ) request = comm.gen_request(request_type="xml", token=token) request.add_request( "GetInfoRequest", { }, "urn:zimbraAccount" ) response = comm.send_request(request) if response.is_fault(): self.fail( "Reponse failed: (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) self.assertEqual( response.get_response()["GetInfoResponse"]["name"], config.get("genrequest_test", "account"), "Request returned unexpected response" )
def test_genrequest_fail(self): """ Create a request only using the Communication-object """ config = get_config() if config.getboolean("genrequest_test", "enabled"): # Run only if enabled comm = Communication(config.get("genrequest_test", "url")) token = authenticate( config.get("genrequest_test", "url"), config.get("genrequest_test", "account"), config.get("genrequest_test", "preauthkey") ) self.assertNotEqual( token, None, "Cannot authenticate." ) self.assertRaises( UnknownRequestType, comm.gen_request, request_type="INVALID", token=token ) request = comm.gen_request(token=token) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) # Deliberately break the request request.request_type = "INVALID" self.assertRaises( UnknownRequestType, comm.send_request, request )
def test_fault_non_existing_folder_batch_json(self): """ Request a non existing folder multiple times to get multiple faults """ config = get_config() if config.getboolean('fault_test', 'enabled'): comm = Communication(config.get('fault_test', 'url')) token = auth.authenticate(config.get('fault_test', 'url'), config.get('fault_test', 'account'), config.get('fault_test', 'preauthkey'), config.get('fault_test', 'account_by')) request = RequestJson() request.set_auth_token(token) request.enable_batch() request.add_request( "GetFolderRequest", { "folder": { "path": config.get('fault_test', 'folder') } }, "urn:zimbraMail" ) request.add_request( "GetFolderRequest", { "folder": { "path": config.get('fault_test', 'folder') } }, "urn:zimbraMail" ) response = ResponseJson() comm.send_request(request, response) self.check_response( response )
def check_response(self, response): # Should be a fault if not response.is_fault(): self.fail( "Response wasn't a fault: %s" % (response.get_response()) ) config = get_config() message = "no such folder path: %s" % config.get('fault_test', 'folder') if response.is_batch(): # Correct error should've been returned for request_id, code in response.get_fault_code().items(): self.assertEqual( "mail.NO_SUCH_FOLDER", code ) # Correct error message should've been returned for request_id, fault_message in \ response.get_fault_message().items(): self.assertEqual( message, fault_message ) else: # Correct error should've been returned self.assertEqual( "mail.NO_SUCH_FOLDER", response.get_fault_code() ) # Correct error message should've been returned self.assertEqual( message, response.get_fault_message() )
def test_password_auth_failure_json(self): """ Send a configured auth request in json format using password based authentication and a wrong password and check the error """ config = get_config() if config.getboolean("auth_by_password_test", "enabled"): # Run only if enabled response = authenticate( config.get("auth_by_password_test", "url"), config.get("auth_by_password_test", "account"), config.get("auth_by_password_test", "password") + "1234", config.get("auth_by_password_test", "account_by"), use_password=True, request_type="json") self.assertEqual( response, None, "Authentication with a bad password" "was successful")
def test_admin_auth_xml(self): """ Send a configured admin auth request in xml format using the admin auth-method and check a successfully returned token """ config = get_config() if config.getboolean("admin_auth_test", "enabled"): # Run only if enabled response = authenticate( config.get("admin_auth_test", "admin_url"), config.get("admin_auth_test", "admin_account"), config.get("admin_auth_test", "admin_password"), config.get("admin_auth_test", "admin_account_by"), admin_auth=True, request_type="xml", ) self.assertNotEqual(response, None, "Authentication with the configured settings " "was not successful")
def test_password_auth_failure_json(self): """ Send a configured auth request in json format using password based authentication and a wrong password and check the error """ config = get_config() if config.getboolean("auth_by_password_test", "enabled"): # Run only if enabled response = authenticate( config.get("auth_by_password_test", "url"), config.get("auth_by_password_test", "account"), config.get("auth_by_password_test", "password") + "1234", config.get("auth_by_password_test", "account_by"), use_password=True, request_type="json", ) self.assertEqual(response, None, "Authentication with a bad password" "was successful")
def test_password_auth_json(self): """ Send a configured auth request in json format using password based authentication and check a successfully returned token """ config = get_config() if config.getboolean("auth_by_password_test", "enabled"): # Run only if enabled response = authenticate( config.get("auth_by_password_test", "url"), config.get("auth_by_password_test", "account"), config.get("auth_by_password_test", "password"), config.get("auth_by_password_test", "account_by"), use_password=True, request_type="json", ) self.assertNotEqual(response, None, "Authentication with the configured settings " "was not successful")
def test_auth_json(self): """ Send a configured auth request in json format and check a successfully returned token """ config = get_config() if config.getboolean('auth_test', 'enabled'): # Run only if enabled try: timestamp = config.getint('auth_test', 'timestamp') except ValueError: # If timestamp is set to a none-integer, we'll just assume # that it's unset timestamp = None response = authenticate( config.get('auth_test', 'url'), config.get('auth_test', 'account'), config.get('auth_test', 'preauthkey'), config.get('auth_test', 'account_by'), config.getint('auth_test', 'expires'), timestamp, request_type='json' ) if response is None: self.fail("Authentication with the configured settings " "was not successful")
def test_admin_auth_json(self): """ Send a configured admin auth request in json format using the admin auth-method and check a successfully returned token """ config = get_config() if config.getboolean("admin_auth_test", "enabled"): # Run only if enabled response = authenticate(config.get("admin_auth_test", "admin_url"), config.get("admin_auth_test", "admin_account"), config.get("admin_auth_test", "admin_password"), config.get("admin_auth_test", "admin_account_by"), admin_auth=True, request_type="json") self.assertNotEqual( response, None, "Authentication with the configured settings " "was not successful")
def test_password_auth_xml(self): """ Send a configured auth request in xml format using password based authentication and check a successfully returned token """ config = get_config() if config.getboolean("auth_by_password_test", "enabled"): # Run only if enabled response = authenticate(config.get("auth_by_password_test", "url"), config.get("auth_by_password_test", "account"), config.get("auth_by_password_test", "password"), config.get("auth_by_password_test", "account_by"), use_password=True, request_type="xml") self.assertNotEqual( response, None, "Authentication with the configured settings " "was not successful")
def run_admin_test(self, request_type): """ Actually do the work """ config = get_config() if config.getboolean("admin_request_test", "enabled"): # Run only if enabled token = authenticate( config.get("admin_request_test", "url"), config.get("admin_request_test", "account"), config.get("admin_request_test", "password"), config.get("admin_request_test", "account_by"), admin_auth=True, request_type=request_type ) if token is None: self.fail("Authentication with the configured settings " "was not successful") # Create an account comm = Communication(config.get("admin_request_test", "url")) if request_type == "xml": request = RequestXml() else: request = RequestJson() request.set_auth_token(token) request.add_request( "CreateAccountRequest", { "name": config.get("admin_request_test", "test_account"), "password": config.get( "admin_request_test", "test_password" ) }, "urn:zimbraAdmin" ) if request_type == "xml": response = ResponseXml() else: response = ResponseJson() comm.send_request(request, response) if response.is_fault(): self.fail( "CreateAccount faulted. %s" % (response.get_response()) ) account_id = response.get_response( )["CreateAccountResponse"]["account"]["id"] # Try to log in as the new account user_token = authenticate( config.get("admin_request_test", "user_url"), config.get("admin_request_test", "test_account"), config.get("admin_request_test", "test_password"), "name", request_type=request_type, use_password=True ) if user_token is None: self.fail("Cannot log in as the test user.") # Remove account request.clean() response.clean() request.set_auth_token(token) request.add_request( "DeleteAccountRequest", { "id": account_id }, "urn:zimbraAdmin" ) comm.send_request(request, response) if response.is_fault(): self.fail( "Cannot remove test account. %s" % response.get_response() )
#!/usr/bin/env python import tests import os, sys, getopt if len(sys.argv) > 1 and sys.argv[1] == "update": if len(sys.argv) > 2: config = tests.get_config(os.path.dirname(sys.argv[2])) root, ext = os.path.splitext(sys.argv[2]) if ext == config.get(tests.get_section(os.path.basename(root), config), 'input_ext'): tests.generate(root, config) else: print(file, 'does not have a valid file extension. Check config.') else: tests.generate_all() else: tests.run()
def test_genrequest_batch_xml(self): """ Create a batch-request only using the Communication-object ( xml-version) """ config = get_config() if config.getboolean("genrequest_test", "enabled"): # Run only if enabled comm = Communication(config.get("genrequest_test", "url")) token = authenticate( config.get("genrequest_test", "url"), config.get("genrequest_test", "account"), config.get("genrequest_test", "preauthkey") ) self.assertNotEqual( token, None, "Cannot authenticate." ) request = comm.gen_request( request_type="xml", token=token, set_batch=True ) self.assertEqual( type(request), RequestXml, "Generated request wasn't an xml-request" ) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) response = comm.send_request(request) if response.is_fault(): self.fail( "Reponse failed: (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) self.assertEqual( response.is_batch(), True, "Batch-request didn't return a Batch response." ) expected_batch = { 'nameToId': { 'NoOpResponse': [ '1', '2' ] }, 'hasFault': False, 'idToName': { '1': 'NoOpResponse', '2': 'NoOpResponse' } } self.assertEqual( response.get_batch(), expected_batch, "Batch-dictionary wasn't expected" )
def test_genrequest_check_response_batch_xml(self): """ Create a batch-request only using the Communication-object """ config = get_config() if config.getboolean("genrequest_test", "enabled"): # Run only if enabled comm = Communication(config.get("genrequest_test", "url")) token = authenticate( config.get("genrequest_test", "url"), config.get("genrequest_test", "account"), config.get("genrequest_test", "preauthkey") ) self.assertNotEqual( token, None, "Cannot authenticate." ) request = comm.gen_request( request_type="xml", token=token, set_batch=True ) self.assertEqual( type(request), RequestXml, "Generated request wasn't an json-request, which should be " "the default." ) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) request.add_request( "GetInfoRequest", { }, "urn:zimbraAccount" ) response = comm.send_request(request) if response.is_fault(): self.fail( "Reponse failed: (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) self.assertEqual( response.get_response(2)["GetInfoResponse"]["name"], config.get("genrequest_test", "account"), "Request returned unexpected response" )
def test_genrequest_batch_invalid_xml(self): """ Create a batchrequest only using the Communication-object, send it and request an invalid request id (xml) """ config = get_config() if config.getboolean("genrequest_test", "enabled"): # Run only if enabled comm = Communication(config.get("genrequest_test", "url")) token = authenticate( config.get("genrequest_test", "url"), config.get("genrequest_test", "account"), config.get("genrequest_test", "preauthkey") ) self.assertNotEqual( token, None, "Cannot authenticate." ) request = comm.gen_request( request_type="xml", token=token, set_batch=True ) self.assertEqual( type(request), RequestXml, "Generated request wasn't an json-request, which should be " "the default." ) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) request.add_request( "NoOpRequest", { }, "urn:zimbraMail" ) response = comm.send_request(request) if response.is_fault(): self.fail( "Reponse failed: (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) self.assertIsNone( response.get_response(3), "Querying an invalid requestId didn't return None" )
#!/usr/bin/env python import tests import os, sys if len(sys.argv) > 1 and sys.argv[1] == "update": if len(sys.argv) > 2: config = tests.get_config(os.path.dirname(sys.argv[2])) root, ext = os.path.splitext(sys.argv[2]) if ext == config.get(tests.get_section(os.path.basename(root), config), 'input_ext'): tests.generate(root, config) else: print(sys.argv[2], 'does not have a valid file extension. Check config.') else: tests.generate_all() else: tests.run()
def run_admin_test(self, request_type): """ Actually do the work """ config = get_config() if config.getboolean("admin_request_test", "enabled"): # Run only if enabled token = authenticate(config.get("admin_request_test", "admin_url"), config.get("admin_request_test", "admin_account"), config.get("admin_request_test", "admin_password"), config.get("admin_request_test", "admin_account_by"), admin_auth=True, request_type=request_type) if token is None: self.fail("Authentication with the configured settings " "was not successful") # Create an account comm = Communication(config.get("admin_request_test", "admin_url")) if request_type == "xml": request = RequestXml() else: request = RequestJson() request.set_auth_token(token) request.add_request( "CreateAccountRequest", { "name": config.get("admin_request_test", "test_account"), "password": config.get("admin_request_test", "test_password") }, "urn:zimbraAdmin") if request_type == "xml": response = ResponseXml() else: response = ResponseJson() comm.send_request(request, response) if response.is_fault(): self.fail( "CreateAccount faulted. (%s) %s" % (response.get_fault_code(), response.get_fault_message())) account_id = response.get_response( )["CreateAccountResponse"]["account"]["id"] # Try to log in as the new account user_token = authenticate(config.get("admin_request_test", "url"), config.get("admin_request_test", "test_account"), config.get("admin_request_test", "test_password"), "name", request_type=request_type, use_password=True) if user_token is None: self.fail("Cannot log in as the test user.") # Remove account request.clean() response.clean() request.set_auth_token(token) request.add_request("DeleteAccountRequest", {"id": account_id}, "urn:zimbraAdmin") comm.send_request(request, response) if response.is_fault(): self.fail( "Cannot remove test account: (%s) %s" % (response.get_fault_code(), response.get_fault_message()))
ZimbraSoapServerError, DomainHasNoPreAuthKey) from zimsoap.client.account import ZimbraAccountClient from zimsoap.client.admin import ZimbraAdminClient from zimsoap.client import ZimbraAPISession from zimsoap.zobjects import ( Account, CalendarResource, ClassOfService, COS, DistributionList, Domain, Mailbox, Server) try: from urllib2 import URLError except ImportError: from urllib.request import URLError from six import text_type, binary_type, assertRegex import tests TEST_CONF = tests.get_config() class ZimbraAdminClientTests(unittest.TestCase): def setUp(self): self.TEST_SERVER = TEST_CONF['host'] self.TEST_LOGIN = TEST_CONF['admin_login'] self.TEST_PASSWORD = TEST_CONF['admin_password'] self.TEST_ADMIN_PORT = TEST_CONF['admin_port'] self.LAMBDA_USER = TEST_CONF['lambda_user'] self.SERVER_NAME = TEST_CONF['server_name'] def testLogin(self): zc = ZimbraAdminClient(self.TEST_SERVER, self.TEST_ADMIN_PORT) zc.login(self.TEST_LOGIN, self.TEST_PASSWORD) self.assertTrue(zc._session.is_logged_in())
#!/usr/bin/env python import tests import os, sys, getopt opts, args = getopt.getopt(sys.argv[1:], "") if args and args[0] == "update": if len(args) > 1: config = tests.get_config(os.path.dirname(args[1])) root, ext = os.path.splitext(args[1]) if ext == config.get(tests.get_section(os.path.basename(root), config), "input_ext"): tests.generate(root, config) else: print(file, "does not have a valid file extension. Check config.") else: tests.generate_all() else: tests.run()
# """ Integration tests against zimbraMail SOAP webservice It has to be tested against a zimbra server (see README.md). """ import unittest from zimsoap.client import ZimbraMailClient, ZimbraAdminClient from zimsoap.zobjects import Task from zimsoap import utils import tests TEST_CONF = tests.get_config() class ZimbraMailAPITests(unittest.TestCase): """ Test logic and Zimbra Mail SOAP methods """ @classmethod def setUpClass(cls): # Login/connection is done at class initialization to reduce tests time cls.zc = ZimbraMailClient(TEST_CONF['host']) cls.zc.login(TEST_CONF['lambda_user'], TEST_CONF['lambda_password']) def setUp(self): self.TEST_SERVER = TEST_CONF['host'] self.TEST_LOGIN = TEST_CONF['lambda_user'] self.TEST_PASSWORD = TEST_CONF['lambda_password'] self.task_id = None
def run_admin_test(self, request_type): """ Actually do the work """ config = get_config() if config.getboolean("admin_request_test", "enabled"): # Run only if enabled token = authenticate( config.get("admin_request_test", "admin_url"), config.get("admin_request_test", "admin_account"), config.get("admin_request_test", "admin_password"), config.get("admin_request_test", "admin_account_by"), admin_auth=True, request_type=request_type ) if token is None: self.fail("Authentication with the configured settings " "was not successful") # Create an account comm = Communication(config.get("admin_request_test", "admin_url")) if request_type == "xml": request = RequestXml() else: request = RequestJson() request.set_auth_token(token) test_account = config.get("admin_request_test", "test_account") if "TEMP" in test_account: # Generate a random number and add it to the test account random.seed() temp_account = random.randint(1000000, 5000000) test_account = test_account.replace("TEMP", str(temp_account)) test_displayname = config.get( "admin_request_test", "test_displayname" ) if sys.version < '3': # Create unicode string for py2 test_displayname = test_displayname.decode("utf-8") request.add_request( "CreateAccountRequest", { "name": test_account, "password": config.get( "admin_request_test", "test_password" ), "a": { "n": "displayName", "_content": test_displayname } }, "urn:zimbraAdmin" ) if request_type == "xml": response = ResponseXml() else: response = ResponseJson() comm.send_request(request, response) if response.is_fault(): self.fail( "CreateAccount faulted. (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) account_id = response.get_response( )["CreateAccountResponse"]["account"]["id"] # Get account from database and compare display name to the setting request.clean() request.set_auth_token(token) response.clean() request.add_request( "GetAccountRequest", { "account": { "by": "name", "_content": test_account } }, "urn:zimbraAdmin" ) comm.send_request(request, response) if response.is_fault(): self.fail( "GetAccount faulted. (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) ) returned_name = get_value( response.get_response()["GetAccountResponse"]["account"]["a"], "displayName" ) self.assertEqual( returned_name, test_displayname, "Zimbra didn't save the display name as requested." ) # Try to log in as the new account user_token = authenticate( config.get("admin_request_test", "url"), test_account, config.get("admin_request_test", "test_password"), "name", request_type=request_type, use_password=True ) if user_token is None: self.fail("Cannot log in as the test user.") # Remove account request.clean() response.clean() request.set_auth_token(token) request.add_request( "DeleteAccountRequest", { "id": account_id }, "urn:zimbraAdmin" ) comm.send_request(request, response) if response.is_fault(): self.fail( "Cannot remove test account: (%s) %s" % ( response.get_fault_code(), response.get_fault_message() ) )
from unittest.mock import MagicMock from cache_alchemy import json_cache, memory_cache from tests import get_config redis_call_mock = MagicMock() config = get_config() @json_cache def json_test(): redis_call_mock() return "test" memory_call_mock = MagicMock() @memory_cache def memory_test(): memory_call_mock() return "test"
original_syslog_handler = logging.handlers.SysLogHandler def fake_syslog_handler(): for attr in dir(original_syslog_handler): if attr.startswith('LOG'): setattr(FakeLogger, attr, copy.copy(getattr(logging.handlers.SysLogHandler, attr))) FakeLogger.priority_map = \ copy.deepcopy(logging.handlers.SysLogHandler.priority_map) logging.handlers.SysLogHandler = FakeLogger if get_config('unit_test').get('fake_syslog', 'False').lower() in TRUE_VALUES: fake_syslog_handler() class MockTrue(object): """ Instances of MockTrue evaluate like True Any attr accessed on an instance of MockTrue will return a MockTrue instance. Any method called on an instance of MockTrue will return a MockTrue instance. >>> thing = MockTrue() >>> thing True >>> thing == True # True == True True