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 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 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 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 BuildProperties_GivenActionRegionNullValues_ExpectNoError()
{
//------------Setup for test--------------------------
var act = new ViewPropertyBuilder()
{
};
IDbActionToolRegion <IDbAction> actionRegion = new DbActionRegion();
//------------Execute Test---------------------------
Assert.IsNotNull(act);
var keyValuePairs = act.BuildProperties(actionRegion, null, null);
//------------Assert Results-------------------------
Assert.AreEqual(0, keyValuePairs.Count);
}
public void DatabaseActionRegion_Constructor_Scenerio_Result()
{
//------------Setup for test--------------------------
var src = new Mock <IDbServiceModel>();
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>());
var sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
//------------Execute Test---------------------------
var dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), sourceRegion, new SynchronousAsyncWorker());
//------------Assert Results-------------------------
Assert.AreEqual(0, dbActionRegion.Errors.Count);
Assert.IsFalse(dbActionRegion.IsEnabled);
}
public void BuildProperties_GivenActionSourceTypeRegionRegionNullValues_ExpectNoError()
{
//------------Setup for test--------------------------
var act = new ViewPropertyBuilder()
{
};
IDbActionToolRegion <IDbAction> actionRegion = new DbActionRegion();
var sourceRegion = new Mock <ISourceToolRegion <IDbSource> >();
//------------Execute Test---------------------------
Assert.IsNotNull(act);
var keyValuePairs = act.BuildProperties(actionRegion, sourceRegion.Object, string.Empty);
//------------Assert Results-------------------------
Assert.AreEqual(0, keyValuePairs.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 DatabaseInputRegion_Constructor_Scenerio_Result()
{
var id = Guid.NewGuid();
var act = new DsfSqlServerDatabaseActivity()
{
SourceId = id
};
var src = new Mock <IDbServiceModel>();
src.Setup(a => a.RetrieveSources()).Returns(new ObservableCollection <IDbSource>());
var sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
var 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);
}
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
});
DatabaseSourceRegion sourceRegion = new DatabaseSourceRegion(src.Object, ModelItemUtils.CreateModelItem(new DsfSqlServerDatabaseActivity()), enSourceType.SqlDatabase);
//------------Execute Test---------------------------
DbActionRegion dbActionRegion = new DbActionRegion(src.Object, ModelItemUtils.CreateModelItem(act), sourceRegion, new SynchronousAsyncWorker());
// ReSharper disable once UseObjectOrCollectionInitializer
DbActionMemento dbActionRegionToRestore = new DbActionMemento();
dbActionRegionToRestore.IsEnabled = false;
dbActionRegionToRestore.SelectedAction = action;
dbActionRegion.RestoreRegion(dbActionRegionToRestore);
//------------Assert Results-------------------------
Assert.AreEqual(dbActionRegion.SelectedAction, action);
Assert.IsFalse(dbActionRegion.IsEnabled);
}
public override IList <IToolRegion> BuildRegions()
{
IList <IToolRegion> regions = new List <IToolRegion>();
if (SourceRegion == null)
{
SourceRegion = new DatabaseSourceRegion(Model, ModelItem, enSourceType.PostgreSQL)
{
SourceChangedAction = () =>
{
OutputsRegion.IsEnabled = false;
}
};
regions.Add(SourceRegion);
ActionRegion = new DbActionRegion(Model, ModelItem, SourceRegion, _worker);
ActionRegion.ErrorsHandler += (sender, list) =>
{
var errorInfos = list.Select(error => new ActionableErrorInfo(new ErrorInfo {
ErrorType = ErrorType.Critical, Message = error
}, () => { })).ToList();
UpdateDesignValidationErrors(errorInfos);
Errors = new List <IActionableErrorInfo>(errorInfos);
};
regions.Add(ActionRegion);
InputArea = new DatabaseInputRegion(ModelItem, ActionRegion);
regions.Add(InputArea);
OutputsRegion = new OutputsRegion(ModelItem);
regions.Add(OutputsRegion);
if (OutputsRegion.Outputs.Count > 0)
{
OutputsRegion.IsEnabled = true;
}
ErrorRegion = new ErrorRegion();
regions.Add(ErrorRegion);
SourceRegion.Dependants.Add(ActionRegion);
ActionRegion.Dependants.Add(InputArea);
ActionRegion.Dependants.Add(OutputsRegion);
}
regions.Add(ManageServiceInputViewModel);
Regions = regions;
return(regions);
}
public void DatabaseActionRegion_ChangeActionSomethingChanged_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()
};
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());
dbActionRegion.SomethingChanged += (a, b) => { evt = true; };
dbActionRegion.SelectedAction = action;
//------------Assert Results-------------------------
Assert.IsTrue(evt);
}
public void DatabaseInputRegion_RestoreFromPrevious_Restore_ExpectValuesChanged()
{
//------------Setup for test--------------------------
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);
// ReSharper disable once UseObjectOrCollectionInitializer
var regionToRestore = new DatabaseInputRegionClone();
regionToRestore.IsEnabled = true;
//------------Execute Test---------------------------
region.RestoreRegion(regionToRestore);
//------------Assert Results-------------------------
}
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());
}
public void Add_A_New_InputOnSqlProcedure_Expect_New_IS_InputAdded()
{
var newName = Guid.NewGuid().ToString();
var cleanProcName = newName.Replace("-", "").Replace(" ", "");
var dropProcedure = "USE [Dev2TestingDB] DROP PROCEDURE [dbo].[" + cleanProcName + "]";
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 diffAction = actionRegion.Actions.First(p => p.Name != sqlActivity.ProcedureName);
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
var alterProcedure = "ALTER procedure [dbo].[" + cleanProcName + "](@ProductId int,@ProductId1 int,@ProductId2 int) as Begin select * from Country select * from City end";
//actionRegion.SelectedAction = diffAction;//trigger action changes
var alterTableResults = SqlHelper.RunSqlCommand(alterProcedure);
actionRegion.RefreshActionsCommand.Execute(null);
var underTest = actionRegion.Actions.Single(p => p.Name.EndsWith(cleanProcName));
Assert.AreEqual(3, databaseInputRegion.Inputs.Count);
Assert.AreEqual("ProductId", underTest.Inputs.ToList()[0].Name);
Assert.AreEqual("ProductId1", underTest.Inputs.ToList()[1].Name);
Assert.AreEqual("ProductId2", underTest.Inputs.ToList()[2].Name);
Assert.AreEqual("ProductId", databaseInputRegion.Inputs.ToList()[0].Name);
Assert.AreEqual("[[ProductId]]", databaseInputRegion.Inputs.ToList()[0].Value);
Assert.AreEqual("ProductId1", databaseInputRegion.Inputs.ToList()[1].Name);
Assert.AreEqual("[[ProductId1]]", databaseInputRegion.Inputs.ToList()[1].Value);
Assert.AreEqual("ProductId2", databaseInputRegion.Inputs.ToList()[2].Name);
Assert.AreEqual("[[ProductId2]]", databaseInputRegion.Inputs.ToList()[2].Value);
Assert.AreEqual(-1, alterTableResults);
var resultForDrop = SqlHelper.RunSqlCommand(dropProcedure);
Assert.AreEqual(-1, resultForDrop);
}
private void CreateDbActionRegion()
{
_selectedSource = _source.Sources.Single(a => a.Id == _sqlActivity.SourceId);
_source.SelectedSource = _selectedSource;
_dbActionRegion = new DbActionRegion(_dbServiceModel, _modelItem, _source, new SynchronousAsyncWorker());
}
