private void RemoveAllRecent()
{
var removals = AllQueries.Where(x => x.Model.QueryType == QueryTypeOption.Recent).ToList();
foreach (var removal in removals)
{
AllQueries.Remove(removal);
}
RefreshQueries();
}
public async Task QueryAllNotFoundIfEmpty()
{
string name = "does-not-matter";
model.AllEntitesAsync().Returns((IEnumerable <ConfigEntity>)null);
var context = new QueryContext(name, QueryTypes.ValueRequest, model);
var result = await AllQueries.QueryConfigEntityAsync(context);
Assert.False(result.IsSuccess);
Assert.Null(result.Result);
Assert.Equal(ResultType.NotFound, result.ResultType);
}
public async Task QuerySingleHappyPath()
{
string name = "config-name";
var entity = new ConfigEntity();
model.GetEntityByNameAsync(name).Returns(entity);
var context = new QueryContext(name, QueryTypes.ValueRequest, model);
var result = await AllQueries.QueryConfigEntityAsync(context);
Assert.Same(entity, result.Result);
Assert.True(result.IsSuccess);
}
public async Task QuerySingleEntityAsyncReturnsNotFoundIfconfigNameDoesNotExist()
{
string name = "config-name";
model.GetEntityByNameAsync(name).Returns((ConfigEntity)null);
var context = new QueryContext(name, QueryTypes.ValueRequest, model);
var result = await AllQueries.QueryConfigEntityAsync(context);
Assert.False(result.IsSuccess);
Assert.Null(result.Result);
Assert.Equal(ResultType.NotFound, result.ResultType);
}
public async Task QueryAllHappyPath()
{
string name = "config-name";
var entity = new ConfigEntity();
var entities = new List <ConfigEntity> {
entity
};
model.AllEntitesAsync().Returns((IEnumerable <ConfigEntity>)entities);
var context = new QueryContext(name, QueryTypes.AllValues, model);
var result = await AllQueries.QueryAllConfigEntityValuesAsync(context);
Assert.IsType <ConfigCollection>(result.Result);
Assert.Same(entity, ((ConfigCollection)(result.Result)).WrappedConfigEntities.First());
Assert.True(result.IsSuccess);
}
private Query NewQueryFor(CoReTypeName type, DefinitionSite defSite)
{
var q = new Query();
AllQueries.Add(q);
try
{
q.definition = defSite;
q.type = type;
q.classCtx = Enclosings.Type.ToCoReName();
q.methodCtx = Enclosings.Method.ToCoReName();
return(q);
}
catch (Exception)
{
Console.WriteLine("failed to create new Query, falling back to Unknown");
return(q);
}
}
protected override bool SaveData()
{
if (model != null)
{
model.Items.CleansePaths();
var removals = model.Items.Where(x => x.IsRemove).ToList();
if (removals.Count > 0)
{
string directory = Path.Combine(AppConstants.ContentDirectory, AppConstants.ContentFiles);
foreach (var removal in removals)
{
if (!removal.Mime.Equals("text") &&
!String.IsNullOrWhiteSpace(removal.Mime) &&
!removal.Mime.Equals("url") &&
!removal.Mime.Equals("text/credential"))
{
string filepath = System.IO.Path.Combine(directory, removal.Body);
if (System.IO.File.Exists(filepath))
{
System.IO.File.Delete(filepath);
}
}
model.Items.Remove(removal);
}
}
List <QueryTypeOption> exclusions = new List <QueryTypeOption>()
{
QueryTypeOption.None, QueryTypeOption.Recent
};
model.Queries = AllQueries.Where(x => !exclusions.Contains(x.Model.QueryType)).Select(x => x.Model).ToList().Cleanse();
if (!DataService.TryWrite <Content>(model, out string message, Filepath()))
{
OnFailure(message);
return(false);
}
}
return(true);
}
public async Task QueryAllThrowsOnWrongQueryType()
{
var context = new QueryContext("does-not-matter", QueryTypes.ValueRequest, model);
await Assert.ThrowsAsync <ArgumentException>(async() => await AllQueries.QueryAllConfigEntityValuesAsync(context));
}
public async Task QuerySingleEntityWithWrongQueryTypeThrowsArgumentException()
{
var context = new QueryContext("does-not-matter", QueryTypes.AllValues, model);
await Assert.ThrowsAsync <ArgumentException>(async() => await AllQueries.QueryConfigEntityAsync(context));
}
public async Task NullContextThrows()
{
await Assert.ThrowsAsync <ArgumentException>(async() => await AllQueries.QueryConfigEntityAsync(null));
await Assert.ThrowsAsync <ArgumentException>(async() => await AllQueries.QueryAllConfigEntityValuesAsync(null));
}
