/// <inheritdoc />
public IActivity GetActivity(ActivitySelectionType selectionType, Func <IActivity, bool> predicate)
{
_activitiesLock.EnterReadLock();
IActivity result = null;
var tmpList = predicate != null?_activities.Where(predicate) : _activities;
switch (selectionType)
{
case ActivitySelectionType.First:
result = tmpList.First();
break;
case ActivitySelectionType.FirstOrDefault:
result = tmpList.FirstOrDefault();
break;
case ActivitySelectionType.Last:
result = tmpList.Last();
break;
case ActivitySelectionType.LastOrDefault:
result = tmpList.LastOrDefault();
break;
}
_activitiesLock.ExitReadLock();
return(result);
}
/// <inheritdoc />
public IActivity GetActivity(ActivitySelectionType selectionType)
{
_activitiesLock.EnterReadLock();
var result = GetActivity(selectionType, null);
_activitiesLock.ExitReadLock();
return(result);
}
void NotifySelectionChanged()
{
if (IsSelected)
{
var content = Content;
if (Parent != null)
{
// Only show selection at the root level!
var parent = Parent;
do
{
content = parent.As <DebugStateTreeViewItemViewModel>()?.Content;
parent = parent.Parent;
}while (parent != null);
}
if (!IsTestView)
{
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs
{
DebugState = content,
SelectionType = SelectionType
});
}
}
else
{
if (!IsTestView)
{
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs
{
DebugState = Content,
SelectionType = ActivitySelectionType.Remove
});
}
}
SelectionType = ActivitySelectionType.Single;
}
protected override void Initialize(IDebugState debugState)
{
if (debugState == null)
{
return;
}
SelectionType = ActivitySelectionType.Add;
IsSelected = debugState.ActivityType != ActivityType.Workflow;
SetServerName(debugState);
BuildBindableListFromDebugItems(debugState.Inputs, _inputs, true);
BuildBindableListFromDebugItems(debugState.Outputs, _outputs);
BuildBindableListFromDebugItems(debugState.AssertResultList, _assertResultList);
if (debugState.HasError)
{
HasError = true;
}
if (debugState.AssertResultList != null)
{
SetTestDescription(debugState);
}
SelectionType = ActivitySelectionType.Single;
}
static void Verify_DebugSelectionChanged(ActivitySelectionType selectionType, Type selectedActivityType, bool selectsModelItem = true)
{
//----------------------- Setup -----------------------//
var ID = Guid.NewGuid();
var states = new List<IDebugState> { new DebugState { DisplayName = "SelectionChangedTest1", ID = ID, WorkSurfaceMappingId = ID } };
ID = Guid.NewGuid();
if (selectionType == ActivitySelectionType.Add || selectionType == ActivitySelectionType.Remove)
{
states.Add(new DebugState { DisplayName = "SelectionChangedTest2", ID = ID, WorkSurfaceMappingId = ID });
}
#region Setup workflow
FlowNode prevNode = null;
var nodes = new List<FlowNode>();
foreach (var node in states.Select(state => CreateFlowNode(state.ID, state.DisplayName, selectsModelItem, selectedActivityType)))
{
if (prevNode != null)
{
var flowStep = prevNode as FlowStep;
if (flowStep != null)
{
flowStep.Next = node;
}
}
nodes.Add(node);
prevNode = node;
}
var workflow = new ActivityBuilder
{
Implementation = new Flowchart
{
StartNode = nodes[0]
}
};
#endregion
#region Setup viewModel
var resourceRep = new Mock<IResourceRepository>();
resourceRep.Setup(r => r.All()).Returns(new List<IResourceModel>());
resourceRep.Setup(r => r.FetchResourceDefinition(It.IsAny<IEnvironmentModel>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<bool>())).Returns(new ExecuteMessage());
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(m => m.Environment.ResourceRepository).Returns(resourceRep.Object);
resourceModel.Setup(m => m.ResourceName).Returns("Some resource name 5");
var workflowHelper = new Mock<IWorkflowHelper>();
workflowHelper.Setup(h => h.CreateWorkflow(It.IsAny<string>())).Returns(workflow);
var viewModel = new WorkflowDesignerViewModelMock(resourceModel.Object, workflowHelper.Object);
viewModel.InitializeDesigner(new Dictionary<Type, Type>());
#endregion
//----------------------- Execute -----------------------//
var i = 0;
foreach (var debugState in states)
{
if (selectionType == ActivitySelectionType.None || selectionType == ActivitySelectionType.Remove)
{
// Ensure we have something to clear/remove
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs { DebugState = debugState, SelectionType = ActivitySelectionType.Add });
// Only issue change event after all have been added
if (++i == states.Count)
{
var selectionBefore = viewModel.Designer.Context.Items.GetValue<Selection>();
Assert.AreEqual(states.Count, selectionBefore.SelectionCount);
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs { DebugState = debugState, SelectionType = selectionType });
}
}
else
{
EventPublishers.Studio.Publish(new DebugSelectionChangedEventArgs { DebugState = debugState, SelectionType = selectionType });
}
}
//----------------------- Assert -----------------------//
var selection = viewModel.Designer.Context.Items.GetValue<Selection>();
switch (selectionType)
{
case ActivitySelectionType.None:
Assert.AreEqual(0, selection.SelectionCount);
Assert.AreEqual(1, viewModel.BringIntoViewHitCount); // 1 because we had to add something first!
Assert.AreEqual(0, viewModel.SelectedDebugModelItems.Count);
break;
case ActivitySelectionType.Single:
Assert.AreEqual(1, selection.SelectionCount);
Assert.AreEqual(1, viewModel.BringIntoViewHitCount);
Assert.AreEqual(1, viewModel.SelectedDebugModelItems.Count);
break;
case ActivitySelectionType.Add:
Assert.AreEqual(2, selection.SelectionCount);
Assert.AreEqual(2, viewModel.BringIntoViewHitCount);
Assert.AreEqual(2, viewModel.SelectedDebugModelItems.Count);
break;
case ActivitySelectionType.Remove:
Assert.AreEqual(2, selection.SelectionCount);
Assert.AreEqual(2, viewModel.BringIntoViewHitCount); // 2 because we had to add something first!
Assert.AreEqual(1, viewModel.SelectedDebugModelItems.Count);
break;
}
foreach (var modelItem in selection.SelectedObjects)
{
Assert.AreEqual(selectedActivityType, modelItem.ItemType);
if (selectsModelItem)
{
var actualID = selectedActivityType == typeof(FlowDecision)
? Guid.Parse(((TestDecisionActivity)modelItem.GetProperty("Condition")).UniqueID)
: ModelItemUtils.GetUniqueID(modelItem);
var actualState = states.FirstOrDefault(s => s.ID == actualID);
Assert.IsNotNull(actualState);
}
}
viewModel.Dispose();
}
static void Verify_IsSelected_PublishesDebugSelectionChangedEventArgs(ActivityType activityType, ActivitySelectionType expectedSelectionType, int expectedCount, bool setIsSelected = false)
{
var expected = new DebugState {
DisplayName = "IsSelectedTest", ID = Guid.NewGuid(), ActivityType = activityType
};
var events = new List <DebugSelectionChangedEventArgs>();
var selectionChangedEvents = EventPublishers.Studio.GetEvent <DebugSelectionChangedEventArgs>();
selectionChangedEvents.Subscribe(events.Add);
var envRep = CreateEnvironmentRepository();
var vm = new DebugStateTreeViewItemViewModelMock(envRep.Object)
{
Content = expected
};
if (setIsSelected)
{
// clear constructor events
events.Clear();
// events are only triggered when property changes to true
vm.IsSelected = false;
vm.SelectionType = expectedSelectionType;
vm.IsSelected = true;
}
else
{
vm.IsSelected = false;
vm.SelectionType = expectedSelectionType;
}
EventPublishers.Studio.RemoveEvent <DebugSelectionChangedEventArgs>();
Assert.AreEqual(expectedCount, events.Count);
if (events.Count > 0)
{
var foundEvent = events.Find(args => args.SelectionType == expectedSelectionType);
Assert.IsNotNull(foundEvent);
Assert.AreSame(expected, foundEvent.DebugState);
}
}
static void Verify_IsSelected_PublishesDebugSelectionChangedEventArgs(ActivityType activityType, ActivitySelectionType expectedSelectionType, int expectedCount, bool setIsSelected = false)
{
var expected = new DebugState { DisplayName = "IsSelectedTest", ID = Guid.NewGuid(), ActivityType = activityType };
var events = new List<DebugSelectionChangedEventArgs>();
var selectionChangedEvents = EventPublishers.Studio.GetEvent<DebugSelectionChangedEventArgs>();
selectionChangedEvents.Subscribe(events.Add);
var envRep = CreateEnvironmentRepository();
var vm = new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = expected };
if(setIsSelected)
{
// clear constructor events
events.Clear();
// events are only triggered when property changes to true
vm.IsSelected = false;
vm.SelectionType = expectedSelectionType;
vm.IsSelected = true;
}
else
{
vm.IsSelected = false;
vm.SelectionType = expectedSelectionType;
}
EventPublishers.Studio.RemoveEvent<DebugSelectionChangedEventArgs>();
Assert.AreEqual(expectedCount, events.Count);
if(events.Count > 0)
{
var foundEvent = events.Find(args => args.SelectionType == expectedSelectionType);
Assert.IsNotNull(foundEvent);
Assert.AreSame(expected, foundEvent.DebugState);
}
}
// ReSharper disable once CyclomaticComplexity
protected override void Initialize(IDebugState content)
{
// _inputs.Clear();
// _outputs.Clear();
// _assertResultList.Clear();
if (content == null)
{
return;
}
// Multiple when creating - so that we show the path of the execution when debugging
SelectionType = ActivitySelectionType.Add;
IsSelected = content.ActivityType != ActivityType.Workflow;
Guid serverId;
var isRemote = Guid.TryParse(content.Server, out serverId);
if (isRemote || string.IsNullOrEmpty(content.Server))
{
var envId = content.EnvironmentID;
var env = _serverRepository.All().FirstOrDefault(e => e.EnvironmentID == envId);
if (env == null)
{
var environmentModels = _serverRepository.LookupEnvironments(_serverRepository.ActiveServer);
if (environmentModels != null)
{
env = environmentModels.FirstOrDefault(e => e.EnvironmentID == envId) ?? _serverRepository.ActiveServer;
}
else
{
env = _serverRepository.Source;
}
}
if (Equals(env, _serverRepository.Source))
{
// We have an unknown remote server ;)
content.Server = "Unknown Remote Server";
}
else
{
if (env != null)
{
content.Server = env.Name;
}
}
}
BuildBindableListFromDebugItems(content.Inputs, _inputs);
BuildBindableListFromDebugItems(content.Outputs, _outputs);
BuildBindableListFromDebugItems(content.AssertResultList, _assertResultList);
if (content.HasError)
{
HasError = true;
}
if (content.AssertResultList != null)
{
var setAllError = false;
// ReSharper disable once UnusedVariable
foreach (var debugItem in content.AssertResultList.Where(debugItem => debugItem.ResultsList.Any(debugItemResult => debugItemResult.HasError)))
{
setAllError = true;
}
foreach (var debugItemResult in content.AssertResultList.SelectMany(debugItem => debugItem.ResultsList))
{
if (setAllError)
{
HasError = true;
HasNoError = false;
}
else
{
HasError = debugItemResult.HasError;
HasNoError = !debugItemResult.HasError;
}
MockSelected = debugItemResult.MockSelected;
TestDescription = debugItemResult.MockSelected ? "Mock :" : "Assert :";
}
}
SelectionType = ActivitySelectionType.Single;
}
protected override void Initialize(IDebugState value)
{
if (value == null)
{
return;
}
SelectionType = ActivitySelectionType.Add;
IsSelected = value.ActivityType != ActivityType.Workflow;
var isRemote = Guid.TryParse(value.Server, out Guid serverId);
if (isRemote || string.IsNullOrEmpty(value.Server))
{
var envId = value.EnvironmentID;
var env = _serverRepository.All().FirstOrDefault(e => e.EnvironmentID == envId);
if (env == null)
{
var environmentModels = _serverRepository.LookupEnvironments(_serverRepository.ActiveServer);
env = environmentModels != null?environmentModels.FirstOrDefault(e => e.EnvironmentID == envId) ?? _serverRepository.ActiveServer : _serverRepository.Source;
}
if (Equals(env, _serverRepository.Source))
{
value.Server = "Unknown Remote Server";
}
else
{
if (env != null)
{
value.Server = env.Name;
}
}
}
BuildBindableListFromDebugItems(value.Inputs, _inputs);
BuildBindableListFromDebugItems(value.Outputs, _outputs);
BuildBindableListFromDebugItems(value.AssertResultList, _assertResultList);
if (value.HasError)
{
HasError = true;
}
if (value.AssertResultList != null)
{
var setAllError = false;
foreach (var debugItem in value.AssertResultList.Where(debugItem => debugItem.ResultsList.Any(debugItemResult => debugItemResult.HasError)))
{
setAllError = true;
}
foreach (var debugItemResult in value.AssertResultList.SelectMany(debugItem => debugItem.ResultsList))
{
if (setAllError)
{
HasError = true;
HasNoError = false;
}
else
{
HasError = debugItemResult.HasError;
HasNoError = !debugItemResult.HasError;
}
MockSelected = debugItemResult.MockSelected;
TestDescription = debugItemResult.MockSelected ? "Mock :" : "Assert :";
}
}
SelectionType = ActivitySelectionType.Single;
}
