public void ManageDatabaseServiceInputViewModel_Properties()
{
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = mod.Sources[0].Id,
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("d", "e", "f")
},
ServiceName = "dsfBob"
};
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
var vm = new ManageDatabaseServiceInputViewModel(sqlServer, mod);
var lst = new List <IServiceInput>();
vm.InputArea.Inputs = lst;
Assert.AreEqual(lst.Count, vm.InputArea.Inputs.Count);
var lsto = new List <IServiceOutputMapping>();
vm.OutputArea.Outputs = lsto;
Assert.AreEqual(lsto, vm.OutputArea.Outputs);
vm.TestResultsAvailable = true;
Assert.IsTrue(vm.TestResultsAvailable);
vm.OkSelected = true;
Assert.IsTrue(vm.OkSelected);
vm.IsTestResultsEmptyRows = true;
Assert.IsTrue(vm.IsTestResultsEmptyRows);
vm.IsTesting = true;
Assert.IsTrue(vm.IsTesting);
Assert.IsNotNull(vm.Model);
}
public void SqlServer_TestActionSetSourceAndTestClickOkHasMappingsErrorFromServer()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
mod.HasRecError = true;
var act = new DsfSqlServerDatabaseActivity();
//------------Execute Test---------------------------
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
sqlServer.ManageServiceInputViewModel = new InputViewForTest(sqlServer, mod);
sqlServer.SourceRegion.SelectedSource = sqlServer.SourceRegion.Sources.First();
#pragma warning disable 4014
sqlServer.TestInputCommand.Execute(null);
sqlServer.ManageServiceInputViewModel.TestCommand.Execute(null);
sqlServer.ManageServiceInputViewModel.IsEnabled = true;
sqlServer.ManageServiceInputViewModel.OutputArea.Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c")
};
sqlServer.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//------------Assert Results-------------------------
Assert.IsTrue(sqlServer.ErrorRegion.IsEnabled);
Assert.AreNotEqual(0, sqlServer.ManageServiceInputViewModel.Errors.Count);
}
public void SqlServer_TestActionSetSourceHasRecSet()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
//------------Execute Test---------------------------
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
sqlServer.ManageServiceInputViewModel = new InputViewForTest(sqlServer, mod);
sqlServer.SourceRegion.SelectedSource = sqlServer.SourceRegion.Sources.First();
sqlServer.ActionRegion.SelectedAction = sqlServer.ActionRegion.Actions.First();
sqlServer.InputArea.Inputs.Add(new ServiceInput("[[a]]", "asa"));
#pragma warning disable 4014
sqlServer.TestInputCommand.Execute(null);
sqlServer.ManageServiceInputViewModel.TestCommand.Execute(null);
sqlServer.ManageServiceInputViewModel.IsEnabled = true;
sqlServer.ManageServiceInputViewModel.OutputArea.Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c")
};
sqlServer.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
//------------Assert Results-------------------------
Assert.IsTrue(sqlServer.SourceRegion.IsEnabled);
Assert.IsTrue(sqlServer.OutputsRegion.IsEnabled);
Assert.IsTrue(sqlServer.InputArea.IsEnabled);
Assert.IsTrue(sqlServer.ErrorRegion.IsEnabled);
Assert.IsTrue(sqlServer.ManageServiceInputViewModel.InputArea.Inputs.Count == 1);
Assert.IsTrue(sqlServer.ManageServiceInputViewModel.InputArea.Inputs.First().Name == "[[a]]");
Assert.IsTrue(sqlServer.ManageServiceInputViewModel.InputArea.Inputs.Last().Name == "[[a]]");
}
public void ManageDatabaseServiceInputViewModel_TestAction()
{
var called = false;
var calledOk = false;
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity
{
SourceId = mod.Sources[0].Id,
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("d", "e", "f")
},
ServiceName = "dsfBob"
};
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
var vm = new ManageDatabaseServiceInputViewModel(sqlServer, mod);
vm.TestAction = () => { called = true; };
vm.OkAction = () =>
{
calledOk = true;
};
vm.TestAction();
vm.OkAction();
//------------Assert Results-------------------------
Assert.IsTrue(called);
Assert.IsTrue(calledOk);
}
public void ManageDatabaseServiceInputViewModel_WithOneColumn_TestActionSetSourceAndTestClickOk()
{
//------------Setup for test--------------------------
var mod = new SqlServerModelWithOneColumnReturn();
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 = "bob"
},
};
inputview.TryExecuteTest();
//------------Execute Test---------------------------
Assert.IsTrue(inputview.TestPassed);
Assert.IsFalse(inputview.TestFailed);
Assert.AreEqual(string.Empty, inputview.TestMessage);
Assert.IsFalse(inputview.ShowTestMessage);
inputview.ExecuteOk();
//------------Execute Ok---------------------------
Assert.IsTrue(sqlServer.SourceRegion.IsEnabled);
Assert.IsTrue(sqlServer.InputArea.IsEnabled);
Assert.IsTrue(sqlServer.OutputsRegion.IsEnabled);
//------------Assert Results-------------------------
Assert.AreEqual(1, sqlServer.OutputsRegion.Outputs.Count);
}
public void GivenIDragASqlServerDatabaseConnector()
{
var sqlServerActivity = new DsfSqlServerDatabaseActivity();
var modelItem = ModelItemUtils.CreateModelItem(sqlServerActivity);
var mockServiceInputViewModel = 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.SqlDatabase
};
var dbSources = new ObservableCollection <IDbSource> {
_greenPointSource
};
mockDbServiceModel.Setup(model => model.RetrieveSources()).Returns(dbSources);
mockServiceInputViewModel.SetupAllProperties();
var sqlServerDesignerViewModel = new SqlServerDatabaseDesignerViewModel(modelItem, mockDbServiceModel.Object, new SynchronousAsyncWorker());
scenarioContext.Add("viewModel", sqlServerDesignerViewModel);
scenarioContext.Add("mockServiceInputViewModel", mockServiceInputViewModel);
scenarioContext.Add("mockDbServiceModel", mockDbServiceModel);
}
public void SqlServer_MethodName_ClearErrors()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
//------------Execute Test---------------------------
sqlServer.ClearValidationMemoWithNoFoundError();
//------------Assert Results-------------------------
Assert.IsNull(sqlServer.Errors);
Assert.AreEqual(sqlServer.DesignValidationErrors.Count, 1);
}
public void SQLServer_VerifyCommandTimeout()
{
//------------Setup for test--------------------------
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
//------------Execute Test---------------------------
using (var vm = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder()))
{
vm.InputArea.CommandTimeout = 321;
//------------Assert Results-------------------------
var dbService = vm.ToModel();
Assert.AreEqual(321, dbService.CommandTimeout);
}
}
public void SqlServer_Ctor_EmptyModelItem()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
//------------Execute Test---------------------------
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
//------------Assert Results-------------------------
Assert.IsTrue(sqlServer.SourceRegion.IsEnabled);
Assert.IsFalse(sqlServer.OutputsRegion.IsEnabled);
Assert.IsFalse(sqlServer.InputArea.IsEnabled);
Assert.IsTrue(sqlServer.ErrorRegion.IsEnabled);
}
public void SqlServer_MethodName_ValidateExpectErrors()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
//------------Execute Test---------------------------
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
sqlServer.Validate();
//------------Assert Results-------------------------
Assert.AreEqual(1, sqlServer.Errors.Count);
Assert.AreEqual(2, sqlServer.DesignValidationErrors.Count);
}
public void ManageDatabaseServiceInputViewModel_RestoreRegion_DoesNothing()
{
//------------Setup for test--------------------------
var mod = new SqlServerModel();
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();
//------------Execute Test---------------------------
inputview.RestoreRegion(null);
//------------Assert Results-------------------------
Assert.IsTrue(true, "Error RestoreRegion should do nothing");
}
public void ManageDatabaseServiceInputViewModelCloneRegion_ReturnsNull()
{
//------------Setup for test--------------------------
var mod = new SqlServerModel();
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();
//------------Execute Test---------------------------
var clone = inputview.CloneRegion();
//------------Assert Results-------------------------
Assert.AreEqual(inputview, clone);
}
public void SqlServer_Refresh_ShouldLoadRefreshActions()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
sqlServer.ManageServiceInputViewModel = new InputViewForTest(sqlServer, mod);
sqlServer.SourceRegion.SelectedSource = sqlServer.SourceRegion.Sources.First();
//------------Execute Test---------------------------
sqlServer.ActionRegion.RefreshActionsCommand.Execute(null);
//------------Assert Results-------------------------
Assert.IsTrue(sqlServer.SourceRegion.IsEnabled);
Assert.AreEqual(1, sqlServer.ActionRegion.Actions.Count);
}
public void ManageDatabaseServiceInputViewModel_PropertyChangedHandler()
{
//------------Setup for test--------------------------
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
var called = false;
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
var inputview = new ManageDatabaseServiceInputViewModel(sqlServer, mod);
inputview.PropertyChanged += (sender, args) => called = true;
inputview.Model = new DatabaseService();
//------------Execute Test---------------------------
inputview.TryExecuteTest();
//------------Assert Results-------------------------
Assert.IsTrue(called);
}
public void ManageDatabaseServiceInputViewModelOkAction_Exception()
{
//------------Setup for test--------------------------
var mod = new SqlServerModel();
mod.HasRecError = true;
var act = new DsfSqlServerDatabaseActivity();
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
var inputview = new ManageDatabaseServiceInputViewModel(sqlServer, mod);
sqlServer.OutputsRegion.Outputs = null;
//------------Execute Test---------------------------
inputview.ExecuteOk();
//------------Assert Results-------------------------
Assert.IsTrue(inputview.Errors.Count == 1);
}
public void SqlServer_TestActionSetSource()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
//------------Execute Test---------------------------
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
sqlServer.ManageServiceInputViewModel = new InputViewForTest(sqlServer, mod);
sqlServer.SourceRegion.SelectedSource = sqlServer.SourceRegion.Sources.First();
//------------Assert Results-------------------------
Assert.IsTrue(sqlServer.SourceRegion.IsEnabled);
Assert.IsFalse(sqlServer.OutputsRegion.IsEnabled);
Assert.IsFalse(sqlServer.InputArea.IsEnabled);
Assert.IsTrue(sqlServer.ErrorRegion.IsEnabled);
}
public void ManageDatabaseServiceInputViewModel_Ctor()
{
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity
{
SourceId = mod.Sources[0].Id,
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("d", "e", "f")
},
ServiceName = "dsfBob"
};
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
//------------Assert Results-------------------------
var vm = new ManageDatabaseServiceInputViewModel(sqlServer, mod);
Assert.IsNotNull(vm.CloseCommand);
Assert.IsNotNull(vm.CloseCommand);
}
public void GivenIHaveWorkflowWithSqlServerDatabaseConnector(string workflowName, string activityName)
{
var environmentModel = _scenarioContext.Get <IServer>("server");
environmentModel.Connect();
CreateNewResourceModel(workflowName, environmentModel);
CreateDBServiceModel(environmentModel);
var dbServiceModel = _scenarioContext.Get <ManageDbServiceModel>("dbServiceModel");
var sqlServerActivity = new DsfSqlServerDatabaseActivity {
DisplayName = activityName
};
var modelItem = ModelItemUtils.CreateModelItem(sqlServerActivity);
var sqlServerDesignerViewModel = new SqlServerDatabaseDesignerViewModel(modelItem, dbServiceModel, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
var serviceInputViewModel = new ManageDatabaseServiceInputViewModel(sqlServerDesignerViewModel, sqlServerDesignerViewModel.Model);
_commonSteps.AddActivityToActivityList(workflowName, activityName, sqlServerActivity);
DebugWriterSubscribe(environmentModel);
_scenarioContext.Add("viewModel", sqlServerDesignerViewModel);
_scenarioContext.Add("parentName", workflowName);
}
public void SqlServer_UpdateHelp_ShouldCallToHelpViewMode()
{
//------------Setup for test--------------------------
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);
CustomContainer.Register(mockMainViewModel.Object);
var mod = new SqlServerModel();
mod.HasRecError = true;
var act = new DsfSqlServerDatabaseActivity();
var viewModel = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker(), new ViewPropertyBuilder());
//------------Execute Test---------------------------
viewModel.UpdateHelpDescriptor("help");
//------------Assert Results-------------------------
mockHelpViewModel.Verify(model => model.UpdateHelpText(It.IsAny <string>()), Times.Once());
}
public void SqlServer_TestActionSetSourceAndTestClickOkHasMappings()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqlServerModel();
var act = new DsfSqlServerDatabaseActivity();
//------------Execute Test---------------------------
var sqlServer = new SqlServerDatabaseDesignerViewModel(ModelItemUtils.CreateModelItem(act), mod, new SynchronousAsyncWorker());
sqlServer.ManageServiceInputViewModel = new InputViewForTest(sqlServer, mod);
sqlServer.SourceRegion.SelectedSource = sqlServer.SourceRegion.Sources.First();
#pragma warning disable 4014
sqlServer.TestInputCommand.Execute(null);
sqlServer.ManageServiceInputViewModel.TestCommand.Execute(null);
sqlServer.ManageServiceInputViewModel.IsEnabled = true;
sqlServer.ManageServiceInputViewModel.OutputArea.Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c"), new ServiceOutputMapping("a", "b", "c")
};
sqlServer.ManageServiceInputViewModel.Model = new DatabaseService()
{
Action = new DbAction()
{
Inputs = new List <IServiceInput>(), Name = "bob"
}
};
sqlServer.ManageServiceInputViewModel.OkCommand.Execute(null);
#pragma warning restore 4014
var hashCode = sqlServer.SourceRegion.SelectedSource.GetHashCode();
//------------Assert Results-------------------------
Assert.IsTrue(sqlServer.SourceRegion.IsEnabled);
Assert.IsTrue(sqlServer.OutputsRegion.IsEnabled);
Assert.IsTrue(sqlServer.InputArea.IsEnabled);
Assert.IsTrue(sqlServer.ErrorRegion.IsEnabled);
Assert.IsFalse(sqlServer.ManageServiceInputViewModel.InputArea.IsEnabled);
Assert.AreEqual(0, sqlServer.ManageServiceInputViewModel.Errors.Count);
Assert.AreEqual("j_bravo", sqlServer.SourceRegion.SelectedSource.ToString());
Assert.AreEqual(hashCode, sqlServer.SourceRegion.SelectedSource.GetHashCode());
}
public void ManageDatabaseServiceInputViewModel_TestActionSetSourceAndTestClickClose()
{
//------------Setup for test--------------------------
var mod = new SqlServerModel();
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();
inputview.ExecuteClose();
//------------Execute Ok---------------------------
Assert.IsNull(inputview.OutputArea.Outputs);
Assert.IsTrue(sqlServer.SourceRegion.IsEnabled);
Assert.IsFalse(sqlServer.OutputsRegion.IsEnabled);
Assert.IsTrue(sqlServer.InputArea.IsEnabled);
Assert.IsTrue(sqlServer.ErrorRegion.IsEnabled);
Assert.IsFalse(sqlServer.ManageServiceInputViewModel.InputArea.IsEnabled);
//------------Assert Results-------------------------
}
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 GivenIHaveAWorkflow(string p0)
{
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 sqlServerActivity = new DsfSqlServerDatabaseActivity
{
SourceId = sourceId,
ProcedureName = "dbo.Pr_CitiesGetCountries",
Inputs = inputs,
Outputs = outputs
};
//sqlServerActivity.Execute(new Mock<IDSFDataObject>().Object, 0);
var modelItem = ModelItemUtils.CreateModelItem(sqlServerActivity);
var mockServiceInputViewModel = 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.SqlDatabase
};
_testingDbSource = new DbSourceDefinition
{
Name = "testingDBSrc",
Type = enSourceType.SqlDatabase,
Id = sourceId,
ServerName = "localhost"
};
_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);
var privateObject = new PrivateObject(sqlServerActivity);
mockDbServiceModel.Setup(model => model.GetActions(It.IsAny <IDbSource>())).Returns(new List <IDbAction> {
_getCountriesAction, _importOrderAction
});
mockServiceInputViewModel.SetupAllProperties();
var sqlServerDesignerViewModel = new SqlServerDatabaseDesignerViewModel(modelItem, mockDbServiceModel.Object, new SynchronousAsyncWorker());
scenarioContext.Add("viewModel", sqlServerDesignerViewModel);
scenarioContext.Add("privateObject", privateObject);
scenarioContext.Add("mockServiceInputViewModel", mockServiceInputViewModel);
scenarioContext.Add("mockDbServiceModel", mockDbServiceModel);
}
