public void ComSourceRegion_ChangeSourceSomethingChanged_RestoreRegion_ExpectedRestore()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfComDllActivity()
{
SourceId = id
};
var src = new Mock <IComPluginServiceModel>();
var pluginSrc = new ComPluginSourceDefinition()
{
Id = id
};
var s2 = new ComPluginSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IComPluginSource>()
{
pluginSrc, s2
});
//------------Execute Test---------------------------
ComSourceRegion region = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
// ReSharper disable once UseObjectOrCollectionInitializer
ComSourceRegion regionToRestore = new ComSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act));
regionToRestore.IsEnabled = false;
regionToRestore.SelectedSource = s2;
region.RestoreRegion(regionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(region.SelectedSource, s2);
Assert.IsFalse(region.IsEnabled);
}
public void DataSplitDesignerViewModel_ValidateCollectionItem_ValidatesPropertiesOfDTO()
{
//------------Setup for test--------------------------
var mi = ModelItemUtils.CreateModelItem(new DsfDataSplitActivity());
mi.SetProperty("DisplayName", "Split");
mi.SetProperty("SourceString", "a,b");
var dto = new DataSplitDTO("a]]", DataSplitDTO.SplitTypeIndex, "a", 0);
// ReSharper disable PossibleNullReferenceException
var miCollection = mi.Properties["ResultsCollection"].Collection;
var dtoModelItem = miCollection.Add(dto);
// ReSharper restore PossibleNullReferenceException
var viewModel = new DataSplitDesignerViewModel(mi);
viewModel.GetDatalistString = () =>
{
const string trueString = "True";
const string noneString = "None";
var datalist = string.Format("<DataList><var Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><b Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><h Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><r Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString);
return(datalist);
};
//------------Execute Test---------------------------
viewModel.Validate();
//------------Assert Results-------------------------
Assert.AreEqual(2, viewModel.Errors.Count);
StringAssert.Contains(viewModel.Errors[0].Message, "'Results' - Invalid expression: opening and closing brackets don't match");
Verify_IsFocused(dtoModelItem, viewModel.Errors[0].Do, "IsOutputVariableFocused");
StringAssert.Contains(viewModel.Errors[1].Message, "'Using' must be a real number");
Verify_IsFocused(dtoModelItem, viewModel.Errors[1].Do, "IsAtFocused");
}
public void MySql_TestActionSetSourceAndTestClickOkHasMappings()
{
//------------Setup for test--------------------------
var mod = new MySqlModel();
var act = new DsfMySqlDatabaseActivity();
//------------Execute Test---------------------------
var mySql = new MySqlDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker());
mySql.ManageServiceInputViewModel = new InputViewForTest(mySql, mod);
mySql.SourceRegion.SelectedSource = mySql.SourceRegion.Sources.First();
#pragma warning disable 4014
mySql.TestInputCommand.Execute();
mySql.ManageServiceInputViewModel.TestCommand.Execute(null);
mySql.ManageServiceInputViewModel.IsEnabled = true;
mySql.ManageServiceInputViewModel.OutputArea.Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c")
};
mySql.ManageServiceInputViewModel.Model = new DatabaseService()
{
Action = new DbAction()
{
Inputs = new List <IServiceInput>(), Name = "bob"
}
};
mySql.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//------------Assert Results-------------------------
Assert.IsTrue(mySql.SourceRegion.IsEnabled);
Assert.IsTrue(mySql.OutputsRegion.IsEnabled);
Assert.IsTrue(mySql.InputArea.IsEnabled);
Assert.IsTrue(mySql.ErrorRegion.IsEnabled);
Assert.IsFalse(mySql.ManageServiceInputViewModel.InputArea.IsEnabled);
Assert.AreEqual(0, mySql.ManageServiceInputViewModel.Errors.Count);
}
public void Oracle_TestActionSetSource()
{
//------------Setup for test--------------------------
CustomContainer.LoadedTypes = new List <Type>()
{
typeof(ManageDbServiceModel)
};
var mockMainViewModel = new Mock <IShellViewModel>();
var mockHelpViewModel = new Mock <IHelpWindowViewModel>();
mockHelpViewModel.Setup(model => model.UpdateHelpText(It.IsAny <string>())).Verifiable();
mockMainViewModel.Setup(model => model.HelpViewModel).Returns(mockHelpViewModel.Object);
var server = new Mock <IServer>();
var updatemanager = new Mock <IStudioUpdateManager>();
var queryManager = new Mock <IQueryManager>();
queryManager.Setup(manager => manager.FetchDbSources()).Returns(new List <IDbSource>());
server.Setup(server1 => server1.UpdateRepository).Returns(updatemanager.Object);
server.Setup(server1 => server1.QueryProxy).Returns(queryManager.Object);
mockMainViewModel.Setup(model => model.ActiveServer).Returns(server.Object);
CustomContainer.Register(mockMainViewModel.Object);
var mod = new OracleModel();
var act = new DsfOracleDatabaseActivity();
//------------Execute Test---------------------------
var oracle = new OracleDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), new SynchronousAsyncWorker(), new ViewPropertyBuilder());
oracle.ManageServiceInputViewModel = new InputViewForTest(oracle, mod);
oracle.SourceRegion.SelectedSource = mod.Sources.First();
//------------Assert Results-------------------------
Assert.IsTrue(oracle.SourceRegion.IsEnabled);
Assert.IsFalse(oracle.OutputsRegion.IsEnabled);
Assert.IsFalse(oracle.InputArea.IsEnabled);
Assert.IsTrue(oracle.ErrorRegion.IsEnabled);
}
public void GivenIDragWriteDropboxToolOntoTheDesignSurface()
{
var dropBoxUploadTool = new DsfDropBoxUploadActivity();
var modelItem = ModelItemUtils.CreateModelItem(dropBoxUploadTool);
var mockEnvironmentRepo = new Mock <IServerRepository>();
var mockEnvironmentModel = new Mock <IServer>();
var mockExecutionEnvironment = new Mock <IExecutionEnvironment>();
var mockResourcRepositorySetUp = new Mock <IResourceRepository>();
var mockEventAggregator = new Mock <IEventAggregator>();
var dropBoxSourceManager = new Mock <IDropboxSourceManager>();
var sources = new List <OauthSource>()
{
new DropBoxSource()
{
ResourceName = "Test Resource Name"
}
};
mockEnvironmentModel.Setup(model => model.IsConnected).Returns(true);
mockEnvironmentModel.Setup(model => model.IsLocalHost).Returns(true);
mockEnvironmentModel.Setup(model => model.EnvironmentID).Returns(Guid.Empty);
mockEnvironmentModel.Setup(model => model.IsLocalHostCheck()).Returns(false);
mockResourcRepositorySetUp.Setup(repository => repository.FindSourcesByType <OauthSource>(mockEnvironmentModel.Object, It.IsAny <enSourceType>()))
.Returns(sources);
mockEnvironmentModel.Setup(model => model.ResourceRepository).Returns(mockResourcRepositorySetUp.Object);
mockEnvironmentRepo.Setup(repository => repository.ActiveServer).Returns(mockEnvironmentModel.Object);
mockEnvironmentRepo.Setup(repository => repository.FindSingle(It.IsAny <Expression <Func <IServer, bool> > >())).Returns(mockEnvironmentModel.Object);
var mock = new Mock <IResourceCatalog>();
mock.Setup(catalog => catalog.GetResourceList <Resource>(It.IsAny <Guid>())).Returns(new List <IResource>());
var uploadViewModel = new DropBoxUploadViewModel(modelItem, dropBoxSourceManager.Object);
scenarioContext.Add("uploadViewModel", uploadViewModel);
scenarioContext.Add("mockEnvironmentModel", mockEnvironmentModel);
scenarioContext.Add("mockEventAggregator", mockEventAggregator);
}
public void WebPostActivityViewModel_WebPost_TestActionSetSourceAndTestClickOkHasMappingsErrorFromServer()
{
//---------------Set up test pack-------------------
var mod = GetMockModel();
var act = GetPostActivityWithOutPuts(mod);
var postViewModel = new WebPostActivityViewModel(ModelItemUtils.CreateModelItem(act), mod);
postViewModel.ManageServiceInputViewModel = new InputViewForWebPostTest(postViewModel, mod);
postViewModel.SourceRegion.SelectedSource = postViewModel.SourceRegion.Sources.First();
#pragma warning disable 4014
postViewModel.TestInputCommand.Execute();
postViewModel.ManageServiceInputViewModel.TestCommand.Execute(null);
postViewModel.ManageServiceInputViewModel.IsEnabled = true;
postViewModel.ManageServiceInputViewModel.OutputArea.Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c")
};
postViewModel.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Assert.IsTrue(postViewModel.ErrorRegion.IsEnabled);
//---------------Test Result -----------------------
}
public void ManageWebServiceInputViewModel_TestActionSetSourceAndTestClickClose()
{
//------------Setup for test--------------------------
var mod = new MyWebModel();
var act = new WebGetActivity();
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
var inputview = new ManageWebServiceInputViewModel(webget, mod)
{
Model = new WebServiceDefinition()
};
inputview.ExecuteClose();
//------------Execute Ok---------------------------
Assert.IsNull(inputview.OutputArea.Outputs);
Assert.IsTrue(webget.SourceRegion.IsEnabled);
Assert.IsFalse(webget.OutputsRegion.IsEnabled);
Assert.IsTrue(webget.InputArea.IsEnabled);
Assert.IsTrue(webget.ErrorRegion.IsEnabled);
Assert.IsFalse(webget.ManageServiceInputViewModel.InputArea.IsEnabled);
//------------Assert Results-------------------------
}
public void ManageWebServiceInputViewModel_TestAction()
{
var called = false;
var calledOk = false;
var mod = new MyWebModel();
var act = new DsfWebGetActivity()
{
SourceId = mod.Sources[0].Id,
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("d", "e", "f")
},
Headers = new List <INameValue> {
new NameValue("a", "x")
},
QueryString = "Bob the builder",
ServiceName = "dsfBob"
};
var webget = new WebServiceGetViewModel(ModelItemUtils.CreateModelItem(act), mod);
var vm = new ManageWebServiceInputViewModel(webget, mod);
vm.TestAction = () => { called = true; };
vm.OkAction = () =>
{
calledOk = true;
};
vm.TestAction();
vm.OkAction();
//------------Assert Results-------------------------
Assert.IsTrue(called);
Assert.IsTrue(calledOk);
}
public void ObjectName_GivenIsObjectAndObjectResult_ShouldFireChanges()
{
//---------------Set up test pack-------------------
var act = new DsfWebGetActivity {
SourceId = Guid.NewGuid(), Outputs = null, IsObject = true
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true)
{
ObjectResult = this.SerializeToJsonString(new DefaultSerializationBinder())
};
var wasCalled = false;
outputsRegion.PropertyChanged += (sender, args) =>
{
wasCalled = true;
};
//---------------Assert Precondition----------------
Assert.IsTrue(outputsRegion.IsObject);
//---------------Execute Test ----------------------
outputsRegion.ObjectName = "a";
//---------------Test Result -----------------------
Assert.IsTrue(wasCalled);
Assert.AreEqual(outputsRegion.ObjectName, act.ObjectName);
}
public void WebPost_TestActionSetSourceAndTestClickOkHasserialisationIssue()
{
//---------------Set up test pack-------------------
var id = Guid.NewGuid();
var mod = GetMockModel();
mod.IsTextResponse = true;
var act = GetEmptyPostActivity();
var deleteViewModel = new WebServiceDeleteViewModel(ModelItemUtils.CreateModelItem(act), mod);
deleteViewModel.ManageServiceInputViewModel = new InputViewForTest(deleteViewModel, mod);
deleteViewModel.SourceRegion.SelectedSource = deleteViewModel.SourceRegion.Sources.First();
#pragma warning disable 4014
deleteViewModel.TestInputCommand.Execute();
deleteViewModel.ManageServiceInputViewModel.TestCommand.Execute(null);
deleteViewModel.ManageServiceInputViewModel.IsEnabled = true;
deleteViewModel.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
Assert.AreEqual(deleteViewModel.OutputsRegion.Outputs.First().MappedFrom, "Result");
//---------------Test Result -----------------------
}
void Verify_ValidateThis(DsfExchangeEmailActivity activity, string expectedErrorMessage = null, DependencyProperty isFocusedProperty = null, bool setSelectedEmailSource = true)
{
var sources = CreateEmailSources(1);
if (setSelectedEmailSource)
{
activity.SavedSource = sources[0];
}
var modelItem = ModelItemUtils.CreateModelItem(activity);
var eventPublisher = new Mock <IEventAggregator>();
eventPublisher.Setup(p => p.Publish(It.IsAny <FileChooserMessage>())).Verifiable();
var viewModel = CreateViewModel(modelItem, eventPublisher.Object);
//------------Execute Test---------------------------
viewModel.Validate();
//------------Assert Results-------------------------
if (string.IsNullOrEmpty(expectedErrorMessage))
{
Assert.IsNull(viewModel.Errors, string.Join("\n", viewModel.Errors?.Select(error => error.Message) ?? new List <string>()));
}
else
{
Assert.IsNotNull(viewModel.Errors);
Assert.AreEqual(1, viewModel.Errors.Count);
StringAssert.Contains(viewModel.Errors[0].Message, expectedErrorMessage);
viewModel.Errors[0].Do();
var isFocused = isFocusedProperty != null && (bool)viewModel.GetValue(isFocusedProperty);
Assert.IsTrue(isFocused);
}
}
public void DataMergeDesignerViewModel_ValidateCollectionItem_ValidatesPropertiesOfDTO()
{
//------------Setup for test--------------------------
var mi = ModelItemUtils.CreateModelItem(new DsfDataMergeActivity());
mi.SetProperty("DisplayName", "Merge");
var dto = new DataMergeDTO("a&]]", DataMergeDTO.MergeTypeIndex, "", 0, "ab", "Left");
var miCollection = mi.Properties["MergeCollection"].Collection;
var dtoModelItem = miCollection.Add(dto);
var viewModel = new DataMergeDesignerViewModel(mi);
viewModel._getDatalistString = () =>
{
const string trueString = "True";
const string noneString = "None";
var datalist = string.Format("<DataList><var Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><a Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><b Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><h Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><r Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /><rec Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" ><set Description=\"\" IsEditable=\"{0}\" ColumnIODirection=\"{1}\" /></rec></DataList>", trueString, noneString);
return(datalist);
};
//------------Execute Test---------------------------
viewModel.Validate();
//------------Assert Results-------------------------
Assert.AreEqual(4, viewModel.Errors.Count);
StringAssert.Contains(viewModel.Errors[0].Message, Warewolf.Resource.Errors.ErrorResource.DataMergeInvalidExpressionErrorTest);
Verify_IsFocused(dtoModelItem, viewModel.Errors[0].Do, "IsFieldNameFocused");
StringAssert.Contains(viewModel.Errors[1].Message, Warewolf.Resource.Errors.ErrorResource.DataMergeUsingNullErrorTest);
Verify_IsFocused(dtoModelItem, viewModel.Errors[1].Do, "IsAtFocused");
}
public void ManageDatabaseServiceInputViewModel_TestActionSetSourceAndReturnNoDataMessage()
{
//------------Setup for test--------------------------
var mod = new SqlServerModel();
mod.ReturnsNoColumns = true;
var act = new DsfSqlServerDatabaseActivity();
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
var inputview = new ManageDatabaseServiceInputViewModel(sqlServer, mod);
inputview.Model = new DatabaseService()
{
Source = new DbSourceDefinition(), Action = new DbAction()
{
Inputs = new List <IServiceInput>(), Name = ""
},
};
inputview.TryExecuteTest();
Assert.IsTrue(inputview.TestPassed);
Assert.IsFalse(inputview.TestFailed);
Assert.AreEqual("No data returned. ", inputview.TestMessage);
Assert.IsTrue(inputview.ShowTestMessage);
}
public void DatabaseActionRegion_ConstructorWithSelectedAction_IsRefreshingTrue_IsActionEnabledFalse()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var dbsrc = new DbSourceDefinition()
{
Id = id, Name = "johnny"
};
var action = new DbAction()
{
Name = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc
});
var sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
sourceRegion.SelectedSource = dbsrc;
//------------Execute Test---------------------------
var dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, new SynchronousAsyncWorker());
dbActionRegion.SelectedAction = action;
dbActionRegion.IsRefreshing = true;
//------------Assert Results-------------------------
Assert.AreEqual(action, dbActionRegion.SelectedAction);
Assert.IsFalse(dbActionRegion.CanRefresh());
}
static ModelItem CreateModelItem(IEnumerable <CaseConvertTO> items, string displayName = "Case Convert")
{
var modelItem = ModelItemUtils.CreateModelItem(new DsfCaseConvertActivity());
modelItem.SetProperty("DisplayName", displayName);
var modelProperty = modelItem.Properties["ConvertCollection"];
if (modelProperty != null)
{
var modelItemCollection = modelProperty.Collection;
if (items != null)
{
foreach (var dto in items)
{
if (modelItemCollection != null)
{
modelItemCollection.Add(dto);
}
}
}
}
return(modelItem);
}
public void WebPut_BodyIsXmlNoHeaders_ExpectNewHeadersAdded()
{
//---------------Set up test pack-------------------
CustomContainer.LoadedTypes = new List <Type>()
{
typeof(ManageWebServiceModel)
};
var shellVm = new Mock <IShellViewModel>();
var serverMock = new Mock <IServer>();
var updateProxy = new Mock <IStudioUpdateManager>();
var updateManager = new Mock <IQueryManager>();
serverMock.Setup(server => server.UpdateRepository).Returns(updateProxy.Object);
serverMock.Setup(server => server.QueryProxy).Returns(updateManager.Object);
shellVm.Setup(model => model.ActiveServer).Returns(serverMock.Object);
CustomContainer.Register(shellVm.Object);
var mod = GetMockModel();
var act = GetPostActivityWithOutPuts(mod);
act.Headers = new List <INameValue>();
var modelItem = ModelItemUtils.CreateModelItem(act);
var postViewModel = new WebServicePostViewModel(modelItem);
var oldCount = postViewModel.InputArea.Headers.Count;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var person = "<person sex=\"female\"><firstname>Anna</firstname><lastname>Smith</lastname></person>";
postViewModel.InputArea.PostData = person;
var newCount = postViewModel.InputArea.Headers.Count;
//---------------Test Result -----------------------
Assert.AreEqual(GlobalConstants.ApplicationXmlHeader, postViewModel.InputArea.Headers.Single(value => value.Value == GlobalConstants.ApplicationXmlHeader).Value);
Assert.AreEqual(GlobalConstants.ContentType, postViewModel.InputArea.Headers.Single(value => value.Name == GlobalConstants.ContentType).Name);
Assert.IsTrue(newCount > oldCount);
}
void AddDto(int indexNumber, string initializeWith = "")
{
//
// DO NOT invoke Renumber() from here - this method is called MANY times when invoking AddToCollection()!!
//
var dto = CreateDto(indexNumber, initializeWith);
AttachEvents(dto);
var idx = indexNumber - 1;
if (ModelItemCollection != null && idx >= ModelItemCollection.Count)
{
ModelItem modelItem = ModelItemUtils.CreateModelItem(dto);
ModelItemCollection.Add(modelItem);
}
else
{
if (ModelItemCollection != null)
{
ModelItemCollection.Insert(idx, dto);
}
}
}
public void OutputsRegion_Clone()
{
CustomContainer.Register <IFieldAndPropertyMapper>(new FieldAndPropertyMapper());
//------------Setup for test--------------------------
var act = new DsfWebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = null,
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true);
outputsRegion.Outputs.Add(new ServiceOutputMapping());
outputsRegion.Outputs.Add(new ServiceOutputMapping());
outputsRegion.Outputs.Add(new ServiceOutputMapping());
outputsRegion.Outputs.Add(new ServiceOutputMapping());
//------------Execute Test---------------------------
Assert.IsFalse(outputsRegion.IsEnabled);
Assert.IsTrue(outputsRegion.IsObjectOutputUsed);
var x = outputsRegion.CloneRegion() as OutputsRegion;
//------------Assert Results-------------------------
Assert.IsNotNull(x, "x != null");
Assert.AreEqual(4, x.Outputs.Count);
}
public void Oracle_UpdateHelp_ShouldCallToHelpViewMode()
{
//------------Setup for test--------------------------
CustomContainer.LoadedTypes = new List <Type>()
{
typeof(ManageDbServiceModel)
};
var mockMainViewModel = new Mock <IShellViewModel>();
var mockHelpViewModel = new Mock <IHelpWindowViewModel>();
mockHelpViewModel.Setup(model => model.UpdateHelpText(It.IsAny <string>())).Verifiable();
mockMainViewModel.Setup(model => model.HelpViewModel).Returns(mockHelpViewModel.Object);
var server = new Mock <IServer>();
var updatemanager = new Mock <IStudioUpdateManager>();
var queryManager = new Mock <IQueryManager>();
queryManager.Setup(manager => manager.FetchDbSources()).Returns(new List <IDbSource>());
server.Setup(server1 => server1.UpdateRepository).Returns(updatemanager.Object);
server.Setup(server1 => server1.QueryProxy).Returns(queryManager.Object);
mockMainViewModel.Setup(model => model.ActiveServer).Returns(server.Object);
CustomContainer.Register(mockMainViewModel.Object);
var mod = new OracleModel();
mod.HasRecError = true;
var act = new DsfOracleDatabaseActivity();
var oracle = new OracleDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), new SynchronousAsyncWorker(), new ViewPropertyBuilder());
//------------Execute Test---------------------------
oracle.UpdateHelpDescriptor("help");
//------------Assert Results-------------------------
mockHelpViewModel.Verify(model => model.UpdateHelpText(It.IsAny <string>()), Times.Once());
}
public void OutputsRegion_GivenNull_ShouldUpdatesModelItem()
{
//---------------Set up test pack-------------------
var act = new DsfWebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = new List <IServiceOutputMapping>(),
};
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true);
var wasCalled = false;
outputsRegion.PropertyChanged += (sender, args) =>
{
wasCalled = true;
};
//---------------Assert Precondition----------------
Assert.IsNotNull(outputsRegion.Outputs);
//---------------Execute Test ----------------------
Assert.IsNotNull(act.Outputs);
//---------------Test Result -----------------------
outputsRegion.Outputs = null;
Assert.AreEqual(0, act.Outputs.Count);
Assert.IsTrue(wasCalled);
}
public void DotNetInputRegion_RestoreFromPrevious_Restore_ExpectValuesChanged()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfDotNetDllActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>());
var nameSpace = new Mock <INamespaceToolRegion <INamespaceItem> >();
DotNetSourceRegion sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfDotNetDllActivity()));
DotNetActionRegion DotNetActionRegion = new DotNetActionRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfDotNetDllActivity()), sourceRegion, nameSpace.Object);
var region = new DotNetInputRegion(ModelItemUtils.CreateModelItem(act), DotNetActionRegion);
// ReSharper disable once UseObjectOrCollectionInitializer
var regionToRestore = new DotNetInputRegionClone();
regionToRestore.IsEnabled = true;
//------------Execute Test---------------------------
region.RestoreRegion(regionToRestore);
//------------Assert Results-------------------------
}
public void OutputsRegion_ViewObjectResult()
{
//---------------Set up test pack-------------------
var updatedOutputs = new List <IServiceOutputMapping>
{
new ServiceOutputMapping {
MappedFrom = "Name", MappedTo = "[[Person().Firstname]]", RecordSetName = "Person"
},
};
var act = new DsfWebGetActivity
{
SourceId = Guid.NewGuid(),
Outputs = new List <IServiceOutputMapping>(),
IsObject = true,
};
var mockJsonObjectsView = new Mock <IJsonObjectsView>();
mockJsonObjectsView.Setup(o => o.ShowJsonString(It.IsAny <string>())).Verifiable();
CustomContainer.RegisterInstancePerRequestType <IJsonObjectsView>(() => mockJsonObjectsView.Object);
var outputsRegion = new OutputsRegion(ModelItemUtils.CreateModelItem(act), true);
outputsRegion.Outputs.Add(new ServiceOutputMapping {
MappedFrom = "Name", MappedTo = "[[Person().Name]]", RecordSetName = "Person"
});
//---------------Assert Precondition----------------
Assert.AreEqual(1, outputsRegion.Outputs.Count);
Assert.AreEqual("[[Person().Name]]", outputsRegion.Outputs.First().MappedTo);
//---------------Execute Test ----------------------
outputsRegion.ResetOutputs(updatedOutputs);
//---------------Test Result -----------------------
outputsRegion.ViewObjectResult.Execute(null);
mockJsonObjectsView.Verify(o => o.ShowJsonString(It.IsAny <string>()), Times.Once);
}
public void DotNetInputRegion_TestClone()
{
var id = Guid.NewGuid();
var act = new DsfDotNetDllActivity()
{
SourceId = id
};
var src = new Mock <IPluginServiceModel>();
var nameSpace = new Mock <INamespaceToolRegion <INamespaceItem> >();
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IPluginSource>());
var sourceRegion = new DotNetSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfDotNetDllActivity()));
var DotNetActionRegion = new DotNetActionRegion();
var region = new DotNetInputRegion(ModelItemUtils.CreateModelItem(act), DotNetActionRegion);
Assert.AreEqual(region.IsEnabled, false);
Assert.AreEqual(region.Errors.Count, 0);
if (region.CloneRegion() is DotNetInputRegion clone)
{
Assert.AreEqual(clone.IsEnabled, false);
Assert.AreEqual(clone.Errors.Count, 0);
}
}
public void SequenceDesignerViewModel_DoDrop_WhenModelItemsFormatHasSingleItem_ActivitiesAdded()
{
//------------Setup for test--------------------------
var dsfSequenceActivity = new DsfSequenceActivity();
var dsfMultiAssignActivity = new DsfMultiAssignActivity();
dsfSequenceActivity.Activities.Add(dsfMultiAssignActivity);
var dsfFindRecordsMultipleCriteriaActivity = new DsfFindRecordsMultipleCriteriaActivity();
dsfSequenceActivity.Activities.Add(dsfFindRecordsMultipleCriteriaActivity);
var sequenceDesignerViewModel = new SequenceDesignerViewModel(CreateModelItem(dsfSequenceActivity));
var dataObjectMock = new Mock <IDataObject>();
dataObjectMock.Setup(o => o.GetFormats()).Returns(new[] { "ModelItemsFormat" });
dataObjectMock.Setup(o => o.GetData("ModelItemsFormat")).Returns(new List <ModelItem> {
ModelItemUtils.CreateModelItem(new DsfGatherSystemInformationActivity())
});
//------------Execute Test---------------------------
bool doDrop = sequenceDesignerViewModel.DoDrop(dataObjectMock.Object);
//------------Assert Results-------------------------
Assert.IsTrue(doDrop);
Assert.AreEqual(3, dsfSequenceActivity.Activities.Count);
}
static ModelItem CreateModelItem()
{
return(ModelItemUtils.CreateModelItem(new DsfSortRecordsActivity()));
}
public void GivenIOpenWolf()
{
var sourceId = Guid.NewGuid();
var inputs = new List <IServiceInput> {
new ServiceInput("Prefix", "[[Prefix]]")
};
var outputs = new List <IServiceOutputMapping>
{
new ServiceOutputMapping("CountryID", "CountryID", "dbo_Pr_CitiesGetCountries"),
new ServiceOutputMapping("Description", "Description", "dbo_Pr_CitiesGetCountries")
};
var oracleServerActivity = new DsfOracleDatabaseActivity
{
SourceId = sourceId,
ProcedureName = "dbo.Pr_CitiesGetCountries",
Inputs = inputs,
Outputs = outputs
};
var modelItem = ModelItemUtils.CreateModelItem(oracleServerActivity);
var mockDatabaseInputViewModel = new Mock <IManageDatabaseInputViewModel>();
var mockDbServiceModel = new Mock <IDbServiceModel>();
var mockEnvironmentRepo = new Mock <IServerRepository>();
var mockEnvironmentModel = new Mock <IServer>();
mockEnvironmentModel.Setup(model => model.IsConnected).Returns(true);
mockEnvironmentModel.Setup(model => model.IsLocalHost).Returns(true);
mockEnvironmentModel.Setup(model => model.EnvironmentID).Returns(Guid.Empty);
mockEnvironmentModel.Setup(model => model.IsLocalHostCheck()).Returns(false);
mockEnvironmentRepo.Setup(repository => repository.ActiveServer).Returns(mockEnvironmentModel.Object);
mockEnvironmentRepo.Setup(repository => repository.FindSingle(It.IsAny <Expression <Func <IServer, bool> > >())).Returns(mockEnvironmentModel.Object);
_greenPointSource = new DbSourceDefinition
{
Name = "GreenPoint",
Type = enSourceType.Oracle
};
_testingDbSource = new DbSourceDefinition
{
Name = "testingDBSrc",
Type = enSourceType.Oracle,
Id = sourceId
};
_importOrderAction = new DbAction
{
Name = "dbo.ImportOrder",
Inputs = new List <IServiceInput> {
new ServiceInput("ProductId", "")
}
};
_getCountriesAction = new DbAction {
Name = "dbo.Pr_CitiesGetCountries"
};
_getCountriesAction.Inputs = inputs;
var dbSources = new ObservableCollection <IDbSource> {
_testingDbSource, _greenPointSource
};
mockDbServiceModel.Setup(model => model.RetrieveSources()).Returns(dbSources);
mockDbServiceModel.Setup(model => model.GetActions(It.IsAny <IDbSource>())).Returns(new List <IDbAction> {
_getCountriesAction, _importOrderAction
});
mockDatabaseInputViewModel.SetupAllProperties();
var oracleDatabaseDesignerViewModel = new OracleDatabaseDesignerViewModel(modelItem, mockDbServiceModel.Object, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
ScenarioContext.Current.Add("viewModel", oracleDatabaseDesignerViewModel);
ScenarioContext.Current.Add("mockDatabaseInputViewModel", mockDatabaseInputViewModel);
ScenarioContext.Current.Add("mockDbServiceModel", mockDbServiceModel);
}
static TestDeleteDesignerViewModel DeleteViewModel()
{
var viewModel = new TestDeleteDesignerViewModel(ModelItemUtils.CreateModelItem(new DsfPathDelete()));
return(viewModel);
}
static ModelItem CreateModelItem(DsfSequenceActivity sequenceActivity)
{
var modelItem = ModelItemUtils.CreateModelItem(sequenceActivity);
return(modelItem);
}
static ModelItem CreateModelItem()
{
return(ModelItemUtils.CreateModelItem(new DsfDropBoxFileActivity()));
}
public void GivenIOpenWorkflowWithPostgreSqlConnector()
{
var sourceId = Guid.NewGuid();
var inputs = new List <IServiceInput> {
new ServiceInput("Prefix", "[[Prefix]]")
};
var outputs = new List <IServiceOutputMapping>
{
new ServiceOutputMapping("name", "name", "getemployees"),
};
var postgresActivity = new DsfPostgreSqlActivity();
var modelItem = ModelItemUtils.CreateModelItem(postgresActivity);
var mockServiceInputViewModel = new Mock <IManageServiceInputViewModel>();
var mockDbServiceModel = new Mock <IDbServiceModel>();
var mockEnvironmentRepo = new Mock <IServerRepository>();
var mockEnvironmentModel = new Mock <IServer>();
mockEnvironmentModel.Setup(model => model.IsConnected).Returns(true);
mockEnvironmentModel.Setup(model => model.IsLocalHost).Returns(true);
mockEnvironmentModel.Setup(model => model.EnvironmentID).Returns(Guid.Empty);
mockEnvironmentModel.Setup(model => model.IsLocalHostCheck()).Returns(false);
mockEnvironmentRepo.Setup(repository => repository.ActiveServer).Returns(mockEnvironmentModel.Object);
mockEnvironmentRepo.Setup(repository => repository.FindSingle(It.IsAny <Expression <Func <IServer, bool> > >())).Returns(mockEnvironmentModel.Object);
_postgresSqlSource = new DbSourceDefinition
{
Name = "postgressql",
Type = enSourceType.PostgreSQL,
ServerName = "Localhost",
UserName = "******",
Password = "******",
AuthenticationType = Runtime.ServiceModel.Data.AuthenticationType.User
};
_testingDbSource = new DbSourceDefinition
{
Name = "testingDBSrc",
Type = enSourceType.PostgreSQL,
Id = sourceId
};
_selectedAction = new DbAction
{
Name = "getemployees",
Inputs = new List <IServiceInput> {
new ServiceInput("fname", "")
}
};
_getEmployees = new DbAction {
Name = "getemployees"
};
_getEmployees.Inputs = inputs;
var dbSources = new ObservableCollection <IDbSource> {
_testingDbSource, _postgresSqlSource
};
mockDbServiceModel.Setup(model => model.RetrieveSources()).Returns(dbSources);
mockDbServiceModel.Setup(model => model.GetActions(It.IsAny <IDbSource>())).Returns(new List <IDbAction> {
_getEmployees, _selectedAction
});
mockServiceInputViewModel.SetupAllProperties();
var postgresDesignerViewModel = new PostgreSqlDatabaseDesignerViewModel(modelItem, mockDbServiceModel.Object, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
_scenarioContext.Add("viewModel", postgresDesignerViewModel);
_scenarioContext.Add("mockServiceInputViewModel", mockServiceInputViewModel);
_scenarioContext.Add("mockDbServiceModel", mockDbServiceModel);
}
