public void AdvancedRecordsetViewModel_ParseTSQL_SelectStatementWithAllias_2_ReturnOutputs()
{
//------------Setup for test--------------------------
CustomContainer.LoadedTypes = new List <Type>
{
typeof(ManageSqliteServiceInputViewModel)
};
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>();
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 dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(new Mock <IResourceModel>().Object);
var recordSetItemModel = new RecordSetItemModel("person", enDev2ColumnArgumentDirection.Input);
var recordSetFieldItemModels = new ObservableCollection <IRecordSetFieldItemModel>
{
new RecordSetFieldItemModel("name", recordSetItemModel),
new RecordSetFieldItemModel("age", recordSetItemModel),
new RecordSetFieldItemModel("address_id", recordSetItemModel)
};
recordSetItemModel.Children = recordSetFieldItemModels;
dataListViewModel.RecsetCollection.Add(recordSetItemModel);
DataListSingleton.SetDataList(dataListViewModel);
var act = new AdvancedRecordsetActivity();
const string query = "select p.name as username,p.address_id as address from person p";
//------------Execute Test---------------------------
using (var viewModel = new AdvancedRecordsetDesignerViewModel(ModelItemUtils.CreateModelItem(act), new ViewPropertyBuilder()))
{
viewModel.SqlQuery = query;
viewModel.OutputsRegion.RecordsetName = "NewPerson";
viewModel.GenerateOutputsCommand.Execute(query);
//------------Assert Results-------------------------
Assert.IsNotNull(viewModel.OutputsRegion.Outputs);
Assert.IsTrue(viewModel.OutputsRegion.IsEnabled);
Assert.IsTrue(viewModel.ErrorRegion.IsEnabled);
Assert.AreEqual(2, viewModel.OutputsRegion.Outputs.Count);
Assert.AreEqual("[[NewPerson().username]]", viewModel.OutputsRegion.Outputs.First().MappedTo);
Assert.AreEqual("username", viewModel.OutputsRegion.Outputs.First().MappedFrom);
Assert.AreEqual("[[NewPerson().address]]", viewModel.OutputsRegion.Outputs.Last().MappedTo);
Assert.AreEqual("address", viewModel.OutputsRegion.Outputs.Last().MappedFrom);
}
}
public void AdvancedRecordsetViewModel_UpdateHelp_ShouldCallToHelpViewMode()
{
//------------Setup for test--------------------------
CustomContainer.LoadedTypes = new List <Type>
{
typeof(ManageSqliteServiceInputViewModel)
};
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>();
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 SqliteModel {
HasRecError = true
};
var act = new AdvancedRecordsetActivity();
using (var viewModel = new AdvancedRecordsetDesignerViewModel(ModelItemUtils.CreateModelItem(act), new ViewPropertyBuilder()))
{
//------------Execute Test---------------------------
viewModel.UpdateHelpDescriptor("help");
}
//------------Assert Results-------------------------
mockHelpViewModel.Verify(model => model.UpdateHelpText(It.IsAny <string>()), Times.Once());
}
public void AdvancedRecordsetActivity_OnExecute()
{
//IDSFDataObject
var activity = new AdvancedRecordsetActivity();
//activity.Execute()
}
public void AdvancedRecordsetViewModel_MethodName_ClearErrors()
{
CustomContainer.LoadedTypes = new List <Type>
{
typeof(ManageSqliteServiceInputViewModel)
};
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>();
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);
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqliteModel();
var act = new AdvancedRecordsetActivity();
using (var advancedRecordset = new AdvancedRecordsetDesignerViewModel(ModelItemUtils.CreateModelItem(act), new ViewPropertyBuilder()))
{
//------------Execute Test---------------------------
advancedRecordset.ClearValidationMemoWithNoFoundError();
//------------Assert Results-------------------------
Assert.IsNull(advancedRecordset.Errors);
Assert.AreEqual(advancedRecordset.DesignValidationErrors.Count, 1);
}
}
public void AdvancedRecordsetActivity_Equal_OtherisObjectofAdvancedRecordsetActivity()
{
var advancedRecordsetActivity = CreateAdvancedRecordsetActivity();
object other = new AdvancedRecordsetActivity();
var advancedRecordsetActivityEqual = advancedRecordsetActivity.Equals(other);
Assert.IsFalse(advancedRecordsetActivityEqual);
}
public void AdvancedRecordsetActivity_SetGet_SqlQuery()
{
using (var advancedRecordsetActivity = new AdvancedRecordsetActivity {
SqlQuery = "Select * from person"
})
{
Assert.AreEqual("Select * from person", advancedRecordsetActivity.SqlQuery);
}
}
public void AdvancedRecordsetActivity_SetGet_RecordsetName()
{
using (var advancedRecordsetActivity = new AdvancedRecordsetActivity {
RecordsetName = "TestRecordsetName"
})
{
Assert.AreEqual("TestRecordsetName", advancedRecordsetActivity.RecordsetName);
}
}
public void AdvancedRecordsetActivity_GetHashCode()
{
using (var advancedRecordsetActivity = new AdvancedRecordsetActivity {
SqlQuery = "Select * from person"
})
{
var hashCode = advancedRecordsetActivity.GetHashCode();
Assert.IsNotNull(hashCode);
}
}
public void AdvancedRecordsetActivity_GetFindMissingType_Expect_DataGridActivity()
{
using (var advancedRecordsetActivity = new AdvancedRecordsetActivity {
SqlQuery = "Select * from person"
})
{
var findMissingType = advancedRecordsetActivity.GetFindMissingType();
Assert.AreEqual(enFindMissingType.DataGridActivity, findMissingType);
}
}
public void AdvancedRecordsetActivity_SetGet_ExecuteActionString()
{
const string executeActionString = "exec StoredProc";
using (var advancedRecordsetActivity = new AdvancedRecordsetActivity {
ExecuteActionString = executeActionString
})
{
Assert.AreEqual(executeActionString, advancedRecordsetActivity.ExecuteActionString);
}
}
public void AdvancedRecordsetActivity_SetGet_DeclareVariables()
{
var declareVariables = new List <INameValue>();
using (var advancedRecordsetActivity = new AdvancedRecordsetActivity {
DeclareVariables = declareVariables
})
{
Assert.AreEqual(declareVariables, advancedRecordsetActivity.DeclareVariables);
}
}
public void AdvancedRecordsetActivity_ExecuteRecordset_GIVEN_JsonObject_ShouldSuccess()
{
var started = false;
var personRecordsetName = "personRec";
var env = CreateExecutionEnvironment();
var personObject = new List <AssignValue> {
new AssignValue("[[@person()]]", "{'name':'bob', 'age':21, 'address_id':'1'}")
};
env.AssignWithFrame(personObject, 0);
env.CommitAssign();
var personRec = new List <AssignValue> {
new AssignValue("[[personRec().name]]", "[[@person(*).name]]")
};
env.AssignWithFrame(personRec, 0);
env.CommitAssign();
var recordset = new AdvancedRecordset(env);
recordset.LoadRecordsetAsTable(personRecordsetName);
var activity = new AdvancedRecordsetActivity()
{
SqlQuery = "Select * from personRec",
Outputs = new List <IServiceOutputMapping>
{
new ServiceOutputMapping
{
MappedFrom = "name",
MappedTo = "[[TableCopy().name]]",
}
}
};
var worker = new AdvancedRecordsetActivityWorker(activity, recordset);
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(true);
dataObject.Setup(o => o.Environment).Returns(env);
dataObject.Object.Environment = env;
worker.ExecuteRecordset(dataObject.Object, 0);
var result = env.Eval("[[TableCopy(1).name]]", 0);
Assert.AreEqual("bob", ExecutionEnvironment.WarewolfEvalResultToString(result));
}
public void AdvancedRecordsetViewModel_ValidateSql_ShowsCorrectErrorFormat()
{
CustomContainer.LoadedTypes = new List <Type>
{
typeof(ManageSqliteServiceInputViewModel)
};
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>();
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 dataListViewModel = new DataListViewModel();
dataListViewModel.InitializeDataListViewModel(new Mock <IResourceModel>().Object);
var recordSetItemModel = new RecordSetItemModel("selectPerson", enDev2ColumnArgumentDirection.Input);
var recordSetFieldItemModels = new ObservableCollection <IRecordSetFieldItemModel>
{
new RecordSetFieldItemModel("name", recordSetItemModel),
new RecordSetFieldItemModel("age", recordSetItemModel),
new RecordSetFieldItemModel("address_id", recordSetItemModel)
};
recordSetItemModel.Children = recordSetFieldItemModels;
dataListViewModel.RecsetCollection.Add(recordSetItemModel);
DataListSingleton.SetDataList(dataListViewModel);
//------------Setup for test--------------------------
var act = new AdvancedRecordsetActivity();
const string expectedFormat = "Invalid Output Mapping: count ( * )";
using (var advancedRecordset = new AdvancedRecordsetDesignerViewModel(ModelItemUtils.CreateModelItem(act), new ViewPropertyBuilder()))
{
advancedRecordset.SqlQuery = "select count(*) from [[selectPerson(*)]]";
//------------Execute Test---------------------------
advancedRecordset.ValidateSql();
advancedRecordset.Validate();
//------------Assert Results-------------------------
Assert.AreEqual(1, advancedRecordset.Errors.Count);
Assert.AreEqual(expectedFormat, advancedRecordset.Errors[0].Message);
}
}
public void AdvancedRecordsetActivity_ExecuteSql()
{
var started = false;
var mockAdvancedRecordset = new Mock <IAdvancedRecordset>();
mockAdvancedRecordset.Setup(o => o.CreateVariableTable());
mockAdvancedRecordset.Setup(o => o.InsertIntoVariableTable(It.IsAny <string>(), It.IsAny <string>()));
var workerInvoker = GetAdvancedRecordsetWorker(mockAdvancedRecordset);
var activity = new AdvancedRecordsetActivity(workerInvoker);
activity.SqlQuery = "Select * from person";
//TODO: this is failing as it needs a mock of the recorset
// workerInvoker.ExecuteSql(0, ref started);
}
public void DataGridActivityFindMissingStrategy_GetActivityFields_AdvancedRecordsetActivity_GivenSqlQueryWithNoAnyField_ShouldReturnResults()
{
//--------------Arrange------------------------------
var fac = new Dev2FindMissingStrategyFactory();
var strategy = fac.CreateFindMissingStrategy(enFindMissingType.DataGridActivity);
var activity = new AdvancedRecordsetActivity()
{
SqlQuery = "Select * from person",
Outputs = new List <IServiceOutputMapping> {
new ServiceOutputMapping("id", "id", "TableCopy")
},
};
//--------------Act----------------------------------
var fields = strategy.GetActivityFields(activity);
//--------------Assert-------------------------------
Assert.AreEqual(3, fields.Count);
Assert.IsTrue(fields.Contains("[[person()]]"));
Assert.IsTrue(fields.Contains("[[person().id]]"));
Assert.IsTrue(fields.Contains("[[TableCopy().id]]"));
}
public void GivenIDragOnAnAdvancedRecordsetTool()
{
var activity = new AdvancedRecordsetActivity();
var modelItem = ModelItemUtils.CreateModelItem(activity);
var mockServiceInputViewModel = new Mock <IManageSqliteInputViewModel>();
var mockServiceModel = new Mock <ISqliteServiceModel>();
_scenarioContext.TryGetValue("variableList", out List <Tuple <string, string> > variableList);
if (variableList == null)
{
variableList = new List <Tuple <string, string> >();
_scenarioContext.Add(nameof(variableList), variableList);
}
BuildShapeAndTestData();
var viewModel = new AdvancedRecordsetDesignerViewModel(modelItem, mockServiceModel.Object);
_scenarioContext.Add(nameof(viewModel), viewModel);
_scenarioContext.Add(nameof(mockServiceInputViewModel), mockServiceInputViewModel);
_scenarioContext.Add(nameof(mockServiceModel), mockServiceModel);
}
public void AdvancedRecordsetViewModel_TestActionSetSourceAndTestClickOkHasMappingsErrorFromServer()
{
CustomContainer.LoadedTypes = new List <Type>
{
typeof(ManageSqliteServiceInputViewModel)
};
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>();
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);
//------------Setup for test--------------------------
var id = Guid.NewGuid();
var mod = new SqliteModel {
HasRecError = true
};
var act = new AdvancedRecordsetActivity();
//------------Execute Test---------------------------
using (var advancedRecordset = new AdvancedRecordsetDesignerViewModel(ModelItemUtils.CreateModelItem(act), new ViewPropertyBuilder()))
{
advancedRecordset.GenerateOutputsCommand.Execute(null);
//------------Assert Results-------------------------
Assert.IsTrue(advancedRecordset.ErrorRegion.IsEnabled);
}
}
public void AdvancedRecordsetActivity_ExecuteRecordset()
{
var started = false;
var personRecordsetName = "person";
var l = new List <AssignValue>();
l.Add(new AssignValue("[[person().name]]", "bob"));
l.Add(new AssignValue("[[person().age]]", "21"));
l.Add(new AssignValue("[[person().address_id]]", "1"));
var env = CreateExecutionEnvironment();
env.AssignWithFrame(l, 0);
env.CommitAssign();
var recordset = new AdvancedRecordset(env);
recordset.LoadRecordsetAsTable(personRecordsetName);
recordset.ApplyResultToEnvironment(personRecordsetName, new List <IServiceOutputMapping>(), new List <DataRow>(), false, 0, ref started);
recordset.CreateVariableTable();
recordset.InsertIntoVariableTable("TestVariable", "testdata");
var activity = new AdvancedRecordsetActivity()
{
SqlQuery = "Select * from person",
};
var worker = new AdvancedRecordsetActivityWorker(activity, recordset);
var dataObject = new Mock <IDSFDataObject>();
dataObject.Setup(o => o.IsDebugMode()).Returns(true);
dataObject.Setup(o => o.Environment).Returns(env);
dataObject.Object.Environment = env;
//TODO: this is failing as it needs a mock of the recorset
// worker.ExecuteRecordset(dataObject.Object, 0)
}
static AdvancedRecordsetActivity GetAdvancedRecordsetActivity(Mock <IAdvancedRecordsetActivityWorker> worker)
{
var activity = new AdvancedRecordsetActivity(worker.Object);
return(activity);
}
