public void ObservableReadOnlyList_IReadOnlyList_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList<string>();
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(IReadOnlyList<string>));
observableReadOnlyList.Insert(0, "Item1");
observableReadOnlyList.Insert(1, "Item3");
observableReadOnlyList.Insert(1, "Item2");
Assert.AreEqual(3, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item2", observableReadOnlyList[1]);
Assert.AreEqual("Item3", observableReadOnlyList[2]);
var idx = observableReadOnlyList.IndexOf("Item3");
Assert.AreEqual(2, idx);
observableReadOnlyList.RemoveAt(1);
Assert.AreEqual(2, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item3", observableReadOnlyList[1]);
observableReadOnlyList[1] = "Item5";
Assert.AreEqual("Item5", observableReadOnlyList[1]);
}
public void ObservableReadOnlyList_IReadOnlyList_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList <string>();
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(IReadOnlyList <string>));
observableReadOnlyList.Insert(0, "Item1");
observableReadOnlyList.Insert(1, "Item3");
observableReadOnlyList.Insert(1, "Item2");
Assert.AreEqual(3, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item2", observableReadOnlyList[1]);
Assert.AreEqual("Item3", observableReadOnlyList[2]);
var idx = observableReadOnlyList.IndexOf("Item3");
Assert.AreEqual(2, idx);
observableReadOnlyList.RemoveAt(1);
Assert.AreEqual(2, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item3", observableReadOnlyList[1]);
observableReadOnlyList[1] = "Item5";
Assert.AreEqual("Item5", observableReadOnlyList[1]);
}
public void ActivityDesignerViewModel_Collapse_HelpButtonGetsRemovedOnCollapse()
{
//------------Setup for test--------------------------
var mockModelItem = GenerateMockModelItem();
var setupResourceModelMock = Dev2MockFactory.SetupResourceModelMock();
var errorInfo = new ErrorInfo {
InstanceID = new Guid()
};
var envRepo = new Mock <IServerRepository>();
envRepo.Setup(e => e.ActiveServer).Returns(setupResourceModelMock.Object.Environment);
IObservableReadOnlyList <IErrorInfo> testErrors = new ObservableReadOnlyList <IErrorInfo> {
errorInfo
};
setupResourceModelMock.Setup(c => c.Errors).Returns(testErrors);
setupResourceModelMock.Setup(c => c.GetErrors(It.IsAny <Guid>())).Returns(new List <IErrorInfo> {
errorInfo
});
var viewModel = new ServiceDesignerViewModel(mockModelItem.Object, setupResourceModelMock.Object, envRepo.Object, new Mock <IEventAggregator>().Object, new SynchronousAsyncWorker());
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
viewModel.ShowLarge = true;
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
//------------Execute Test---------------------------
viewModel.Collapse();
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
}
public TestResourceModel()
{
_serverID = Guid.Empty;
WorkflowActivity = null;
TagList = new List <string>();
Error = "";
HasErrors = false;
Errors = new ObservableReadOnlyList <IErrorInfo>();
FixedErrors = new ObservableReadOnlyList <IErrorInfo>();
}
public TestResourceModel()
{
_serverID = Guid.Empty;
WorkflowActivity = null;
TagList = new List<string>();
Error = "";
HasErrors = false;
Errors = new ObservableReadOnlyList<IErrorInfo>();
FixedErrors = new ObservableReadOnlyList<IErrorInfo>();
}
void VerifyCollectionChangedBoundToCollectionViewDoesNotThrowException(Action <ObservableReadOnlyList <string> > action)
{
//------------Setup for test--------------------------
var otherDone = new ManualResetEventSlim(false);
//
// Create list and view on the Dispatcher.CurrentDispatcher thread
// MUST bind to CollectionView!!
//
var observableReadOnlyList = new ObservableReadOnlyList <string> {
"item1", "item2"
};
var px = new PrivateObject(observableReadOnlyList);
px.SetProperty("TestDispatcherFrame", new DispatcherFrame());
var collectionView = CollectionViewSource.GetDefaultView(observableReadOnlyList);
//
// Modify list from another thread
//
string exceptionMessage = null;
var otherThread = new Thread(() =>
{
try
{
action?.Invoke(observableReadOnlyList);
exceptionMessage = null;
}
catch (Exception ex)
{
exceptionMessage = ex.Message;
}
finally
{
otherDone.Set();
}
});
//------------Execute Test---------------------------
otherThread.Start();
// Wait for thread to finish
Dispatcher.PushFrame((DispatcherFrame)px.GetProperty("TestDispatcherFrame"));
otherDone.Wait();
//------------Assert Results-------------------------
Assert.IsNull(exceptionMessage);
}
public void ObservableReadOnlyList_INotifyCollectionChanged_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList <string>(new List <string> {
"Item1", "Item2", "Item3"
});
var collectionChanged = false;
observableReadOnlyList.CollectionChanged += (sender, args) => collectionChanged = true;
//------------Execute Test---------------------------
observableReadOnlyList.Add("item4");
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(INotifyCollectionChanged));
Assert.IsTrue(collectionChanged);
}
public void ObservableReadOnlyList_IReadOnlyCollection_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList <string>();
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(IReadOnlyCollection <string>));
Assert.IsTrue(observableReadOnlyList.IsReadOnly);
observableReadOnlyList.Add("Item1");
observableReadOnlyList.Add("Item2");
observableReadOnlyList.Add("Item3");
Assert.AreEqual(3, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item2", observableReadOnlyList[1]);
Assert.AreEqual("Item3", observableReadOnlyList[2]);
var contains = observableReadOnlyList.Contains("Item3");
var notContains = observableReadOnlyList.Contains("Item4");
Assert.IsTrue(contains);
Assert.IsFalse(notContains);
observableReadOnlyList.Remove("Item2");
Assert.AreEqual(2, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item3", observableReadOnlyList[1]);
var array = new string[3];
observableReadOnlyList.CopyTo(array, 1);
Assert.IsNull(array[0]);
Assert.AreEqual("Item1", array[1]);
Assert.AreEqual("Item3", array[2]);
}
public void ObservableReadOnlyList_IEnumerable_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList <string>(new List <string> {
"Item1", "Item2", "Item3"
});
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(IEnumerable <string>));
var enumeratorCount = 0;
var enumerator = observableReadOnlyList.GetEnumerator();
while (enumerator.MoveNext())
{
Assert.AreEqual("Item" + ++enumeratorCount, enumerator.Current);
}
Assert.AreEqual(3, enumeratorCount);
}
public static Mock <IContextualResourceModel> CreateResourceModel(Guid resourceID, out Mock <IResourceRepository> resourceRepository, params IErrorInfo[] resourceErrors)
{
var connection = new Mock <IEnvironmentConnection>();
connection.Setup(conn => conn.ServerEvents).Returns(new EventPublisher());
var environmentID = Guid.NewGuid();
var environment = new Mock <IEnvironmentModel>();
environment.Setup(e => e.Connection).Returns(connection.Object);
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.IsConnected).Returns(true);
var errors = new ObservableReadOnlyList <IErrorInfo>();
if (resourceErrors != null)
{
foreach (var resourceError in resourceErrors)
{
errors.Add(resourceError);
}
}
var model = new Mock <IContextualResourceModel>();
model.Setup(r => r.ResourceName).Returns("TestResource");
model.Setup(r => r.ServerID).Returns(Guid.NewGuid());
model.Setup(r => r.WorkflowXaml).Returns(new StringBuilder("<root/>"));
model.Setup(m => m.Errors).Returns(errors);
model.Setup(m => m.ID).Returns(resourceID);
model.Setup(m => m.Environment).Returns(environment.Object);
model.Setup(m => m.GetErrors(It.IsAny <Guid>())).Returns(errors);
model.Setup(m => m.RemoveError(It.IsAny <IErrorInfo>())).Callback((IErrorInfo error) => errors.Remove(error));
resourceRepository = new Mock <IResourceRepository>();
environment.Setup(e => e.ResourceRepository).Returns(resourceRepository.Object);
return(model);
}
public void ObservableReadOnlyList_IReadOnlyCollection_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList<string>();
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(IReadOnlyCollection<string>));
Assert.IsTrue(observableReadOnlyList.IsReadOnly);
observableReadOnlyList.Add("Item1");
observableReadOnlyList.Add("Item2");
observableReadOnlyList.Add("Item3");
Assert.AreEqual(3, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item2", observableReadOnlyList[1]);
Assert.AreEqual("Item3", observableReadOnlyList[2]);
var contains = observableReadOnlyList.Contains("Item3");
var notContains = observableReadOnlyList.Contains("Item4");
Assert.IsTrue(contains);
Assert.IsFalse(notContains);
observableReadOnlyList.Remove("Item2");
Assert.AreEqual(2, observableReadOnlyList.Count);
Assert.AreEqual("Item1", observableReadOnlyList[0]);
Assert.AreEqual("Item3", observableReadOnlyList[1]);
var array = new string[3];
observableReadOnlyList.CopyTo(array, 1);
Assert.IsNull(array[0]);
Assert.AreEqual("Item1", array[1]);
Assert.AreEqual("Item3", array[2]);
}
public void ObservableReadOnlyList_IEnumerable_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList<string>(new List<string> { "Item1", "Item2", "Item3" });
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(IEnumerable<string>));
var enumeratorCount = 0;
var enumerator = observableReadOnlyList.GetEnumerator();
while(enumerator.MoveNext())
{
Assert.AreEqual("Item" + ++enumeratorCount, enumerator.Current);
}
Assert.AreEqual(3, enumeratorCount);
}
public void ServiceDesignerViewModel_WhenRemoteEnvironmentLoads_ShouldUseNameToFindEnvironment()
{
//------------Setup for test--------------------------
var resourceID = Guid.Empty;
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(conn => conn.ServerEvents).Returns(new EventPublisher());
var environmentID = Guid.NewGuid();
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.Connection).Returns(connection.Object);
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.IsConnected).Returns(true);
environment.Setup(model => model.IsLocalHost).Returns(false);
environment.Setup(e => e.IsLocalHostCheck()).Returns(false);
var errors = new ObservableReadOnlyList<IErrorInfo>();
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(r => r.ResourceName).Returns("TestResource").Verifiable();
resourceModel.Setup(r => r.ServerID).Returns(Guid.NewGuid());
resourceModel.Setup(r => r.WorkflowXaml).Returns(new StringBuilder("<root/>"));
resourceModel.Setup(m => m.Errors).Returns(errors);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(m => m.Environment).Returns(environment.Object);
resourceModel.Setup(m => m.GetErrors(It.IsAny<Guid>())).Returns(errors);
resourceModel.Setup(m => m.HasErrors).Returns(() => false);
resourceModel.SetupProperty(m => m.IsValid);
resourceModel.Setup(m => m.RemoveError(It.IsAny<IErrorInfo>())).Callback((IErrorInfo error) => errors.Remove(error));
resourceModel.Setup(model => model.DataList).Returns("<DataList><n1/></DataList>");
var resources = new Mock<IResourceRepository>();
environment.Setup(a => a.ResourceRepository).Returns(resources.Object);
var dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(resourceModel.Object);
dataListViewModel.ScalarCollection.Add(new DataListItemModel("n1"));
DataListSingleton.SetDataList(dataListViewModel);
var rootModel = CreateResourceModel(resourceID);
var envRepository = new Mock<IEnvironmentRepository>();
envRepository.Setup(r => r.FindSingle(It.IsAny<Expression<Func<IEnvironmentModel, bool>>>())).Returns(resourceModel.Object.Environment);
envRepository.Setup(r => r.ActiveEnvironment).Returns(resourceModel.Object.Environment);
var activity = new DsfActivity
{
ServiceName = "bob",
ResourceID = new InArgument<Guid>(resourceID),
EnvironmentID = new InArgument<Guid>(Guid.Empty),
UniqueID = Guid.Empty.ToString(),
SimulationMode = SimulationMode.OnDemand,
InputMapping = "<Inputs><Input Name=\"n1\" Source=\"[[n1]]\" /></Inputs>",
OutputMapping = "<Outputs><Output Name=\"n1\" MapsTo=\"[[n1]]\" Value=\"[[n1]]\" /></Outputs>"
};
var modelItem = CreateModelItem(activity);
var worker = new Mock<IAsyncWorker>();
// ReSharper disable MaximumChainedReferences
worker.Setup(a => a.Start(It.IsAny<System.Action>(), It.IsAny<System.Action>()))
.Callback((System.Action a, System.Action b) =>
// ReSharper restore MaximumChainedReferences
{
a.Invoke();
b.Invoke();
}
);
//------------Execute Test---------------------------
// ReSharper disable UnusedVariable
var viewModel = new ServiceDesignerViewModel(modelItem, rootModel.Object, envRepository.Object, new Mock<IEventAggregator>().Object, worker.Object);
var webFact = new Mock<IWebActivityFactory>();
var wa = new Mock<IWebActivity>();
// ReSharper disable MaximumChainedReferences
webFact.Setup(
a => a.CreateWebActivity(It.IsAny<Object>(), It.IsAny<IContextualResourceModel>(), It.IsAny<string>())).Returns(wa.Object).Verifiable();
// ReSharper restore MaximumChainedReferences
viewModel.ActivityFactory = webFact.Object;
var mappingF = new Mock<IDataMappingViewModelFactory>();
var mapping = new Mock<IDataMappingViewModel>();
mapping.Setup(a => a.GetOutputString(It.IsAny<IList<IInputOutputViewModel>>())).Returns("bob");
// ReSharper disable once MaximumChainedReferences
mappingF.Setup(a => a.CreateModel(It.IsAny<IWebActivity>(), It.IsAny<NotifyCollectionChangedEventHandler>()))
.Returns(mapping.Object);
viewModel.MappingFactory = mappingF.Object;
// ReSharper restore UnusedVariable
// ReSharper disable MaximumChainedReferences
// ReSharper disable MaximumChainedReferences
resources.Setup(a => a.FindSingle(It.IsAny<Expression<Func<IResourceModel, bool>>>(), true, false))
.Returns(resourceModel.Object)
.Callback((Expression<Func<IResourceModel, bool>> expression, bool b) => Assert.IsTrue(expression.ToString().Contains("c => (c.ResourceName == ")))
.Verifiable();
// ReSharper restore MaximumChainedReferences
environment.Setup(a => a.IsConnected).Returns(true);
environment.Raise((a => a.ResourcesLoaded += null), new ResourcesLoadedEventArgs { Model = environment.Object });
//------------Assert Results-------------------------
Assert.IsTrue(viewModel.LastValidationMemo.Errors.First().Message.Contains("Incorrect Version. The remote workflow has changed.Please refresh"));
}
void VerifyCollectionChangedBoundToCollectionViewDoesNotThrowException(Action<ObservableReadOnlyList<string>> action)
{
//------------Setup for test--------------------------
var otherDone = new ManualResetEventSlim(false);
//
// Create list and view on the Dispatcher.CurrentDispatcher thread
// MUST bind to CollectionView!!
//
var observableReadOnlyList = new ObservableReadOnlyList<string> { "item1", "item2" };
observableReadOnlyList.TestDispatcherFrame = new DispatcherFrame();
var collectionView = CollectionViewSource.GetDefaultView(observableReadOnlyList);
//
// Modify list from another thread
//
string exceptionMessage = null;
var otherThread = new Thread(() =>
{
try
{
action(observableReadOnlyList);
exceptionMessage = null;
}
catch(Exception ex)
{
exceptionMessage = ex.Message;
}
finally
{
otherDone.Set();
}
});
//------------Execute Test---------------------------
otherThread.Start();
// Wait for thread to finish
Dispatcher.PushFrame(observableReadOnlyList.TestDispatcherFrame);
otherDone.Wait();
//------------Assert Results-------------------------
Assert.IsNull(exceptionMessage);
}
public void ObservableReadOnlyList_INotifyCollectionChanged_Implemented()
{
//------------Setup for test--------------------------
var observableReadOnlyList = new ObservableReadOnlyList<string>(new List<string> { "Item1", "Item2", "Item3" });
var collectionChanged = false;
observableReadOnlyList.CollectionChanged += (sender, args) => collectionChanged = true;
//------------Execute Test---------------------------
observableReadOnlyList.Add("item4");
//------------Assert Results-------------------------
Assert.IsInstanceOfType(observableReadOnlyList, typeof(INotifyCollectionChanged));
Assert.IsTrue(collectionChanged);
}
public void ServiceDesignerViewModel_WhenResourceHasSource_ShouldGetSourceName()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(conn => conn.ServerEvents).Returns(new EventPublisher());
var environmentID = Guid.NewGuid();
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.Connection).Returns(connection.Object);
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.IsConnected).Returns(true);
environment.Setup(model => model.IsLocalHost).Returns(false);
environment.Setup(e => e.IsLocalHostCheck()).Returns(false);
var errors = new ObservableReadOnlyList<IErrorInfo>();
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(r => r.ResourceName).Returns("TestResource");
resourceModel.Setup(r => r.ServerID).Returns(Guid.NewGuid());
resourceModel.Setup(r => r.WorkflowXaml).Returns(new StringBuilder("<root/>"));
resourceModel.Setup(m => m.Errors).Returns(errors);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(m => m.Environment).Returns(environment.Object);
resourceModel.Setup(m => m.GetErrors(It.IsAny<Guid>())).Returns(errors);
resourceModel.Setup(m => m.HasErrors).Returns(() => false);
resourceModel.SetupProperty(m => m.IsValid);
resourceModel.Setup(m => m.RemoveError(It.IsAny<IErrorInfo>())).Callback((IErrorInfo error) => errors.Remove(error));
resourceModel.Setup(model => model.DataList).Returns("<DataList><n1/></DataList>");
var dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(resourceModel.Object);
dataListViewModel.ScalarCollection.Add(new DataListItemModel("n1"));
DataListSingleton.SetDataList(dataListViewModel);
var rootModel = CreateResourceModel(resourceID);
var envRepository = new Mock<IEnvironmentRepository>();
envRepository.Setup(r => r.FindSingle(It.IsAny<Expression<Func<IEnvironmentModel, bool>>>())).Returns(resourceModel.Object.Environment);
envRepository.Setup(r => r.ActiveEnvironment).Returns(resourceModel.Object.Environment);
var activity = new DsfActivity
{
ResourceID = new InArgument<Guid>(resourceID),
EnvironmentID = new InArgument<Guid>(Guid.Empty),
UniqueID = Guid.NewGuid().ToString(),
SimulationMode = SimulationMode.OnDemand,
InputMapping = "<Inputs><Input Name=\"n1\" Source=\"[[n1]]\" /></Inputs>",
OutputMapping = "<Outputs><Output Name=\"n1\" MapsTo=\"[[n1]]\" Value=\"[[n1]]\" /></Outputs>"
};
var modelItem = CreateModelItem(activity);
var resRepo = new Mock<IResourceRepository>();
var srcRes = new Mock<IResourceModel>();
srcRes.Setup(a => a.DisplayName).Returns("bob");
resRepo.Setup(a => a.FindSingle(It.IsAny<Expression<Func<IResourceModel, bool>>>(), false, false)).Returns(srcRes.Object);
environment.Setup(a => a.ResourceRepository).Returns(resRepo.Object);
//------------Execute Test---------------------------
var viewModel = new ServiceDesignerViewModel(modelItem, rootModel.Object, envRepository.Object, new Mock<IEventAggregator>().Object);
//------------Assert Results-------------------------
Assert.AreEqual("bob", viewModel.Properties.FirstOrDefault(a => a.Key == "Source :").Value);
}
public void ServiceDesignerViewModel_WhenRemoteEnvironmentLoads_ShouldNotSetVersionMemoIfCorrect()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(conn => conn.ServerEvents).Returns(new EventPublisher());
var environmentID = Guid.NewGuid();
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.Connection).Returns(connection.Object);
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.IsConnected).Returns(true);
environment.Setup(model => model.IsLocalHost).Returns(false);
environment.Setup(model => model.IsLocalHostCheck()).Returns(false);
var errors = new ObservableReadOnlyList<IErrorInfo>();
var resourceModel = new Mock<IContextualResourceModel>();
resourceModel.Setup(r => r.ResourceName).Returns("TestResource");
resourceModel.Setup(r => r.ServerID).Returns(Guid.NewGuid());
resourceModel.Setup(r => r.WorkflowXaml).Returns(new StringBuilder("<root/>"));
resourceModel.Setup(m => m.Errors).Returns(errors);
resourceModel.Setup(m => m.ID).Returns(resourceID);
resourceModel.Setup(m => m.Environment).Returns(environment.Object);
resourceModel.Setup(m => m.GetErrors(It.IsAny<Guid>())).Returns(errors);
resourceModel.Setup(m => m.HasErrors).Returns(() => false);
resourceModel.SetupProperty(m => m.IsValid);
resourceModel.Setup(m => m.RemoveError(It.IsAny<IErrorInfo>())).Callback((IErrorInfo error) => errors.Remove(error));
resourceModel.Setup(model => model.DataList).Returns("<DataList><n1/></DataList>");
var resources = new Mock<IResourceRepository>();
// ReSharper disable MaximumChainedReferences
resources.Setup(a => a.FindSingle(It.IsAny<Expression<Func<IResourceModel, bool>>>(), true, false))
.Callback((Expression<Func<IResourceModel, bool>> expression, bool b,bool c) => Assert.IsTrue(expression.ToString().Contains("c => (c.ID == ")))
.Returns(resourceModel.Object).Verifiable();
// ReSharper restore MaximumChainedReferences
environment.Setup(a => a.ResourceRepository).Returns(resources.Object);
var dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(resourceModel.Object);
dataListViewModel.ScalarCollection.Add(new DataListItemModel("n1"));
DataListSingleton.SetDataList(dataListViewModel);
var rootModel = CreateResourceModel(resourceID);
var envRepository = new Mock<IEnvironmentRepository>();
envRepository.Setup(r => r.FindSingle(It.IsAny<Expression<Func<IEnvironmentModel, bool>>>())).Returns(resourceModel.Object.Environment);
envRepository.Setup(r => r.ActiveEnvironment).Returns(resourceModel.Object.Environment);
var activity = new DsfActivity
{
ResourceID = new InArgument<Guid>(resourceID),
EnvironmentID = new InArgument<Guid>(Guid.Empty),
UniqueID = Guid.NewGuid().ToString(),
SimulationMode = SimulationMode.OnDemand,
InputMapping = "<Inputs></Inputs>",
OutputMapping = "<Outputs></Outputs>"
};
var modelItem = CreateModelItem(activity);
var worker = new Mock<IAsyncWorker>();
// ReSharper disable MaximumChainedReferences
worker.Setup(a => a.Start(It.IsAny<System.Action>(), It.IsAny<System.Action>())).Callback(
// ReSharper restore MaximumChainedReferences
(
System.Action a, System.Action b) =>
{
a.Invoke();
b.Invoke();
}
);
//------------Execute Test---------------------------
// ReSharper disable UnusedVariable
var viewModel = new ServiceDesignerViewModel(modelItem, rootModel.Object, envRepository.Object, new Mock<IEventAggregator>().Object, worker.Object);
// ReSharper restore UnusedVariable
environment.Setup(a => a.IsConnected).Returns(true);
connection.Setup(a => a.Verify(It.IsAny<Action<ConnectResult>>(), true)).Verifiable();
environment.Raise((a => a.ResourcesLoaded += null), new ResourcesLoadedEventArgs { Model = environment.Object });
//------------Assert Results-------------------------
Assert.IsTrue(viewModel.LastValidationMemo.Errors.Count == 0);
}
public static Mock<IContextualResourceModel> CreateResourceModel(Guid resourceID, out Mock<IResourceRepository> resourceRepository, params IErrorInfo[] resourceErrors)
{
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(conn => conn.ServerEvents).Returns(new EventPublisher());
var environmentID = Guid.NewGuid();
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.Connection).Returns(connection.Object);
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.IsConnected).Returns(true);
var errors = new ObservableReadOnlyList<IErrorInfo>();
if (resourceErrors != null)
{
foreach (var resourceError in resourceErrors)
{
errors.Add(resourceError);
}
}
var model = new Mock<IContextualResourceModel>();
model.Setup(r => r.ResourceName).Returns("TestResource");
model.Setup(r => r.ServerID).Returns(Guid.NewGuid());
model.Setup(r => r.WorkflowXaml).Returns(new StringBuilder("<root/>"));
model.Setup(m => m.Errors).Returns(errors);
model.Setup(m => m.ID).Returns(resourceID);
model.Setup(m => m.Environment).Returns(environment.Object);
model.Setup(m => m.GetErrors(It.IsAny<Guid>())).Returns(errors);
model.Setup(m => m.RemoveError(It.IsAny<IErrorInfo>())).Callback((IErrorInfo error) => errors.Remove(error));
resourceRepository = new Mock<IResourceRepository>();
environment.Setup(e => e.ResourceRepository).Returns(resourceRepository.Object);
return model;
}
static Mock<IContextualResourceModel> CreateResourceModel(Guid resourceID, out Mock<IResourceRepository> resourceRepository, params IErrorInfo[] resourceErrors)
{
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(conn => conn.ServerEvents).Returns(new EventPublisher());
var environmentID = Guid.NewGuid();
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.Connection).Returns(connection.Object);
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.IsConnected).Returns(true);
environment.Setup(e => e.HasLoadedResources).Returns(true);
environment.Setup(e => e.IsLocalHost).Returns(true);
environment.Setup(e => e.IsLocalHostCheck()).Returns(true);
var errors = new ObservableReadOnlyList<IErrorInfo>();
if (resourceErrors != null)
{
foreach (var resourceError in resourceErrors)
{
errors.Add(resourceError);
}
}
var model = new Mock<IContextualResourceModel>();
model.Setup(r => r.ResourceName).Returns("TestResource");
model.Setup(r => r.ServerID).Returns(Guid.NewGuid());
model.Setup(r => r.WorkflowXaml).Returns(new StringBuilder("<root/>"));
model.Setup(m => m.Errors).Returns(errors);
model.Setup(m => m.ID).Returns(resourceID);
var environmentModel = environment.Object;
model.Setup(m => m.Environment).Returns(environmentModel);
model.Setup(m => m.GetErrors(It.IsAny<Guid>())).Returns(errors);
model.Setup(m => m.HasErrors).Returns(() => model.Object.Errors.Count > 0);
model.SetupProperty(m => m.IsValid);
model.Setup(m => m.RemoveError(It.IsAny<IErrorInfo>())).Callback((IErrorInfo error) => errors.Remove(error));
resourceRepository = new Mock<IResourceRepository>();
var mockEnvironmentRepository = new Mock<IEnvironmentRepository>();
mockEnvironmentRepository.Setup(e => e.LookupEnvironments(It.IsAny<IEnvironmentModel>(), null)).Returns(new List<IEnvironmentModel> { environmentModel });
// ReSharper disable ObjectCreationAsStatement
new EnvironmentRepository(mockEnvironmentRepository.Object);
// ReSharper restore ObjectCreationAsStatement
environment.Setup(e => e.ResourceRepository).Returns(resourceRepository.Object);
return model;
}
public void ActivityDesignerViewModel_Collapse_HelpButtonGetsRemovedOnCollapse()
{
//------------Setup for test--------------------------
var mockModelItem = GenerateMockModelItem();
Mock<IContextualResourceModel> setupResourceModelMock = Dev2MockFactory.SetupResourceModelMock();
ErrorInfo errorInfo = new ErrorInfo { InstanceID = new Guid() };
var envRepo = new Mock<IEnvironmentRepository>();
envRepo.Setup(e => e.ActiveEnvironment).Returns(setupResourceModelMock.Object.Environment);
IObservableReadOnlyList<IErrorInfo> testErrors = new ObservableReadOnlyList<IErrorInfo> { errorInfo };
setupResourceModelMock.Setup(c => c.Errors).Returns(testErrors);
setupResourceModelMock.Setup(c => c.GetErrors(It.IsAny<Guid>())).Returns(new List<IErrorInfo> { errorInfo });
var viewModel = new ServiceDesignerViewModel(mockModelItem.Object, setupResourceModelMock.Object, envRepo.Object, new Mock<IEventAggregator>().Object, new TestAsyncWorker());
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
viewModel.ShowLarge = true;
Assert.AreEqual(2, viewModel.TitleBarToggles.Count);
//------------Execute Test---------------------------
viewModel.Collapse();
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.TitleBarToggles.Count);
}
