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()); }