public QueryControllerTest()
{
this._serviceProviderMock = new ServiceProviderMock();
this._controller = new QueryController(this._serviceProviderMock.getMock());
this._controller.ControllerContext = new ControllerContext();
this._controller.ControllerContext.HttpContext = new DefaultHttpContext();
}
public void SelectFieldsUniqueFailTest()
{
var qc = new QueryController(null);
var t1 = new QueryFromTable {
Alias = "t", StoreDefinition = new StoreDefinition {
Name = "table1"
}
};
var p1 = new QueryFromProperty {
Alias = "id", StoreProperty = new StoreProperty {
Name = "x1"
}
};
var p2 = new QueryFromProperty {
StoreProperty = new StoreProperty {
Name = "id"
}
};
var p3 = new QueryFromProperty {
Alias = "myid", StoreProperty = new StoreProperty {
Name = "x2"
}
};
qc.AddSelectionProperty(t1, p1);
qc.AddSelectionProperty(t1, p2);
qc.AddSelectionProperty(t1, p3);
var rule = new SelectFieldsUnique();
var vr = rule.Validate(qc);
Assert.NotNull(vr);
Assert.True(vr.IsFailed);
Assert.Contains("id", vr.Message);
Assert.DoesNotContain("myid", vr.Message);
}
public async Task SearchInternalAsync_WithValidRequest_ReturnsExpectedResult(string content, Type resultType)
{
Ensure.IsNotNull(resultType, nameof(resultType));
// Arrange
var mockTranslator = new Mock <ITranslator>();
var mockLogger = new Mock <ILogger <QueryController> >();
var mockResponseParser = new Mock <IResponseParser>();
var mockQueryExecutor = new Mock <IQueryExecutor>();
var httpContext = new DefaultHttpContext();
httpContext.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(content));
// Controller needs a controller context
var controllerContext = new ControllerContext()
{
HttpContext = httpContext,
};
var controller = new QueryController(
mockQueryExecutor.Object,
mockTranslator.Object,
mockLogger.Object,
mockResponseParser.Object)
{
ControllerContext = controllerContext
};
// Act
var result = await controller.SearchAsync(true, true, It.IsAny <RequestContext>());
// Assert
Assert.IsInstanceOf(resultType, result, $"result {result} is not of expected type {resultType.Name}");
}
/// <summary>
/// This method deletes a Vendor record
/// <returns>The return value from the stored procedure.</returns>
public int MarkMoved(DBOFactoryTransaction objTransaction)
{
LastUpdated = DateTime.Now;
if (string.IsNullOrWhiteSpace(UpdatedBy))
{
UpdatedBy = CurrentWindowsUser.Name;
}
FillCommandParamsDelegate objFillParamsMethod = new FillCommandParamsDelegate(
delegate(SqlCommand objSQLCommand)
{
objSQLCommand.Parameters.AddWithValue($"@{Identity}", IdValue);
objSQLCommand.Parameters.AddWithValue("@IsMoved", IsMoved);
objSQLCommand.Parameters.AddWithValue("@NewFullPath", NewFullPath);
objSQLCommand.Parameters.AddWithValue("@LastUpdated", LastUpdated);
objSQLCommand.Parameters.AddWithValue("@UpdatedBy", UpdatedBy);
}
);
QueryController objQueryController = new QueryController(null, $"UPDATE {Table} SET IsMoved = @IsMoved, NewFullPath = @NewFullPath, LastUpdated = @LastUpdated, UpdatedBy = @UpdatedBy WHERE {Identity} = @{Identity}", objFillParamsMethod, null);
int intReturnCode = PerformQuery(objQueryController, "GetByName", null);
this.ResultDataSet = null;
return(intReturnCode);
}
private QueryController GetController()
{
var mockQueryData = new QueryData("query", "kibana_logs");
var mockTranslator = new Mock <ITranslator>();
mockTranslator.Setup(x => x.Translate(It.IsAny <string>(), It.IsAny <string>())).Returns(mockQueryData);
var mockQueryExecutor = new Mock <IQueryExecutor>();
mockQueryExecutor.Setup(exec => exec.ExecuteQueryAsync(It.IsAny <QueryData>(), It.IsAny <RequestContext>())).Returns(Task.FromResult((default(TimeSpan), new Mock <IDataReader>().Object)));
var mockLogger = new Mock <ILogger <QueryController> >();
var mockResponseParser = new Mock <IResponseParser>();
mockResponseParser.Setup(exec =>
exec.Parse(
It.IsAny <IDataReader>(),
It.IsAny <QueryData>(),
It.IsAny <TimeSpan>()))
.Returns(new ElasticResponse());
var ctr = new QueryController(mockQueryExecutor.Object, mockTranslator.Object, mockLogger.Object, mockResponseParser.Object)
{
ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext(),
},
};
return(ctr);
}
public async Task <IViewComponentResult> InvokeAsync(Models.Query query)
{
if (query == null)
{
query = new Models.Query();
}
//Models.Query query = new Models.Query();
if (string.IsNullOrEmpty(query.QueryTerm) && !string.IsNullOrEmpty(Request.Query["term"]))
{
query.QueryTerm = Request.Query["term"];
}
if (string.IsNullOrEmpty(query.ChosenOptions) && !string.IsNullOrEmpty(Request.Query["options"]))
{
query.ChosenOptions = Request.Query["options"];
}
if (string.IsNullOrEmpty(query.ChosenAggregations) && !string.IsNullOrEmpty(Request.Query["aggregations"]))
{
query.ChosenAggregations = Request.Query["aggregations"];
}
if (query.MinScore == 0 && !string.IsNullOrEmpty(Request.Query["minScore"]))
{
query.MinScore = double.Parse(Request.Query["minScore"]);
}
if (query.QueryOptions.Count() == 0)
{
var qc = new QueryController(_logger, _memoryCache);
query.QueryOptions = await qc.GetQueryOptions(query.ChosenOptions);
}
return(View(query));
}
/// <summary>
/// Counts the number of objects that match this query.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The number of objects that match this query.</returns>
public override Task <int> CountAsync(CancellationToken cancellationToken)
{
return(AVUser.GetCurrentUserAsync().OnSuccess(t =>
{
return QueryController.CountAsync <T>(this, t.Result, cancellationToken);
}).Unwrap());
}
void filterCurrentData_FilterChangedEvent(object sender, EventArgs e)
{
if (DataGrid != null)
{
FilterHandler handler = DataGridExtensions.GetFilterHandler(DataGrid);
if (handler != null)
{
FilterCurrentData.Column = AssignedDataGridColumnHeader.Column.Header.ToString();
FilterDatas filterDatas = DataGridExtensions.GetFilterDatas(DataGrid);
if (filterDatas != null)
{
filterDatas.AddOrUpdateData(FilterCurrentData);
}
handler.DoFilter(FilterCurrentData);
}
else
{
QueryController query = QueryControllerFactory.GetQueryController(
DataGrid, FilterCurrentData, DataGridItemsSource);
addFilterStateHandlers(query);
query.DoQuery();
IsFirstFilterControl = query.IsCurentControlFirstControl;
}
}
}
internal static T GetEditContent <T, C>(QueryController <C> controller, string command, T page) where T : PageEdit
{
T result = page;
result.ContentEn = string.Empty;
result.ContentRu = string.Empty;
controller.ExecQuery((query) =>
{
query.Execute(command, new SqlParameter[]
{
new SqlParameter()
{
ParameterName = "@Id", Value = page.Id
}
}
, onExecute: null
, (values) =>
{
string content = values[2] == DBNull.Value ? string.Empty : (string)values[2];
if (!string.IsNullOrEmpty(content))
{
result.ContentEn = string.Concat(result.ContentEn, content);
}
content = values[3] == DBNull.Value ? string.Empty : (string)values[3];
if (!string.IsNullOrEmpty(content))
{
result.ContentRu = string.Concat(result.ContentRu, content);
}
});
});
return(result);
}
public void SelectFieldsUniquePassTest()
{
var qc = new QueryController(null);
var t1 = new QueryFromTable(new StoreDefinition {
Name = "table1"
})
{
Alias = "t"
};
var p1 = new QueryFromProperty {
Alias = "id2", OriginalStoreProperty = new StoreProperty {
Name = "id"
}
};
var p2 = new QueryFromProperty {
OriginalStoreProperty = new StoreProperty {
Name = "id"
}
};
var p3 = new QueryFromProperty {
Alias = "myid", OriginalStoreProperty = new StoreProperty {
Name = "id"
}
};
qc.AddSelectionProperty(t1, p1);
qc.AddSelectionProperty(t1, p2);
qc.AddSelectionProperty(t1, p3);
var rule = new SelectFieldsUnique();
var vr = rule.Validate(qc.MainQuery);
Assert.Null(vr);
}
private void addFilterStateHandlers(QueryController query)
{
query.FilteringStarted -= query_FilteringStarted;
query.FilteringFinished -= query_FilteringFinished;
query.FilteringStarted += query_FilteringStarted;
query.FilteringFinished += query_FilteringFinished;
}
public static void SetDataGridFilterQueryController(DependencyObject target, QueryController value)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
target.SetValue(DataGridFilterQueryControllerProperty, value);
}
private void AddFilterStateHandlers(QueryController query)
{
query.FilteringStarted -= new EventHandler <EventArgs>(query_FilteringStarted);
query.FilteringFinished -= new EventHandler <EventArgs>(query_FilteringFinished);
query.FilteringStarted += new EventHandler <EventArgs>(query_FilteringStarted);
query.FilteringFinished += new EventHandler <EventArgs>(query_FilteringFinished);
}
/// <summary>
/// Retrieves at most one ParseObject that satisfies this query.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A single ParseObject that satisfies this query, or else null.</returns>
public Task <T> FirstOrDefaultAsync(CancellationToken cancellationToken)
{
EnsureNotInstallationQuery();
return(QueryController.FirstAsync <T>(this, ParseUser.CurrentUser, cancellationToken).OnSuccess(t => {
IObjectState state = t.Result;
return state == null ? default(T) : ParseObject.FromState <T>(state, ClassName);
}));
}
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
Instance = this;
}
/// <summary>
/// This method deletes a Vendor record
/// <returns>The return value from the stored procedure.</returns>
public int DeleteAll(DBOFactoryTransaction objTransaction)
{
GetResultsDataSetDelegate objGetResultsMethod = null;
FillCommandParamsDelegate objFillParamsMethod = null;
QueryController objQueryController = new QueryController(null, $"DELETE {Table}", objFillParamsMethod, objGetResultsMethod);
int intReturnCode = PerformQuery(objQueryController, "GetByName", null);
return(intReturnCode);
}
public void QueryInValidResponseRoadTest()
{
string RoadId = "A233";
var controller = new QueryController();
// Act
IHttpActionResult actionResult = controller.SearchResponse(RoadId);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(NotFoundResult));
}
public QueryInterface()
{
controller = new QueryController();
userCommands = new Dictionary <string, Action>()
{
{ "country", QueryCountry }
, { "full", QueryFull }
};
}
/// <summary>
/// Retrieves a list of ParseObjects that satisfy this query from Parse.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The list of ParseObjects that match this query.</returns>
public Task <IEnumerable <T> > FindAsync(CancellationToken cancellationToken)
{
EnsureNotInstallationQuery();
return(QueryController.FindAsync <T>(this, ParseUser.CurrentUser, cancellationToken).OnSuccess(t => {
IEnumerable <IObjectState> states = t.Result;
return (from state in states
select ParseObject.FromState <T>(state, ClassName));
}));
}
public void Execute(object parameter)
{
var mainViewModel = (MainViewModel)Application.Current.Properties["mainViewModel"];
var customer = new Equipment(mainViewModel.SelectedItemRow);
QueryController controller = new QueryController(EntityType.Equipment);
controller.DeleteRecord(customer);
}
private void ClearQuery(object parameter)
{
if (DataGrid != null)
{
QueryController query = QueryControllerFactory.GetQueryController(
DataGrid, FilterCurrentData, DataGridItemsSource);
query.ClearFilter();
}
}
public void IndexTest()
{
QueryController target = new QueryController(); // TODO: Initialize to an appropriate value
ActionResult expected = null; // TODO: Initialize to an appropriate value
ActionResult actual;
actual = target.Index();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void QueryInValidRoadTest()
{
string RoadId = "A233";
var controller = new QueryController();
// Act
var result = controller.Search(RoadId);
// Assert the result
Assert.IsNotNull(result);
Assert.AreEqual("404", result.httpStatusCode);
}
public void QueryValidRoadTest()
{
string RoadId = "A2";;
var controller = new QueryController();
// Act
var result = controller.Search(RoadId);
// Assert the result
Assert.IsNotNull(result);
Assert.AreEqual("A2", result.displayName);
}
/// <summary>
/// Retrieves at most one AVObject that satisfies this query.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A single AVObject that satisfies this query, or else null.</returns>
public override Task <T> FirstOrDefaultAsync(CancellationToken cancellationToken)
{
return(AVUser.GetCurrentUserAsync().OnSuccess(t =>
{
return QueryController.FirstAsync <T>(this, t.Result, cancellationToken);
}).Unwrap().OnSuccess(t =>
{
IObjectState state = t.Result;
return state == null ? default(T) : AVObject.FromState <T>(state, ClassName);
}));
}
public MainPageViewModel(INavigationService navigationService, IPageDialogService pageDialogService)
{
QueryController = new QueryController();
SelectText = new ReactiveProperty <string>();
FromText = new ReactiveProperty <string>();
WhereText = new ReactiveProperty <string>();
GroupByText = new ReactiveProperty <string>();
HavingText = new ReactiveProperty <string>();
OrderByText = new ReactiveProperty <string>();
NavigateSearchCommand = new DelegateCommand(() =>
{
try
{
var table = QueryParser.Parse(SelectText.Value,
FromText.Value,
WhereText.Value,
GroupByText.Value,
HavingText.Value,
OrderByText.Value);
var navigationParameters = new NavigationParameters {
{ "table", table }
};
if (table.Columns[0] == "User")
{
User.GetDummyResult(table);
navigationService.NavigateAsync("UserResultPage", navigationParameters);
}
else if (table.Columns[0] == "Tweet")
{
Tweet.GetDummyResult(table);
navigationService.NavigateAsync("TweetResultPage", navigationParameters);
}
else if (table.Columns[0] == "List")
{
List.GetDummyResult(table);
navigationService.NavigateAsync("ListResultPage", navigationParameters);
}
}
catch (Exception e)
{
pageDialogService.DisplayAlertAsync(e.GetType().Name, e.Message, "OK");
}
});
FromTextChangedCommand = new Command(() =>
{
QueryController.OnFromTextChanged(FromText.Value);
});
}
public void QueryWeatherInfoTest()
{
QueryController target = new QueryController(); // TODO: Initialize to an appropriate value
string weatherCountyCode = string.Empty; // TODO: Initialize to an appropriate value
string Date = string.Empty; // TODO: Initialize to an appropriate value
JsonResult expected = null; // TODO: Initialize to an appropriate value
JsonResult actual;
actual = target.QueryWeatherInfo(weatherCountyCode, Date);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public void Execute(object parameter)
{
var input = (Customer)parameter;
QueryController controller = new QueryController(EntityType.Customer);
controller.UpdateRecord(input);
var viewModel = (MainViewModel)Application.Current.Properties["mainViewModel"];
viewModel.MainDataTable = controller.GetAllRecords();
viewModel.StatusTextOutput += viewModel.MainDataTable.Rows.Count + " Customers Loaded\n";
}
/// <summary>
/// Retrieves a list of AVObjects that satisfy this query from LeanCloud.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The list of AVObjects that match this query.</returns>
public override Task <IEnumerable <T> > FindAsync(CancellationToken cancellationToken)
{
return(AVUser.GetCurrentUserAsync().OnSuccess(t =>
{
return QueryController.FindAsync <T>(this, t.Result, cancellationToken);
}).Unwrap().OnSuccess(t =>
{
IEnumerable <IObjectState> states = t.Result;
return (from state in states
select AVObject.FromState <T>(state, ClassName));
}));
}
void filterCurrentData_FilterChangedEvent(object sender, EventArgs e)
{
if (DataGrid != null)
{
QueryController query = QueryControllerFactory.GetQueryController(
DataGrid, FilterCurrentData, DataGridItemsSource);
AddFilterStateHandlers(query);
query.DoQuery();
IsFirstFilterControl = query.IsCurentControlFirstControl;
}
}
public void Setup()
{
queryRepository = new Mock<IQueryRepository>();
userRepository = new Mock<IUserRepository>();
controller = new QueryController(queryRepository.Object, userRepository.Object);
}
