public void Init()
{
PrivateType p = new PrivateType(typeof(Dev2DataLanguageParser));
var cache = p.GetStaticField("_expressionCache") as ConcurrentDictionary<string, IList<IIntellisenseResult>>;
Assert.IsNotNull(cache);
cache.Clear();
var cache2 = p.GetStaticField("_payloadCache") as ConcurrentDictionary<Tuple<string, string>, IList<IIntellisenseResult>>;
Assert.IsNotNull(cache2);
cache2.Clear();
Monitor.Enter(DataListSingletonTest.DataListSingletonTestGuard);
var testEnvironmentModel = ResourceModelTest.CreateMockEnvironment();
_resourceModel = new ResourceModel(testEnvironmentModel.Object)
{
ResourceName = "test",
ResourceType = ResourceType.Service,
DataList = @"
<DataList>
<Scalar/>
<Country/>
<State />
<City>
<Name/>
<GeoLocation />
</City>
</DataList>
"
};
IDataListViewModel setupDatalist = new DataListViewModel();
DataListSingleton.SetDataList(setupDatalist);
DataListSingleton.ActiveDataList.InitializeDataListViewModel(_resourceModel);
}
public void Init()
{
Monitor.Enter(DataListSingletonTest.DataListSingletonTestGuard);
var testEnvironmentModel = ResourceModelTest.CreateMockEnvironment();
_resourceModel = new ResourceModel(testEnvironmentModel.Object)
{
ResourceName = "test",
ResourceType = ResourceType.Service,
DataList = @"
<DataList>
<Scalar/>
<Country/>
<State />
<City>
<Name/>
<GeoLocation />
</City>
</DataList>
"
};
IDataListViewModel setupDatalist = new DataListViewModel();
DataListSingleton.SetDataList(setupDatalist);
DataListSingleton.ActiveDataList.InitializeDataListViewModel(_resourceModel);
}
internal IDataListViewModel CreateDataListViewModel(IResourceModel resourceModel)
{
DataListViewModel dLVM = new DataListViewModel();
dLVM.InitializeDataListViewModel(resourceModel);
return dLVM;
}
internal IDataListViewModel CreateDataListViewModelWithDefaultResourceModel() {
TestResourceModel testResourceModel = new TestResourceModel();
IDataListViewModel dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(testResourceModel);
return dataListViewModel;
}
public void ZipDesignerViewModel_Validate_CorrectFieldsAreValidated()
{
//------------Setup for test-------------------------
var dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(new ResourceModel(null));
DataListSingleton.SetDataList(dataListViewModel);
var viewModel = ZipViewModel();
//------------Execute Test---------------------------
viewModel.Validate();
//------------Assert Results-------------------------
Assert.AreEqual(1, viewModel.ValidateInputPathHitCount);
Assert.AreEqual(1, viewModel.ValidateUserNameAndPasswordHitCount);
Assert.AreEqual(1, viewModel.ValidateDestinationUsernameAndPasswordHitCount);
}
public void GivenIHaveTheFollowingVariableList(string variableList)
{
const string Root = "<DataList>##</DataList>";
var datalist = Root.Replace("##", variableList);
ScenarioContext.Current.Add("dataList", datalist);
var testEnvironmentModel = ResourceModelTest.CreateMockEnvironment();
var resourceModel = new ResourceModel(testEnvironmentModel.Object)
{
ResourceName = "test",
ResourceType = ResourceType.Service,
DataList = datalist
};
IDataListViewModel setupDatalist = new DataListViewModel();
DataListSingleton.SetDataList(setupDatalist);
DataListSingleton.ActiveDataList.InitializeDataListViewModel(resourceModel);
}
void Setup()
{
//_mockMediatorRepo = new Mock<IMediatorRepo>();
_mockResourceModel = Dev2MockFactory.SetupResourceModelMock();
//_mockMediatorRepo.Setup(c => c.addKey(It.IsAny<Int32>(), It.IsAny<MediatorMessages>(), It.IsAny<String>()));
//_mockMediatorRepo.Setup(c => c.deregisterAllItemMessages(It.IsAny<Int32>()));
_dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
_dataListViewModel.InitializeDataListViewModel(_mockResourceModel.Object);
//Mock<IMainViewModel> _mockMainViewModel = Dev2MockFactory.SetupMainViewModel();
_dataListViewModel.RecsetCollection.Clear();
_dataListViewModel.ScalarCollection.Clear();
IDataListItemModel carRecordset = DataListItemModelFactory.CreateDataListModel("Car", "A recordset of information about a car", enDev2ColumnArgumentDirection.Both);
carRecordset.Children.Add(DataListItemModelFactory.CreateDataListModel("Make", "Make of vehicle", carRecordset));
carRecordset.Children.Add(DataListItemModelFactory.CreateDataListModel("Model", "Model of vehicle", carRecordset));
_dataListViewModel.RecsetCollection.Add(carRecordset);
_dataListViewModel.ScalarCollection.Add(DataListItemModelFactory.CreateDataListModel("Country", "name of Country", enDev2ColumnArgumentDirection.Both));
DataListSingleton.SetDataList(_dataListViewModel);
}
public void WriteResourceModel_DataListContainingScalarWithError_WithDoubleBracketedScalar_Expected_Positive()
{
//------------Setup for test--------------------------
_mockResourceModel = Dev2MockFactory.SetupResourceModelMock();
_dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
_dataListViewModel.InitializeDataListViewModel(_mockResourceModel.Object);
_dataListViewModel.RecsetCollection.Clear();
_dataListViewModel.ScalarCollection.Clear();
IDataListItemModel carRecordset = DataListItemModelFactory.CreateDataListModel("[[Car]]", "A recordset of information about a car", enDev2ColumnArgumentDirection.Both);
carRecordset.Children.Add(DataListItemModelFactory.CreateDataListModel("Make", "Make of vehicle", carRecordset));
carRecordset.Children.Add(DataListItemModelFactory.CreateDataListModel("Model", "Model of vehicle", carRecordset));
_dataListViewModel.RecsetCollection.Add(carRecordset);
var scalarDataListItemWithError = DataListItemModelFactory.CreateDataListModel("[[Country]]", "name of Country", enDev2ColumnArgumentDirection.Both);
scalarDataListItemWithError.HasError = true;
scalarDataListItemWithError.ErrorMessage = "This is an Error";
_dataListViewModel.ScalarCollection.Add(scalarDataListItemWithError);
_dataListViewModel.ScalarCollection.Add(scalarDataListItemWithError);
_dataListViewModel.ValidateNames(scalarDataListItemWithError);
DataListSingleton.SetDataList(_dataListViewModel);
//------------Execute Test---------------------------
var xmlDataList = _dataListViewModel.WriteToResourceModel();
//------------Assert Results-------------------------
Assert.AreEqual(2, _dataListViewModel.ScalarCollection.Count);
Assert.IsTrue(_dataListViewModel.ScalarCollection[0].DisplayName == "Country");
Assert.IsTrue(_dataListViewModel.ScalarCollection[1].DisplayName == "Country");
Assert.IsFalse(xmlDataList.Contains("Country"));
}
public void DataListViewModel_MissingDataListParts_WithRecsetPartNotInDataList_ShouldReturnPartInList()
{
//------------Setup for test--------------------------
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
const string recsetName = "recset";
const string firstFieldName = "f1";
var dataListParts = new List<IDataListVerifyPart>();
var part = CreateRecsetPart(recsetName, firstFieldName);
dataListParts.Add(part.Object);
//----------------------Precondition----------------------------
//------------Execute Test---------------------------
List<IDataListVerifyPart> missingDataListParts = dataListViewModel.MissingDataListParts(dataListParts);
//------------Assert Results-------------------------
Assert.AreEqual(1, missingDataListParts.Count);
}
static ServiceDesignerViewModel CreateServiceDesignerViewModelWithEmptyResourceID(Guid instanceID, params IErrorInfo[] resourceErrors)
{
var rootModel = CreateResourceModel(Guid.NewGuid(), false, resourceErrors);
rootModel.Setup(model => model.ResourceType).Returns(Studio.Core.AppResources.Enums.ResourceType.WorkflowService);
var resourceModel = CreateResourceModel(Guid.Empty, false);
resourceModel.Setup(model => model.ResourceType).Returns(Studio.Core.AppResources.Enums.ResourceType.WorkflowService);
resourceModel.Setup(model => model.DataList).Returns("<DataList><n1/></DataList>");
resourceModel.Setup(model => model.ResourceName).Returns("TestResource");
var dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(resourceModel.Object);
dataListViewModel.ScalarCollection.Add(new DataListItemModel("n1"));
DataListSingleton.SetDataList(dataListViewModel);
var modelItem = CreateModelItem(instanceID, resourceModel.Object.ID, resourceModel.Object.Environment.ID, null);
var envRepository = new Mock<IEnvironmentRepository>();
envRepository.Setup(e => e.ActiveEnvironment).Returns(resourceModel.Object.Environment);
envRepository.Setup(r => r.FindSingle(It.IsAny<Expression<Func<IEnvironmentModel, bool>>>())).Returns(resourceModel.Object.Environment);
var worker = new Mock<IAsyncWorker>().Object;
return new ServiceDesignerViewModel(modelItem.Object, rootModel.Object, envRepository.Object, new Mock<IEventAggregator>().Object, worker);
}
public void DataListViewModel_RemoveDataListItem_WithScalarItem_ShouldRemoveFromScalarCollection()
{
//------------Setup for test--------------------------
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
var scalarItem = new DataListItemModel("scalar");
dataListViewModel.ScalarCollection.Add(scalarItem);
//----------------------Precondition----------------------------
Assert.AreEqual(1, dataListViewModel.ScalarCollection.Count);
//------------Execute Test---------------------------
dataListViewModel.RemoveDataListItem(scalarItem);
//------------Assert Results-------------------------
Assert.AreEqual(0, dataListViewModel.ScalarCollection.Count);
}
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"));
}
public void ServiceDesingerViewModel_SetRunWorkflowAsync_True_OutputMappingEnabledFalse()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
var resourceModel = CreateResourceModel(Guid.Empty, false);
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(Guid.Empty);
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 };
var modelItem = CreateModelItem(activity);
var viewModel = new ServiceDesignerViewModel(modelItem, rootModel.Object, envRepository.Object, new Mock<IEventAggregator>().Object) { RunWorkflowAsync = true };
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsTrue(viewModel.RunWorkflowAsync);
Assert.IsFalse(viewModel.OutputMappingEnabled);
}
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);
}
static IDataListViewModel CreateDataListViewModel(Mock<IContextualResourceModel> mockResourceModel, IEventAggregator eventAggregator = null)
{
var dataListViewModel = new DataListViewModel(eventAggregator ?? new Mock<IEventAggregator>().Object);
dataListViewModel.InitializeDataListViewModel(mockResourceModel.Object);
return dataListViewModel;
}
public void AddRecordSetNamesIfMissing_DataListContainingRecordSet_WithRoundBracketedScalar_Expected_Positive()
{
//------------Setup for test--------------------------
_mockResourceModel = Dev2MockFactory.SetupResourceModelMock();
_dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
_dataListViewModel.InitializeDataListViewModel(_mockResourceModel.Object);
_dataListViewModel.RecsetCollection.Clear();
_dataListViewModel.ScalarCollection.Clear();
IDataListItemModel carRecordset = DataListItemModelFactory.CreateDataListModel("[Car]", "A recordset of information about a car", enDev2ColumnArgumentDirection.Both);
carRecordset.Children.Add(DataListItemModelFactory.CreateDataListModel("Make", "Make of vehicle", carRecordset));
carRecordset.Children.Add(DataListItemModelFactory.CreateDataListModel("Model", "Model of vehicle", carRecordset));
_dataListViewModel.RecsetCollection.Add(carRecordset);
_dataListViewModel.ScalarCollection.Add(DataListItemModelFactory.CreateDataListModel("Country()", "name of Country", enDev2ColumnArgumentDirection.Both));
DataListSingleton.SetDataList(_dataListViewModel);
//------------Execute Test---------------------------
_dataListViewModel.WriteToResourceModel();
//------------Assert Results-------------------------
Assert.AreEqual(1, _dataListViewModel.ScalarCollection.Count);
Assert.IsTrue(_dataListViewModel.ScalarCollection[0].DisplayName == "Country");
}
public void DataListViewModel_MissingDataListParts_ScalarPartInDataList_ShouldNotReturnPartInList()
{
//------------Setup for test--------------------------
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
const string scalarName = "scalar";
var scalarItem = new DataListItemModel(scalarName);
dataListViewModel.ScalarCollection.Add(scalarItem);
var parts = new List<IDataListVerifyPart> { CreateScalarPart(scalarName).Object };
//----------------------Precondition----------------------------
Assert.AreEqual(1, dataListViewModel.ScalarCollection.Count);
//------------Execute Test---------------------------
List<IDataListVerifyPart> missingDataListParts = dataListViewModel.MissingDataListParts(parts);
//------------Assert Results-------------------------
Assert.AreEqual(0, missingDataListParts.Count);
}
public void DataListViewModel_RemoveDataListItem_WithRecsetItem_ShouldRemoveFromRecsetCollection()
{
//------------Setup for test--------------------------
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
const string recsetName = "recset";
const string firstFieldName = "f1";
var recSetDataModel = CreateRecsetDataListModelWithTwoFields(recsetName, firstFieldName, "f2");
dataListViewModel.RecsetCollection.Add(recSetDataModel);
var dataListParts = new List<IDataListVerifyPart>();
var part = CreateRecsetPart(recsetName, firstFieldName);
dataListParts.Add(part.Object);
//----------------------Precondition----------------------------
Assert.AreEqual(1, dataListViewModel.RecsetCollection.Count);
//------------Execute Test---------------------------
dataListViewModel.RemoveDataListItem(recSetDataModel);
//------------Assert Results-------------------------
Assert.AreEqual(0, dataListViewModel.RecsetCollection.Count);
}
public void WorkflowDesignerViewModel_BuildDataPart_ValidItem_ShouldAddItemToDataList()
{
//------------Setup for test--------------------------
var eventAggregator = new EventAggregator();
Mock<IContextualResourceModel> mockResourceModel = Dev2MockFactory.SetupResourceModelMock();
mockResourceModel.Setup(resModel => resModel.WorkflowXaml).Returns(WorkflowXAMLForTest());
var workflowDesigner = CreateWorkflowDesignerViewModel(eventAggregator, mockResourceModel.Object, null, false);
var dataListViewModel = new DataListViewModel();
DataListSingleton.SetDataList(dataListViewModel);
dataListViewModel.AddBlankRow(null);
//------------Execute Test---------------------------
workflowDesigner.Handle(new AddStringListToDataListMessage(new List<string> { "[[rec().set]]", "[[test()]]", "[[scalar]]" }));
//------------Assert Results-------------------------
var dataListItemModels = DataListSingleton.ActiveDataList.DataList;
workflowDesigner.Dispose();
Assert.AreEqual(5, dataListItemModels.Count);
}
public void DataListViewModel_MissingDataListParts_WithRecsetFieldPartInDataList_ShouldNotReturnPartInList()
{
//------------Setup for test--------------------------
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
const string recsetName = "recset";
const string firstFieldName = "f1";
IDataListItemModel recSetDataModel = DataListItemModelFactory.CreateDataListModel(recsetName, "A recordset of information about a car", enDev2ColumnArgumentDirection.Both);
IDataListItemModel firstFieldDataListItemModel = CreateFieldDataListModel(firstFieldName, recSetDataModel);
recSetDataModel.Children.Add(firstFieldDataListItemModel);
recSetDataModel.Children.Add(CreateFieldDataListModel("f2", recSetDataModel));
dataListViewModel.RecsetCollection.Add(recSetDataModel);
var dataListParts = new List<IDataListVerifyPart>();
var part = CreateRecsetPart(recsetName, firstFieldName);
dataListParts.Add(part.Object);
//----------------------Precondition----------------------------
Assert.AreEqual(2, dataListViewModel.RecsetCollection[0].Children.Count);
//------------Execute Test---------------------------
List<IDataListVerifyPart> missingDataListParts = dataListViewModel.MissingDataListParts(dataListParts);
//------------Assert Results-------------------------
Assert.AreEqual(0, missingDataListParts.Count);
}
public void GetDecisionElementsWhenItemAlreadyInDataListShouldNotReturnRecsetIfScalarNonExistent()
{
//Execute
Mock<IContextualResourceModel> resourceModel = Dev2MockFactory.ResourceModel;
var eventAggregator = new EventAggregator();
var model = CreateWorkflowDesignerViewModel(eventAggregator, resourceModel.Object, null, false);
var dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(resourceModel.Object);
var recsetModel = new DataListItemModel("RecSet");
dataListViewModel.RecsetCollection.Add(recsetModel);
dataListViewModel.RecsetCollection[2].Children.Add(new DataListItemModel("aasszzz", parent: recsetModel));
const string expression = "Dev2.Data.Decision.Dev2DataListDecisionHandler.Instance.ExecuteDecisionStack(\"{!TheStack!:[{!Col1!:![[a]]!,!Col2!:!Is Equal!,!Col3!:!0!,!PopulatedColumnCount!:2,!EvaluationFn!:!IsEqual!}],!TotalDecisions!:1,!ModelName!:!Dev2DecisionStack!,!Mode!:!AND!,!TrueArmText!:!True!,!FalseArmText!:!False!,!DisplayText!:!If ]] Is Equal [[scalar]]!}\",AmbientDataList)";
var actual = model.GetDecisionElements(expression, dataListViewModel);
model.Dispose();
//Assert
Assert.AreEqual(1, actual.Count, "Find missing returned an unexpected number of results when finding variables in a decision");
Assert.AreEqual("{!TheStack!:[{!Col1!:!a!,!Col2!:!Is Equal!,!Col3!:!0!,!PopulatedColumnCount!:2,!EvaluationFn!:!IsEqual!}],!TotalDecisions!:1,!ModelName!:!Dev2DecisionStack!,!Mode!:!AND!,!TrueArmText!:!True!,!FalseArmText!:!False!,!DisplayText!:!If Is Equal scalar!}", actual[0], "Find missing found an invalid variable in a decision");
}
public void DataListViewModel_UpdateDataListItems_NoMissingScalarWorkflowItems_ShouldMarkScalarValuesUsedTrue()
{
//------------Setup for test--------------------------
IResourceModel resourceModel = new Mock<IResourceModel>().Object;
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
dataListViewModel.InitializeDataListViewModel(resourceModel);
const string scalarName = "scalar";
var scalarItem = new DataListItemModel(scalarName) { IsUsed = false };
dataListViewModel.ScalarCollection.Add(scalarItem);
var parts = new List<IDataListVerifyPart> { CreateScalarPart(scalarName).Object };
//------------Execute Test---------------------------
dataListViewModel.UpdateDataListItems(resourceModel, parts);
//------------Assert Results-------------------------
Assert.IsTrue(dataListViewModel.ScalarCollection[0].IsUsed);
}
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 void DataListViewModel_UpdateDataListItems_WithNoMissingRecsetFieldWorkflowItems_ShouldMarkRecsetFieldValueIsUsedTrue()
{
//------------Setup for test--------------------------
IResourceModel resourceModel = new Mock<IResourceModel>().Object;
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
dataListViewModel.InitializeDataListViewModel(resourceModel);
const string recsetName = "recset";
const string firstFieldName = "f1";
IDataListItemModel recSetDataModel = DataListItemModelFactory.CreateDataListModel(recsetName, "A recordset of information about a car", enDev2ColumnArgumentDirection.Both);
IDataListItemModel firstFieldDataListItemModel = CreateFieldDataListModel(firstFieldName, recSetDataModel);
recSetDataModel.IsUsed = false;
firstFieldDataListItemModel.IsUsed = false;
recSetDataModel.Children.Add(firstFieldDataListItemModel);
dataListViewModel.RecsetCollection.Add(recSetDataModel);
var dataListParts = new List<IDataListVerifyPart>();
var part = CreateRecsetPart(recsetName, firstFieldName);
dataListParts.Add(part.Object);
//------------Execute Test---------------------------
dataListViewModel.UpdateDataListItems(resourceModel, dataListParts);
//------------Assert Results-------------------------
Assert.IsTrue(dataListViewModel.RecsetCollection[0].Children[0].IsUsed);
}
public void ServiceDesignerViewModel_InitializeResourceIDNull_StillCorrectlySetsUp()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
var resourceModel = CreateResourceModel(Guid.Empty, false);
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(Guid.Empty);
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 };
var modelItem = CreateModelItem(activity);
//------------Execute Test---------------------------
var viewModel = new ServiceDesignerViewModel(modelItem, rootModel.Object, envRepository.Object, new Mock<IEventAggregator>().Object);
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.ResourceModel);
var inputMapping = viewModel.ModelItem.GetProperty<string>("InputMapping");
var outputMapping = viewModel.ModelItem.GetProperty<string>("OutputMapping");
Assert.AreEqual("<Inputs><Input Name=\"n1\" Source=\"[[n1]]\" /></Inputs>", inputMapping);
Assert.AreEqual("<Outputs><Output Name=\"n1\" MapsTo=\"[[n1]]\" Value=\"[[n1]]\" /></Outputs>", outputMapping);
}
public void DataListViewModel_SearchText_MatchingScalars_ShouldSetScalarVisible()
{
//------------Setup for test--------------------------
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
const string scalarName = "scalar";
var scalarItem = new DataListItemModel(scalarName) { IsVisable = false };
dataListViewModel.ScalarCollection.Add(scalarItem);
//------------Execute Test---------------------------
dataListViewModel.SearchText = "sca";
//------------Assert Results-------------------------
Assert.IsTrue(dataListViewModel.ScalarCollection[0].IsVisable);
}
public void ServiceDesingerViewModel_IsAsyncVisible_NotWorkflowResource_False()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
var resourceModel = CreateResourceModel(Guid.Empty, false);
resourceModel.Setup(model => model.ResourceType).Returns(Studio.Core.AppResources.Enums.ResourceType.Service);
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(Guid.Empty);
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 resourceType = resourceModel.Object.ResourceType.ToString();
var activity = new DsfActivity { ResourceID = new InArgument<Guid>(resourceID), EnvironmentID = new InArgument<Guid>(Guid.Empty), UniqueID = Guid.NewGuid().ToString(), SimulationMode = SimulationMode.OnDemand, Type = new InArgument<string>(resourceType) };
var modelItem = CreateModelItem(activity);
//------------Execute Test---------------------------
var viewModel = new ServiceDesignerViewModel(modelItem, rootModel.Object, envRepository.Object, new Mock<IEventAggregator>().Object);
//------------Assert Results-------------------------
Assert.IsFalse(viewModel.IsAsyncVisible);
}
public void DataListViewModel_SearchText_WithNoMatchingRecsetField_ShouldSetRecsetFieldNotVisible()
{
//------------Setup for test--------------------------
var dataListViewModel = new DataListViewModel(new Mock<IEventAggregator>().Object);
const string recsetName = "recset";
const string firstFieldName = "f1";
IDataListItemModel recSetDataModel = DataListItemModelFactory.CreateDataListModel(recsetName, "A recordset of information about a car", enDev2ColumnArgumentDirection.Both);
IDataListItemModel firstFieldDataListItemModel = CreateFieldDataListModel(firstFieldName, recSetDataModel);
recSetDataModel.IsVisable = true;
firstFieldDataListItemModel.IsVisable = true;
recSetDataModel.Children.Add(firstFieldDataListItemModel);
dataListViewModel.RecsetCollection.Add(recSetDataModel);
//------------Execute Test---------------------------
dataListViewModel.SearchText = "jim";
//------------Assert Results-------------------------
Assert.IsFalse(dataListViewModel.RecsetCollection[0].Children[0].IsVisable);
}
static ServiceDesignerViewModel CreateServiceDesignerViewModel(Guid instanceID, bool resourceRepositoryReturnsNull, IEventAggregator eventPublisher, ModelProperty[] modelProperties, Mock<IContextualResourceModel> resourceModel, params IErrorInfo[] resourceErrors)
{
var rootModel = CreateResourceModel(Guid.NewGuid(), resourceRepositoryReturnsNull, resourceErrors);
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 modelItem = CreateModelItem(instanceID, resourceModel.Object.ID, resourceModel.Object.Environment.ID, modelProperties);
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);
return new ServiceDesignerViewModel(modelItem.Object, rootModel.Object, envRepository.Object, eventPublisher);
}
public void DataListViewModel_UpdateDataListItems_DataListHasNoParts_UpdateIntellisenseMessageIsPublished()
{
//------------Setup for test--------------------------
IResourceModel resourceModel = new Mock<IResourceModel>().Object;
Mock<IEventAggregator> eventAggregator = new Mock<IEventAggregator>();
var dataListViewModel = new DataListViewModel(eventAggregator.Object);
dataListViewModel.InitializeDataListViewModel(resourceModel);
eventAggregator.Setup(c => c.Publish(It.IsAny<UpdateIntellisenseMessage>())).Verifiable();
var dataListParts = new List<IDataListVerifyPart>();
//------------Execute Test---------------------------
dataListViewModel.UpdateDataListItems(resourceModel, dataListParts);
//------------Assert Results-------------------------
eventAggregator.Verify(c => c.Publish(It.IsAny<UpdateIntellisenseMessage>()), Times.Once());
}
