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
