private ItemType[] HandleGetItemResponse(BaseResponseMessageType response) { ResponseMessageType[] array = this.HandleBaseResponseMessage(response); if (array == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetItem returned NULL responseType."); return(null); } List <ItemType> list = new List <ItemType>(); foreach (ResponseMessageType responseMessageType in array) { if (responseMessageType.ResponseCode != ResponseCodeType.NoError) { Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseMessageType.ResponseCode); } else { ItemInfoResponseMessageType itemInfoResponseMessageType = responseMessageType as ItemInfoResponseMessageType; if (itemInfoResponseMessageType == null || itemInfoResponseMessageType.Items == null || itemInfoResponseMessageType.Items.Items == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetItem web request returned NULL ItemType."); } else { list.AddRange(itemInfoResponseMessageType.Items.Items); } } } return(list.ToArray()); }
/// <summary> /// Verify the UploadItemsResponseType related requirements when UploadItems executes unsuccessfully. /// </summary> /// <param name="uploadItemsResponse">The UploadItemsResponseType instance returned from the server.</param> protected void VerifyUploadItemsErrorResponse(BaseResponseMessageType uploadItemsResponse) { foreach (UploadItemsResponseMessageType responseMessage in uploadItemsResponse.ResponseMessages.Items) { // If the UploadItems operation is unsuccessful, the ResponseClass should be set to "Error", then requirement MS-OXWSBTRF_R2009 can be captured. // Add debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2009"); // Verify requirement: MS-OXWSBTRF_R2009. Site.CaptureRequirementIfAreEqual <ResponseClassType>( ResponseClassType.Error, responseMessage.ResponseClass, 2009, @"[In tns:UploadItemsSoapOut Message] If the request [UploadItems request] is unsuccessful, the UploadItems operation returns an UploadItemsResponse element with the ResponseClass attribute of the UploadItemsResponseMessage element set to ""Error""."); // If the ResponseCode is correspond to the schema, the ResponseCode should be a value of the ResponseCodeType simple type, then requirement MS-OXWSBTRF_R2010 can be captured. // Add debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2010"); // Verify requirement: MS-OXWSBTRF_R2010 Site.CaptureRequirementIfIsTrue( this.IsSchemaValidated, 2010, @"[In tns:UploadItemsSoapOut Message][If the request UploadItems request is unsuccessful]The ResponseCode element of the UploadItemsResponseMessage element is set to a value of the ResponseCodeType simple type, as specified in [MS-OXWSCDATA] section 2.2.5.24."); } }
/// <summary> /// Verify whether the response is a valid response message and extract the ResponseClass and ResponseCode. /// </summary> /// <param name="baseResponseMessage">The response message.</param> private void VerifyResponseMessage(BaseResponseMessageType baseResponseMessage) { this.InitializeCollections(); Site.Assert.IsNotNull(baseResponseMessage, @"The response should not be null."); Site.Assert.IsNotNull(baseResponseMessage.ResponseMessages, @"The ResponseMessages in response should not be null."); Site.Assert.IsNotNull(baseResponseMessage.ResponseMessages.Items, @"The items of ResponseMessages in response should not be null."); Site.Assert.IsTrue(baseResponseMessage.ResponseMessages.Items.Length > 0, @"The items of ResponseMessages in response should not be null."); int messageCount = baseResponseMessage.ResponseMessages.Items.Length; for (int i = 0; i < messageCount; i++) { ResponseMessageType responseMessage = baseResponseMessage.ResponseMessages.Items[i]; this.ResponseClass.Add(responseMessage.ResponseClass); if (responseMessage.ResponseCodeSpecified) { this.responseCode.Add(responseMessage.ResponseCode); } if (responseMessage.ResponseClass == ResponseClassType.Success && !(baseResponseMessage is DeleteItemResponseType)) { ItemInfoResponseMessageType itemInfo = responseMessage as ItemInfoResponseMessageType; Site.Assert.IsNotNull(itemInfo.Items, @"The items of ResponseMessages in response should not be null."); Site.Assert.IsNotNull(itemInfo.Items.Items, @"The task items in response should not be null."); Site.Assert.IsTrue(itemInfo.Items.Items.Length > 0, @"There is one task item at least in response."); foreach (ItemType item in itemInfo.Items.Items) { Site.Assert.IsNotNull(item.ItemId, @"The task item id in response should not be null."); } } } }
/// <summary> /// Handle the server response. /// </summary> /// <param name="request">The request messages.</param> /// <param name="response">The response messages.</param> /// <param name="isSchemaValidated">Whether the schema is validated.</param> protected void ExchangeServiceBinding_ResponseEvent( BaseRequestType request, BaseResponseMessageType response, bool isSchemaValidated) { this.IsSchemaValidated = isSchemaValidated; }
/// <summary> /// Get the items' id and change key from successful response. /// </summary> /// <param name="response">Response message from server.</param> /// <returns>Item ids contained in response.</returns> public static ItemIdType[] GetItemIdsFromInfoResponse(BaseResponseMessageType response) { ArrayList arrayOfItems = new ArrayList(); ArrayOfResponseMessagesType responseMessages = response.ResponseMessages; foreach (ResponseMessageType responseMessage in responseMessages.Items) { if (responseMessage.ResponseCode != ResponseCodeType.NoError || responseMessage.ResponseClass != ResponseClassType.Success) { continue; } ItemInfoResponseMessageType itemInfoResponseMessage = responseMessage as ItemInfoResponseMessageType; ArrayOfRealItemsType arrayOfRealItemsType = itemInfoResponseMessage.Items; if (arrayOfRealItemsType.Items == null) { continue; } foreach (ItemType tempItem in arrayOfRealItemsType.Items) { arrayOfItems.Add(tempItem.ItemId); } } return((ItemIdType[])arrayOfItems.ToArray(typeof(ItemIdType))); }
/// <summary> /// Verify the response returned by server when the operating multiple items. /// </summary> /// <param name="response">A response returned by server.</param> /// <returns>The validation result.</returns> protected bool VerifyMultipleResponse(BaseResponseMessageType response) { bool isValidResponse = false; if (response != null && response.ResponseMessages != null && response.ResponseMessages.Items != null && response.ResponseMessages.Items.Length > 0) { Site.Assert.AreEqual <int>(2, response.ResponseMessages.Items.Length, "There should be two Items elements in the operation response because this case only design for operate two items"); bool isValidFirstItemsofResponse = string.Equals(response.ResponseMessages.Items[0].ResponseClass.ToString(), "Success", System.StringComparison.CurrentCultureIgnoreCase); if (!isValidFirstItemsofResponse) { Site.Assert.Fail("The operation failed with response code '{0}'", response.ResponseMessages.Items[0].ResponseCode.ToString()); } bool isValidSecondItemsofResponse = string.Equals(response.ResponseMessages.Items[1].ResponseClass.ToString(), "Success", System.StringComparison.CurrentCultureIgnoreCase); if (!isValidSecondItemsofResponse) { Site.Assert.Fail("The operation failed with response code '{0}'", response.ResponseMessages.Items[1].ResponseCode.ToString()); } isValidResponse = isValidFirstItemsofResponse && isValidSecondItemsofResponse; } return(isValidResponse); }
/// <summary> /// Get the items from successful response. /// </summary> /// <typeparam name="T">The type of item</typeparam> /// <param name="response">Response message from server.</param> /// <returns>Items contained in response.</returns> public static T[] GetItemsFromInfoResponse <T>(BaseResponseMessageType response) where T : ItemType, new() { T itemReturnedByServer = null; ArrayList arrayOfItems = new ArrayList(); ArrayOfResponseMessagesType responseMessages = response.ResponseMessages; foreach (ResponseMessageType responseMessage in responseMessages.Items) { if (responseMessage.ResponseCode != ResponseCodeType.NoError || responseMessage.ResponseClass != ResponseClassType.Success) { continue; } ItemInfoResponseMessageType itemRet = responseMessage as ItemInfoResponseMessageType; ArrayOfRealItemsType aorit = itemRet.Items; if (aorit.Items == null) { continue; } foreach (ItemType tempItem in aorit.Items) { itemReturnedByServer = tempItem as T; arrayOfItems.Add(itemReturnedByServer); } } return((T[])arrayOfItems.ToArray(typeof(T))); }
private ResponseMessageType[] ExecuteWebMethod(Func<BaseResponseMessageType> webMethodDelegate) { ExchangeService.Tracer.TraceDebug<ExchangeService, string>((long)this.GetHashCode(), "{0}: calling {1}", this, webMethodDelegate.Method.Name); BaseResponseMessageType response = null; int num = 0; for (;;) { Exception exception = null; try { GrayException.MapAndReportGrayExceptions(delegate() { ExchangeService.Tracer.TraceDebug<string>((long)this.GetHashCode(), "Calling {0}", webMethodDelegate.Method.Name); try { response = webMethodDelegate(); } catch (SoapException exception) { SoapException exception = exception; } catch (WebException exception2) { SoapException exception = exception2; } catch (IOException exception3) { SoapException exception = exception3; } catch (InvalidOperationException exception4) { SoapException exception = exception4; } }); } catch (GrayException ex) { ExchangeService.Tracer.TraceError<ExchangeService, string, GrayException>((long)this.GetHashCode(), "{0}: Failed request {1} with gray exception {2}", this, webMethodDelegate.Method.Name, ex); throw new UnexpectedRemoteDataException(ex); } if (exception == null) { goto IL_10A; } ExchangeService.Tracer.TraceError<ExchangeService, string, Exception>((long)this.GetHashCode(), "{0}: failed request {1} with exception {2}", this, webMethodDelegate.Method.Name, exception); if (num >= 3 || HttpWebRequestExceptionHandler.IsConnectionException(exception, ExchangeService.Tracer)) { break; } num++; } throw new FailedCommunicationException(CS$<>8__locals2.exception); IL_10A: if (response == null || response.ResponseMessages == null || response.ResponseMessages.Items == null || response.ResponseMessages.Items.Length == 0) { ExchangeService.Tracer.TraceError<ExchangeService, string>((long)this.GetHashCode(), "{0}: received empty response from request {1}", this, webMethodDelegate.Method.Name); throw new UnexpectedRemoteDataException(); } return response.ResponseMessages.Items; }
/// <summary> /// Verify the UploadItemsResponseType related requirements when UploadItems operation executes successfully. /// </summary> /// <param name="uploadItemsResponse">The UploadItemsResponseType instance returned from the server.</param> protected void VerifyUploadItemsSuccessResponse(BaseResponseMessageType uploadItemsResponse) { foreach (UploadItemsResponseMessageType responseMessage in uploadItemsResponse.ResponseMessages.Items) { Site.Assert.IsNotNull(responseMessage, "The response got from server should not be null."); // If the length of items in UploadItems response is equal to this.ItemCount, and uploaded Items' subject are the same as created items' subject then requirement MS-OXWSBTRF_R207 can be captured. Site.Assert.AreEqual <int>(uploadItemsResponse.ResponseMessages.Items.Length, this.ItemCount, "The count of uploaded items should be the same as the count of created items"); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2007."); // Verify requirement: MS-OXWSBTRF_R2007 Site.CaptureRequirementIfAreEqual <ResponseClassType>( ResponseClassType.Success, responseMessage.ResponseClass, 2007, @"[In tns:UploadItemsSoapOut Message]If the request [UploadItems request] is successful, the UploadItems operation returns an UploadItemsResponse element with the ResponseClass attribute of the UploadItemsResponseMessage element set to ""Success""."); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2008."); // Verify requirement: MS-OXWSBTRF_R2008 Site.CaptureRequirementIfAreEqual <ResponseCodeType>( ResponseCodeType.NoError, responseMessage.ResponseCode, 2008, @"[In tns:UploadItemsSoapOut Message][If the UploadItems request is successful] The ResponseCode element of the UploadItemsResponseMessage element is set to ""NoError""."); } }
private UserConfigurationType HandleGetUserConfigurationResponse(BaseResponseMessageType response, out bool itemNotFound) { itemNotFound = false; ResponseMessageType responseMessageType = this.HandleBaseResponseMessage(response); if (responseMessageType == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetUserConfiguration returned NULL responseType."); return(null); } if (responseMessageType.ResponseCode == ResponseCodeType.ErrorItemNotFound) { itemNotFound = true; return(null); } if (responseMessageType.ResponseCode != ResponseCodeType.NoError) { Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseMessageType.ResponseCode); return(null); } GetUserConfigurationResponseMessageType getUserConfigurationResponseMessageType = responseMessageType as GetUserConfigurationResponseMessageType; if (getUserConfigurationResponseMessageType == null || getUserConfigurationResponseMessageType.UserConfiguration == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetUserConfiguration web request returned NULL UserConfiguration."); return(null); } return(getUserConfigurationResponseMessageType.UserConfiguration); }
private ItemType[] HandleGetItemResponse(BaseResponseMessageType response) { ResponseMessageType responseMessageType = this.HandleBaseResponseMessage(response); ItemInfoResponseMessageType itemInfoResponseMessageType = responseMessageType as ItemInfoResponseMessageType; if (itemInfoResponseMessageType == null || itemInfoResponseMessageType.Items == null || itemInfoResponseMessageType.Items.Items == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "GetItem web request returned NULL ItemType."); return(null); } return(itemInfoResponseMessageType.Items.Items); }
/// <summary> /// Get items in ResponseMessages. /// </summary> /// <typeparam name="T">An enumerator type.</typeparam> /// <param name="response">A web service call response.</param> /// <returns>An array instance of the specified ResponseMessageType items.</returns> public static T[] GetResponseMessages <T>(BaseResponseMessageType response) where T : ResponseMessageType { T[] responseMessages = new T[response.ResponseMessages.Items.Length]; for (int i = 0; i < response.ResponseMessages.Items.Length; i++) { // Get the uploaded ExportItemsResponseMessageType items responseMessages[i] = (T)response.ResponseMessages.Items[i]; } return(responseMessages); }
/// <summary> /// Parses items in ResponseMessages /// </summary> /// <typeparam name="T">the type of the items.</typeparam> /// <param name="response">a web service call Response</param> /// <returns>An array instance of the specified ResponseMessageType</returns> public static T[] ParseResponse <T>(BaseResponseMessageType response) where T : ResponseMessageType { T[] responseMessage; responseMessage = new T[response.ResponseMessages.Items.Length]; for (int i = 0; i < responseMessage.Length; i++) { responseMessage[i] = response.ResponseMessages.Items[i] as T; } return(responseMessage); }
private ResponseMessageType[] HandleBaseResponseMessage(BaseResponseMessageType response) { if (response.ResponseMessages == null || response.ResponseMessages.Items == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "Web request returned NULL ResponseMessages."); return(null); } ResponseMessageType[] items = response.ResponseMessages.Items; if (items == null || items.Length < 1) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "Web request returned NULL ResponseMessageType."); return(null); } return(items); }
/// <summary> /// Verify the validation of a response returned by server. /// </summary> /// <param name="response">A response returned by server.</param> /// <returns>The validation result.</returns> protected bool VerifyResponse(BaseResponseMessageType response) { bool isValidResponse = false; if (response != null && response.ResponseMessages != null && response.ResponseMessages.Items != null && response.ResponseMessages.Items.Length > 0 && response.ResponseMessages.Items[0] != null) { isValidResponse = string.Equals(response.ResponseMessages.Items[0].ResponseClass.ToString(), "Success", StringComparison.CurrentCultureIgnoreCase); if (!isValidResponse && response.ResponseMessages.Items[0].ResponseCodeSpecified) { Site.Assert.Fail("The operation failed with response code '{0}'", response.ResponseMessages.Items[0].ResponseCode.ToString()); } } return(isValidResponse); }
/// <summary> /// Check the response and the count of items in ResponseMessages. /// </summary> /// <param name="response">The response of a operation.</param> /// <param name="expectedItemCount">The count of expected items in ResponseMessages.</param> /// <param name="site">An instance of interface ITestSite which provides logging, assertions, and adapters for test code onto its execution context.</param> public static void CheckOperationSuccess(BaseResponseMessageType response, int expectedItemCount, ITestSite site) { site.Assert.AreEqual <int>( expectedItemCount, response.ResponseMessages.Items.GetLength(0), "Expected Item Count: {0}, Actual Item Count: {1}", expectedItemCount, response.ResponseMessages.Items.GetLength(0)); foreach (ResponseMessageType responseMessage in response.ResponseMessages.Items) { site.Assert.AreEqual <ResponseClassType>( ResponseClassType.Success, responseMessage.ResponseClass, string.Format( "The operation should be successful! Expected response code: {0}, actual response code: {1}", ResponseCodeType.NoError, responseMessage.ResponseCode)); } }
/// <summary> /// Parses the first item in ResponseMessages, ensure the returned value is correct. /// </summary> /// <typeparam name="T">Type of the item.</typeparam> /// <param name="response">A web service call response.</param> /// <returns>An instance of the specified ResponseMessageType.</returns> public static T EnsureResponse <T>(BaseResponseMessageType response) where T : ResponseMessageType { T[] responseMessage = ParseResponse <T>(response); if (responseMessage.Length != 1) { throw new IncorrectItemCountException("There should be only 1 item in the response."); } if (responseMessage[0].ResponseClass != ResponseClassType.Success || responseMessage[0].ResponseCode != ResponseCodeType.NoError) { throw new ResponseErrorException( string.Format( "ResponseClass or ResponseCode error. Response Code: {0}; Response Class: {1}; MessageText: {2}", responseMessage[0].ResponseCode, responseMessage[0].ResponseClass, responseMessage[0].MessageText)); } return(responseMessage[0]); }
/// <summary> /// Get message related Item elements of ItemInfoResponseMessageType type in a response message returned from server. /// </summary> /// <param name="response">A response message returned by an operation: GetItem, CopyItem, CreateItem, MoveItem, or UpdateItem.</param> /// <returns>Message related Item elements of ItemInfoResponseMessageType type.</returns> public static ItemInfoResponseMessageType[] GetInfoItemsInResponse(BaseResponseMessageType response) { ItemInfoResponseMessageType[] infoItems = null; if (response != null && response.ResponseMessages != null && response.ResponseMessages.Items != null && response.ResponseMessages.Items.Length > 0) { List <ItemInfoResponseMessageType> infoItemList = new List <ItemInfoResponseMessageType>(); foreach (ResponseMessageType item in response.ResponseMessages.Items) { infoItemList.Add(item as ItemInfoResponseMessageType); } if (infoItemList.Count > 0) { infoItems = infoItemList.ToArray(); } } return(infoItems); }
private ItemType[] HandleFindItemResponse(BaseResponseMessageType response) { ResponseMessageType[] array = this.HandleBaseResponseMessage(response); if (array == null || array[0] == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem returned NULL responseType."); return(null); } ResponseMessageType responseMessageType = array[0]; if (responseMessageType.ResponseCode != ResponseCodeType.NoError) { Globals.ConsistencyChecksTracer.TraceDebug <ResponseCodeType>((long)this.GetHashCode(), "Web request returned ResponseCodeType {0}.", responseMessageType.ResponseCode); return(null); } FindItemResponseMessageType findItemResponseMessageType = responseMessageType as FindItemResponseMessageType; if (findItemResponseMessageType == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem web request returned NULL FindItemResponseMessageType."); return(null); } if (findItemResponseMessageType.RootFolder == null || findItemResponseMessageType.RootFolder.Item == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem web request returned NULL RootFolder."); return(null); } ArrayOfRealItemsType arrayOfRealItemsType = findItemResponseMessageType.RootFolder.Item as ArrayOfRealItemsType; if (arrayOfRealItemsType == null || arrayOfRealItemsType.Items == null || arrayOfRealItemsType.Items[0] == null) { Globals.ConsistencyChecksTracer.TraceDebug((long)this.GetHashCode(), "FindItem web request returned NULL ItemType."); return(null); } return(arrayOfRealItemsType.Items); }
private ResponseMessageType HandleBaseResponseMessage(BaseResponseMessageType response) { return(null); }
private static void CallEwsWithRetries(Func<BaseResponseMessageType> delegateEwsCall, Func<ResponseMessageType, int, bool> responseMessageProcessor, StoreRetentionPolicyTagHelper srpth) { ExDateTime t = ExDateTime.UtcNow.Add(StoreRetentionPolicyTagHelper.TotalExecutionTimeWindow); Exception ex = null; int num = -1; bool flag; do { ex = null; flag = false; try { BaseResponseMessageType baseResponseMessageType = delegateEwsCall(); num++; int i = 0; while (i < baseResponseMessageType.ResponseMessages.Items.Length) { ResponseMessageType responseMessageType = baseResponseMessageType.ResponseMessages.Items[i]; if (responseMessageProcessor != null && responseMessageProcessor(responseMessageType, i)) { ExTraceGlobals.ELCTracer.TraceDebug(0L, "Successfully executed EWS call"); break; } if (responseMessageType.ResponseClass == ResponseClassType.Error) { if (responseMessageType.ResponseCode == ResponseCodeType.ErrorCrossSiteRequest) { ExTraceGlobals.ELCTracer.TraceDebug(0L, "Crosssite request error , recreate exchange binding and reset the url caches"); flag = true; StoreRetentionPolicyTagHelper.InitializePrincipal(srpth); StoreRetentionPolicyTagHelper.InitializeServiceBinding(srpth); break; } if (!StoreRetentionPolicyTagHelper.TransientServiceErrors.Contains(responseMessageType.ResponseCode)) { ExTraceGlobals.ELCTracer.TraceError(0L, string.Format("Permanent error encountered: {0}, {1}, {2}", responseMessageType.ResponseClass.ToString(), responseMessageType.ResponseCode.ToString(), responseMessageType.MessageText.ToString())); throw new ElcUserConfigurationException(Strings.FailedToGetElcUserConfigurationFromService(responseMessageType.ResponseClass.ToString(), responseMessageType.ResponseCode.ToString(), responseMessageType.MessageText.ToString())); } flag = true; ex = new ElcUserConfigurationException(Strings.FailedToGetElcUserConfigurationFromService(responseMessageType.ResponseClass.ToString(), responseMessageType.ResponseCode.ToString(), responseMessageType.MessageText.ToString())); ExTraceGlobals.ELCTracer.TraceDebug(0L, "Transient error encountered, will attempt to retry, Exception: " + ex); break; } else { i++; } } } catch (CommunicationException ex2) { ex = ex2; ExTraceGlobals.ELCTracer.TraceDebug(0L, "Transient error encountered, will attempt to retry, Exception: " + ex); flag = true; } catch (WebException ex3) { ex = ex3; ExTraceGlobals.ELCTracer.TraceDebug(0L, "Transient error encountered, will attempt to retry, Exception: " + ex); flag = true; } catch (TimeoutException ex4) { ex = ex4; flag = false; } catch (SoapException ex5) { ex = ex5; flag = false; } catch (IOException ex6) { ex = ex6; flag = false; } catch (InvalidOperationException ex7) { ex = ex7; flag = false; } catch (LocalizedException ex8) { ex = ex8; flag = false; } } while (flag && t > ExDateTime.UtcNow); if (ex != null) { ExTraceGlobals.ELCTracer.TraceError(0L, string.Format("Failed to access elc user configuration. Total attempts made {0}, Exception: {1} ", num, ex)); throw new ElcUserConfigurationException(Strings.ErrorElcUserConfigurationServiceCall, ex); } }
/// <summary> /// Verify the ExportItemsResponseType related requirements when the ExportItems operation executes successfully. /// </summary> /// <param name="exportItemsResponse">The ExportItemsResponseType instance returned from the server.</param> protected void VerifyExportItemsSuccessResponse(BaseResponseMessageType exportItemsResponse) { foreach (ResponseMessageType responseMessage in exportItemsResponse.ResponseMessages.Items) { ExportItemsResponseMessageType exportResponse = responseMessage as ExportItemsResponseMessageType; Site.Assert.IsNotNull(exportResponse, "The response got from server should not be null."); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2107."); // Verify requirement: MS-OXWSBTRF_R2107 Site.CaptureRequirementIfAreEqual <ResponseClassType>( ResponseClassType.Success, responseMessage.ResponseClass, 2107, @"[In tns:ExportItemsSoapOut Message]If the request is successful, the ExportItems operation returns an ExportItemsResponse element with the ResponseClass attribute of the ExportItemsResponseMessage element set to ""Success""."); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R170."); // If the ItemId in exportResponse is not null, then requirement MS-OXWSBTRF_R170 can be verified. // Verify requirement: MS-OXWSBTRF_R170 Site.CaptureRequirementIfIsNotNull( exportResponse.ItemId, 170, @"[In m:ExportItemsResponseMessageType Complex Type]This element[ItemId] MUST be present if the export operation is successful."); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R172."); // If the data in exportResponse is not null, then requirement MS-OXWSBTRF_R172 and MS-OXWSBTRF_R173 can be verified. // Verify requirement: MS-OXWSBTRF_R172 Site.CaptureRequirementIfIsNotNull( exportResponse.Data, 172, @"[In m:ExportItemsResponseMessageType Complex Type][Data] specifies the data of a single exported item."); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R173."); // Verify requirement: MS-OXWSBTRF_R173 Site.CaptureRequirementIfIsNotNull( exportResponse.Data, 173, @"[In m:ExportItemsResponseMessageType Complex Type]This element[Data] MUST be present if the export operation is successful."); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R2108."); // Verify requirement: MS-OXWSBTRF_R2108 Site.CaptureRequirementIfAreEqual <ResponseCodeType>( ResponseCodeType.NoError, responseMessage.ResponseCode, 2108, @"[In tns:ExportItemsSoapOut Message][If the request is successful]The ResponseCode element of the ExportItemsResponseMessage element is set to ""NoError""."); } // If the length of items in ExportItems response is equal to this.ItemCount, and the exported items' id are same as created items' id then requirement MS-OXWSBTRF_R179 can be captured. Site.Assert.AreEqual <int>(exportItemsResponse.ResponseMessages.Items.Length, this.ItemCount, "The exported items' count should be the same with created items' count"); bool isSameId = false; for (int i = 0; i < this.ItemCount; i++) { Site.Log.Add( LogEntryKind.Debug, "The exported items' id: '{0}' should be same with the created items' id: {1}.", (exportItemsResponse.ResponseMessages.Items[i] as ExportItemsResponseMessageType).ItemId.Id, this.CreatedItemId[i].Id); if ((exportItemsResponse.ResponseMessages.Items[i] as ExportItemsResponseMessageType).ItemId.Id == this.CreatedItemId[i].Id) { isSameId = true; } else { isSameId = false; break; } } Site.Assert.IsTrue(isSameId, "The exported items' id should be same to the created items' id. "); // Add the debug information. Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSBTRF_R179."); // After verify the length of items in ExportItems response is equal to this.ItemCount, and the exported items' id are same as created items' id then requirement MS-OXWSBTRF_R179 can be captured. Site.CaptureRequirement( 179, @"[In ExportItemsType Complex Type][ItemIds] specifies the item identifier array of the items to export."); }