def setUp(self):
""" Generate a Response object and set our tested server result string
"""
self.response = ResponseXml()
self.response.set_response(self.tested_server_result)
self.response_multi = ResponseXml()
self.response_multi.set_response(self.tested_server_result_multi_value)
def request(self, name, data, urn):
comm = Communication(self.url)
account_request = RequestXml()
account_request.set_auth_token(self.getToken())
account_request.add_request(name, data, urn)
account_response = ResponseXml()
comm.send_request(account_request, account_response)
return account_response.get_response()
def setUp(self):
""" Generate a Response object and set our tested server result string
"""
self.response = ResponseXml()
self.response.set_response(self.tested_server_result)
self.response_multi = ResponseXml()
self.response_multi.set_response(self.tested_server_result_multi_value)
def request(self, request_name, params=None, context=None, urn=None, opts={}):
""" Send a single request to Zimbra; return the response as native python data. """
if 'xml' in opts and opts['xml']:
request, response = RequestXml(), ResponseXml()
else:
request, response = RequestJson(), ResponseJson()
try:
if urn == None:
urn = urn_for_request(request_name)
request.add_request(request_name, params or {}, "urn:"+urn)
if context:
request.set_context_params(context)
request.set_auth_token(self.token)
except:
log.exception("failed to build request: request_name=%s, params=%s, context=%s",
request_name, params, context)
return None
if opts['debug']:
if isinstance(request, RequestXml):
print xml.dom.minidom.parseString(request.get_request()).toprettyxml(indent=". ")
else:
pprint.pprint(yaml.load(request.get_request()))
try:
self.comm.send_request(request, response)
except urllib2.HTTPError as e:
requestbody = request.get_request()
responsebody = e.read()
log.error('''send_request HTTP Error %s: %s; request="%s" response="%s"''',
e.code, e.reason, requestbody, responsebody)
if isinstance(request, RequestXml):
requestdoc = xml.dom.minidom.parseString(requestbody)
print "REQUEST=", requestdoc.toprettyxml(indent=". ")
else:
print "REQUEST=\n", pprint.pformat(yaml.load(requestbody))
if isinstance(response, ResponseXml):
responsedoc = xml.dom.minidom.parseString(responsebody)
print "RESPONSE=", responsedoc.toprettyxml(indent=". ")
else:
print "RESPONSE=\n", pprint.pformat(yaml.load(responsebody))
return None
except Exception as e:
log.exception("send_request failed (%s): request=%s", type(e), request.get_request())
return None
if response.is_fault():
log.error("send_request returned fault: request=%s, response=%s",
request.get_request(), response.get_response())
return None
info = response.get_response()
return info
def test_fault_non_existing_folder_batch_xml(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 = RequestXml()
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 = ResponseXml()
comm.send_request(request, response)
self.check_response(
response
)
class TestResponseXml(TestCase):
""" Response class tests
"""
tested_server_result = '<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetVersionInfoResponse ' \
'xmlns="urn:zimbraAdmin"><info ' \
'platform="UBUNTU12_64" host="zre-ubuntu12-64" ' \
'minorversion="0" microversion="5" ' \
'buildDate="20130910-1244" type="NETWORK" ' \
'majorversion="8" release="20130910124124" ' \
'version="8.0.5_GA_5839' \
'.NETWORK"/></GetVersionInfoResponse></soap:Body' \
'></soap:Envelope>'
""" The result we test against (coming from a GetVersionInfoRequest by
running zmsoap -z --json -t admin GetVersionInfoRequest -vv) """
tested_server_result_multi_value = \
'<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetAllDomainsResponse> ' \
'<domain id="b37d6b9" name="client1.unbound.example.fr"></domain>' \
'<domain id="444d6b9" name="client1.unbound.example.fr"></domain>' \
'</GetAllDomainsResponse></soap:Body' \
'></soap:Envelope>'\
""" This one is a stripped version of a GetAlDomains """
response = None
""" Our response object """
def setUp(self):
""" Generate a Response object and set our tested server result string
"""
self.response = ResponseXml()
self.response.set_response(self.tested_server_result)
self.response_multi = ResponseXml()
self.response_multi.set_response(self.tested_server_result_multi_value)
def test_get_body(self):
""" Checks the body against a pickled expectation
"""
expected_result = "(dp0\nVsoap:Body\np1\n(" \
"dp2\nVGetVersionInfoResponse\np3\n(" \
"dp4\nVinfo\np5\n(" \
"dp6\nVmajorversion\np7\nV8\np8\nsVminorversion\np9" \
"\nV0\np10\nsVmicroversion\np11\nV5\np12" \
"\nsVplatform\np13\nVUBUNTU12_64\np14\nsVhost\np15" \
"\nVzre-ubuntu12-64\np16\nsVversion\np17\nV8.0" \
".5_GA_5839" \
".NETWORK\np18\nsVrelease\np19\nV20130910124124" \
"\np20\nsVtype\np21\nVNETWORK\np22\nsVbuildDate" \
"\np23\nV20130910-1244\np24\nssS'xmlns'\np25\nVurn" \
":zimbraAdmin\np26\nsss."
self.assertEqual(
expected_result,
pickle.dumps(self.response.get_body())
)
def test_get_header(self):
expected_result = "(dp0\nVsoap:Header\np1\n(dp2\nVcontext\np3\n(" \
"dp4\nS'xmlns'\np5\nVurn:zimbra\np6\nsss."
self.assertEqual(
expected_result,
pickle.dumps(self.response.get_header())
)
def test_is_batch(self):
self.assertFalse(
self.response.is_batch(),
"Is_Batch hasn't returned False, rather than %s" % (
str(self.response.is_batch())
)
)
def test_get_batch(self):
self.assertIsNone(
self.response.get_batch(),
"get_batch hasn't returned None"
)
def test_get_response(self):
expected_result = "(dp0\nVGetVersionInfoResponse\np1\n(" \
"dp2\nVinfo\np3\n(" \
"dp4\nVmajorversion\np5\nV8\np6\nsVminorversion\np7" \
"\nV0\np8\nsVmicroversion\np9\nV5\np10\nsVplatform" \
"\np11\nVUBUNTU12_64\np12\nsVhost\np13\nVzre" \
"-ubuntu12-64\np14\nsVversion\np15\nV8.0.5_GA_5839" \
".NETWORK\np16\nsVrelease\np17\nV20130910124124" \
"\np18\nsVtype\np19\nVNETWORK\np20\nsVbuildDate" \
"\np21\nV20130910-1244\np22\nssS'xmlns'\np23\nVurn" \
":zimbraAdmin\np24\nss."
self.assertEqual(
expected_result,
pickle.dumps(self.response.get_response())
)
def test_get_response_multi(self):
""" For cases where we have several tags with the same name.
In that case, for a given tag name as a key, we want a list of dicts
containing the content of each tag, instead of a single dict.
"""
resp = self.response_multi.get_response()
gad_resp = resp['GetAllDomainsResponse']
self.assertTrue(gad_resp.has_key('domain'))
self.assertTrue(gad_resp['domain'])
self.assertIsInstance(gad_resp['domain'], list)
self.assertEqual(len(gad_resp['domain']), 2)
def authenticate(url,
account,
key,
by='name',
expires=0,
timestamp=None,
timeout=None,
request_type="xml",
admin_auth=False,
use_password=False,
raise_on_error=False):
""" Authenticate to the Zimbra server
:param url: URL of Zimbra SOAP service
:param account: The account to be authenticated against
:param key: The preauth key of the domain of the account or a password (if
admin_auth or use_password is True)
:param by: If the account is specified as a name, an ID or a
ForeignPrincipal
:param expires: When the token expires (or 0 for default expiration)
:param timestamp: When the token was requested (None for "now")
:param timeout: Timeout for the communication with the server. Defaults
to the urllib2-default
:param request_type: Which type of request to use ("xml" (default) or
"json")
:param admin_auth: This request should authenticate and generate an admin
token. The "key"-parameter therefore holds the admin password (implies
use_password)
:param use_password: The "key"-parameter holds a password. Do a password-
based user authentication.
:param raise_on_error: Should I raise an exception when an authentication
error occurs or just return None?
:return: The authentication token or None
:rtype: str or None or unicode
"""
if timestamp is None:
timestamp = int(time.time()) * 1000
pak = ""
if not admin_auth:
pak = preauth.create_preauth(account, key, by, expires, timestamp)
if request_type == 'xml':
auth_request = RequestXml()
else:
auth_request = RequestJson()
request_data = {'account': {'by': by, '_content': account}}
ns = "urn:zimbraAccount"
if admin_auth:
ns = "urn:zimbraAdmin"
request_data['password'] = key
elif use_password:
request_data['password'] = {"_content": key}
else:
request_data['preauth'] = {
'timestamp': timestamp,
'expires': expires,
'_content': pak
}
auth_request.add_request('AuthRequest', request_data, ns)
server = Communication(url, timeout)
if request_type == 'xml':
response = ResponseXml()
else:
response = ResponseJson()
server.send_request(auth_request, response)
if response.is_fault():
if raise_on_error:
raise AuthenticationFailed(
"Cannot authenticate user: (%s) %s" %
(response.get_fault_code(), response.get_fault_message()))
return None
return response.get_response()['AuthResponse']['authToken']['_content']
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()
)
)
def send_request(self, request, response=None):
""" Send the request.
Sends the request and retrieves the results, formats them and returns
them in a dict or a list (when it's a batchresponse). If something
goes wrong, raises a SoapFailure or a HTTPError on system-side
failures. Note: AuthRequest raises an HTTPError on failed
authentications!
:param request: The request to send
:type request: pythonzimbra.request.Request
:param response: A prebuilt response object
:type response: pythonzimbra.response.Response
:raises: pythonzimbra.exceptions.communication.SoapFailure or
urllib2.HTTPError
"""
local_response = None
if response is None:
if request.request_type == "json":
local_response = ResponseJson()
elif request.request_type == "xml":
local_response = ResponseXml()
else:
raise UnknownRequestType()
try:
server_request = ur.urlopen(self.url,
request.get_request().encode("utf-8"),
self.timeout)
server_response = server_request.read()
if isinstance(server_response, bytes):
server_response = server_response.decode("utf-8")
if response is None:
local_response.set_response(server_response)
else:
response.set_response(server_response)
except ue.HTTPError as e:
if e.code == 500:
# 500 codes normally returns a SoapFault, that we can use
server_response = e.fp.read()
if isinstance(server_response, bytes):
server_response = server_response.decode("utf-8")
if response is None:
local_response.set_response(server_response)
else:
response.set_response(server_response)
else:
raise e
if response is None:
return local_response
class TestResponseXml(TestCase):
""" Response class tests
"""
tested_server_result = '<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetVersionInfoResponse ' \
'xmlns="urn:zimbraAdmin"><info ' \
'platform="UBUNTU12_64" host="zre-ubuntu12-64" ' \
'minorversion="0" microversion="5" ' \
'buildDate="20130910-1244" type="NETWORK" ' \
'majorversion="8" release="20130910124124" ' \
'version="8.0.5_GA_5839' \
'.NETWORK"/></GetVersionInfoResponse></soap:Body' \
'></soap:Envelope>'
""" The result we test against (coming from a GetVersionInfoRequest by
running zmsoap -z --json -t admin GetVersionInfoRequest -vv) """
tested_server_result_multi_value = \
'<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetAllDomainsResponse> ' \
'<domain id="b37d6b9" name="client1.unbound.example.fr"></domain>' \
'<domain id="444d6b9" name="client1.unbound.example.fr"></domain>' \
'</GetAllDomainsResponse></soap:Body' \
'></soap:Envelope>'\
""" This one is a stripped version of a GetAlDomains """
response = None
""" Our response object """
def setUp(self):
""" Generate a Response object and set our tested server result string
"""
self.response = ResponseXml()
self.response.set_response(self.tested_server_result)
self.response_multi = ResponseXml()
self.response_multi.set_response(self.tested_server_result_multi_value)
def test_get_body(self):
""" Checks the body against a pickled expectation
"""
expected_result = "(dp0\nVBody\np1\n(" \
"dp2\nVGetVersionInfoResponse\np3\n(" \
"dp4\nVinfo\np5\n(" \
"dp6\nVmajorversion\np7\nV8\np8\nsVminorversion\np9" \
"\nV0\np10\nsVmicroversion\np11\nV5\np12" \
"\nsVplatform\np13\nVUBUNTU12_64\np14\nsVhost\np15" \
"\nVzre-ubuntu12-64\np16\nsVversion\np17\nV8.0" \
".5_GA_5839.NETWORK\np18\nsVrelease\np19" \
"\nV20130910124124\np20\nsVtype\np21\nVNETWORK\np22" \
"\nsVbuildDate\np23\nV20130910-1244\np24\nssS" \
"'xmlns'\np25\nVurn:zimbraAdmin\np26\nsss."
self.assertEqual(expected_result,
pickle.dumps(self.response.get_body()))
def test_get_header(self):
expected_result = "(dp0\nVHeader\np1\n(dp2\nVcontext\np3\n(" \
"dp4\nS'xmlns'\np5\nVurn:zimbra\np6\nsss."
self.assertEqual(expected_result,
pickle.dumps(self.response.get_header()))
def test_is_batch(self):
self.assertFalse(
self.response.is_batch(),
"Is_Batch hasn't returned False, rather than %s" %
(str(self.response.is_batch())))
def test_get_batch(self):
self.assertIsNone(self.response.get_batch(),
"get_batch hasn't returned None")
def test_get_response(self):
expected_result = "(dp0\nVGetVersionInfoResponse\np1\n(" \
"dp2\nVinfo\np3\n(" \
"dp4\nVmajorversion\np5\nV8\np6\nsVminorversion\np7" \
"\nV0\np8\nsVmicroversion\np9\nV5\np10\nsVplatform" \
"\np11\nVUBUNTU12_64\np12\nsVhost\np13\nVzre" \
"-ubuntu12-64\np14\nsVversion\np15\nV8.0.5_GA_5839" \
".NETWORK\np16\nsVrelease\np17\nV20130910124124" \
"\np18\nsVtype\np19\nVNETWORK\np20\nsVbuildDate" \
"\np21\nV20130910-1244\np22\nssS'xmlns'\np23\nVurn" \
":zimbraAdmin\np24\nss."
self.assertEqual(expected_result,
pickle.dumps(self.response.get_response()))
def test_get_response_multi(self):
""" For cases where we have several tags with the same name.
In that case, for a given tag name as a key, we want a list of dicts
containing the content of each tag, instead of a single dict.
"""
resp = self.response_multi.get_response()
gad_resp = resp['GetAllDomainsResponse']
self.assertTrue(gad_resp.has_key('domain'))
self.assertTrue(gad_resp['domain'])
self.assertIsInstance(gad_resp['domain'], list)
self.assertEqual(len(gad_resp['domain']), 2)
def authenticate(url, account, key, by='name', expires=0, timestamp=None,
timeout=None, request_type="xml"):
""" Authenticate to the Zimbra server
:param url: URL of Zimbra SOAP service
:param account: The account to be authenticated against
:param key: The preauth key of the domain of the account
:param by: If the account is specified as a name, an ID or a
ForeignPrincipal
:param expires: When the token expires (or 0 for default expiration)
:param timestamp: When the token was requested (None for "now")
:param timeout: Timeout for the communication with the server. Defaults
to the urllib2-default
:return: The authentication token
:rtype: str or None or unicode
"""
if timestamp is None:
timestamp = int(datetime.now().strftime("%s")) * 1000
pak = preauth.create_preauth(account, key, by, expires, timestamp)
if request_type == 'xml':
auth_request = RequestXml()
else:
auth_request = RequestJson()
auth_request.add_request(
'AuthRequest',
{
'account': {
'by': by,
'_content': account
},
'preauth': {
'timestamp': timestamp,
'expires': expires,
'_content': pak
}
},
'urn:zimbraAccount'
)
server = Communication(url, timeout)
if request_type == 'xml':
response = ResponseXml()
else:
response = ResponseJson()
try:
server.send_request(auth_request, response)
except HTTPError:
# A HTTPError (which is an AuthError in most cases) occured. Simply
# return nothing
return None
return response.get_response()['AuthResponse']['authToken']['_content']
class TestResponseXml(TestCase):
""" Response class tests
"""
tested_server_result = (
'<soap:Envelope xmlns:soap="http://www.w3'
'.org/2003/05/soap-envelope"><soap:Header><context'
' xmlns="urn:zimbra"/></soap:Header><soap:Body'
"><GetVersionInfoResponse "
'xmlns="urn:zimbraAdmin"><info '
'platform="UBUNTU12_64" host="zre-ubuntu12-64" '
'minorversion="0" microversion="5" '
'buildDate="20130910-1244" type="NETWORK" '
'majorversion="8" release="20130910124124" '
'version="8.0.5_GA_5839'
'.NETWORK"/></GetVersionInfoResponse></soap:Body'
"></soap:Envelope>"
)
""" The result we test against (coming from a GetVersionInfoRequest by
running zmsoap -z --json -t admin GetVersionInfoRequest -vv) """
response = None
""" Our response object """
def setUp(self):
""" Generate a Response object and set our tested server result string
"""
self.response = ResponseXml()
self.response.set_response(self.tested_server_result)
def test_get_body(self):
""" Checks the body against a pickled expectation
"""
expected_result = (
"(dp0\nVsoap:Body\np1\n("
"dp2\nVGetVersionInfoResponse\np3\n("
"dp4\nVinfo\np5\n("
"dp6\nVmajorversion\np7\nV8\np8\nsVminorversion\np9"
"\nV0\np10\nsVmicroversion\np11\nV5\np12"
"\nsVplatform\np13\nVUBUNTU12_64\np14\nsVhost\np15"
"\nVzre-ubuntu12-64\np16\nsVversion\np17\nV8.0"
".5_GA_5839"
".NETWORK\np18\nsVrelease\np19\nV20130910124124"
"\np20\nsVtype\np21\nVNETWORK\np22\nsVbuildDate"
"\np23\nV20130910-1244\np24\nssS'xmlns'\np25\nVurn"
":zimbraAdmin\np26\nsss."
)
self.assertEqual(expected_result, pickle.dumps(self.response.get_body()))
def test_get_header(self):
expected_result = "(dp0\nVsoap:Header\np1\n(dp2\nVcontext\np3\n(" "dp4\nS'xmlns'\np5\nVurn:zimbra\np6\nsss."
self.assertEqual(expected_result, pickle.dumps(self.response.get_header()))
def test_is_batch(self):
self.assertFalse(
self.response.is_batch(), "Is_Batch hasn't returned False, rather than %s" % (str(self.response.is_batch()))
)
def test_get_batch(self):
self.assertIsNone(self.response.get_batch(), "get_batch hasn't returned None")
def test_get_response(self):
expected_result = (
"(dp0\nVGetVersionInfoResponse\np1\n("
"dp2\nVinfo\np3\n("
"dp4\nVmajorversion\np5\nV8\np6\nsVminorversion\np7"
"\nV0\np8\nsVmicroversion\np9\nV5\np10\nsVplatform"
"\np11\nVUBUNTU12_64\np12\nsVhost\np13\nVzre"
"-ubuntu12-64\np14\nsVversion\np15\nV8.0.5_GA_5839"
".NETWORK\np16\nsVrelease\np17\nV20130910124124"
"\np18\nsVtype\np19\nVNETWORK\np20\nsVbuildDate"
"\np21\nV20130910-1244\np22\nssS'xmlns'\np23\nVurn"
":zimbraAdmin\np24\nss."
)
self.assertEqual(expected_result, pickle.dumps(self.response.get_response()))
class TestResponseXml(TestCase):
""" Response class tests
"""
tested_server_result = '<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetVersionInfoResponse ' \
'xmlns="urn:zimbraAdmin"><info ' \
'platform="UBUNTU12_64" host="zre-ubuntu12-64" ' \
'minorversion="0" microversion="5" ' \
'buildDate="20130910-1244" type="NETWORK" ' \
'majorversion="8" release="20130910124124" ' \
'version="8.0.5_GA_5839' \
'.NETWORK"/></GetVersionInfoResponse></soap:Body' \
'></soap:Envelope>'
""" The result we test against (coming from a GetVersionInfoRequest by
running zmsoap -z --json -t admin GetVersionInfoRequest -vv) """
tested_server_result_multi_value = \
'<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetAllDomainsResponse> ' \
'<domain id="b37d6b9" name="client1.unbound.example.fr"></domain>' \
'<domain id="444d6b9" name="client1.unbound.example.fr"></domain>' \
'</GetAllDomainsResponse></soap:Body' \
'></soap:Envelope>'\
""" This one is a stripped version of a GetAlDomains """
response = None
""" Our response object """
def setUp(self):
""" Generate a Response object and set our tested server result string
"""
self.response = ResponseXml()
self.response.set_response(self.tested_server_result)
self.response_multi = ResponseXml()
self.response_multi.set_response(self.tested_server_result_multi_value)
def test_get_body(self):
""" Checks the body against a pickled expectation
"""
expected_result = {
"GetVersionInfoResponse": {
"info": {
"majorversion": "8",
"buildDate": "20130910-1244",
"microversion": "5",
"platform": "UBUNTU12_64",
"host": "zre-ubuntu12-64",
"version": "8.0.5_GA_5839.NETWORK",
"release": "20130910124124",
"type": "NETWORK",
"minorversion": "0"
}
}
}
self.assertEqual(expected_result, self.response.get_body())
def test_get_header(self):
expected_result = {"context": {}}
self.assertEqual(expected_result, self.response.get_header())
def test_is_batch(self):
self.assertFalse(
self.response.is_batch(),
"Is_Batch hasn't returned False, rather than %s" %
(str(self.response.is_batch())))
def test_get_batch(self):
self.assertIsNone(self.response.get_batch(),
"get_batch hasn't returned None")
def test_get_response(self):
expected_result = {
"GetVersionInfoResponse": {
"info": {
"majorversion": "8",
"buildDate": "20130910-1244",
"microversion": "5",
"platform": "UBUNTU12_64",
"host": "zre-ubuntu12-64",
"version": "8.0.5_GA_5839.NETWORK",
"release": "20130910124124",
"type": "NETWORK",
"minorversion": "0"
}
}
}
self.assertEqual(expected_result, self.response.get_response())
def test_get_response_multi(self):
""" For cases where we have several tags with the same name.
In that case, for a given tag name as a key, we want a list of dicts
containing the content of each tag, instead of a single dict.
"""
resp = self.response_multi.get_response()
gad_resp = resp['GetAllDomainsResponse']
self.assertTrue('domain' in gad_resp)
self.assertTrue(gad_resp['domain'])
self.assertIsInstance(gad_resp['domain'], list)
self.assertEqual(len(gad_resp['domain']), 2)
class TestResponseXml(TestCase):
""" Response class tests
"""
tested_server_result = '<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetVersionInfoResponse ' \
'xmlns="urn:zimbraAdmin"><info ' \
'platform="UBUNTU12_64" host="zre-ubuntu12-64" ' \
'minorversion="0" microversion="5" ' \
'buildDate="20130910-1244" type="NETWORK" ' \
'majorversion="8" release="20130910124124" ' \
'version="8.0.5_GA_5839' \
'.NETWORK"/></GetVersionInfoResponse></soap:Body' \
'></soap:Envelope>'
""" The result we test against (coming from a GetVersionInfoRequest by
running zmsoap -z --json -t admin GetVersionInfoRequest -vv) """
tested_server_result_multi_value = \
'<soap:Envelope xmlns:soap="http://www.w3' \
'.org/2003/05/soap-envelope"><soap:Header><context' \
' xmlns="urn:zimbra"/></soap:Header><soap:Body' \
'><GetAllDomainsResponse> ' \
'<domain id="b37d6b9" name="client1.unbound.example.fr"></domain>' \
'<domain id="444d6b9" name="client1.unbound.example.fr"></domain>' \
'</GetAllDomainsResponse></soap:Body' \
'></soap:Envelope>'\
""" This one is a stripped version of a GetAlDomains """
response = None
""" Our response object """
def setUp(self):
""" Generate a Response object and set our tested server result string
"""
self.response = ResponseXml()
self.response.set_response(self.tested_server_result)
self.response_multi = ResponseXml()
self.response_multi.set_response(self.tested_server_result_multi_value)
def test_get_body(self):
""" Checks the body against a pickled expectation
"""
expected_result = {
"GetVersionInfoResponse": {
"info": {
"majorversion": "8",
"buildDate": "20130910-1244",
"microversion": "5",
"platform": "UBUNTU12_64",
"host": "zre-ubuntu12-64",
"version": "8.0.5_GA_5839.NETWORK",
"release": "20130910124124",
"type": "NETWORK",
"minorversion": "0"
}
}
}
self.assertEqual(
expected_result,
self.response.get_body()
)
def test_get_header(self):
expected_result = {
"context": {
}
}
self.assertEqual(
expected_result,
self.response.get_header()
)
def test_is_batch(self):
self.assertFalse(
self.response.is_batch(),
"Is_Batch hasn't returned False, rather than %s" % (
str(self.response.is_batch())
)
)
def test_get_batch(self):
self.assertIsNone(
self.response.get_batch(),
"get_batch hasn't returned None"
)
def test_get_response(self):
expected_result = {
"GetVersionInfoResponse": {
"info": {
"majorversion": "8",
"buildDate": "20130910-1244",
"microversion": "5",
"platform": "UBUNTU12_64",
"host": "zre-ubuntu12-64",
"version": "8.0.5_GA_5839.NETWORK",
"release": "20130910124124",
"type": "NETWORK",
"minorversion": "0"
}
}
}
self.assertEqual(
expected_result,
self.response.get_response()
)
def test_get_response_multi(self):
""" For cases where we have several tags with the same name.
In that case, for a given tag name as a key, we want a list of dicts
containing the content of each tag, instead of a single dict.
"""
resp = self.response_multi.get_response()
gad_resp = resp['GetAllDomainsResponse']
self.assertTrue('domain' in gad_resp)
self.assertTrue(gad_resp['domain'])
self.assertIsInstance(gad_resp['domain'], list)
self.assertEqual(len(gad_resp['domain']), 2)
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()
)
def authenticate(url, account, key, by='name', expires=0, timestamp=None,
timeout=None, request_type="xml", admin_auth=False,
use_password=False, raise_on_error=False):
""" Authenticate to the Zimbra server
:param url: URL of Zimbra SOAP service
:param account: The account to be authenticated against
:param key: The preauth key of the domain of the account or a password (if
admin_auth or use_password is True)
:param by: If the account is specified as a name, an ID or a
ForeignPrincipal
:param expires: When the token expires (or 0 for default expiration)
:param timestamp: When the token was requested (None for "now")
:param timeout: Timeout for the communication with the server. Defaults
to the urllib2-default
:param request_type: Which type of request to use ("xml" (default) or
"json")
:param admin_auth: This request should authenticate and generate an admin
token. The "key"-parameter therefore holds the admin password (implies
use_password)
:param use_password: The "key"-parameter holds a password. Do a password-
based user authentication.
:param raise_on_error: Should I raise an exception when an authentication
error occurs or just return None?
:return: The authentication token or None
:rtype: str or None or unicode
"""
if timestamp is None:
timestamp = int(time.time()) * 1000
pak = ""
if not admin_auth:
pak = preauth.create_preauth(account, key, by, expires, timestamp)
if request_type == 'xml':
auth_request = RequestXml()
else:
auth_request = RequestJson()
request_data = {
'account': {
'by': by,
'_content': account
}
}
ns = "urn:zimbraAccount"
if admin_auth:
ns = "urn:zimbraAdmin"
request_data['password'] = key
elif use_password:
request_data['password'] = {
"_content": key
}
else:
request_data['preauth'] = {
'timestamp': timestamp,
'expires': expires,
'_content': pak
}
auth_request.add_request(
'AuthRequest',
request_data,
ns
)
server = Communication(url, timeout)
if request_type == 'xml':
response = ResponseXml()
else:
response = ResponseJson()
server.send_request(auth_request, response)
if response.is_fault():
if raise_on_error:
raise AuthenticationFailed(
"Cannot authenticate user: (%s) %s" % (
response.get_fault_code(),
response.get_fault_message()
)
)
return None
return response.get_response()['AuthResponse']['authToken']
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()))
