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 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() )
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 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 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']
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", 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 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", "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()))