public async Task ShouldGetObjectResolved()
{
/// Arrange
var request = new SchemaSearchRequest
{
Limit = 100,
Filter = new TermFilter
{
Field = "types",
Term = SchemaType.List.ToString()
}
};
var result = await _client.Schemas.SearchAsync(request);
Assert.True(result.Results.Any());
// For debugging: .Where(i => i.Id == "Esselabore1"))
var tuple = result.Results
.Select(i => new { schemaId = i.Id, objectId = _fixture.GetRandomObjectIdAsync(i.Id, 20).Result })
.First(i => !string.IsNullOrEmpty(i.objectId));
/// Act
var listItem = await _client.ListItems.GetAsync(tuple.objectId, true);
/// Assert
Assert.Equal(tuple.schemaId, listItem.ContentSchemaId);
}
public async Task ShouldSearch()
{
/// Act
var searchRequest = new SchemaSearchRequest
{
Limit = 12,
SearchString = "D*"
};
var result = await _client.Schemas.SearchAsync(searchRequest);
/// Assert
Assert.True(result.Results.Any());
}
public static async Task <string> GetRandomSchemaIdAsync(PictureparkClient client, int limit)
{
string schemaId = string.Empty;
var request = new SchemaSearchRequest {
Limit = limit
};
SchemaSearchResult result = await client.Schemas.SearchAsync(request);
if (result.Results.Count > 0)
{
int randomNumber = new Random().Next(0, result.Results.Count);
schemaId = result.Results.Skip(randomNumber).First().Id;
}
return(schemaId);
}
public async Task ShouldGet()
{
/// Arrange
var searchRequest = new SchemaSearchRequest {
Start = 0, Limit = 100
};
var searchResult = await _client.Schemas.SearchAsync(searchRequest);
Assert.True(searchResult.Results.Any());
List <string> schemaIds = searchResult.Results
.Select(i => i.Id)
.OrderBy(i => i)
.ToList();
/// Act
var schemaIdsOk = new List <string>();
var schemaIdsNotOk = new List <string>();
foreach (var schemaId in schemaIds)
{
try
{
var schema = await _client.Schemas.GetAsync(schemaId);
schemaIdsOk.Add(schema.Id);
}
catch
{
schemaIdsNotOk.Add(schemaId);
}
}
/// Assert
Assert.False(schemaIdsNotOk.Count > 0);
Assert.True(schemaIdsOk.Count > 0);
}
public async Task ShouldSearchListItemsAndScrollThroughResults()
{
// Arrange
// ---------------------------------------------------------------------------
// Get a list of MetadataSchemaIds
// ---------------------------------------------------------------------------
var searchRequestSchema = new SchemaSearchRequest
{
Limit = 2,
Filter = FilterBase.FromExpression <Schema>(i => i.Types, SchemaType.List.ToString())
};
var searchResultSchema = await _client.Schema.SearchAsync(searchRequestSchema).ConfigureAwait(false);
Assert.True(searchResultSchema.Results.Any());
List <string> metadataSchemaIds = searchResultSchema.Results
.Select(i => i.Id)
.OrderBy(i => i)
.ToList();
var searchRequestObject = new ListItemSearchRequest()
{
Limit = 100
};
var items = new List <ListItem>();
List <string> failedMetadataSchemaIds = new List <string>();
// Act
// ---------------------------------------------------------------------------
// Loop over all metadataSchemaIds and make a search for each metadataSchemaId
// ---------------------------------------------------------------------------
foreach (var metadataSchemaId in metadataSchemaIds)
{
searchRequestObject.SchemaIds = new List <string> {
metadataSchemaId
};
searchRequestObject.PageToken = null;
try
{
int i = 0;
ListItemSearchResult searchResultObject;
do
{
searchResultObject = await _client.ListItem.SearchAsync(searchRequestObject).ConfigureAwait(false);
if (searchResultObject.Results.Any())
{
items.AddRange(searchResultObject.Results);
}
}while (++i < 3 && ((searchRequestObject.PageToken = searchResultObject.PageToken) != null));
}
catch (Exception)
{
failedMetadataSchemaIds.Add(metadataSchemaId);
}
}
// Assert
Assert.True(!failedMetadataSchemaIds.Any());
Assert.True(items.Any());
}
public async Task ShouldSearchObjects()
{
/// Arrange
// ---------------------------------------------------------------------------
// Get a list of MetadataSchemaIds
// ---------------------------------------------------------------------------
var searchRequestSchema = new SchemaSearchRequest
{
Start = 0,
Limit = 999,
Filter = new TermFilter
{
Field = "types",
Term = SchemaType.List.ToString()
}
};
var searchResultSchema = await _client.Schemas.SearchAsync(searchRequestSchema);
Assert.True(searchResultSchema.Results.Any());
List <string> metadataSchemaIds = searchResultSchema.Results
.Select(i => i.Id)
.OrderBy(i => i)
.ToList();
var searchRequestObject = new ListItemSearchRequest()
{
Start = 0, Limit = 100
};
var items = new List <ListItem>();
List <string> failedMetadataSchemaIds = new List <string>();
/// Act
// ---------------------------------------------------------------------------
// Loop over all metadataSchemaIds and make a search for each metadataSchemaId
// ---------------------------------------------------------------------------
foreach (var metadataSchemaId in metadataSchemaIds)
{
searchRequestObject.SchemaIds = new List <string> {
metadataSchemaId
};
try
{
var searchResultObject = await _client.ListItems.SearchAsync(searchRequestObject);
if (searchResultObject.Results.Any())
{
items.AddRange(searchResultObject.Results);
}
}
catch (Exception)
{
failedMetadataSchemaIds.Add(metadataSchemaId);
}
}
/// Assert
Assert.True(!failedMetadataSchemaIds.Any());
Assert.True(items.Any());
}
