public void Filter_Where_ContentIsDebugState_And_FilterTextMatchesNothing_Expected_False()
{
DebugState debugState = new DebugState();
bool actual = _debugOutputFilterStrategy.Filter(debugState, "cake");
Assert.AreEqual(false, actual);
}
// ReSharper disable InconsistentNaming - Unit Test
public void Constructor_Expected_InitializesInputsAndOutputsAsEmptyLists()
// ReSharper restore InconsistentNaming
{
var debugState = new DebugState();
Assert.IsNotNull(debugState.Inputs);
Assert.IsNotNull(debugState.Outputs);
Assert.AreEqual(0, debugState.Inputs.Count);
Assert.AreEqual(0, debugState.Outputs.Count);
}
public void ReadXml(XmlReader reader)
{
DebugStates = new List<DebugState>();
reader.MoveToContent();
reader.ReadStartElement();
while(reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "DebugState")
{
var item = new DebugState();
item.ReadXml(reader);
DebugStates.Add(item);
}
reader.ReadEndElement();
}
public static IDebugState Create(string message, IContextualResourceModel resourceModel)
{
var state = new DebugState
{
Message = message,
};
if(resourceModel != null)
{
state.ServerID = resourceModel.ServerID;
state.OriginatingResourceID = resourceModel.ID;
}
state.StateType = String.IsNullOrWhiteSpace(message) ? StateType.Clear : StateType.Message;
return state;
}
// ReSharper disable InconsistentNaming - Unit Test
public void Write_With_ByteWriterBase_Expected_InvokesByteWriterBase()
// ReSharper restore InconsistentNaming
{
var debugState = new DebugState();
var writer = new Mock<IByteWriterBase>();
writer.Setup(w => w.Write(It.IsAny<int>())).Verifiable();
writer.Setup(w => w.Write(It.IsAny<string>())).Verifiable();
writer.Setup(w => w.Write(It.IsAny<bool>())).Verifiable();
writer.Setup(w => w.Write(It.IsAny<Guid>())).Verifiable();
writer.Setup(w => w.Write(It.IsAny<DateTime>())).Verifiable();
debugState.Write(writer.Object);
writer.Verify(w => w.Write(It.IsAny<int>()));
writer.Verify(w => w.Write(It.IsAny<string>()));
writer.Verify(w => w.Write(It.IsAny<bool>()));
writer.Verify(w => w.Write(It.IsAny<Guid>()));
writer.Verify(w => w.Write(It.IsAny<DateTime>()));
}
public void DebugStateTreeViewItemViewModel_Constructor_EnvironmentRepository_SetsDebugStateServer()
{
var environmentID = Guid.NewGuid();
const string ServerName = "Myserver";
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.ID).Returns(environmentID);
env.Setup(e => e.Name).Returns(ServerName);
var env2 = new Mock<IEnvironmentModel>();
env2.Setup(e => e.ID).Returns(Guid.NewGuid());
var envRep = new Mock<IEnvironmentRepository>();
envRep.Setup(e => e.All()).Returns(() => new[] { env.Object, env2.Object });
var content = new DebugState { EnvironmentID = environmentID };
// ReSharper disable ObjectCreationAsStatement
new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = content };
// ReSharper restore ObjectCreationAsStatement
Assert.AreEqual(ServerName, content.Server);
}
// ReSharper disable InconsistentNaming
public void DebugStateTreeViewItemViewModel_Constructor_IsExpanded_False()
{
//Setup
var serverID = Guid.NewGuid();
const string ServerName = "Myserver";
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.ID).Returns(serverID);
env.Setup(e => e.Name).Returns(ServerName);
var env2 = new Mock<IEnvironmentModel>();
env2.Setup(e => e.ID).Returns(Guid.NewGuid());
var envRep = new Mock<IEnvironmentRepository>();
envRep.Setup(e => e.All()).Returns(() => new[] { env.Object, env2.Object });
var content = new DebugState { ServerID = serverID };
//Execute
var vm = new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = content };
//Assert
Assert.IsFalse(vm.IsExpanded, "The debug state tree viewmodel should be collapsed if not explicitly expanded in constructor");
}
public void Filter_Where_ContentIsDebugState_And_FilterTextMatchesDisplayName_Expected_True()
{
DebugState debugState = new DebugState { DisplayName = "Cake" };
bool actual = _debugOutputFilterStrategy.Filter(debugState, "ak");
Assert.AreEqual(true, actual);
}
public void Filter_Where_ContentIsDebugState_And_FilterTextMatchesActivityType_Expected_True()
{
DebugState debugState = new DebugState { ActivityType = ActivityType.Workflow };
bool actual = _debugOutputFilterStrategy.Filter(debugState, "work");
Assert.AreEqual(true, actual);
}
static void DebugOutputViewModel_Append_SearchText(string searchText, string contentText, bool isAdded)
{
//------------Setup for test--------------------------
var envRepo = GetEnvironmentRepository();
var filterStrat = new Mock<IDebugOutputFilterStrategy>();
filterStrat.Setup(e => e.Filter(It.IsAny<Object>(), It.IsAny<String>())).Returns(searchText == contentText);
var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, filterStrat.Object) { SearchText = searchText };
var content = new DebugState { DisplayName = contentText, ID = Guid.NewGuid(), StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID };
//------------Execute Test---------------------------
viewModel.Append(content);
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.ContentItemCount);
Assert.AreEqual(isAdded ? 1 : 0, viewModel.RootItems.Count);
}
public void Filter_Where_ContentIsDebugState_And_FilterTextMatchesOuputOnValue_Expected_True()
{
var debugState = new DebugState();
DebugItem itemToAdd = new DebugItem();
itemToAdd.Add(new DebugItemResult { Type = DebugItemResultType.Variable, Value = "cake" });
debugState.Outputs.Add(itemToAdd);
const bool Expected = true;
var actual = _debugOutputFilterStrategy.Filter(debugState, "ak");
Assert.AreEqual(Expected, actual);
}
public void Filter_Where_ContentIsDebugState_And_ActivityTypeIsWorkflow_And_FilterTextMatchesEndTime_Expected_True()
{
DebugState debugState = new DebugState { ActivityType = ActivityType.Workflow, StateType = StateType.After, EndTime = new DateTime(2012, 01, 02, 2, 2, 3) };
bool actual = _debugOutputFilterStrategy.Filter(debugState, "2012");
Assert.AreEqual(true, actual);
}
public void DebugStateTreeViewItemViewModel_Constructor_ContentWithItems_BindsInputsAndOutputs()
{
//------------Setup for test--------------------------
var envRep = CreateEnvironmentRepository();
var expected = new DebugState { DisplayName = "IsSelectedTest", ID = Guid.NewGuid(), ActivityType = ActivityType.Step };
expected.Inputs.Add(new DebugItem(new[] { new DebugItemResult(), new DebugItemResult { GroupName = "group1", GroupIndex = 1 } }));
expected.Outputs.Add(new DebugItem(new[] { new DebugItemResult(), new DebugItemResult { GroupName = "group1", GroupIndex = 1 } }));
//------------Execute Test---------------------------
var vm = new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = expected };
//------------Assert Results-------------------------
Assert.AreEqual(1, vm.Inputs.Count);
Assert.AreEqual(1, vm.Outputs.Count);
}
static void DebugOutputViewModel_Append_ContentStateType(StateType stateType, Type expectedType, bool isExpanded)
{
//------------Setup for test--------------------------
var envRepo = GetEnvironmentRepository();
var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object);
var content = new DebugState { DisplayName = "Content", ID = Guid.NewGuid(), StateType = stateType, ActivityType = ActivityType.Step, Message = "The message", SessionID = viewModel.SessionID };
//------------Execute Test---------------------------
viewModel.Append(content);
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.ContentItemCount);
Assert.AreEqual(1, viewModel.RootItems.Count);
Assert.AreEqual(viewModel.RootItems[0].IsExpanded, isExpanded);
Assert.IsInstanceOfType(viewModel.RootItems[0], expectedType);
if(expectedType == typeof(DebugStringTreeViewItemViewModel))
{
Assert.AreEqual(0, viewModel.RootItems[0].Depth);
var viewContent = ((DebugStringTreeViewItemViewModel)viewModel.RootItems[0]).Content;
Assert.AreEqual(content.Message, viewContent);
}
else
{
Assert.IsTrue(viewModel.RootItems[0].Depth >= 0);
var viewContent = ((DebugStateTreeViewItemViewModel)viewModel.RootItems[0]).Content;
Assert.AreSame(content, viewContent);
}
}
private static void CreateDebugState(string result, string workflowName, string taskName)
{
string user = Thread.CurrentPrincipal.Identity.Name.Replace("\\", "-");
var state = new DebugState
{
HasError = true,
ID = Guid.NewGuid(),
Message = string.Format("{0}", result),
StartTime = DateTime.Now,
EndTime = DateTime.Now,
ErrorMessage = string.Format("{0}", result),
DisplayName = workflowName
};
var debug = new DebugItem();
debug.Add(new DebugItemResult
{
Type = DebugItemResultType.Label,
Value = "Warewolf Execution Error:",
Label = "Scheduler Execution Error",
Variable = result
});
var js = new Dev2JsonSerializer();
Thread.Sleep(5000);
string correlation = GetCorrelationId(WarewolfTaskSchedulerPath + taskName);
if (!Directory.Exists(OutputPath))
Directory.CreateDirectory(OutputPath);
File.WriteAllText(
string.Format("{0}DebugItems_{1}_{2}_{3}_{4}.txt", OutputPath, workflowName.Replace("\\","_"),
DateTime.Now.ToString("yyyy-MM-dd"), correlation, user),
js.SerializeToBuilder(new List<DebugState> { state }).ToString());
}
public void DispatchDebugState(IDSFDataObject dataObject, StateType stateType, bool hasErrors, string existingErrors, out ErrorResultTO errors, DateTime? workflowStartTime = null, bool interrogateInputs = false, bool interrogateOutputs = false)
{
errors = new ErrorResultTO();
if(dataObject != null)
{
Guid parentInstanceId;
Guid.TryParse(dataObject.ParentInstanceID, out parentInstanceId);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
bool hasError = dataObject.Environment.HasErrors();
var errorMessage = String.Empty;
if(hasError)
{
errorMessage = dataObject.Environment.FetchErrors();
}
if(String.IsNullOrEmpty(existingErrors))
{
existingErrors = errorMessage;
}
else
{
existingErrors += Environment.NewLine + errorMessage;
}
var debugState = new DebugState
{
ID = dataObject.OriginalInstanceID,
ParentID = parentInstanceId,
WorkspaceID = dataObject.WorkspaceID,
StateType = stateType,
StartTime = workflowStartTime ?? DateTime.Now,
EndTime = DateTime.Now,
ActivityType = ActivityType.Workflow,
DisplayName = dataObject.ServiceName,
IsSimulation = dataObject.IsOnDemandSimulation,
ServerID = dataObject.ServerID,
OriginatingResourceID = dataObject.ResourceID,
OriginalInstanceID = dataObject.OriginalInstanceID,
Server = string.Empty,
Version = string.Empty,
SessionID = dataObject.DebugSessionID,
EnvironmentID = dataObject.EnvironmentID,
ClientID = dataObject.ClientID,
Name = stateType.ToString(),
HasError = hasErrors || hasError,
ErrorMessage = existingErrors
};
if(interrogateInputs)
{
ErrorResultTO invokeErrors;
var defs = compiler.GenerateDefsFromDataListForDebug(FindServiceShape(dataObject.WorkspaceID, dataObject.ResourceID), enDev2ColumnArgumentDirection.Input);
var inputs = GetDebugValues(defs, dataObject, out invokeErrors);
errors.MergeErrors(invokeErrors);
debugState.Inputs.AddRange(inputs);
}
if(interrogateOutputs)
{
ErrorResultTO invokeErrors;
var defs = compiler.GenerateDefsFromDataListForDebug(FindServiceShape(dataObject.WorkspaceID, dataObject.ResourceID), enDev2ColumnArgumentDirection.Output);
var inputs = GetDebugValues(defs, dataObject, out invokeErrors);
errors.MergeErrors(invokeErrors);
debugState.Outputs.AddRange(inputs);
}
if(stateType == StateType.End)
{
debugState.NumberOfSteps = dataObject.NumberOfSteps;
}
if(stateType == StateType.Start)
{
debugState.ExecutionOrigin = dataObject.ExecutionOrigin;
debugState.ExecutionOriginDescription = dataObject.ExecutionOriginDescription;
}
if(dataObject.IsDebugMode() || (dataObject.RunWorkflowAsync && !dataObject.IsFromWebServer))
{
var debugDispatcher = GetDebugDispatcher();
if(debugState.StateType == StateType.End)
{
while(!debugDispatcher.IsQueueEmpty)
{
Thread.Sleep(100);
}
debugDispatcher.Write(debugState, dataObject.RemoteInvoke, dataObject.RemoteInvokerID, dataObject.ParentInstanceID, dataObject.RemoteDebugItems);
}
else
{
debugDispatcher.Write(debugState);
}
}
}
}
public void DebugStateTreeViewItemViewModel_Constructor_CanDetectRemoteServerName()
{
var serverID = Guid.NewGuid();
const string ServerName = "Myserver";
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.ID).Returns(serverID);
env.Setup(e => e.Name).Returns(ServerName);
var env2ID = Guid.NewGuid();
var env2 = new Mock<IEnvironmentModel>();
env2.Setup(e => e.ID).Returns(env2ID);
env2.Setup(e => e.Name).Returns("Unknown Remote Server");
var envRep = new Mock<IEnvironmentRepository>();
envRep.Setup(e => e.All()).Returns(() => new[] { env.Object, env2.Object });
var content = new DebugState { ServerID = serverID, Server = env2ID.ToString() };
var vm = new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = content };
Assert.AreEqual("Unknown Remote Server", vm.Content.Server);
}
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_Constructor_AssignsNameToContentServer(StateType stateType, bool contentServerIsSource = false)
{
//------------Setup for test--------------------------
var environmentID = Guid.NewGuid();
const string serverName = "TestEnvironment";
var env = new Mock<IEnvironmentModel>();
env.Setup(e => e.ID).Returns(environmentID);
env.Setup(e => e.Name).Returns(serverName);
var envRep = CreateEnvironmentRepository(env.Object);
var content = new DebugState { Server = (!contentServerIsSource ? Guid.Empty : Guid.NewGuid()).ToString(), EnvironmentID = environmentID, StateType = stateType, DisplayName = "IsSelectedTest", ID = Guid.NewGuid(), ActivityType = ActivityType.Workflow };
content.OriginalInstanceID = content.ID;
//------------Execute Test---------------------------
// ReSharper disable ObjectCreationAsStatement
new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = content };
// ReSharper restore ObjectCreationAsStatement
//------------Assert Results-------------------------
Assert.AreEqual(serverName, content.Server);
}
static void Verify_AppendError(bool contentHasError)
{
//------------Setup for test--------------------------
const string AppendError = "Appended text";
const string ContentError = "Content text";
var content = new DebugState { DisplayName = "Error Test", ID = Guid.NewGuid(), ActivityType = ActivityType.Workflow };
var expectedProps = new[] { "Content.ErrorMessage", "Content.HasError", "Content", "HasError" };
var actualProps = new List<string>();
var envRep = CreateEnvironmentRepository();
var vm = new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = content };
vm.PropertyChanged += (sender, args) => actualProps.Add(args.PropertyName);
//------------Execute Test---------------------------
vm.Content.HasError = contentHasError;
vm.Content.ErrorMessage = ContentError;
vm.AppendError(AppendError);
//------------Assert Results-------------------------
if(contentHasError)
{
Assert.AreEqual(ContentError + AppendError, content.ErrorMessage);
}
else
{
Assert.AreEqual(AppendError, content.ErrorMessage);
}
Assert.IsTrue(content.HasError);
Assert.IsTrue(vm.HasError != null && vm.HasError.Value);
CollectionAssert.AreEqual(expectedProps, actualProps);
}
public void DebugStateTreeViewItemViewModel_IsSelected_SetsSelectionTypeToSingle()
{
//------------Setup for test--------------------------
var content = new DebugState { DisplayName = "Error Test", ID = Guid.NewGuid(), ActivityType = ActivityType.Workflow };
var envRep = CreateEnvironmentRepository();
var vm = new DebugStateTreeViewItemViewModelMock(envRep.Object) { Content = content, SelectionType = ActivitySelectionType.Add, IsSelected = true };
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.AreEqual(ActivitySelectionType.Single, vm.SelectionType);
}
// BUG 9706 - 2013.06.22 - TWR : refactored
void DispatchDebugErrors(ErrorResultTO errors, IDSFDataObject dataObject, StateType stateType)
{
if(errors.HasErrors() && dataObject.IsDebugMode())
{
Guid parentInstanceId;
Guid.TryParse(dataObject.ParentInstanceID, out parentInstanceId);
var debugState = new DebugState
{
ID = dataObject.DataListID,
ParentID = parentInstanceId,
WorkspaceID = dataObject.WorkspaceID,
StateType = stateType,
StartTime = DateTime.Now,
EndTime = DateTime.Now,
ActivityType = ActivityType.Workflow,
DisplayName = dataObject.ServiceName,
IsSimulation = dataObject.IsOnDemandSimulation,
ServerID = dataObject.ServerID,
OriginatingResourceID = dataObject.ResourceID,
OriginalInstanceID = dataObject.OriginalInstanceID,
SessionID = dataObject.DebugSessionID,
EnvironmentID = dataObject.EnvironmentID,
ClientID = dataObject.ClientID,
Server = string.Empty,
Version = string.Empty,
Name = GetType().Name,
HasError = errors.HasErrors(),
ErrorMessage = errors.MakeDisplayReady()
};
DebugDispatcher.Instance.Write(debugState, dataObject.RemoteInvoke, dataObject.RemoteInvokerID);
}
}
static DebugState DebugStateIn()
{
var debugStateIn = new DebugState
{
WorkspaceID = Guid.NewGuid(),
ID = Guid.NewGuid(),
ParentID = Guid.NewGuid(),
StateType = StateType.Before,
DisplayName = "DisplayName",
Name = "Name",
ActivityType = ActivityType.Step,
Version = "Version",
IsSimulation = false,
HasError = false,
ErrorMessage = "ErrorMessage",
Server = "Server",
ServerID = Guid.NewGuid(),
StartTime = DateTime.Now,
EndTime = DateTime.Now.AddMinutes(3),
SessionID = Guid.NewGuid()
};
return debugStateIn;
}
// ReSharper disable InconsistentNaming - Unit Test
public void Serialized_Expected_CanBeDeserialized()
// ReSharper restore InconsistentNaming
{
var rw = new MockByteReaderWriter();
var debugStateIn = DebugStateIn();
DebugItem itemToAdd = new DebugItem();
itemToAdd.Add(new DebugItemResult { GroupIndex = 0, GroupName = "Group1", Type = DebugItemResultType.Label, Value = "MyLabel" });
itemToAdd.Add(new DebugItemResult { GroupIndex = 0, GroupName = "Group1", Type = DebugItemResultType.Variable, Value = "[[MyVar]]" });
itemToAdd.Add(new DebugItemResult { GroupIndex = 0, GroupName = "Group1", Type = DebugItemResultType.Value, Value = "MyValue" });
debugStateIn.Inputs.Add(itemToAdd);
debugStateIn.Write(rw);
var debugStateOut = new DebugState(rw);
Assert.AreEqual(debugStateIn.WorkspaceID, debugStateOut.WorkspaceID);
Assert.AreEqual(debugStateIn.ID, debugStateOut.ID);
Assert.AreEqual(debugStateIn.ParentID, debugStateOut.ParentID);
Assert.AreEqual(debugStateIn.StateType, debugStateOut.StateType);
Assert.AreEqual(debugStateIn.DisplayName, debugStateOut.DisplayName);
Assert.AreEqual(debugStateIn.Name, debugStateOut.Name);
Assert.AreEqual(debugStateIn.ActivityType, debugStateOut.ActivityType);
Assert.AreEqual(debugStateIn.Version, debugStateOut.Version);
Assert.AreEqual(debugStateIn.IsSimulation, debugStateOut.IsSimulation);
Assert.AreEqual(debugStateIn.HasError, debugStateOut.HasError);
Assert.AreEqual(debugStateIn.ErrorMessage, debugStateOut.ErrorMessage);
Assert.AreEqual(debugStateIn.Server, debugStateOut.Server);
Assert.AreEqual(debugStateIn.Server, debugStateOut.Server);
Assert.AreEqual(debugStateIn.ServerID, debugStateOut.ServerID);
Assert.AreEqual(debugStateIn.StartTime, debugStateOut.StartTime);
Assert.AreEqual(debugStateIn.EndTime, debugStateOut.EndTime);
Assert.AreEqual(debugStateIn.SessionID, debugStateOut.SessionID);
Assert.IsTrue(debugStateOut.Inputs[0].FetchResultsList().SequenceEqual(debugStateIn.Inputs[0].FetchResultsList(), new DebugItemResultEqualityComparer()));
}
void DebugOutputViewModel_Append_ContentIsDebugStateErrors(bool parentContentHasErrors, bool childContentHasErrors)
{
//------------Setup for test--------------------------
var envRepo = GetEnvironmentRepository();
var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object);
var parentContent = new DebugState { HasError = parentContentHasErrors, DisplayName = "Content", ID = Guid.NewGuid(), ParentID = Guid.Empty, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID };
var childContent = new DebugState { HasError = childContentHasErrors, DisplayName = "Content", ID = Guid.NewGuid(), ParentID = parentContent.ID, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID };
//------------Execute Test---------------------------
viewModel.Append(parentContent);
viewModel.Append(childContent);
//------------Assert Results-------------------------
Assert.AreEqual(2, viewModel.ContentItemCount);
Assert.AreEqual(1, viewModel.RootItems.Count);
var childItem = viewModel.RootItems[0].Children[0];
Assert.AreEqual(childContentHasErrors, childItem.HasError);
Assert.AreEqual(parentContentHasErrors, childItem.Parent.HasError);
}
public void DebugOutputViewModel_Append_ItemHasSameID_ShouldAddAsNewItemIntoTree()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var envRepo = GetEnvironmentRepository();
var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object);
var content = new DebugState { DisplayName = "Content", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID };
viewModel.Append(content);
var content2 = new DebugState { DisplayName = "Content2", ID = id, ParentID = id, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID };
//------------Execute Test---------------------------
viewModel.Append(content2);
//------------Assert Results-------------------------
Assert.AreEqual(2, viewModel.RootItems.Count);
var child = viewModel.RootItems[0] as DebugStateTreeViewItemViewModel;
Assert.IsNotNull(child);
// ReSharper disable ConditionIsAlwaysTrueOrFalse
if(child != null)
// ReSharper restore ConditionIsAlwaysTrueOrFalse
{
Assert.AreEqual("Content", child.Content.DisplayName);
}
var child2 = viewModel.RootItems[1] as DebugStateTreeViewItemViewModel;
Assert.IsNotNull(child2);
// ReSharper disable ConditionIsAlwaysTrueOrFalse
if(child2 != null)
// ReSharper restore ConditionIsAlwaysTrueOrFalse
{
Assert.AreEqual("Content2", child2.Content.DisplayName);
}
}
public void Filter_Where_ContentIsDebugState_And_ActivityTypeIsStep_And_FilterTextMatchesDurration_Expected_True()
{
DebugState debugState = new DebugState { ActivityType = ActivityType.Step, StartTime = new DateTime(2012, 01, 02, 1, 2, 3), EndTime = new DateTime(2012, 01, 02, 2, 2, 3) };
bool actual = _debugOutputFilterStrategy.Filter(debugState, "01:");
Assert.AreEqual(true, actual);
}
void DebugOutputViewModel_Append_ContentIsDebugState(Guid contentID, Guid contentParentID, string displayName)
{
//------------Setup for test--------------------------
var envRepo = GetEnvironmentRepository();
var viewModel = new DebugOutputViewModel(new Mock<IEventPublisher>().Object, envRepo, new Mock<IDebugOutputFilterStrategy>().Object);
var content = new DebugState { DisplayName = displayName, ID = contentID, ParentID = contentParentID, StateType = StateType.All, ActivityType = ActivityType.Step, SessionID = viewModel.SessionID };
//------------Execute Test---------------------------
viewModel.Append(content);
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.ContentItemCount);
Assert.AreEqual(1, viewModel.RootItems.Count);
var child = viewModel.RootItems[0];
Assert.AreEqual(0, child.Depth);
Assert.IsNull(child.Parent);
Assert.IsFalse(child.IsExpanded);
}
private static void WriteDebugItems(string workflowName, string taskName, string result)
{
string user = Thread.CurrentPrincipal.Identity.Name.Replace("\\", "-");
var state = new DebugState
{
HasError = false,
ID = Guid.NewGuid(),
StartTime = DateTime.Now,
EndTime = DateTime.Now,
ActivityType = ActivityType.Workflow,
ExecutingUser = user,
Server = "localhost",
ServerID = Guid.Empty,
DisplayName = workflowName
};
if(!string.IsNullOrEmpty(result))
{
var data = DataListUtil.AdjustForEncodingIssues(result);
bool isFragment;
var isXml = DataListUtil.IsXml(data, out isFragment);
if(isXml)
{
var xmlData = XElement.Parse(data);
var allChildren = xmlData.Elements();
var groupedData = allChildren.GroupBy(element => element.Name);
var recSets = groupedData as IGrouping<XName, XElement>[] ?? groupedData.ToArray();
foreach(var grouping in recSets)
{
var debugItem = new DebugItem();
foreach(var name in grouping)
{
if(name.HasElements)
{
var debugItemResult = ProcessRecordSet(name, name.Elements());
debugItem.ResultsList.AddRange(debugItemResult);
}
else
{
var debugItemResult = new DebugItemResult
{
Variable = DataListUtil.AddBracketsToValueIfNotExist(name.Name.LocalName),
Value = name.Value,
Operator = "=",
Type = DebugItemResultType.Variable
};
debugItem.ResultsList.Add(debugItemResult);
}
}
state.Outputs.Add(debugItem);
}
}
}
var js = new Dev2JsonSerializer();
Thread.Sleep(5000);
string correlation = GetCorrelationId(WarewolfTaskSchedulerPath + taskName);
if(!Directory.Exists(OutputPath))
Directory.CreateDirectory(OutputPath);
File.WriteAllText(
string.Format("{0}DebugItems_{1}_{2}_{3}_{4}.txt", OutputPath, workflowName.Replace("\\", "_"),
DateTime.Now.ToString("yyyy-MM-dd"), correlation, user),
js.SerializeToBuilder(new List<DebugState> { state }).ToString());
}
public void Filter_Where_ContentIsDebugState_And_ActivityTypeIsWorkflow_And_FilterTextMatchesServer_Expected_True()
{
DebugState debugState = new DebugState { ActivityType = ActivityType.Workflow, DisplayName = "Cake" };
bool actual = _debugOutputFilterStrategy.Filter(debugState, "ak");
Assert.AreEqual(true, actual);
}