public void OctaneMyItemsViewModelTests_Refresh_ItemRemoved_Success()
{
var defect = DefectUtilities.CreateDefect();
bool removed = false;
try
{
var viewModel = new OctaneMyItemsViewModel();
viewModel.LoadMyItemsAsync().Wait();
var myItems = viewModel.MyItems.ToList();
Assert.AreEqual(1, myItems.Count(item => item.ID == defect.Id), $"Couldn't find entity {defect.Name}");
EntityService.DeleteById <Defect>(WorkspaceContext, defect.Id);
removed = true;
viewModel.RefreshCommand.Execute(null);
Utility.WaitUntil(() => viewModel.Mode == MainWindowMode.ItemsLoaded,
"Timeout waiting for Refresh to finish", new TimeSpan(0, 0, 30));
myItems = viewModel.MyItems.ToList();
Assert.AreEqual(0, myItems.Count(item => item.ID == defect.Id), $"Found previously deleted entity {defect.Name} after refresh");
}
finally
{
if (!removed)
{
EntityService.DeleteById <Defect>(WorkspaceContext, defect.Id);
}
}
}
public void DetailedItemViewModelTests_VisibleFields_MultipleEntitiesOfSameTime_ChangesAreReflectedInAllEntities()
{
var viewModel = new DetailedItemViewModel(_story);
viewModel.InitializeAsync().Wait();
var secondStory = StoryUtilities.CreateStory();
try
{
var secondViewModel = new DetailedItemViewModel(_story);
secondViewModel.InitializeAsync().Wait();
ChangeFieldVisibility(viewModel, "Release", false);
ChangeFieldVisibility(viewModel, "Committers", true);
var expectedVisibleFields = viewModel.VisibleFields.Select(f => f.Name).OrderBy(f => f).ToList();
var actualVisibleFields = secondViewModel.FilteredEntityFields.Where(f => f.IsSelected).Select(f => f.Name).OrderBy(f => f).ToList();
CollectionAssert.AreEqual(expectedVisibleFields, actualVisibleFields, "Mismathed visible fields");
}
finally
{
EntityService.DeleteById <Story>(WorkspaceContext, secondStory.Id);
}
}
public void OctaneMyItemsViewModelTests_MyItems_NotSupported_Feature_Success()
{
var epic = EpicUtilities.CreateEpic();
try
{
ValidateType(FeatureUtilities.CreateFeature(epic), 0);
}
finally
{
EntityService.DeleteById <Epic>(WorkspaceContext, epic.Id);
}
}
public void OctaneMyItemsViewModelTests_MyItems_Supported_Task_Success()
{
var story = StoryUtilities.CreateStory();
try
{
ValidateType(TaskUtilities.CreateTask(story), 1);
}
finally
{
EntityService.DeleteById <Story>(WorkspaceContext, story.Id);
}
}
public static void ClassCleanup()
{
EntityService.DeleteById <Story>(WorkspaceContext, _story.Id);
EntityService.DeleteById <Epic>(WorkspaceContext, _epic.Id);
EntityService.DeleteById <TestGherkin>(WorkspaceContext, _gherkinTest.Id);
EntityService.DeleteById <Story>(WorkspaceContext, _storyQuote.Id);
EntityService.DeleteById <Story>(WorkspaceContext, _storyDoubleQuote.Id);
EntityService.DeleteById <Story>(WorkspaceContext, _refreshStory.Id);
EntityService.DeleteById <Epic>(WorkspaceContext, _refreshEpic.Id);
EntityService.DeleteById <TestGherkin>(WorkspaceContext, _refreshGherkinTest.Id);
}
public void OctaneMyItemsViewModelTests_MyItems_Supported_ManualRun_Success()
{
var manualTest = TestManualUtilities.CreateManualTest();
var manualRun = RunManualUtilities.CreateManualRun(manualTest);
Thread.Sleep(1500);
try
{
ValidateType(manualRun, 1);
}
finally
{
EntityService.DeleteById <TestManual>(WorkspaceContext, manualTest.Id);
}
}
public void OctaneMyItemsViewModelTests_MyItems_Supported_SuiteRun_Success()
{
var testSuite = TestSuiteUtilities.CreateTestSuite();
var suiteRun = RunSuiteUtilities.CreateSuiteRun(testSuite);
Thread.Sleep(1500);
try
{
ValidateType(suiteRun, 1);
}
finally
{
EntityService.DeleteById <TestSuite>(WorkspaceContext, testSuite.Id);
}
}
private void ValidateType <T>(T entity, int expectedCount) where T : BaseEntity
{
try
{
var viewModel = new OctaneMyItemsViewModel();
viewModel.LoadMyItemsAsync().Wait();
Assert.AreEqual(expectedCount, viewModel.MyItems.Count(i => i.ID == entity.Id && i.Entity.Name == entity.Name),
$"Couldn't find exactly one entity with the name {entity.Name}");
}
finally
{
EntityService.DeleteById <T>(WorkspaceContext, entity.Id);
}
}
public void ToolWindowHelperTests_ConstructContextMenu_Feature_Success()
{
var epic = EpicUtilities.CreateEpic();
try
{
ValidateContextMenuItems(FeatureUtilities.CreateFeature(epic),
new List <MenuItemEnum>
{
MenuItemEnum.OpenInBrowser,
}, false);
}
finally
{
EntityService.DeleteById <Epic>(WorkspaceContext, epic.Id);
}
}
public void ToolWindowHelperTests_ConstructContextMenu_ManualRun_Success()
{
var manualTest = TestManualUtilities.CreateManualTest();
var manualRun = RunManualUtilities.CreateManualRun(manualTest);
Thread.Sleep(1500);
try
{
ValidateContextMenuItems(manualRun,
new List <MenuItemEnum>
{
MenuItemEnum.ViewDetails,
MenuItemEnum.OpenInBrowser,
});
}
finally
{
EntityService.DeleteById <TestManual>(WorkspaceContext, manualTest.Id);
}
}
public void ToolWindowHelperTests_ConstructContextMenu_SuiteRun_Success()
{
var testSuite = TestSuiteUtilities.CreateTestSuite();
var suiteRun = RunSuiteUtilities.CreateSuiteRun(testSuite);
Thread.Sleep(1500);
try
{
ValidateContextMenuItems(suiteRun,
new List <MenuItemEnum>
{
MenuItemEnum.ViewDetails,
MenuItemEnum.OpenInBrowser,
});
}
finally
{
EntityService.DeleteById <TestSuite>(WorkspaceContext, testSuite.Id);
}
}
public void ToolWindowHelperTests_ContextMenuForActiveItem_Task_Success()
{
var story = StoryUtilities.CreateStory();
try
{
ValidateContextMenuItems(TaskUtilities.CreateTask(story),
new List <MenuItemEnum>
{
MenuItemEnum.ViewDetails,
MenuItemEnum.TaskViewParentDetails,
MenuItemEnum.OpenInBrowser,
MenuItemEnum.StopWork,
MenuItemEnum.CopyCommitMessage
}, true, true);
}
finally
{
EntityService.DeleteById <Story>(WorkspaceContext, story.Id);
}
}
public void SearchItemsViewModelTests_Refresh_Changes_Success()
{
var viewModel = new SearchItemsViewModel(_refreshGuid.ToString());
ValidateSearch(viewModel, new List <BaseEntity> {
_refreshStory, _refreshEpic, _refreshGherkinTest
});
var newEpic = EpicUtilities.CreateEpic("Epic2_" + _refreshGuid);
try
{
viewModel.RefreshCommand.Execute(null);
ValidateSearch(viewModel, new List <BaseEntity> {
_refreshStory, _refreshEpic, _refreshGherkinTest, newEpic
});
}
finally
{
EntityService.DeleteById <Epic>(WorkspaceContext, newEpic.Id);
}
}
///<summary>
///Removes an entity from my work
/// </summary>
public void RemoveFromMyWork(UserItem entity)
{
RestConnector.AwaitContinueOnCapturedContext = false;
es.DeleteById <UserItem>(workspaceContext, entity.Id);
}
public static void ClassCleanup()
{
EntityService.DeleteById <Story>(WorkspaceContext, _addedStory.Id);
EntityService.DeleteById <Story>(WorkspaceContext, _dismissedStory.Id);
}
// TODO remove useMyItems and use a more generic mechanism to obtain the BaseItemViewModel
private void ValidateContextMenuItems <T>(T entity, List <MenuItemEnum> expectedMenuItems, bool useMyItems = true, bool setActiveItem = false) where T : BaseEntity
{
try
{
BaseItemViewModel selectedItem;
if (useMyItems)
{
var viewModel = new OctaneMyItemsViewModel();
viewModel.LoadMyItemsAsync().Wait();
selectedItem = viewModel.MyItems.FirstOrDefault(i => i.ID == entity.Id);
if (setActiveItem)
{
OctaneItemViewModel.SetActiveItem(selectedItem as OctaneItemViewModel);
}
}
else
{
selectedItem = new BaseItemViewModel(entity);
}
Assert.IsNotNull(selectedItem, "Couldn't find entity");
var cm = new ContextMenu();
ToolWindowHelper.ConstructContextMenu(cm, selectedItem,
_viewDetailsDelegate,
_viewTaskParentDetailsDelegate,
_viewCommentParentDetailsDelegate,
_openInBrowserDelegate,
_copyCommitMessageDelegate,
_downloadScriptDelegate,
_startWorkDelegate,
_stopWorkDelegate,
null,
null);
Assert.AreEqual(expectedMenuItems.Count, cm.Items.Count,
"Mismatched number of menu items in context menu");
var items = new MenuItem[cm.Items.Count];
cm.Items.CopyTo(items, 0);
int index = 0;
foreach (var item in expectedMenuItems)
{
switch (item)
{
case MenuItemEnum.ViewDetails:
ValidateMenuItem(items, index, ToolWindowHelper.ViewDetailsHeader, ViewDetailsValue);
break;
case MenuItemEnum.TaskViewParentDetails:
ValidateMenuItem(items, index, ToolWindowHelper.ViewTaskParentDetailsHeader, ViewTaskParentDetailsValue);
break;
case MenuItemEnum.CommentViewParentDetails:
ValidateMenuItem(items, index, ToolWindowHelper.CopyCommitMessageHeader, ViewCommentParentDetailsValue);
break;
case MenuItemEnum.OpenInBrowser:
ValidateMenuItem(items, index, ToolWindowHelper.OpenInBrowserHeader, OpenInBrowserValue);
break;
case MenuItemEnum.CopyCommitMessage:
ValidateMenuItem(items, index, ToolWindowHelper.CopyCommitMessageHeader, CopyCommitMessageValue);
break;
case MenuItemEnum.DownloadScript:
ValidateMenuItem(items, index, ToolWindowHelper.DownloadScriptHeader, DownloadScriptValue);
break;
case MenuItemEnum.StartWork:
ValidateMenuItem(items, index, ToolWindowHelper.StartWorkHeader, StartWorkValue);
break;
case MenuItemEnum.StopWork:
ValidateMenuItem(items, index, ToolWindowHelper.StopWorkHeader, StopWorkValue);
break;
}
index++;
}
}
finally
{
EntityService.DeleteById <T>(WorkspaceContext, entity.Id);
}
}
public static void AssemblyCleanup()
{
EntityService.DeleteById <Release>(WorkspaceContext, CurrentRelease.Id);
}
public static void ClassCleanup()
{
EntityService.DeleteById <Task>(WorkspaceContext, _task.Id);
EntityService.DeleteById <Story>(WorkspaceContext, _story.Id);
}
public static void ClassCleanup()
{
EntityService.DeleteById <Task>(WorkspaceContext, _taskEntity.Id);
EntityService.DeleteById <Story>(WorkspaceContext, _storyEntity.Id);
EntityService.DeleteById <TestGherkin>(WorkspaceContext, _gherkinTestEntity.Id);
}
