public void DatabaseSourceRegion_ChangeSourceSomethingChanged_ExpectedChange_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var dbsrc = new DbSourceDefinition()
{
Id = id
};
var evt = false;
var s2 = new DbSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc, s2
});
//------------Execute Test---------------------------
var region = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act), enSourceType.SqlDatabase);
region.SomethingChanged += (a, b) => { evt = true; };
region.SelectedSource = s2;
//------------Assert Results-------------------------
Assert.IsTrue(evt);
}
public void DatabaseSourceRegion_ConstructorWithSelectedSource_Scenerio_Result()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var dbsrc = new DbSourceDefinition()
{
Id = id
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc
});
//------------Execute Test---------------------------
var region = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act), enSourceType.SqlDatabase);
//------------Assert Results-------------------------
Assert.AreEqual(dbsrc, region.SelectedSource);
Assert.IsTrue(region.CanEditSource());
}
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 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 DatabaseActionRegion_ChangeActionSomethingChanged_CloneRegion_ExpectedClone()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var dbsrc = new DbSourceDefinition()
{
Id = id
};
var s2 = new DbSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc, s2
});
var sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
//------------Execute Test---------------------------
var dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, new SynchronousAsyncWorker());
var cloned = dbActionRegion.CloneRegion();
//------------Assert Results-------------------------
Assert.AreEqual(cloned.IsEnabled, dbActionRegion.IsEnabled);
Assert.AreEqual(((DbActionMemento)cloned).SelectedAction, dbActionRegion.SelectedAction);
}
public void BuildProperties_GivenActionSourceTypeRegionRegionNullValues_ExpectNoError_DefinedValues()
{
//------------Setup for test--------------------------
var act = new ViewPropertyBuilder()
{
};
var serviceModel = new Mock <IDbServiceModel>();
var dsfSqlServerDatabaseActivity = new DsfSqlServerDatabaseActivity()
{
ProcedureName = "proc a"
};
IDbActionToolRegion <IDbAction> actionRegion = new DbActionRegion(serviceModel.Object, ModelItemUtils.CreateModelItem(dsfSqlServerDatabaseActivity), new DatabaseSourceRegion(), new SynchronousAsyncWorker());
var sourceRegion = new Mock <ISourceToolRegion <IDbSource> >();
sourceRegion.Setup(region => region.SelectedSource).Returns(new DbSourceDefinition()
{
Name = "Sourcename"
});
//------------Execute Test---------------------------
Assert.IsNotNull(act);
var keyValuePairs = act.BuildProperties(actionRegion, sourceRegion.Object, "DsfSqlServerDatabaseActivity");
//------------Assert Results-------------------------
Assert.AreEqual(3, keyValuePairs.Count);
var keySource = keyValuePairs.Single(pair => pair.Key == "Source :").Value;
var keyType = keyValuePairs.Single(pair => pair.Key == "Type :").Value;
var keyProcedure = keyValuePairs.Single(pair => pair.Key == "Procedure :").Value;
Assert.AreEqual("Sourcename", keySource);
Assert.AreEqual("DsfSqlServerDatabaseActivity", keyType);
Assert.AreEqual("proc a", keyProcedure);
}
public void DataGridActivityFindMissingStrategy_GetActivityFields_SqlServer_ShouldReturnResults()
{
//------------Setup for test--------------------------
Dev2FindMissingStrategyFactory fac = new Dev2FindMissingStrategyFactory();
IFindMissingStrategy strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
var activity = new DsfSqlServerDatabaseActivity
{
Inputs = new List <IServiceInput> {
new ServiceInput("Input1", "[[InputValue1]]"), new ServiceInput("Input2", "[[InputValue2]]"), new ServiceInput("Input3", "[[InputValue3]]")
},
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("Output1", "OutputValue1", "rec"), new ServiceOutputMapping("Output2", "OutputValue2", "rec")
},
OnErrorVariable = "[[err]]",
OnErrorWorkflow = "[[errSvc]]"
};
//------------Execute Test---------------------------
var fields = strategy.GetActivityFields(activity);
//------------Assert Results-------------------------
Assert.AreEqual(7, fields.Count);
Assert.IsTrue(fields.Contains("[[InputValue1]]"));
Assert.IsTrue(fields.Contains("[[InputValue2]]"));
Assert.IsTrue(fields.Contains("[[InputValue3]]"));
Assert.IsTrue(fields.Contains("[[rec().OutputValue1]]"));
Assert.IsTrue(fields.Contains("[[rec().OutputValue2]]"));
Assert.IsTrue(fields.Contains("[[err]]"));
Assert.IsTrue(fields.Contains("[[errSvc]]"));
}
public void UpdateOnActionSelection_GivenHasInputs_ShouldWriteToActiveDatalistAndPopulatesInputValues()
{
//---------------Set up test pack-------------------
var mock = new Mock <IDataListViewModel>();
mock.Setup(model => model.ScalarCollection).Returns(new ObservableCollection <IScalarItemModel>());
DataListSingleton.SetDataList(mock.Object);
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var modelItem = ModelItemUtils.CreateModelItem(act);
var actionRegion = new Mock <IActionToolRegion <IDbAction> >();
actionRegion.Setup(region => region.SelectedAction).Returns(ValueFunction);
//---------------Assert Precondition----------------
// ReSharper disable once PossibleNullReferenceException
var countBefore = DataListSingleton.ActiveDataList.ScalarCollection.Count;
Assert.AreEqual(0, countBefore);
//---------------Execute Test ----------------------
var inputRegion = new DatabaseInputRegion(modelItem, actionRegion.Object);
var methodInfo = typeof(DatabaseInputRegion).GetMethod("UpdateOnActionSelection", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.IsNotNull(methodInfo);
methodInfo.Invoke(inputRegion, new object[] { });
//---------------Test Result -----------------------
Assert.AreEqual("[[name]]", inputRegion.Inputs.ToList()[0].Value);
Assert.AreEqual("[[surname]]", inputRegion.Inputs.ToList()[1].Value);
}
public void DatabaseInputRegion_TestClone()
{
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>());
DatabaseSourceRegion sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
DbActionRegion dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), sourceRegion, new SynchronousAsyncWorker());
var region = new DatabaseInputRegion(ModelItemUtils.CreateModelItem(act), dbActionRegion);
Assert.AreEqual(region.IsEnabled, false);
Assert.AreEqual(region.Errors.Count, 0);
var clone = region.CloneRegion() as DatabaseInputRegion;
if (clone != null)
{
Assert.AreEqual(clone.IsEnabled, false);
Assert.AreEqual(clone.Errors.Count, 0);
}
}
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 DatabaseInputRegion_SourceChanged_UpdateValues()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var lst = new ObservableCollection <IDbSource>()
{
new DbSourceDefinition()
{
Name = "bravo"
}, new DbSourceDefinition()
{
Name = "johnny"
}
};
src.Setup(a => a.RetrieveSources()).Returns(lst);
DatabaseSourceRegion sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
DbActionRegion dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), sourceRegion, new SynchronousAsyncWorker());
var region = new DatabaseInputRegion(ModelItemUtils.CreateModelItem(act), dbActionRegion);
sourceRegion.SelectedSource = lst[0];
Assert.AreEqual(region.Inputs.Count, 0);
}
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 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 DatabaseSourceRegion_ChangeSourceSomethingChanged_RestoreRegion_ExpectedRestore()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var dbsrc = new DbSourceDefinition()
{
Id = id
};
var s2 = new DbSourceDefinition()
{
Id = Guid.NewGuid()
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc, s2
});
//------------Execute Test---------------------------
var region = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act), enSourceType.SqlDatabase);
var regionToRestore = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act), enSourceType.SqlDatabase);
regionToRestore.SelectedSource = s2;
region.RestoreRegion(regionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(region.SelectedSource, s2);
}
public void DatabaseActionRegion_ChangeActionSomethingChanged_RestoreRegion_ExpectedRestore()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var dbsrc = new DbSourceDefinition()
{
Id = id
};
var s2 = new DbSourceDefinition()
{
Id = Guid.NewGuid()
};
var action = new DbAction()
{
Name = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc, s2
});
var sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
//------------Execute Test---------------------------
var dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, new SynchronousAsyncWorker());
var dbActionRegionToRestore = new DbActionMemento
{
IsEnabled = false,
SelectedAction = action,
ToolRegionName = "New Tool Action Region",
Dependants = new List <IToolRegion> {
new DbActionMemento()
},
Errors = new List <string> {
"New Action Region Error"
},
Actions = new List <IDbAction> {
new DbAction()
},
IsActionEnabled = true,
IsRefreshing = false,
LabelWidth = 1.0
};
dbActionRegion.RestoreRegion(dbActionRegionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(dbActionRegion.SelectedAction, action);
Assert.IsFalse(dbActionRegion.IsEnabled);
}
public void DatabaseActionRegion_ChangeActionSomethingChanged_RegionsNotRestored_Invalid()
{
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
var dbsrc = new DbSourceDefinition()
{
Id = id
};
var action = new DbAction()
{
Name = "bravo"
};
var s2 = new DbSourceDefinition()
{
Id = Guid.NewGuid()
};
var action1 = new DbAction()
{
Name = "bravo"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc, s2
});
var sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
//------------Execute Test---------------------------
var dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, new SynchronousAsyncWorker());
var clone1 = new Mock <IToolRegion>();
var clone2 = new Mock <IToolRegion>();
var dep1 = new Mock <IToolRegion>();
dep1.Setup(a => a.CloneRegion()).Returns(clone1.Object);
var dep2 = new Mock <IToolRegion>();
dep2.Setup(a => a.CloneRegion()).Returns(clone2.Object);
dbActionRegion.Dependants = new List <IToolRegion> {
dep1.Object, dep2.Object
};
dbActionRegion.SelectedAction = action;
dbActionRegion.SelectedAction = action1;
//------------Assert Results-------------------------
dep1.Verify(a => a.RestoreRegion(clone1.Object), Times.Never);
dep2.Verify(a => a.RestoreRegion(clone2.Object), Times.Never);
}
public void change_sql_source_verify_Empty_Inputs()
{
var newName = Guid.NewGuid().ToString();
var cleanProcName = newName.Replace("-", "").Replace(" ", "");
var createProcedure = "CREATE procedure [dbo].[" + cleanProcName + "](@ProductId int) as Begin select * from Country select * from City end";
var result = SqlHelper.RunSqlCommand(createProcedure);
Assert.AreEqual(-1, result);
var inputs = new List <IServiceInput>()
{
new ServiceInput("ProductId", "[[ProductId]]")
{
ActionName = "dbo." + cleanProcName
}
};
var sqlActivity = new DsfSqlServerDatabaseActivity()
{
Inputs = inputs,
ActionName = "dbo." + cleanProcName,
ProcedureName = "dbo." + cleanProcName,
SourceId = new Guid("b9184f70-64ea-4dc5-b23b-02fcd5f91082")
};
var modelItem = ModelItemUtils.CreateModelItem(sqlActivity);
var environmentModel = ServerRepository.Instance.Source;
environmentModel.Connect();
var environmentConnection = environmentModel.Connection;
var controllerFactory = new CommunicationControllerFactory();
var _proxyLayer = new StudioServerProxy(controllerFactory, environmentConnection);
var mock = new Mock <IShellViewModel>();
var dbServiceModel = new ManageDbServiceModel(new StudioResourceUpdateManager(controllerFactory, environmentConnection)
, _proxyLayer.QueryManagerProxy
, mock.Object
, environmentModel);
var source = new DatabaseSourceRegion(dbServiceModel, modelItem, Common.Interfaces.Core.DynamicServices.enSourceType.SqlDatabase);
var selectedSource = source.Sources.Single(a => a.Id == sqlActivity.SourceId);
source.SelectedSource = selectedSource;
var actionRegion = new DbActionRegion(dbServiceModel, modelItem, source, new SynchronousAsyncWorker());
var mockSource = new Mock <IDbSource>();
IDatabaseInputRegion databaseInputRegion = new DatabaseInputRegion(modelItem, actionRegion);
Assert.AreEqual(1, databaseInputRegion.Inputs.Count);
Assert.AreEqual("ProductId", databaseInputRegion.Inputs.Single().Name);
Assert.AreEqual("[[ProductId]]", databaseInputRegion.Inputs.Single().Value);
//add testing here
source.SelectedSource = mockSource.Object;
Assert.AreEqual(0, databaseInputRegion.Inputs.Count);
}
public void UniqueIDDifferent_EmptySqlDatabase_Object_Is_Not_Equal()
{
//---------------Set up test pack-------------------
var uniqueId = Guid.NewGuid().ToString();
var activity1 = new DsfSqlServerDatabaseActivity();
var sqlDatabase = new DsfSqlServerDatabaseActivity();
//---------------Assert Precondition----------------
Assert.IsNotNull(activity1);
//---------------Execute Test ----------------------
var @equals = activity1.Equals(sqlDatabase);
//---------------Test Result -----------------------
Assert.IsFalse(@equals);
}
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 DatabaseInputRegion_Test_InputAddHeader_ExpectHeightChanges()
{
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>());
DatabaseSourceRegion sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
DbActionRegion dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), sourceRegion, new SynchronousAsyncWorker());
var region = new DatabaseInputRegion(ModelItemUtils.CreateModelItem(act), dbActionRegion);
Assert.AreEqual(region.IsEnabled, false);
}
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 DatabaseSourceRegion_ChangeSourceSomethingChanged_RestoreRegion_Result()
{
//------------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 = "bob"
};
var s2 = new DbSourceDefinition()
{
Id = Guid.NewGuid(), Name = "bob"
};
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>()
{
dbsrc, s2
});
//------------Execute Test---------------------------
var region = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(act), enSourceType.SqlDatabase);
var clone1 = new Mock <IToolRegion>();
var clone2 = new Mock <IToolRegion>();
var dep1 = new Mock <IToolRegion>();
dep1.Setup(a => a.CloneRegion()).Returns(clone1.Object);
var dep2 = new Mock <IToolRegion>();
dep2.Setup(a => a.CloneRegion()).Returns(clone2.Object);
region.Dependants = new List <IToolRegion> {
dep1.Object, dep2.Object
};
region.SelectedSource = s2;
region.SelectedSource = dbsrc;
//------------Assert Results-------------------------
dep1.Verify(a => a.RestoreRegion(clone1.Object), Times.Never);
dep2.Verify(a => a.RestoreRegion(clone2.Object), Times.Never);
}
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);
}
private void CreateSqlServerActivity(string procName)
{
var inputs = new List <IServiceInput>
{
new ServiceInput("ProductId", "[[ProductId]]")
{
ActionName = "dbo." + procName
}
};
_sqlActivity = new DsfSqlServerDatabaseActivity
{
Inputs = inputs,
ActionName = "dbo." + procName,
ProcedureName = "dbo." + procName,
SourceId = new Guid("b9184f70-64ea-4dc5-b23b-02fcd5f91082")
};
}
