/// <summary>
/// Log on to a mailbox with a specified user account and create an user configuration objects on inbox folder.
/// </summary>
/// <param name="userName">The name of the user used to communicate with server</param>
/// <param name="password">The password of the user used to communicate with server</param>
/// <param name="domain">The domain of the user used to communicate with server</param>
/// <param name="userConfigurationName">Name of the user configuration object.</param>
/// <returns>If succeed, return true; otherwise, return false.</returns>
public bool CreateUserConfiguration(string userName, string password, string domain, string userConfigurationName)
{
userConfigurationName = userConfigurationName.Replace("_", string.Empty);
this.exchangeServiceBinding.Credentials = new System.Net.NetworkCredential(userName, password, domain);
CreateUserConfigurationType request = new CreateUserConfigurationType();
request.UserConfiguration = new UserConfigurationType();
request.UserConfiguration.UserConfigurationName = new UserConfigurationNameType();
request.UserConfiguration.UserConfigurationName.Name = userConfigurationName;
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
distinguishedFolderId.Id = DistinguishedFolderIdNameType.inbox;
request.UserConfiguration.UserConfigurationName.Item = distinguishedFolderId;
CreateUserConfigurationResponseType response = this.exchangeServiceBinding.CreateUserConfiguration(request);
return response.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success
&& response.ResponseMessages.Items[0].ResponseCode == ResponseCodeType.NoError ? true : false;
}
public void MSOXWSMTGS_S03_TC01_CopySingleCalendar()
{
#region Define a calendar item to copy
CalendarItemType calendarItem = new CalendarItemType();
calendarItem.UID = Guid.NewGuid().ToString();
calendarItem.Subject = this.Subject;
#endregion
#region Create the calendar item with CalendarItemCreateOrDeleteOperationType set to SendToNone
ItemInfoResponseMessageType item = this.CreateSingleCalendarItem(Role.Organizer, calendarItem, CalendarItemCreateOrDeleteOperationType.SendToNone);
Site.Assert.IsNotNull(item, "Create a calendar item should be successful.");
ItemIdType calendarId = item.Items.Items[0].ItemId;
#endregion
#region Copy the calendar item to Drafts folder
DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
folderId.Id = DistinguishedFolderIdNameType.drafts;
TargetFolderIdType targetFolderId = new TargetFolderIdType();
targetFolderId.Item = folderId;
ItemInfoResponseMessageType copiedItem = this.CopySingleCalendarItem(Role.Organizer, calendarId, targetFolderId);
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSMTGS_R602");
// Verify MS-OXWSMTGS requirement: MS-OXWSMTGS_R602
this.Site.CaptureRequirementIfIsNotNull(
copiedItem,
602,
@"[In Messages] CopyItemSoapIn: For each item being copied that is not a recurring calendar item, the ItemIds element MUST contain an ItemId child element ([MS-OXWSCORE] section 2.2.4.11).");
#endregion
#region Call GetItem operation to verify whether the calendar item is really copied
CalendarItemType calendar = this.SearchSingleItem(Role.Organizer, DistinguishedFolderIdNameType.drafts, "IPM.Appointment", calendarItem.UID) as CalendarItemType;
Site.Assert.IsNotNull(calendar, "The calendar item should be in organizer's drafts folder.");
CalendarItemType calendarInCalendar = this.SearchSingleItem(Role.Organizer, DistinguishedFolderIdNameType.calendar, "IPM.Appointment", calendarItem.UID) as CalendarItemType;
Site.Assert.IsNotNull(calendarInCalendar, "The calendar item should also be in organizer's calendar folder.");
#endregion
#region Clean up organizer's drafts and calendar folders
this.CleanupFoldersByRole(Role.Organizer, new List<DistinguishedFolderIdNameType>() { DistinguishedFolderIdNameType.calendar, DistinguishedFolderIdNameType.drafts });
#endregion
}
public void MSOXWSMTGS_S04_TC01_MoveSingleCalendar()
{
#region Define a calendar item to move
CalendarItemType calendarItem = new CalendarItemType();
calendarItem.UID = Guid.NewGuid().ToString();
calendarItem.Subject = this.Subject;
#endregion
#region Create the calendar item
ItemInfoResponseMessageType item = this.CreateSingleCalendarItem(Role.Organizer, calendarItem, CalendarItemCreateOrDeleteOperationType.SendToNone);
ItemIdType calendarId = item.Items.Items[0].ItemId;
#endregion
#region Move the created calendar item to Inbox folder
DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
folderId.Id = DistinguishedFolderIdNameType.inbox;
TargetFolderIdType targetFolderId = new TargetFolderIdType();
targetFolderId.Item = folderId;
ItemInfoResponseMessageType movedItem = this.MoveSingleCalendarItem(Role.Organizer, calendarId, targetFolderId);
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSMTGS_R640");
// Verify MS-OXWSMTGS requirement: MS-OXWSMTGS_R640
this.Site.CaptureRequirementIfIsNotNull(
movedItem,
640,
@"[In Messages] MoveItemSoapIn: For each item being moved that is not a recurring calendar item, the ItemIds element MUST contain an ItemId child element ([MS-OXWSCORE] section 2.2.4.11).");
#endregion
#region Verify the calendar item is moved to Inbox folder
CalendarItemType calendar = this.SearchSingleItem(Role.Organizer, DistinguishedFolderIdNameType.inbox, "IPM.Appointment", calendarItem.UID) as CalendarItemType;
Site.Assert.IsNotNull(calendar, "The calendar item should be moved to Inbox folder.");
CalendarItemType calendarInCalendar = this.SearchDeletedSingleItem(Role.Organizer, DistinguishedFolderIdNameType.calendar, "IPM.Appointment", calendarItem.UID) as CalendarItemType;
Site.Assert.IsNull(calendarInCalendar, "The calendar item should not be in the Calendar folder.");
#endregion
#region Clean up organizer's inbox folder.
this.CleanupFoldersByRole(Role.Organizer, new List<DistinguishedFolderIdNameType>() { DistinguishedFolderIdNameType.inbox });
#endregion
}
public void MSOXWSCONT_S03_TC01_CopyContactItem()
{
#region Step 1:Create the contact item.
// Create a contact item.
ContactItemType item = this.BuildContactItemWithRequiredProperties();
CreateItemResponseType createItemResponse = this.CallCreateItemOperation(item);
// Check the response.
Common.CheckOperationSuccess(createItemResponse, 1, this.Site);
#endregion
#region Step 2:Copy the contact item.
CopyItemType copyItemRequest = new CopyItemType();
CopyItemResponseType copyItemResponse = new CopyItemResponseType();
// Configure ItemIds.
copyItemRequest.ItemIds = new BaseItemIdType[1];
copyItemRequest.ItemIds[0] = this.ExistContactItems[0];
// Configure the copy Distinguished Folder.
DistinguishedFolderIdType distinguishedFolderIdForCopyItem = new DistinguishedFolderIdType();
distinguishedFolderIdForCopyItem.Id = DistinguishedFolderIdNameType.drafts;
copyItemRequest.ToFolderId = new TargetFolderIdType();
copyItemRequest.ToFolderId.Item = distinguishedFolderIdForCopyItem;
copyItemResponse = this.CONTAdapter.CopyItem(copyItemRequest);
// Check the response.
Common.CheckOperationSuccess(copyItemResponse, 1, this.Site);
#endregion
#region Step 3:Get the contact item.
// The contact item to get.
ItemIdType[] itemArray = new ItemIdType[this.ExistContactItems.Count];
this.ExistContactItems.CopyTo(itemArray, 0);
GetItemResponseType getItemResponse = this.CallGetItemOperation(itemArray);
// Check the response.
Common.CheckOperationSuccess(getItemResponse, 2, this.Site);
#endregion
}
public void MSOXWSFOLD_S08_TC01_AllOperationsWithAllOptionalElements()
{
#region Configure SOAP header
this.ConfigureSOAPHeader();
#endregion
#region Create new folders in the inbox folder.
// CreateFolder request.
CreateFolderType createFolderRequest = this.GetCreateFolderRequest(
DistinguishedFolderIdNameType.inbox.ToString(),
new string[] { "Custom Folder1", "Custom Folder2", "Custom Folder3", "Custom Folder4" },
new string[] { "IPF.MyCustomFolderClass", "IPF.Appointment", "IPF.Contact", "IPF.Task" },
null);
// Set ExtendedProperty defined in BaseFolderType.
PathToExtendedFieldType publishInAddressBook = new PathToExtendedFieldType();
// A hexadecimal tag of the extended property.
publishInAddressBook.PropertyTag = "0x671E";
publishInAddressBook.PropertyType = MapiPropertyTypeType.Boolean;
ExtendedPropertyType pubAddressbook = new ExtendedPropertyType();
pubAddressbook.ExtendedFieldURI = publishInAddressBook;
pubAddressbook.Item = "1";
ExtendedPropertyType[] extendedProperties = new ExtendedPropertyType[1];
extendedProperties[0] = pubAddressbook;
createFolderRequest.Folders[0].ExtendedProperty = extendedProperties;
createFolderRequest.Folders[1].ExtendedProperty = extendedProperties;
createFolderRequest.Folders[2].ExtendedProperty = extendedProperties;
createFolderRequest.Folders[3].ExtendedProperty = extendedProperties;
// Define a permissionSet with all optional elements
PermissionSetType permissionSet = new PermissionSetType();
permissionSet.Permissions = new PermissionType[1];
permissionSet.Permissions[0] = new PermissionType();
permissionSet.Permissions[0].ReadItems = new PermissionReadAccessType();
permissionSet.Permissions[0].ReadItems = PermissionReadAccessType.FullDetails;
permissionSet.Permissions[0].ReadItemsSpecified = true;
permissionSet.Permissions[0].CanCreateItems = true;
permissionSet.Permissions[0].CanCreateItemsSpecified = true;
permissionSet.Permissions[0].CanCreateSubFolders = true;
permissionSet.Permissions[0].CanCreateSubFoldersSpecified = true;
permissionSet.Permissions[0].IsFolderVisible = true;
permissionSet.Permissions[0].IsFolderVisibleSpecified = true;
permissionSet.Permissions[0].IsFolderContact = true;
permissionSet.Permissions[0].IsFolderContactSpecified = true;
permissionSet.Permissions[0].IsFolderOwner = true;
permissionSet.Permissions[0].IsFolderOwnerSpecified = true;
permissionSet.Permissions[0].IsFolderContact = true;
permissionSet.Permissions[0].IsFolderContactSpecified = true;
permissionSet.Permissions[0].EditItems = new PermissionActionType();
permissionSet.Permissions[0].EditItems = PermissionActionType.All;
permissionSet.Permissions[0].EditItemsSpecified = true;
permissionSet.Permissions[0].DeleteItems = new PermissionActionType();
permissionSet.Permissions[0].DeleteItems = PermissionActionType.All;
permissionSet.Permissions[0].DeleteItemsSpecified = true;
permissionSet.Permissions[0].PermissionLevel = new PermissionLevelType();
permissionSet.Permissions[0].PermissionLevel = PermissionLevelType.Custom;
permissionSet.Permissions[0].UserId = new UserIdType();
permissionSet.Permissions[0].UserId.PrimarySmtpAddress = Common.GetConfigurationPropertyValue("User2Name", this.Site) + "@" + Common.GetConfigurationPropertyValue("Domain", this.Site);
// Set PermissionSet for FolderType folder.
((FolderType)createFolderRequest.Folders[0]).PermissionSet = permissionSet;
// Set PermissionSet for ContactsType folder.
((ContactsFolderType)createFolderRequest.Folders[2]).PermissionSet = permissionSet;
// Set PermissionSet for TasksFolderType folder.
((TasksFolderType)createFolderRequest.Folders[3]).PermissionSet = permissionSet;
// Create a new folder.
CreateFolderResponseType createFolderResponse = this.FOLDAdapter.CreateFolder(createFolderRequest);
// Check the response.
Common.CheckOperationSuccess(createFolderResponse, 4, this.Site);
// Folder ids.
FolderIdType[] folderIds = new FolderIdType[createFolderResponse.ResponseMessages.Items.Length];
for (int index = 0; index < createFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, createFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be created successfully!");
// Save folder ids.
folderIds[index] = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[index]).Folders[0].FolderId;
// Save the new created folder's folder id.
this.NewCreatedFolderIds.Add(folderIds[index]);
}
#endregion
#region Create a managedfolder
CreateManagedFolderRequestType createManagedFolderRequest = this.GetCreateManagedFolderRequest(Common.GetConfigurationPropertyValue("ManagedFolderName1", this.Site));
// Add an email address into request.
EmailAddressType mailBox = new EmailAddressType()
{
EmailAddress = Common.GetConfigurationPropertyValue("User1Name", this.Site) + "@" + Common.GetConfigurationPropertyValue("Domain", this.Site)
};
createManagedFolderRequest.Mailbox = mailBox;
// Create the specified managed folder.
CreateManagedFolderResponseType createManagedFolderResponse = this.FOLDAdapter.CreateManagedFolder(createManagedFolderRequest);
// Check the response.
Common.CheckOperationSuccess(createManagedFolderResponse, 1, this.Site);
// Save the new created managed folder's folder id.
FolderIdType newFolderId = ((FolderInfoResponseMessageType)createManagedFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
this.NewCreatedFolderIds.Add(newFolderId);
#endregion
#region Get the new created folders
// GetFolder request.
GetFolderType getCreatedFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folderIds);
// Get the new created folder.
GetFolderResponseType getCreatedFolderResponse = this.FOLDAdapter.GetFolder(getCreatedFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getCreatedFolderResponse, 4, this.Site);
for (int index = 0; index < getCreatedFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, getCreatedFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder information should be returned!");
}
#endregion
#region Update the new created folders
// UpdateFolder request.
UpdateFolderType updateFolderRequest = this.GetUpdateFolderRequest(
new string[] { "Folder", "CalendarFolder", "ContactsFolder", "TasksFolder" },
new string[] { "SetFolderField", "SetFolderField", "SetFolderField", "SetFolderField" },
folderIds);
// Update the folders' properties.
UpdateFolderResponseType updateFolderResponse = this.FOLDAdapter.UpdateFolder(updateFolderRequest);
// Check the response.
Common.CheckOperationSuccess(updateFolderResponse, 4, this.Site);
for (int index = 0; index < updateFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, updateFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
}
#endregion
#region Copy the updated folders to "drafts" folder
// Copy the folders into "drafts" folder
CopyFolderType copyFolderRequest = this.GetCopyFolderRequest(DistinguishedFolderIdNameType.drafts.ToString(), folderIds);
// Copy the folders.
CopyFolderResponseType copyFolderResponse = this.FOLDAdapter.CopyFolder(copyFolderRequest);
// Check the response.
Common.CheckOperationSuccess(copyFolderResponse, 4, this.Site);
// Copied Folders' id.
FolderIdType[] copiedFolderIds = new FolderIdType[copyFolderResponse.ResponseMessages.Items.Length];
for (int index = 0; index < copyFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, copyFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
// Variable to save the folders.
copiedFolderIds[index] = ((FolderInfoResponseMessageType)copyFolderResponse.ResponseMessages.Items[index]).Folders[0].FolderId;
// Save the copied folders' folder id.
this.NewCreatedFolderIds.Add(copiedFolderIds[index]);
}
#endregion
#region Move the updated folders to "deleteditems" folder
// MoveFolder request.
MoveFolderType moveFolderRequest = new MoveFolderType();
// Set the request's folderId field.
moveFolderRequest.FolderIds = folderIds;
// Set the request's destFolderId field.
DistinguishedFolderIdType toFolderId = new DistinguishedFolderIdType();
toFolderId.Id = DistinguishedFolderIdNameType.deleteditems;
moveFolderRequest.ToFolderId = new TargetFolderIdType();
moveFolderRequest.ToFolderId.Item = toFolderId;
// Move the specified folders.
MoveFolderResponseType moveFolderResponse = this.FOLDAdapter.MoveFolder(moveFolderRequest);
// Check the response.
Common.CheckOperationSuccess(moveFolderResponse, 4, this.Site);
for (int index = 0; index < moveFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, moveFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
}
#endregion
#region Delete all folders
// All folder ids.
FolderIdType[] allFolderIds = new FolderIdType[folderIds.Length + copiedFolderIds.Length];
for (int index = 0; index < allFolderIds.Length / 2; index++)
{
allFolderIds[index] = folderIds[index];
allFolderIds[index + folderIds.Length] = copiedFolderIds[index];
}
// DeleteFolder request.
DeleteFolderType deleteFolderRequest = this.GetDeleteFolderRequest(DisposalType.HardDelete, allFolderIds);
// Delete the specified folder.
DeleteFolderResponseType deleteFolderResponse = this.FOLDAdapter.DeleteFolder(deleteFolderRequest);
// Check the response.
Common.CheckOperationSuccess(deleteFolderResponse, 8, this.Site);
for (int index = 0; index < deleteFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, deleteFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
}
#endregion
}
/// <summary>
/// Generate the request message for operation "CopyFolder".
/// </summary>
/// <param name="toFolderId">A target folder for operations that copy folders.</param>
/// <param name="folderIds">An array of folder identifier of the folders need to be copied.</param>
/// <returns>Copy folder request instance that will send to server.</returns>
protected CopyFolderType GetCopyFolderRequest(string toFolderId, params BaseFolderIdType[] folderIds)
{
Site.Assert.IsNotNull(folderIds, "Folders id should not be null!");
Site.Assert.AreNotEqual<int>(0, folderIds.Length, "Folders id should contains at least one id!");
// CopyFolder request.
CopyFolderType copyFolderRequest = new CopyFolderType();
int folderCount = folderIds.Length;
// Identify the folders to be copied.
copyFolderRequest.FolderIds = new BaseFolderIdType[folderCount];
for (int folderIdIndex = 0; folderIdIndex < folderCount; folderIdIndex++)
{
copyFolderRequest.FolderIds[folderIdIndex] = folderIds[folderIdIndex];
}
// Identify the destination folder.
copyFolderRequest.ToFolderId = new TargetFolderIdType();
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType distinguishedFolderIdName = new DistinguishedFolderIdNameType();
bool isSuccess = Enum.TryParse<DistinguishedFolderIdNameType>(toFolderId, true, out distinguishedFolderIdName);
if (isSuccess)
{
distinguishedFolderId.Id = distinguishedFolderIdName;
copyFolderRequest.ToFolderId.Item = distinguishedFolderId;
}
else
{
FolderIdType id = new FolderIdType();
id.Id = toFolderId;
copyFolderRequest.ToFolderId.Item = id;
}
return copyFolderRequest;
}
public void MSOXWSFOLD_S08_TC02_AllOperationsWithoutAllOptionalElements()
{
#region Create new folders in the inbox folder.
// CreateFolder request.
CreateFolderType createFolderRequest = this.GetCreateFolderRequest(
DistinguishedFolderIdNameType.inbox.ToString(),
new string[] { "Custom Folder1", "Custom Folder2", "Custom Folder3", "Custom Folder4" },
new string[] { "IPF.MyCustomFolderClass", "IPF.Appointment", "IPF.Contact", "IPF.Task" },
null);
// Remove FolderClass for FolderType folder.
createFolderRequest.Folders[0].FolderClass = null;
// Create a new folder.
CreateFolderResponseType createFolderResponse = this.FOLDAdapter.CreateFolder(createFolderRequest);
// Check the response.
Common.CheckOperationSuccess(createFolderResponse, 4, this.Site);
// Folder ids.
FolderIdType[] folderIds = new FolderIdType[createFolderResponse.ResponseMessages.Items.Length];
for (int index = 0; index < createFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, createFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be created successfully!");
// Save folder ids.
folderIds[index] = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[index]).Folders[0].FolderId;
// Save the new created folder's folder id.
this.NewCreatedFolderIds.Add(folderIds[index]);
}
#endregion
#region Create a managedfolder
CreateManagedFolderRequestType createManagedFolderRequest = this.GetCreateManagedFolderRequest(Common.GetConfigurationPropertyValue("ManagedFolderName1", this.Site));
// Create the specified managed folder.
CreateManagedFolderResponseType createManagedFolderResponse = this.FOLDAdapter.CreateManagedFolder(createManagedFolderRequest);
// Check the response.
Common.CheckOperationSuccess(createManagedFolderResponse, 1, this.Site);
// Save the new created managed folder's folder id.
FolderIdType newManagedFolderId = ((FolderInfoResponseMessageType)createManagedFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
this.NewCreatedFolderIds.Add(newManagedFolderId);
#endregion
#region Get the new created folders
// GetFolder request.
GetFolderType getCreatedFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folderIds);
// Get the new created folder.
GetFolderResponseType getCreatedFolderResponse = this.FOLDAdapter.GetFolder(getCreatedFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getCreatedFolderResponse, 4, this.Site);
for (int index = 0; index < getCreatedFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, getCreatedFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder information should be returned!");
}
#endregion
#region Update the new created folders
// UpdateFolder request.
UpdateFolderType updateFolderRequest = this.GetUpdateFolderRequest(
new string[] { "Folder", "CalendarFolder", "ContactsFolder", "TasksFolder" },
new string[] { "SetFolderField", "SetFolderField", "SetFolderField", "SetFolderField" },
folderIds);
// Update the folders' properties.
UpdateFolderResponseType updateFolderResponse = this.FOLDAdapter.UpdateFolder(updateFolderRequest);
// Check the response.
Common.CheckOperationSuccess(updateFolderResponse, 4, this.Site);
for (int index = 0; index < updateFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, updateFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
}
#endregion
#region Copy the updated folders to "drafts" folder
// Copy the folders into "drafts" folder
CopyFolderType copyFolderRequest = this.GetCopyFolderRequest(DistinguishedFolderIdNameType.drafts.ToString(), folderIds);
// Copy the folders.
CopyFolderResponseType copyFolderResponse = this.FOLDAdapter.CopyFolder(copyFolderRequest);
// Check the response.
Common.CheckOperationSuccess(copyFolderResponse, 4, this.Site);
// Copied folders' id.
FolderIdType[] copiedFolderIds = new FolderIdType[copyFolderResponse.ResponseMessages.Items.Length];
for (int index = 0; index < copyFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, copyFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
// Variable to save the folders.
copiedFolderIds[index] = ((FolderInfoResponseMessageType)copyFolderResponse.ResponseMessages.Items[index]).Folders[0].FolderId;
// Save the copied folders' folder id.
this.NewCreatedFolderIds.Add(copiedFolderIds[index]);
}
#endregion
#region Move the updated folders to "deleteditems" folder
// MoveFolder request.
MoveFolderType moveFolderRequest = new MoveFolderType();
// Set the request's folderId field.
moveFolderRequest.FolderIds = folderIds;
// Set the request's destFolderId field.
DistinguishedFolderIdType toFolderId = new DistinguishedFolderIdType();
toFolderId.Id = DistinguishedFolderIdNameType.deleteditems;
moveFolderRequest.ToFolderId = new TargetFolderIdType();
moveFolderRequest.ToFolderId.Item = toFolderId;
// Move the specified folders.
MoveFolderResponseType moveFolderResponse = this.FOLDAdapter.MoveFolder(moveFolderRequest);
// Check the response.
Common.CheckOperationSuccess(moveFolderResponse, 4, this.Site);
for (int index = 0; index < moveFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, moveFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
}
#endregion
#region Delete all folders
// All folder ids.
FolderIdType[] allFolderIds = new FolderIdType[folderIds.Length + copiedFolderIds.Length];
for (int index = 0; index < allFolderIds.Length / 2; index++)
{
allFolderIds[index] = folderIds[index];
allFolderIds[index + folderIds.Length] = copiedFolderIds[index];
}
// DeleteFolder request.
DeleteFolderType deleteFolderRequest = this.GetDeleteFolderRequest(DisposalType.HardDelete, allFolderIds);
// Delete the specified folder.
DeleteFolderResponseType deleteFolderResponse = this.FOLDAdapter.DeleteFolder(deleteFolderRequest);
// Check the response.
Common.CheckOperationSuccess(deleteFolderResponse, 8, this.Site);
for (int index = 0; index < deleteFolderResponse.ResponseMessages.Items.Length; index++)
{
Site.Assert.AreEqual<ResponseClassType>(ResponseClassType.Success, deleteFolderResponse.ResponseMessages.Items[index].ResponseClass, "Folder should be updated successfully!");
}
#endregion
}
public void MSOXWSMTGS_S04_TC03_MoveRecurringCalendar()
{
#region Define a recurring calendar item to move
DateTime startTime = DateTime.Now;
DailyRecurrencePatternType pattern = new DailyRecurrencePatternType();
pattern.Interval = this.PatternInterval;
NumberedRecurrenceRangeType range = new NumberedRecurrenceRangeType();
range.NumberOfOccurrences = this.NumberOfOccurrences;
range.StartDate = startTime;
CalendarItemType calendarItem = new CalendarItemType();
calendarItem.UID = Guid.NewGuid().ToString();
calendarItem.Subject = this.Subject;
calendarItem.Start = startTime;
calendarItem.StartSpecified = true;
calendarItem.End = startTime.AddHours(this.TimeInterval);
calendarItem.EndSpecified = true;
calendarItem.Recurrence = new RecurrenceType();
calendarItem.Recurrence.Item = pattern;
calendarItem.Recurrence.Item1 = range;
#endregion
#region Create the recurring calendar item and extract the Id of an occurrence item
ItemInfoResponseMessageType item = this.CreateSingleCalendarItem(Role.Organizer, calendarItem, CalendarItemCreateOrDeleteOperationType.SendToNone);
OccurrenceItemIdType occurrenceItemId = new OccurrenceItemIdType();
occurrenceItemId.ChangeKey = item.Items.Items[0].ItemId.ChangeKey;
occurrenceItemId.RecurringMasterId = item.Items.Items[0].ItemId.Id;
occurrenceItemId.InstanceIndex = this.InstanceIndex;
#endregion
#region Get the Id of the occurrence item
ItemInfoResponseMessageType getItem = this.GetSingleCalendarItem(Role.Organizer, occurrenceItemId);
Site.Assert.IsNotNull(getItem, "Organizer should get the occurrence item successfully.");
RecurringMasterItemIdType recurringMasterItemId = new RecurringMasterItemIdType();
recurringMasterItemId.ChangeKey = getItem.Items.Items[0].ItemId.ChangeKey;
recurringMasterItemId.OccurrenceId = getItem.Items.Items[0].ItemId.Id;
#endregion
#region Move the recurring calendar item to Inbox folder
DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
folderId.Id = DistinguishedFolderIdNameType.inbox;
TargetFolderIdType targetFolderId = new TargetFolderIdType();
targetFolderId.Item = folderId;
ItemInfoResponseMessageType movedItem = this.MoveSingleCalendarItem(Role.Organizer, recurringMasterItemId, targetFolderId);
Site.Assert.IsNotNull(movedItem, @"Server should return success for moving the recurring calendar item.");
#endregion
#region Call FindItem to verify the recurring calendar item is moved to Inbox folder
CalendarItemType calendar = this.SearchSingleItem(Role.Organizer, DistinguishedFolderIdNameType.inbox, "IPM.Appointment", calendarItem.UID) as CalendarItemType;
Site.Assert.IsNotNull(calendar, "The recurring calendar should be in organizer's inbox folder.");
if (Common.IsRequirementEnabled(808, this.Site))
{
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSMTGS_R808");
// Verify MS-OXWSMTGS requirement: MS-OXWSMTGS_R808
this.Site.CaptureRequirementIfAreEqual<CalendarItemTypeType>(
CalendarItemTypeType.RecurringMaster,
calendar.CalendarItemType1,
808,
@"[In Appendix C: Product Behavior] MoveItemSoapIn: For each item being moved that is a recurring calendar item, implementation does contain a RecurringMasterItemId child element ([MS-OXWSCORE] section 2.2.4.11). (Exchange 2007 and above follow this behavior.)");
}
#endregion
#region Clean up organizer's inbox folder.
this.CleanupFoldersByRole(Role.Organizer, new List<DistinguishedFolderIdNameType>() { DistinguishedFolderIdNameType.inbox });
#endregion
}
/// <summary>
/// Generate the request message for operation "CreateFolder".
/// </summary>
/// <param name="parentFolderId">The folder identifier for the parent folder.</param>
/// <param name="folderNames">An array of display name of the folders to be created.</param>
/// <param name="folderClasses">An array of folder class value of the folders to be created.</param>
/// <param name="permissionSet">An array of permission set value of the folder.</param>
/// <returns>Create folder request instance that will send to server.</returns>
protected CreateFolderType GetCreateFolderRequest(string parentFolderId, string[] folderNames, string[] folderClasses, PermissionSetType[] permissionSet)
{
CreateFolderType createFolderRequest = new CreateFolderType();
createFolderRequest.ParentFolderId = new TargetFolderIdType();
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType distinguishedFolderIdName = new DistinguishedFolderIdNameType();
bool isSuccess = Enum.TryParse<DistinguishedFolderIdNameType>(parentFolderId, true, out distinguishedFolderIdName);
if (isSuccess)
{
distinguishedFolderId.Id = distinguishedFolderIdName;
createFolderRequest.ParentFolderId.Item = distinguishedFolderId;
}
else
{
FolderIdType id = new FolderIdType();
id.Id = parentFolderId;
createFolderRequest.ParentFolderId.Item = id;
}
createFolderRequest = this.ConfigureFolderProperty(folderNames, folderClasses, permissionSet, createFolderRequest);
return createFolderRequest;
}
public void MSOXWSFOLD_S03_TC02_MoveMultipleFolders()
{
#region Create multiple folders in the "drafts" folder
// CreateFolder request.
CreateFolderType createFolderRequest = this.GetCreateFolderRequest(DistinguishedFolderIdNameType.drafts.ToString(), new string[] { "ForMoveFolder1", "ForMoveFolder2" }, new string[] { "IPF.MyCustomFolderClass", "IPF.MyCustomFolderClass" }, null);
// Create a new folder.
CreateFolderResponseType createFolderResponse = this.FOLDAdapter.CreateFolder(createFolderRequest);
FolderIdType newFolderId1 = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
FolderIdType newFolderId2 = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[1]).Folders[0].FolderId;
// Check the response.
Common.CheckOperationSuccess(createFolderResponse, 2, this.Site);
// Save the new created folder's folder id.
this.NewCreatedFolderIds.Add(newFolderId1);
this.NewCreatedFolderIds.Add(newFolderId2);
#endregion
#region Move the new created folder to the inbox folder
// MoveFolder request.
MoveFolderType moveFolderRequest = new MoveFolderType();
// Set the request's folderId field.
moveFolderRequest.FolderIds = new BaseFolderIdType[2];
moveFolderRequest.FolderIds[0] = newFolderId1;
moveFolderRequest.FolderIds[1] = newFolderId2;
// Set the request's destFolderId field.
DistinguishedFolderIdType toFolderId = new DistinguishedFolderIdType();
toFolderId.Id = DistinguishedFolderIdNameType.inbox;
moveFolderRequest.ToFolderId = new TargetFolderIdType();
moveFolderRequest.ToFolderId.Item = toFolderId;
// Move the specified folder.
MoveFolderResponseType moveFolderResponse = this.FOLDAdapter.MoveFolder(moveFolderRequest);
// Check the response.
Common.CheckOperationSuccess(moveFolderResponse, 2, this.Site);
#endregion
}
public void MSOXWSMTGS_S04_TC02_MoveMeeting()
{
#region Define the target folder to move
// Define the Inbox folder as the target folder for moving meeting item.
DistinguishedFolderIdType inboxFolder = new DistinguishedFolderIdType();
inboxFolder.Id = DistinguishedFolderIdNameType.inbox;
TargetFolderIdType meetingTargetFolder = new TargetFolderIdType();
meetingTargetFolder.Item = inboxFolder;
// Define the Calendar folder as the target folder for moving meeting request message, meeting response message and meeting cancellation message.
DistinguishedFolderIdType calendarFolder = new DistinguishedFolderIdType();
calendarFolder.Id = DistinguishedFolderIdNameType.calendar;
TargetFolderIdType msgTargetFolder = new TargetFolderIdType();
msgTargetFolder.Item = calendarFolder;
#endregion
#region Organizer creates a meeting with CalendarItemCreateOrDeleteOperationType value set to SendOnlyToAll
#region Define a meeting to be moved
CalendarItemType meetingItem = new CalendarItemType();
meetingItem.Subject = this.Subject;
meetingItem.UID = Guid.NewGuid().ToString();
meetingItem.RequiredAttendees = new AttendeeType[] { GetAttendeeOrResource(this.AttendeeEmailAddress) };
meetingItem.OptionalAttendees = new AttendeeType[] { GetAttendeeOrResource(this.OrganizerEmailAddress) };
meetingItem.Resources = new AttendeeType[] { GetAttendeeOrResource(this.RoomEmailAddress) };
#endregion
ItemInfoResponseMessageType item = this.CreateSingleCalendarItem(Role.Organizer, meetingItem, CalendarItemCreateOrDeleteOperationType.SendOnlyToAll);
ItemIdType meetingId = item.Items.Items[0].ItemId;
#endregion
#region Organizer moves the meeting item to Inbox folder
ItemInfoResponseMessageType movedItem = this.MoveSingleCalendarItem(Role.Organizer, meetingId, meetingTargetFolder);
Site.Assert.AreEqual<ResponseClassType>(
ResponseClassType.Success,
movedItem.ResponseClass,
"Server should return success for moving the meeting item.");
ItemIdType movedMeetingItemId = movedItem.Items.Items[0].ItemId;
#endregion
#region Organizer calls FindItem to verify the meeting item is moved to Inbox folder
CalendarItemType calendar = this.SearchSingleItem(Role.Organizer, DistinguishedFolderIdNameType.inbox, "IPM.Appointment", meetingItem.UID) as CalendarItemType;
Site.Assert.IsNotNull(calendar, "The meeting item should be moved into organizer's Inbox folder.");
#endregion
#region Attendee finds the meeting request message in his Inbox folder
MeetingRequestMessageType request = this.SearchSingleItem(Role.Attendee, DistinguishedFolderIdNameType.inbox, "IPM.Schedule.Meeting.Request", meetingItem.UID) as MeetingRequestMessageType;
Site.Assert.IsNotNull(request, "The meeting request message should exist in attendee's inbox folder.");
#endregion
#region Attendee moves the meeting request message to the Calendar folder
movedItem = this.MoveSingleCalendarItem(Role.Attendee, request.ItemId, msgTargetFolder);
Site.Assert.AreEqual<ResponseClassType>(
ResponseClassType.Success,
movedItem.ResponseClass,
@"Server should return success for moving meeting request message.");
#endregion
#region Attendee calls FindItem to verify the meeting request message is moved to Calendar folder
request = this.SearchSingleItem(Role.Attendee, DistinguishedFolderIdNameType.calendar, "IPM.Schedule.Meeting.Request", meetingItem.UID) as MeetingRequestMessageType;
Site.Assert.IsNotNull(request, "The meeting request message should exist in attendee's calendar folder.");
#endregion
#region Attendee calls CreateItem to accept the meeting request with CalendarItemCreateOrDeleteOperationType value set to SendOnlyToAll
AcceptItemType acceptItem = new AcceptItemType();
acceptItem.ReferenceItemId = request.ItemId;
item = this.CreateSingleCalendarItem(Role.Attendee, acceptItem, CalendarItemCreateOrDeleteOperationType.SendOnlyToAll);
#endregion
#region Organizer finds the meeting response message in its Inbox folder
MeetingResponseMessageType response = this.SearchSingleItem(Role.Organizer, DistinguishedFolderIdNameType.inbox, "IPM.Schedule.Meeting.Resp", meetingItem.UID) as MeetingResponseMessageType;
Site.Assert.IsNotNull(response, "The meeting response message should exist in organizer's inbox folder.");
#endregion
#region Organizer moves the meeting response message to his Calendar folder
movedItem = this.MoveSingleCalendarItem(Role.Organizer, response.ItemId, msgTargetFolder);
Site.Assert.AreEqual<ResponseClassType>(
ResponseClassType.Success,
movedItem.ResponseClass,
"EWS should return success for moving the meeting response message.");
#endregion
#region Organizer calls FindItem to verify the meeting response message is moved to Calendar folder
response = this.SearchSingleItem(Role.Organizer, DistinguishedFolderIdNameType.calendar, "IPM.Schedule.Meeting.Resp", meetingItem.UID) as MeetingResponseMessageType;
Site.Assert.IsNotNull(response, "The meeting response message should be in organizer's calendar folder.");
#endregion
#region Organizer calls DeleteItem to delete the meeting with CalendarItemCreateOrDeleteOperationType value set to SendOnlyToAll
ResponseMessageType deletedItem = this.DeleteSingleCalendarItem(Role.Organizer, movedMeetingItemId, CalendarItemCreateOrDeleteOperationType.SendOnlyToAll);
Site.Assert.IsNotNull(deletedItem, "Delete the meeting should be successful.");
#endregion
#region Attendee finds the meeting cancellation message in his Inbox folder
MeetingCancellationMessageType canceledMeeting = this.SearchSingleItem(Role.Attendee, DistinguishedFolderIdNameType.inbox, "IPM.Schedule.Meeting.Canceled", meetingItem.UID) as MeetingCancellationMessageType;
Site.Assert.IsNotNull(canceledMeeting, "The meeting cancellation message should be in attendee's inbox folder.");
#endregion
#region Attendee moves the meeting cancellation message to his Calendar folder
movedItem = this.MoveSingleCalendarItem(Role.Attendee, canceledMeeting.ItemId, msgTargetFolder);
Site.Assert.AreEqual<ResponseClassType>(
ResponseClassType.Success,
movedItem.ResponseClass,
"EWS should return success for moving the meeting cancellation message.");
#endregion
#region Attendee calls FindItem to verify the meeting cancellation message is moved to Calendar folder
canceledMeeting = this.SearchSingleItem(Role.Attendee, DistinguishedFolderIdNameType.calendar, "IPM.Schedule.Meeting.Canceled", meetingItem.UID) as MeetingCancellationMessageType;
Site.Assert.IsNotNull(canceledMeeting, "The meeting cancellation message should be in attendee's calendar folder.");
#endregion
#region Attendee removes the meeting item
RemoveItemType removeItem = new RemoveItemType();
removeItem.ReferenceItemId = canceledMeeting.ItemId;
item = this.CreateSingleCalendarItem(Role.Attendee, removeItem, CalendarItemCreateOrDeleteOperationType.SendToNone);
Site.Assert.IsNotNull(item, "The meeting item should be removed.");
#endregion
#region Clean up organizer's calendar and deleteditems folders, and attendee's sentitems and deleteditems folders
this.CleanupFoldersByRole(Role.Organizer, new List<DistinguishedFolderIdNameType>() { DistinguishedFolderIdNameType.calendar, DistinguishedFolderIdNameType.deleteditems });
this.CleanupFoldersByRole(Role.Attendee, new List<DistinguishedFolderIdNameType>() { DistinguishedFolderIdNameType.sentitems, DistinguishedFolderIdNameType.deleteditems });
#endregion
}
public void MSOXWSFOLD_S04_TC09_GetFolderIdOnly()
{
#region Get the contacts folder.
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = DistinguishedFolderIdNameType.contacts;
// GetFolder request.
GetFolderType getContactsFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.IdOnly, folder);
// Get the Contacts folder.
GetFolderResponseType getContactsFolderResponse = this.FOLDAdapter.GetFolder(getContactsFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getContactsFolderResponse, 1, this.Site);
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R42103");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R42103
bool isVerifiedR42103 = Common.IsIdOnly((XmlElement)this.FOLDAdapter.LastRawResponseXml, "t:ContactsFolder", "t:FolderId");
this.Site.CaptureRequirementIfIsTrue(
isVerifiedR42103,
42103,
@"[In t:DefaultShapeNamesType Simple Type] A value of ""IdOnly"" [in DefaultShapeNamesType] specifies only the item or folder ID. include in the response.");
}
public void MSOXWSFOLD_S03_TC01_FolderPropertiesAfterMoved()
{
#region Create two nested folders with an item in the high-level one into the "drafts" folder.
// CreateFolder request.
CreateFolderType createFolderRequest = this.GetCreateFolderRequest(DistinguishedFolderIdNameType.drafts.ToString(), new string[] { "ForMoveFolder" }, new string[] { "IPF.MyCustomFolderClass" }, null);
// Create a new folder.
CreateFolderResponseType createFolderResponse = this.FOLDAdapter.CreateFolder(createFolderRequest);
// Check the response.
Common.CheckOperationSuccess(createFolderResponse, 1, this.Site);
FolderIdType newFolderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
// Create a message into this folder
string itemName = Common.GenerateResourceName(this.Site, "Test Mail");
ItemIdType itemId = this.CreateItem(Common.GetConfigurationPropertyValue("User1Name", this.Site) + "@" + Common.GetConfigurationPropertyValue("Domain", this.Site), newFolderId.Id, itemName);
this.NewCreatedItemIds.Add(itemId);
// Create sub folder request.
CreateFolderType createSubFolderRequest = this.GetCreateFolderRequest(newFolderId.Id, new string[] { "SubFolder" }, new string[] { "IPF.MyCustomFolderClass" }, null);
// Create a new folder.
CreateFolderResponseType createNewFolderResponse = this.FOLDAdapter.CreateFolder(createSubFolderRequest);
// Check the response.
Common.CheckOperationSuccess(createNewFolderResponse, 1, this.Site);
FolderIdType subFolderId = ((FolderInfoResponseMessageType)createNewFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
// Save the new created folder's folder id.
this.NewCreatedFolderIds.Add(subFolderId);
#endregion
#region Move the new created folder to the inbox folder
// MoveFolder request.
MoveFolderType moveFolderRequest = new MoveFolderType();
// Set the request's folderId field.
moveFolderRequest.FolderIds = new BaseFolderIdType[1];
moveFolderRequest.FolderIds[0] = newFolderId;
// Set the request's destFolderId field.
DistinguishedFolderIdType toFolderId = new DistinguishedFolderIdType();
toFolderId.Id = DistinguishedFolderIdNameType.inbox;
moveFolderRequest.ToFolderId = new TargetFolderIdType();
moveFolderRequest.ToFolderId.Item = toFolderId;
// Move the specified folder.
MoveFolderResponseType moveFolderResponse = this.FOLDAdapter.MoveFolder(moveFolderRequest);
// Check the response.
Common.CheckOperationSuccess(moveFolderResponse, 1, this.Site);
FolderIdType movedFolderId = ((FolderInfoResponseMessageType)moveFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
// Save the new created folder's folder id.
this.NewCreatedFolderIds.Add(movedFolderId);
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R4314");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R4314
this.Site.CaptureRequirementIfAreEqual<ResponseCodeType>(
ResponseCodeType.NoError,
moveFolderResponse.ResponseMessages.Items[0].ResponseCode,
4314,
@"[In MoveFolder Operation]A successful MoveFolder operation request returns a MoveFolderResponse element with the ResponseCode element of the MoveFolderResponse element set to ""NoError"".");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R43144");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R43144
this.Site.CaptureRequirementIfAreEqual<ResponseClassType>(
ResponseClassType.Success,
moveFolderResponse.ResponseMessages.Items[0].ResponseClass,
43144,
@"[In MoveFolder Operation]A successful MoveFolder operation request returns a MoveFolderResponse element with the ResponseClass attribute of the MoveFolderResponseMessage element set to ""Success"".");
#region Get the inbox folder's folder id
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = DistinguishedFolderIdNameType.inbox;
// GetFolder request.
GetFolderType getInboxFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folder);
// Get the Inbox folder.
GetFolderResponseType getInboxFolderResponse = this.FOLDAdapter.GetFolder(getInboxFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getInboxFolderResponse, 1, this.Site);
// Variable to save folder.
FolderInfoResponseMessageType inboxFolder = (FolderInfoResponseMessageType)getInboxFolderResponse.ResponseMessages.Items[0];
BaseFolderType inboxFolderInfo = (BaseFolderType)inboxFolder.Folders[0];
// Save the inbox's folder id.
FolderIdType inboxFolderId = inboxFolderInfo.FolderId;
#endregion
#region Get the new created folder after moved to inbox folder
// GetFolder request.
GetFolderType getSubFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, movedFolderId);
// Get the specified folder.
GetFolderResponseType getSubFolderResponse = this.FOLDAdapter.GetFolder(getSubFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getSubFolderResponse, 1, this.Site);
FolderInfoResponseMessageType allFolders = (FolderInfoResponseMessageType)getSubFolderResponse.ResponseMessages.Items[0];
BaseFolderType folderInfo = (BaseFolderType)allFolders.Folders[0];
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R595");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R595
// Since one message in the folder before move, if TotalCount for the folder is 1 after move, this requirement can be captured.
this.Site.CaptureRequirementIfAreEqual<int>(
1,
folderInfo.TotalCount,
595,
@"[In MoveFolder Operation]The contents of the folder move with the folder.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R461");
// The moved folder can be gotten successfully, so the specified folder was moved.
this.Site.CaptureRequirement(
461,
@"[In m:MoveFolderType Complex Type]The MoveFolderType complex type specifies a request message to move folders in a mailbox.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R429");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R429
this.Site.CaptureRequirementIfAreEqual<string>(
inboxFolderId.Id,
folderInfo.ParentFolderId.Id,
429,
@"[In MoveFolder Operation]The MoveFolder operation moves folders from a specified parent folder and puts them in another parent folder.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R594");
// Verify MS-OXWSFOLD_R594.
// Verify if the values of FolderClass and DisplayName property are changed after the folder being moved.
bool isVerifyR594 = folderInfo.FolderClass == "IPF.MyCustomFolderClass" &&
folderInfo.DisplayName == createFolderRequest.Folders[0].DisplayName;
Site.Log.Add(
LogEntryKind.Debug,
"FolderClass expected to be \"IPF.MyCustomFolderClass\" and actual is {0};\n" +
"DisplayName expected to be {1} and actual is {2};\n ",
folderInfo.FolderClass,
createFolderRequest.Folders[0].DisplayName,
folderInfo.DisplayName);
Site.CaptureRequirementIfIsTrue(
isVerifyR594,
594,
@"[In MoveFolder Operation]The properties FolderClass and DisplayName of the folder move with the folder.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R7501");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R7501
// Only one child folder was created in the folder.
this.Site.CaptureRequirementIfAreEqual<int>(
1,
folderInfo.ChildFolderCount,
7501,
@"[In t:BaseFolderType Complex Type]ChildFolderCount specifies the total number of child folders in a folder.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R5912");
// Child folder count is returned from server so this requirement can be captured.
this.Site.CaptureRequirement(
5912,
@"[In t:BaseFolderType Complex Type]This property[ChildFolderCount] is returned in a response.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R75");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R75
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.ChildFolderCount,
75,
@"[In t:BaseFolderType Complex Type]The type of element ChildFolderCount is xs:int.");
#region Get subfolder in the moved folder
// GetFolder request.
GetFolderType getSubFolderAfterMovedRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, subFolderId);
// Get the specified folder.
GetFolderResponseType getFolderAfterMovedResponse = this.FOLDAdapter.GetFolder(getSubFolderAfterMovedRequest);
// Check the response.
Common.CheckOperationSuccess(getFolderAfterMovedResponse, 1, this.Site);
allFolders = (FolderInfoResponseMessageType)getFolderAfterMovedResponse.ResponseMessages.Items[0];
folderInfo = (BaseFolderType)allFolders.Folders[0];
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R596");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R596
this.Site.CaptureRequirementIfAreEqual<string>(
movedFolderId.ToString(),
folderInfo.ParentFolderId.ToString(),
596,
@"[In MoveFolder Operation]The subfolders of the folder move with the folder.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R68");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R68
// Parent folder id is returned from server, and schema is verified in adapter so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.ParentFolderId,
68,
@"[In t:BaseFolderType Complex Type]The type of element ParentFolderId is t:FolderIdType.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R6801");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R6801
this.Site.CaptureRequirementIfAreEqual<string>(
NewCreatedFolderIds[0].ToString(),
folderInfo.ParentFolderId.ToString(),
6801,
@"[In t:BaseFolderType Complex Type]ParentFolderId specifies the folder identifier and change key for the parent folder.");
}
public void MSOXWSFOLD_S04_TC06_GetTasksFolder()
{
#region Get the tasks folder.
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = DistinguishedFolderIdNameType.tasks;
// GetFolder request.
GetFolderType getTasksFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folder);
// Get the tasks folder.
GetFolderResponseType getTasksFolderResponse = this.FOLDAdapter.GetFolder(getTasksFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getTasksFolderResponse, 1, this.Site);
// Variable to save the folder.
FolderInfoResponseMessageType allFolders = (FolderInfoResponseMessageType)getTasksFolderResponse.ResponseMessages.Items[0];
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R35");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R35
this.Site.CaptureRequirementIfIsInstanceOfType(
allFolders.Folders[0],
typeof(TasksFolderType),
35,
@"[In t:ArrayOfFoldersType Complex Type]The type of element TasksFolder is t:TasksFolderType ([MS-OXWSTASK] section 2.2.4.5).");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R3501");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R3501
this.Site.CaptureRequirementIfIsInstanceOfType(
allFolders.Folders[0],
typeof(TasksFolderType),
3501,
@"[In t:ArrayOfFoldersType Complex Type]TasksFolder represents a Tasks folder that is contained in a mailbox.");
TasksFolderType folderInfo = (TasksFolderType)allFolders.Folders[0];
#endregion
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R589.");
// Verify MS-OXWSFOLD_R589.
Site.CaptureRequirementIfAreEqual<string>(
"IPF.Task",
folderInfo.FolderClass,
589,
@"[In t:BaseFolderType Complex Type]This value[FolderClass] MUST be ""IPF.Task"" for Tasks folders.");
}
public void MSOXWSFOLD_S04_TC07_UnReadCount()
{
#region Get the Inbox folder
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = DistinguishedFolderIdNameType.inbox;
// GetFolder request.
GetFolderType getInboxRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folder);
// Get the Inbox folder.
GetFolderResponseType getInboxResponse = this.FOLDAdapter.GetFolder(getInboxRequest);
// Check the response.
Common.CheckOperationSuccess(getInboxResponse, 1, this.Site);
// Variable to save the folder.
FolderInfoResponseMessageType allFolders = (FolderInfoResponseMessageType)getInboxResponse.ResponseMessages.Items[0];
BaseFolderType folderInfo = (BaseFolderType)allFolders.Folders[0];
// Variable to save the count of unread messages before sent mail to the specific account.
// Save the unread message count.
int count = ((FolderType)folderInfo).UnreadCount;
#endregion
#region Create an unread message.
string itemName = Common.GenerateResourceName(this.Site, "Test Mail");
// Send a mail to User1
ItemIdType itemId = this.CreateItem(Common.GetConfigurationPropertyValue("User1Name", this.Site) + "@" + Common.GetConfigurationPropertyValue("Domain", this.Site), DistinguishedFolderIdNameType.inbox.ToString(), itemName);
this.NewCreatedItemIds.Add(itemId);
#endregion
#region Get the Inbox folder
// Set the request's folderId field.
folder.Id = DistinguishedFolderIdNameType.inbox;
// GetFolder request.
GetFolderType getInboxAfterMailReceivedRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folder);
// Get the Inbox folder.
GetFolderResponseType getInboxAfterMailReceivedResponse = this.FOLDAdapter.GetFolder(getInboxAfterMailReceivedRequest);
// Check the response.
Common.CheckOperationSuccess(getInboxAfterMailReceivedResponse, 1, this.Site);
// Variable to save the folder.
allFolders = (FolderInfoResponseMessageType)getInboxAfterMailReceivedResponse.ResponseMessages.Items[0];
folderInfo = (BaseFolderType)allFolders.Folders[0];
FolderType folderType = (FolderType)folderInfo;
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R99");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R99
// Unread count value is returned from server, and schema is verified in adapter so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
folderType.UnreadCount,
99,
@"[In t:FolderType Complex Type]The type of element UnreadCount is xs:int [XMLSCHEMA2].");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R10010");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R10010
// After sending a new message to mail box, the number of unread messages should be (count + 1).
this.Site.CaptureRequirementIfAreEqual<int>(
1 + count,
folderType.UnreadCount,
10010,
@"[In t:FolderType Complex Type]This element[UnreadCount] MUST exist in responses.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R9901");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R9901
this.Site.CaptureRequirementIfAreEqual<int>(
1 + count,
folderType.UnreadCount,
9901,
@"[In t:FolderType Complex Type]UnreadCount specifies the number of unread items in a folder.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R10011");
// Since R9901 and R100 are captured successfully, this requirement will be captured.
this.Site.CaptureRequirement(
10011,
@"[In t:FolderType Complex Type]This element[UnreadCount] MUST equal the sum of all MessageType complex types ([MS-OXWSMSG] section 2.2.4.1) and PostItemType complex types ([MS-OXWSPOST] section 2.2.4.1) that have the IsRead property set to ""false"".");
}
public void MSOXWSFOLD_S04_TC05_GetNotesFolder()
{
#region Get the notes folder.
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = DistinguishedFolderIdNameType.notes;
// GetFolder request.
GetFolderType getNotesFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folder);
// Get the notes folder.
GetFolderResponseType getNotesFolderResponse = this.FOLDAdapter.GetFolder(getNotesFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getNotesFolderResponse, 1, this.Site);
// Variable to save the folder.
FolderInfoResponseMessageType allFolders = (FolderInfoResponseMessageType)getNotesFolderResponse.ResponseMessages.Items[0];
BaseFolderType folderInfo = (BaseFolderType)allFolders.Folders[0];
#endregion
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R588.");
// Verify MS-OXWSFOLD_R588.
Site.CaptureRequirementIfAreEqual<string>(
"IPF.StickyNote",
folderInfo.FolderClass,
588,
@"[In t:BaseFolderType Complex Type]This value[FolderClass] MUST be ""IPF.StickyNote"" for note folders.");
}
public void MSOXWSFOLD_S04_TC01_GetCalendarFolder()
{
#region Get the Calendar folder.
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = (DistinguishedFolderIdNameType)DistinguishedFolderIdNameType.calendar;
// GetFolder request.
GetFolderType getCalendarFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.IdOnly, folder);
// Set to get additional property : folder class
getCalendarFolderRequest.FolderShape.AdditionalProperties = new BasePathToElementType[]
{
new PathToUnindexedFieldType()
{
FieldURI = UnindexedFieldURIType.folderFolderClass
},
new PathToUnindexedFieldType()
{
FieldURI = UnindexedFieldURIType.folderEffectiveRights
}
};
// Get the Calendar folder.
GetFolderResponseType getCalendarFolderResponse = this.FOLDAdapter.GetFolder(getCalendarFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getCalendarFolderResponse, 1, this.Site);
// Variable to save the folder.
FolderInfoResponseMessageType foldersResponseInfo = (FolderInfoResponseMessageType)getCalendarFolderResponse.ResponseMessages.Items[0];
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R29");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R29
this.Site.CaptureRequirementIfIsInstanceOfType(
foldersResponseInfo.Folders[0],
typeof(CalendarFolderType),
29,
@"[In t:ArrayOfFoldersType Complex Type]The type of element CalendarFolder is t:CalendarFolderType ([MS-OXWSMTGS] section 2.2.4.8).");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R2901");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R2901
this.Site.CaptureRequirementIfIsInstanceOfType(
foldersResponseInfo.Folders[0],
typeof(CalendarFolderType),
2901,
@"[In t:ArrayOfFoldersType Complex Type]CalendarFolder represents a Calendar folder in a mailbox.");
CalendarFolderType folderInfo = (CalendarFolderType)foldersResponseInfo.Folders[0];
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R81");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R81
// Since the schema has been validate and this element is not null, this requirement will be captured.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.EffectiveRights,
81,
@"[In t:BaseFolderType Complex Type]The type of element EffectiveRights is t:EffectiveRightsType ([MS-OXWSCDATA] section 2.2.4.29).");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R5934");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R5934
// Effective rights is returned in response and schema is verified in adapter so this requirement can be captured.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.EffectiveRights,
5934,
@"[In t:BaseFolderType Complex Type]This property[EffectiveRights] is returned in a response.");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R70.");
// Verify MS-OXWSFOLD_R70.
Site.CaptureRequirementIfAreEqual<string>(
"IPF.Appointment",
folderInfo.FolderClass,
70,
@"[In t:BaseFolderType Complex Type]This value[FolderClass] MUST be ""IPF.Appointment"" for Calendar folders.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R42104");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R42104
// Additional property folder class is returned from server and schema is verified in adapter, so this requirement can be captured.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.FolderClass,
42104,
@"[In t:FolderResponseShapeType Complex Type]The element [AdditionalProperties] with type [t:NonEmptyArrayOfPathsToElementType] specifies the identity of additional properties to be returned in a response.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R42105");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R42105
// Additional property folder class is returned from server and schema is verified in adapter, so this requirement can be captured.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.FolderClass,
42105,
@"[In t:FolderResponseShapeType Complex Type][In t:NonEmptyArrayOfPathsToElementType Complex Type] The element [t:Path] with type [t:Path] specifies a property to be returned in a response.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R3864");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R3864
this.Site.CaptureRequirementIfAreEqual<ResponseClassType>(
ResponseClassType.Success,
getCalendarFolderResponse.ResponseMessages.Items[0].ResponseClass,
3864,
@"[In GetFolder Operation]A successful GetFolder operation request returns a GetFolderResponse element with the ResponseClass attribute of the GetFolderResponseMessage element set to ""Success"".");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R38644");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R38644
this.Site.CaptureRequirementIfAreEqual<ResponseCodeType>(
ResponseCodeType.NoError,
getCalendarFolderResponse.ResponseMessages.Items[0].ResponseCode,
38644,
@"[In GetFolder Operation]A successful GetFolder operation request returns a GetFolderResponse element with the ResponseCode element of the GetFolderResponse element set to ""NoError"".");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R575");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R575
// Folder information is returned from server and schema has verified in adapter, so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
foldersResponseInfo,
575,
@"[In m:GetFolderType Complex Type]The GetFolderType complex type specifies a request message to get a folder in a server database.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R428");
// GetFolder operation in this test case gets a distinguished folder : Calendar folder.
this.Site.CaptureRequirement(
428,
@"[In t:NonEmptyArrayOfBaseFolderIdsType Complex Type]DistinguishedFolderId specifies a distinguished folder identifier.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R8402");
// GetFolder operation in this test case gets a distinguished folder : Calendar folder.
this.Site.CaptureRequirement(
8402,
@"[In t:BaseFolderType Complex Type]DistinguishedFolderId specifies an identifier for a folder that can be referenced by name.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R96");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R96
// Folder information is returned from server and schema has verified in adapter, so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
foldersResponseInfo,
96,
@"[In m:FolderInfoResponseMessageType Complex Type]The type of element Folders is t:ArrayOfFoldersType (section 2.2.4.2).");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R9602");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R9602
// Folder information is returned from server and schema has verified in adapter, so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
foldersResponseInfo,
9602,
@"[In m:FolderInfoResponseMessageType Complex Type][Folders] Represents the folders that are returned with the response message.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R8401");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R8401
// Distinguished folder id is set in request and schema is verified in adapter, so if folder information is returned successfully this can be covered.
this.Site.CaptureRequirementIfAreEqual<ResponseClassType>(
ResponseClassType.Success,
getCalendarFolderResponse.ResponseMessages.Items[0].ResponseClass,
8401,
@"[In t:BaseFolderType Complex Type]The type of element DistinguishedFolderId is t:DistinguishedFolderIdNameType ([MS-OXWSCDATA] section 2.2.5.10).");
#endregion
}
public void MSOXWSFOLD_S04_TC02_GetContactsFolder()
{
#region Get the contacts folder.
DistinguishedFolderIdType folder = new DistinguishedFolderIdType();
folder.Id = DistinguishedFolderIdNameType.contacts;
// GetFolder request.
GetFolderType getContactsFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folder);
// Get the Contacts folder.
GetFolderResponseType getContactsFolderResponse = this.FOLDAdapter.GetFolder(getContactsFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getContactsFolderResponse, 1, this.Site);
// Variable to save the folder.
FolderInfoResponseMessageType allFolders = (FolderInfoResponseMessageType)getContactsFolderResponse.ResponseMessages.Items[0];
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R31");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R31
this.Site.CaptureRequirementIfIsInstanceOfType(
allFolders.Folders[0],
typeof(ContactsFolderType),
31,
@"[In t:ArrayOfFoldersType Complex Type]The type of element ContactsFolder is t:ContactsFolderType ([MS-OXWSCONT] section 3.1.4.1.1.6).");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R3301");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R3301
this.Site.CaptureRequirementIfIsInstanceOfType(
allFolders.Folders[0],
typeof(ContactsFolderType),
3301,
@"[In t:ArrayOfFoldersType Complex Type]ContactsFolder represents a Contacts folder in a mailbox.");
ContactsFolderType folderInfo = (ContactsFolderType)allFolders.Folders[0];
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R69");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R69
// Folder class value is returned from server and schema has verified in adapter, so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.FolderClass,
69,
@"[In t:BaseFolderType Complex Type]The type of element FolderClass is xs:string [XMLSCHEMA2].");
// Add the debug information.
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R585.");
// Verify MS-OXWSFOLD_R585.
Site.CaptureRequirementIfAreEqual<string>(
"IPF.Contact",
folderInfo.FolderClass,
585,
@"[In t:BaseFolderType Complex Type]This value[FolderClass] MUST be ""IPF.Contact"" for Contacts folders.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R7101");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R7101
this.Site.CaptureRequirementIfAreEqual<string>(
"Contacts",
folderInfo.DisplayName,
7101,
@"[In t:BaseFolderType Complex Type]DisplayName specifies the display name of the folder.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R71");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R71
// Folder display name is returned from server and schema has verified in adapter, so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.DisplayName,
71,
@"[In t:BaseFolderType Complex Type]The type of element DisplayName is xs:string.");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R66");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R66
// Folder id is returned from server and schema has verified in adapter, so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.FolderId,
66,
@"[In t:BaseFolderType Complex Type]The type of element FolderId is t:FolderIdType ([MS-OXWSCDATA] section 2.2.4.36).");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R6602");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R6602
// Folder id is returned from server and schema is verified in adapter so this requirement can be covered.
this.Site.CaptureRequirementIfIsNotNull(
folderInfo.FolderId,
6602,
@"[In t:BaseFolderType Complex Type]FolderId specifies the folder identifier and change key.");
}
/// <summary>
/// The method searches the mailbox and returns the items that meet a specified search restriction.
/// </summary>
/// <param name="folder">A string that specifies the folder to search.</param>
/// <param name="value">A string that specifies the value for a search restriction.</param>
/// <returns>If the method succeeds, return an array of item; otherwise, return null.</returns>
private ItemIdType[] GetItemIds(string folder, string value)
{
#region Construct FindItem request
FindItemType findRequest = new FindItemType();
if (string.IsNullOrEmpty(folder) || string.IsNullOrEmpty(value))
{
Site.Assert.Fail("Invalid argument: one or more invalid arguments passed to GetItemIds method.");
}
findRequest.ItemShape = new ItemResponseShapeType();
findRequest.ItemShape.BaseShape = DefaultShapeNamesType.AllProperties;
DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType folderIdName;
if (Enum.TryParse<DistinguishedFolderIdNameType>(folder, out folderIdName))
{
folderId.Id = folderIdName;
}
else
{
Site.Assert.Fail("The value of the first argument (foldIdNameType) of FindItem operation is invalid.");
}
findRequest.ParentFolderIds = new BaseFolderIdType[1];
findRequest.ParentFolderIds[0] = folderId;
PathToUnindexedFieldType itemClass = new PathToUnindexedFieldType();
itemClass.FieldURI = UnindexedFieldURIType.itemSubject;
ContainsExpressionType expressionType = new ContainsExpressionType();
expressionType.Item = itemClass;
expressionType.ContainmentMode = ContainmentModeType.Substring;
expressionType.ContainmentModeSpecified = true;
expressionType.ContainmentComparison = ContainmentComparisonType.IgnoreCaseAndNonSpacingCharacters;
expressionType.ContainmentComparisonSpecified = true;
expressionType.Constant = new ConstantValueType();
expressionType.Constant.Value = value;
RestrictionType restriction = new RestrictionType();
restriction.Item = expressionType;
findRequest.Restriction = restriction;
#endregion
#region Get the ids of all ItemId instances
int counter = 0;
int upperBound = int.Parse(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
int waitTime = int.Parse(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
FindItemResponseType findResponse = new FindItemResponseType();
while (counter < upperBound)
{
Thread.Sleep(waitTime);
findResponse = this.exchangeServiceBinding.FindItem(findRequest);
if (findResponse != null
&& findResponse.ResponseMessages != null
&& findResponse.ResponseMessages.Items != null
&& findResponse.ResponseMessages.Items.Length > 0)
{
ArrayOfRealItemsType items = ((FindItemResponseMessageType)findResponse.ResponseMessages.Items[0]).RootFolder.Item as ArrayOfRealItemsType;
if (items.Items != null && items.Items.Length > 0)
{
List<ItemIdType> itemIds = new List<ItemIdType>();
foreach (ItemType item in items.Items)
{
if (item.ItemId != null)
{
itemIds.Add(item.ItemId);
}
}
if (itemIds.Count > 0)
{
return itemIds.ToArray();
}
}
}
counter++;
}
Site.Log.Add(LogEntryKind.Debug, "When there is not any message found by FindItem operation, the retry count is {0}", counter);
return null;
#endregion
}
/// <summary>
/// Log on to a mailbox with a specified user account and create two different-level subfolders in the specified parent folder.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="parentFolderName">Name of the parent folder.</param>
/// <param name="firstLevelSubFolderName">Name of the first level sub folder which will be created under the parent folder.</param>
/// <param name="secondLevelSubFolderName">Name of the second level sub folder which will be created under the first level sub folder.</param>
/// <returns>If the two level sub folders are created successfully, return true; otherwise, return false.</returns>
public bool CreateSubFolders(string userName, string userPassword, string userDomain, string parentFolderName, string firstLevelSubFolderName, string secondLevelSubFolderName)
{
// Log on mailbox with specified user account(userName, userPassword, userDomain).
bool isLoged = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isLoged,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
// Initialize variables
FolderIdType folderId = null;
CreateFolderType createFolderRequest = new CreateFolderType();
string folderClassName = null;
DistinguishedFolderIdNameType parentFolderIdName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), parentFolderName, true);
// Define different folder class name according to different parent folder.
switch (parentFolderIdName)
{
case DistinguishedFolderIdNameType.inbox:
folderClassName = "IPF.Note";
break;
case DistinguishedFolderIdNameType.contacts:
folderClassName = "IPF.Contact";
break;
case DistinguishedFolderIdNameType.calendar:
folderClassName = "IPF.Appointment";
break;
case DistinguishedFolderIdNameType.tasks:
folderClassName = "IPF.Task";
break;
default:
Site.Assume.Fail(string.Format("The parent folder name '{0}' is invalid. Valid values are: inbox, contacts, calendar or tasks.", parentFolderName));
break;
}
// Set parent folder ID.
createFolderRequest.ParentFolderId = new TargetFolderIdType();
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = parentFolderIdName;
createFolderRequest.ParentFolderId.Item = parentFolder;
// Set Display Name and Folder Class for the folder to be created.
FolderType folderProperties = new FolderType();
folderProperties.DisplayName = firstLevelSubFolderName;
folderProperties.FolderClass = folderClassName;
createFolderRequest.Folders = new BaseFolderType[1];
createFolderRequest.Folders[0] = folderProperties;
bool isSubFolderCreated = false;
// Invoke CreateFolder operation and get the response.
CreateFolderResponseType createFolderResponse = this.exchangeServiceBinding.CreateFolder(createFolderRequest);
if (createFolderResponse != null && ResponseClassType.Success == createFolderResponse.ResponseMessages.Items[0].ResponseClass)
{
// If the first level sub folder is created successfully, save the folder ID of it.
folderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
FolderType created = new FolderType() { DisplayName = folderProperties.DisplayName, FolderClass = folderClassName, FolderId = folderId };
AdapterHelper.CreatedFolders.Add(created);
}
// Create another sub folder under the created folder above.
if (folderId != null)
{
createFolderRequest.ParentFolderId.Item = folderId;
folderProperties.DisplayName = secondLevelSubFolderName;
createFolderResponse = this.exchangeServiceBinding.CreateFolder(createFolderRequest);
if (createFolderResponse != null && ResponseClassType.Success == createFolderResponse.ResponseMessages.Items[0].ResponseClass)
{
// If the two level sub folders are created successfully, return true; otherwise, return false.
isSubFolderCreated = true;
folderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
FolderType created = new FolderType() { DisplayName = folderProperties.DisplayName, FolderClass = folderClassName, FolderId = folderId };
AdapterHelper.CreatedFolders.Add(created);
}
}
return isSubFolderCreated;
}
public void MSOXWSFOLD_S06_TC06_UpdateDistinguishedFolder()
{
#region Get the sent items folder.
DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
folderId.Id = DistinguishedFolderIdNameType.sentitems;
// GetFolder request.
GetFolderType getSentItemsFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folderId);
GetFolderResponseType getSentItemsFolderResponse = this.FOLDAdapter.GetFolder(getSentItemsFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getSentItemsFolderResponse, 1, this.Site);
// Variable to save the folder.
FolderInfoResponseMessageType allFolders = (FolderInfoResponseMessageType)getSentItemsFolderResponse.ResponseMessages.Items[0];
BaseFolderType folderInfo = (BaseFolderType)allFolders.Folders[0];
#endregion
#region Update Folder Operation.
// UpdateFolder request to delete folder permission value.
UpdateFolderType updateFolderRequest = this.GetUpdateFolderRequest("Folder", "DeleteFolderField", folderInfo.FolderId);
// Set change key value.
folderId.ChangeKey = folderInfo.FolderId.ChangeKey;
updateFolderRequest.FolderChanges[0].Item = folderId;
// Update the specific folder's properties.
UpdateFolderResponseType updateFolderResponse = this.FOLDAdapter.UpdateFolder(updateFolderRequest);
// Check the response.
Common.CheckOperationSuccess(updateFolderResponse, 1, this.Site);
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R9101");
// Distinguished folder id set and update folder return a successfully, this requirement can be captured.
this.Site.CaptureRequirement(
9101,
@"[In t:FolderChangeType Complex Type]DistinguishedFolderId specifies an identifier for a distinguished folder.");
}
public void MSOXWSFOLD_S02_TC02_CopyMultipleFolders()
{
#region Copy the "drafts" and "deleteditems" folder to inbox
// Set "drafts" and "deleteditems" folders' Id.
DistinguishedFolderIdType copiedFolderId1 = new DistinguishedFolderIdType();
copiedFolderId1.Id = DistinguishedFolderIdNameType.drafts;
DistinguishedFolderIdType copiedFolderId2 = new DistinguishedFolderIdType();
copiedFolderId2.Id = DistinguishedFolderIdNameType.deleteditems;
// CopyFolder request.
CopyFolderType copyFolderRequest = this.GetCopyFolderRequest(DistinguishedFolderIdNameType.inbox.ToString(), copiedFolderId1, copiedFolderId2);
// Copy the "drafts" and "deleteditems" folder.
CopyFolderResponseType copyFolderResponse = this.FOLDAdapter.CopyFolder(copyFolderRequest);
// Check the response.
Common.CheckOperationSuccess(copyFolderResponse, 2, this.Site);
// Save copied folders' id.
FolderIdType folderId1 = ((FolderInfoResponseMessageType)copyFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
FolderIdType folderId2 = ((FolderInfoResponseMessageType)copyFolderResponse.ResponseMessages.Items[1]).Folders[0].FolderId;
// Save the copied folders' id.
this.NewCreatedFolderIds.Add(folderId1);
this.NewCreatedFolderIds.Add(folderId2);
#endregion
}
public void MSOXWSFOLD_S03_TC03_MoveFolderFailed()
{
#region Create a new folder in the inbox folder
// CreateFolder request.
CreateFolderType createFolderRequest = this.GetCreateFolderRequest(DistinguishedFolderIdNameType.inbox.ToString(), new string[] { "Custom Folder" }, new string[] { "IPF.MyCustomFolderClass" }, null);
// Create a new folder.
CreateFolderResponseType createFolderResponse = this.FOLDAdapter.CreateFolder(createFolderRequest);
// Check the response.
Common.CheckOperationSuccess(createFolderResponse, 1, this.Site);
// Save the new created folder's folder id.
FolderIdType newFolderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
this.NewCreatedFolderIds.Add(newFolderId);
#endregion
#region Delete the created folder
// DeleteFolder request.
DeleteFolderType deleteFolderRequest = this.GetDeleteFolderRequest(DisposalType.HardDelete, newFolderId);
// Delete the specified folder.
DeleteFolderResponseType deleteFolderResponse = this.FOLDAdapter.DeleteFolder(deleteFolderRequest);
// Check the response.
Common.CheckOperationSuccess(deleteFolderResponse, 1, this.Site);
// The folder has been deleted, so its folder id has disappeared.
this.NewCreatedFolderIds.Remove(newFolderId);
#endregion
#region Move the deleted folder
MoveFolderType moveFolderRequest = new MoveFolderType();
moveFolderRequest.FolderIds = new BaseFolderIdType[1];
moveFolderRequest.FolderIds[0] = newFolderId;
DistinguishedFolderIdType toFolderId = new DistinguishedFolderIdType();
toFolderId.Id = DistinguishedFolderIdNameType.inbox;
moveFolderRequest.ToFolderId = new TargetFolderIdType();
moveFolderRequest.ToFolderId.Item = toFolderId;
// Move the specified folder.
MoveFolderResponseType moveFolderResponse = this.FOLDAdapter.MoveFolder(moveFolderRequest);
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R4315");
this.Site.CaptureRequirementIfAreEqual<ResponseClassType>(
ResponseClassType.Error,
moveFolderResponse.ResponseMessages.Items[0].ResponseClass,
4315,
@"[In MoveFolder Operation]An unsuccessful MoveFolder operation request returns a MoveFolderResponse element with the ResponseClass attribute of the MoveFolderResponseMessage element set to ""Error"".");
#endregion
}
public void MSOXWSMTGS_S04_TC04_MoveItemErrorCalendarCannotMoveOrCopyOccurrence()
{
#region Define a recurring calendar item
DateTime startTime = DateTime.Now;
DailyRecurrencePatternType pattern = new DailyRecurrencePatternType();
pattern.Interval = this.PatternInterval;
NumberedRecurrenceRangeType range = new NumberedRecurrenceRangeType();
range.NumberOfOccurrences = this.NumberOfOccurrences;
range.StartDate = startTime;
CalendarItemType calendarItem = new CalendarItemType();
calendarItem.UID = Guid.NewGuid().ToString();
calendarItem.Subject = this.Subject;
calendarItem.Start = startTime;
calendarItem.StartSpecified = true;
calendarItem.End = startTime.AddHours(this.TimeInterval);
calendarItem.EndSpecified = true;
calendarItem.Recurrence = new RecurrenceType();
calendarItem.Recurrence.Item = pattern;
calendarItem.Recurrence.Item1 = range;
#endregion
#region Create the recurring calendar item and extract the Id of an occurrence item
ItemInfoResponseMessageType item = this.CreateSingleCalendarItem(Role.Organizer, calendarItem, CalendarItemCreateOrDeleteOperationType.SendToNone);
OccurrenceItemIdType occurrenceItemId = new OccurrenceItemIdType();
occurrenceItemId.ChangeKey = item.Items.Items[0].ItemId.ChangeKey;
occurrenceItemId.RecurringMasterId = item.Items.Items[0].ItemId.Id;
occurrenceItemId.InstanceIndex = this.InstanceIndex;
#endregion
#region Copy one occurrence of the recurring calendar item
DistinguishedFolderIdType folderId = new DistinguishedFolderIdType();
folderId.Id = DistinguishedFolderIdNameType.drafts;
TargetFolderIdType targetFolderId = new TargetFolderIdType();
targetFolderId.Item = folderId;
MoveItemType moveItemRequest = new MoveItemType();
moveItemRequest.ItemIds = new BaseItemIdType[] { occurrenceItemId };
moveItemRequest.ToFolderId = targetFolderId;
MoveItemResponseType response = this.MTGSAdapter.MoveItem(moveItemRequest);
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSMTGS_R1228");
// Verify MS-OXWSMSG requirement: MS-OXWSMTGS_R1228
Site.CaptureRequirementIfAreEqual<ResponseClassType>(
ResponseClassType.Error,
response.ResponseMessages.Items[0].ResponseClass,
1228,
@"[In Messages] If the request is unsuccessful, the MoveItem operation returns a MoveItemResponse element with the ResponseClass attribute of the MoveItemResponseMessage element set to ""Error"". ");
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSMTGS_R1231");
// Verify MS-OXWSMSG requirement: MS-OXWSMTGS_R1231
Site.CaptureRequirementIfAreEqual<ResponseCodeType>(
ResponseCodeType.ErrorCalendarCannotMoveOrCopyOccurrence,
response.ResponseMessages.Items[0].ResponseCode,
1231,
@"[In Messages] ErrorCalendarCannotMoveOrCopyOccurrence: Specifies that an attempt was made to move or copy an occurrence of a recurring calendar item.");
#endregion
#region Clean up organizer's calendar folders.
this.CleanupFoldersByRole(Role.Organizer, new List<DistinguishedFolderIdNameType>() { DistinguishedFolderIdNameType.calendar });
#endregion
}
/// <summary>
/// Log on to a mailbox with a specified user account and create a search folder.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="searchFolderName">Name of the search folder.</param>
/// <param name="searchText">Search text of the search folder.</param>
/// <returns>If the search folder is created successfully, return true; otherwise, return false.</returns>
public bool CreateSearchFolder(string userName, string userPassword, string userDomain, string searchFolderName, string searchText)
{
// Log on mailbox with specified user account(userName, userPassword, userDomain).
bool isLoged = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isLoged,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
// Create the request.
CreateFolderType createFolder = new CreateFolderType();
SearchFolderType[] folderArray = new SearchFolderType[1];
SearchFolderType searchFolder = new SearchFolderType();
// Use the following search filter to get all mail in the Inbox with the word searchText in the subject line.
searchFolder.SearchParameters = new SearchParametersType();
searchFolder.SearchParameters.Traversal = SearchFolderTraversalType.Deep;
searchFolder.SearchParameters.TraversalSpecified = true;
searchFolder.SearchParameters.BaseFolderIds = new DistinguishedFolderIdType[4];
// Create a distinguished folder Identified of the inbox folder.
DistinguishedFolderIdType inboxFolder = new DistinguishedFolderIdType();
inboxFolder.Id = new DistinguishedFolderIdNameType();
inboxFolder.Id = DistinguishedFolderIdNameType.inbox;
searchFolder.SearchParameters.BaseFolderIds[0] = inboxFolder;
DistinguishedFolderIdType contactType = new DistinguishedFolderIdType();
contactType.Id = new DistinguishedFolderIdNameType();
contactType.Id = DistinguishedFolderIdNameType.contacts;
searchFolder.SearchParameters.BaseFolderIds[1] = contactType;
DistinguishedFolderIdType calendarType = new DistinguishedFolderIdType();
calendarType.Id = new DistinguishedFolderIdNameType();
calendarType.Id = DistinguishedFolderIdNameType.calendar;
searchFolder.SearchParameters.BaseFolderIds[2] = calendarType;
DistinguishedFolderIdType taskType = new DistinguishedFolderIdType();
taskType.Id = new DistinguishedFolderIdNameType();
taskType.Id = DistinguishedFolderIdNameType.calendar;
searchFolder.SearchParameters.BaseFolderIds[3] = taskType;
// Use the following search filter.
searchFolder.SearchParameters.Restriction = new RestrictionType();
PathToUnindexedFieldType path = new PathToUnindexedFieldType();
path.FieldURI = UnindexedFieldURIType.itemSubject;
RestrictionType restriction = new RestrictionType();
FieldURIOrConstantType fieldURIORConstant = new FieldURIOrConstantType();
fieldURIORConstant.Item = new ConstantValueType();
(fieldURIORConstant.Item as ConstantValueType).Value = searchText;
ExistsType isEqual = new ExistsType();
isEqual.Item = path;
restriction.Item = isEqual;
searchFolder.SearchParameters.Restriction = restriction;
// Give the search folder a unique name.
searchFolder.DisplayName = searchFolderName;
folderArray[0] = searchFolder;
// Create the search folder under the default Search Folder.
TargetFolderIdType targetFolder = new TargetFolderIdType();
DistinguishedFolderIdType searchFolders = new DistinguishedFolderIdType();
searchFolders.Id = DistinguishedFolderIdNameType.searchfolders;
targetFolder.Item = searchFolders;
createFolder.ParentFolderId = targetFolder;
createFolder.Folders = folderArray;
bool isSearchFolderCreated = false;
// Invoke CreateFolder operation and get the response.
CreateFolderResponseType response = this.exchangeServiceBinding.CreateFolder(createFolder);
if (response != null && ResponseClassType.Success == response.ResponseMessages.Items[0].ResponseClass)
{
// If the search folder is created successfully, return true; otherwise, return false.
isSearchFolderCreated = true;
searchFolder.FolderId = ((FolderInfoResponseMessageType)response.ResponseMessages.Items[0]).Folders[0].FolderId;
AdapterHelper.CreatedFolders.Add(searchFolder);
}
return isSearchFolderCreated;
}
/// <summary>
/// Create item within a specific folder.
/// </summary>
/// <param name="toAddress">To address of created item</param>
/// <param name="folderId">Parent folder id of the created item.</param>
/// <param name="subject">Subject of the item.</param>
/// <returns>Id of created item.</returns>
protected ItemIdType CreateItem(string toAddress, string folderId, string subject)
{
CreateItemType createItemRequest = new CreateItemType();
createItemRequest.MessageDispositionSpecified = true;
createItemRequest.MessageDisposition = MessageDispositionType.SaveOnly;
createItemRequest.SendMeetingInvitations = CalendarItemCreateOrDeleteOperationType.SendToAllAndSaveCopy;
createItemRequest.SendMeetingInvitationsSpecified = true;
createItemRequest.SavedItemFolderId = new TargetFolderIdType();
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType distinguishedFolderIdName = new DistinguishedFolderIdNameType();
bool isSuccess = Enum.TryParse<DistinguishedFolderIdNameType>(folderId, true, out distinguishedFolderIdName);
if (isSuccess)
{
distinguishedFolderId.Id = distinguishedFolderIdName;
createItemRequest.SavedItemFolderId.Item = distinguishedFolderId;
}
else
{
FolderIdType id = new FolderIdType();
id.Id = folderId;
createItemRequest.SavedItemFolderId.Item = id;
}
MessageType message = new MessageType();
message.Subject = subject;
EmailAddressType address = new EmailAddressType();
address.EmailAddress = toAddress;
// Set this message to unread.
message.IsRead = false;
message.IsReadSpecified = true;
message.ToRecipients = new EmailAddressType[1];
message.ToRecipients[0] = address;
BodyType body = new BodyType();
body.Value = Common.GenerateResourceName(this.Site, "Test Mail Body");
message.Body = body;
createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
createItemRequest.Items.Items = new ItemType[1];
createItemRequest.Items.Items[0] = message;
CreateItemResponseType createItemResponse = this.COREAdapter.CreateItem(createItemRequest);
ItemInfoResponseMessageType itemInfo = (ItemInfoResponseMessageType)createItemResponse.ResponseMessages.Items[0];
// Return item id.
if (itemInfo.Items.Items != null)
{
return itemInfo.Items.Items[0].ItemId;
}
else
{
return null;
}
}
public void MSOXWSCONT_S01_TC09_VerifyErrorCannotCreateContactInNonContactFolder()
{
#region Step 1:Create the contact item.
CreateItemType createItemRequest = new CreateItemType();
#region Config the contact item
createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
createItemRequest.Items.Items = new ContactItemType[1];
// Create a contact item without optional elements.
createItemRequest.Items.Items[0] = this.BuildContactItemWithRequiredProperties();
// Configure create item to draft folder to trigger the error.
DistinguishedFolderIdType errorDistinguishedFolderId = new DistinguishedFolderIdType();
errorDistinguishedFolderId.Id = DistinguishedFolderIdNameType.drafts;
createItemRequest.SavedItemFolderId = new TargetFolderIdType();
createItemRequest.SavedItemFolderId.Item = errorDistinguishedFolderId;
#endregion
CreateItemResponseType createItemResponse = this.CONTAdapter.CreateItem(createItemRequest);
Site.Assert.AreEqual<int>(
1,
createItemResponse.ResponseMessages.Items.GetLength(0),
"Expected Item Count: {0}, Actual Item Count: {1}",
1,
createItemResponse.ResponseMessages.Items.GetLength(0));
#endregion
#region Capture Code
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSCDATA_R262");
// Verify MS-OXWSCDATA requirement: MS-OXWSCDATA_R262
Site.CaptureRequirementIfAreEqual<ResponseCodeType>(
ResponseCodeType.ErrorCannotCreateContactInNonContactFolder,
createItemResponse.ResponseMessages.Items[0].ResponseCode,
"MS-OXWSCDATA",
262,
@"[In m:ResponseCodeType Simple Type]The value ""ErrorCannotCreateContactInNonContactFolder"" specifies that an attempt was made to create a contact in a folder other than the Contacts folder.");
#endregion
}
/// <summary>
/// Find if item within a specific folder is deleted.
/// </summary>
/// <param name="folderName">The name of the folder to search item.</param>
/// <param name="itemSubject">The subject of the item to be searched.</param>
/// <returns>If item has been deleted.</returns>
protected bool IfItemDeleted(string folderName, string itemSubject)
{
// Create the request and specify the parent folder ID.
FindItemType findItemRequest = new FindItemType();
findItemRequest.ParentFolderIds = new BaseFolderIdType[1];
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), folderName, true);
findItemRequest.ParentFolderIds[0] = parentFolder;
// Get properties that are defined as the default for the items.
findItemRequest.ItemShape = new ItemResponseShapeType();
findItemRequest.ItemShape.BaseShape = DefaultShapeNamesType.AllProperties;
// Await the item created properly.
int sleepTime = Convert.ToInt32(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
int retryCount = Convert.ToInt32(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
int timesOfSleep = 0;
bool itemDeleted = true;
do
{
itemDeleted = true;
Thread.Sleep(sleepTime);
// Invoke the FindItem operation.
FindItemResponseType findItemResponse = this.SRCHAdapter.FindItem(findItemRequest);
if (findItemResponse != null)
{
// Get the found items from the response.
FindItemResponseMessageType findItemMessage = findItemResponse.ResponseMessages.Items[0] as FindItemResponseMessageType;
ArrayOfRealItemsType itemArray = findItemMessage.RootFolder.Item as ArrayOfRealItemsType;
ItemType[] items = itemArray.Items;
if (items != null)
{
foreach (ItemType item in items)
{
if (item.Subject == itemSubject)
{
itemDeleted = false;
break;
}
}
}
timesOfSleep++;
}
}
while (!itemDeleted && timesOfSleep <= retryCount);
return itemDeleted;
}
public void MSOXWSFOLD_S02_TC01_CopyFolder()
{
#region Copy the "drafts" folder to the inbox folder
// Identify the folders to be copied.
DistinguishedFolderIdType copiedFolderId = new DistinguishedFolderIdType();
copiedFolderId.Id = DistinguishedFolderIdNameType.drafts;
// CopyFolder request.
CopyFolderType copyFolderRequest = this.GetCopyFolderRequest(DistinguishedFolderIdNameType.inbox.ToString(), copiedFolderId);
// Copy the "drafts" folder.
CopyFolderResponseType copyFolderResponse = this.FOLDAdapter.CopyFolder(copyFolderRequest);
// Check the response.
Common.CheckOperationSuccess(copyFolderResponse, 1, this.Site);
// Variable to save the folder.
FolderIdType folderId = ((FolderInfoResponseMessageType)copyFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
// Save the copied folder's folder id.
this.NewCreatedFolderIds.Add(folderId);
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R1852");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R1852
this.Site.CaptureRequirementIfAreEqual<ResponseClassType>(
ResponseClassType.Success,
copyFolderResponse.ResponseMessages.Items[0].ResponseClass,
1852,
@"[In CopyFolder Operation]A successful CopyFolder operation request returns a CopyFolderResponse element with the ResponseClass attribute of the CopyFolderResponseMessage element set to ""Success"".");
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R185222");
// Verify MS-OXWSFOLD requirement: MS-OXWSFOLD_R185222
this.Site.CaptureRequirementIfAreEqual<ResponseCodeType>(
ResponseCodeType.NoError,
copyFolderResponse.ResponseMessages.Items[0].ResponseCode,
185222,
@"[In CopyFolder Operation]A successful CopyFolder operation request returns a CopyFolderResponse element with the ResponseCode element of the CopyFolderResponse element set to ""NoError"".");
#region Get the new copied folder
// GetFolder request.
GetFolderType getSubFolderRequest = this.GetGetFolderRequest(DefaultShapeNamesType.AllProperties, folderId);
// Get the specified folder.
GetFolderResponseType getSubFolderResponse = this.FOLDAdapter.GetFolder(getSubFolderRequest);
// Check the response.
Common.CheckOperationSuccess(getSubFolderResponse, 1, this.Site);
#endregion
// Add the debug information
this.Site.Log.Add(LogEntryKind.Debug, "Verify MS-OXWSFOLD_R211");
// The copied folder can be gotten successfully through returned folder id, so the draft folder was copied.
this.Site.CaptureRequirement(
211,
@"[In m:CopyFolderType Complex Type]The CopyFolderType complex type specifies a request message to copy folders in a server database.");
}
/// <summary>
/// Set related folder properties of create folder request
/// </summary>
/// <param name="displayNames">Display names of folders that will be set into create folder request.</param>
/// <param name="folderClasses">Folder class values of folders that will be set into create folder request.</param>
/// <param name="folderPermissions">Folder permission values of folders that will be set into create folder request. </param>
/// <param name="createFolderRequest">Create folder request instance that needs to set property values.</param>
/// <returns>Create folder request instance that have folder property value configured.</returns>
protected CreateFolderType ConfigureFolderProperty(string[] displayNames, string[] folderClasses, PermissionSetType[] folderPermissions, CreateFolderType createFolderRequest)
{
Site.Assert.IsNotNull(displayNames, "Display names should not be null!");
Site.Assert.IsNotNull(folderClasses, "Folder classes should not be null!");
Site.Assert.AreEqual<int>(displayNames.Length, folderClasses.Length, "Folder names count should equals to folder class value count!");
if (folderPermissions != null)
{
Site.Assert.AreEqual<int>(displayNames.Length, folderPermissions.Length, "Folder names count should equals to folder permission value count!");
}
int folderCount = displayNames.Length;
createFolderRequest.Folders = new BaseFolderType[folderCount];
for (int folderPropertyIndex = 0; folderPropertyIndex < folderCount; folderPropertyIndex++)
{
string folderResourceName = Common.GenerateResourceName(this.Site, displayNames[folderPropertyIndex]);
if (folderClasses[folderPropertyIndex] == "IPF.Appointment")
{
CalendarFolderType calendarFolder = new CalendarFolderType();
calendarFolder.DisplayName = folderResourceName;
createFolderRequest.Folders[folderPropertyIndex] = calendarFolder;
}
else if (folderClasses[folderPropertyIndex] == "IPF.Contact")
{
ContactsFolderType contactFolder = new ContactsFolderType();
contactFolder.DisplayName = folderResourceName;
if (folderPermissions != null)
{
contactFolder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = contactFolder;
}
else if (folderClasses[folderPropertyIndex] == "IPF.Task")
{
TasksFolderType taskFolder = new TasksFolderType();
taskFolder.DisplayName = folderResourceName;
if (folderPermissions != null)
{
taskFolder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = taskFolder;
}
else if (folderClasses[folderPropertyIndex] == "IPF.Search")
{
SearchFolderType searchFolder = new SearchFolderType();
searchFolder.DisplayName = folderResourceName;
// Set search parameters.
searchFolder.SearchParameters = new SearchParametersType();
searchFolder.SearchParameters.Traversal = SearchFolderTraversalType.Deep;
searchFolder.SearchParameters.TraversalSpecified = true;
searchFolder.SearchParameters.BaseFolderIds = new DistinguishedFolderIdType[1];
DistinguishedFolderIdType inboxType = new DistinguishedFolderIdType();
inboxType.Id = new DistinguishedFolderIdNameType();
inboxType.Id = DistinguishedFolderIdNameType.inbox;
searchFolder.SearchParameters.BaseFolderIds[0] = inboxType;
// Use the following search filter
searchFolder.SearchParameters.Restriction = new RestrictionType();
PathToUnindexedFieldType path = new PathToUnindexedFieldType();
path.FieldURI = UnindexedFieldURIType.itemSubject;
RestrictionType restriction = new RestrictionType();
ExistsType isEqual = new ExistsType();
isEqual.Item = path;
restriction.Item = isEqual;
searchFolder.SearchParameters.Restriction = restriction;
if (folderPermissions != null)
{
searchFolder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = searchFolder;
}
else
{
// Set Display Name and Folder Class for the folder to be created.
FolderType folder = new FolderType();
folder.DisplayName = folderResourceName;
folder.FolderClass = folderClasses[folderPropertyIndex];
if (folderPermissions != null)
{
folder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = folder;
}
}
return createFolderRequest;
}