/// <summary>
/// Puts payload in a batch response.
/// </summary>
/// <typeparam name="T">T must be a PayloadTestDescriptor.</typeparam>
/// <param name="originalPayload">Payload to be inserted into batch.</param>
/// <param name="statusCode">Status code associated with payload</param>
/// <param name="random">Use of random makes this method non deterministic</param>
/// <param name="requestManager">Used to construct the response payload.</param>
/// <param name="inChangeset">Specifies whether this is in a changeset or an operation.</param>
/// <param name="operationsBefore">Number of operations/changesets to go before payload.</param>
/// <param name="operationsAfter">Number of operations/changesets to go after payload.</param>
/// <param name="version">Maximum version for extra generated payloads</param>
/// <returns>Test descriptor for the new BatchResponsePayload.</returns>
public static T InBatchResponse <T>(
this T originalPayload,
int statusCode,
IRandomNumberGenerator random,
IODataRequestManager requestManager,
bool inChangeset = false,
int operationsBefore = 0,
int operationsAfter = 0,
ODataVersion version = ODataVersion.V4
) where T : PayloadTestDescriptor
{
ExceptionUtilities.CheckArgumentNotNull(originalPayload, "originalPayload");
ExceptionUtilities.CheckArgumentNotNull(statusCode, "statusCode");
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
var payload = (T)originalPayload.Clone();
var headers = new Dictionary <string, string> {
{ "ResponseHeader", "ResponseValue" }
};
var baseUri = new ODataUri(ODataUriBuilder.Root(new Uri("http://www.odata.org/service.svc")));
IMimePart[] extraoperations = BatchUtils.ExtraResponseChangesets(random, (EdmModel)payload.PayloadEdmModel, version); // add extraChangesets methods
extraoperations.Concat(BatchUtils.ExtraResponseOperations(random, (EdmModel)payload.PayloadEdmModel, version));
//Work out the operations and changesets to go before the payload
var parts = Enumerable.Range(0, operationsBefore).Select(i => random.ChooseFrom(extraoperations));
if (!inChangeset)
{
extraoperations.ConcatSingle(payload.InResponseOperation(statusCode, requestManager));
}
else
{
extraoperations.ConcatSingle(payload.InResponseChangeset(statusCode, random, requestManager, random.NextFromRange(0, 2), random.NextFromRange(0, 2), version));
}
parts.Concat(Enumerable.Range(0, operationsAfter).Select(i => random.ChooseFrom(extraoperations)));
var batchResponse = new BatchResponsePayload();
foreach (var part in parts)
{
HttpResponseData operation = part as HttpResponseData;
if (operation != null)
{
batchResponse.Add(operation.AsBatchFragment());
}
BatchResponseChangeset changeset = part as BatchResponseChangeset;
if (changeset != null)
{
batchResponse.Add(changeset);
}
}
//payload.PayloadEdmModel.Fixup();
payload.PayloadElement = batchResponse;
return(payload);
}
/// <summary>
/// Puts payload in a batch request.
/// </summary>
/// <typeparam name="T">T must be a PayloadTestDescriptor.</typeparam>
/// <param name="originalPayload">Payload to put into batch.</param>
/// <param name="verb">HttpVerb associated with payload.</param>
/// <param name="random">Use of random makes this method non deterministic.</param>
/// <param name="requestManager">Used to construct requests.</param>
/// <param name="operationsBefore">Number of operations/changesets to go before payload.</param>
/// <param name="operationsAfter">Number of operations/changesets to go after payload.</param>
/// <param name="version">Maximum version for extra payloads</param>
/// <returns>The test descriptor for the new BatchRequestPayload</returns>
public static T InBatchRequest <T>(
this T originalPayload,
HttpVerb verb,
IRandomNumberGenerator random,
IODataRequestManager requestManager,
int operationsBefore = 0,
int operationsAfter = 0,
ODataVersion version = ODataVersion.V4
) where T : PayloadTestDescriptor
{
ExceptionUtilities.CheckArgumentNotNull(originalPayload, "originalPayload");
ExceptionUtilities.CheckArgumentNotNull(verb, "verb");
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
var payload = (T)originalPayload.Clone();
var baseUri = new ODataUri(ODataUriBuilder.Root(new Uri("http://www.odata.org/service.svc")));
IMimePart[] extraOperations = BatchUtils.ExtraRequestChangesets(random, requestManager, (EdmModel)payload.PayloadEdmModel, baseUri, version); // add extraChangesets methods
extraOperations.Concat(BatchUtils.ExtraRequestChangesets(random, requestManager, (EdmModel)payload.PayloadEdmModel, baseUri, version));
//Work out the operations and changesets to go before the payload
var parts = Enumerable.Range(0, operationsBefore).Select(i => random.ChooseFrom(extraOperations));
if (verb != HttpVerb.Get)
{
extraOperations.ConcatSingle(payload.InRequestOperation(HttpVerb.Get, baseUri, requestManager));
}
else
{
extraOperations.ConcatSingle(payload.InRequestChangeset(verb, random, requestManager, random.NextFromRange(0, 2), random.NextFromRange(0, 2), version));
}
parts.Concat(Enumerable.Range(0, operationsAfter).Select(i => random.ChooseFrom(extraOperations)));
var batchRequest = new BatchRequestPayload();
foreach (var part in parts)
{
IHttpRequest operation = part as IHttpRequest;
if (operation != null)
{
batchRequest.Add(operation.AsBatchFragment());
}
BatchRequestChangeset changeset = part as BatchRequestChangeset;
if (changeset != null)
{
batchRequest.Add(changeset);
}
}
//payload.PayloadEdmModel.Fixup();
payload.PayloadElement = batchRequest;
return(payload);
}
/// <summary>
/// When overridden in a derived class, generates a random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
protected override string GenerateStringCore(IRandomNumberGenerator random, int minLength, int maxLength)
{
this.EnsureAlphabetLoaded();
var minimumCharacterLength = this.alphabet.Min(w => w.Length);
var desiredLength = random.NextFromRange(minLength, maxLength);
// This is an intentionally naive check to determine whether the desired length
// is actually one that this resource string generator can satisfy. Since the minimum
// length of existing alphabets is either 1 or 2, and the alphabet that has
// characters of length 2 has no characters of length 3 or more, then this check works.
if ((desiredLength % minimumCharacterLength) != 0)
{
// Get the closest length to the randomly chosen length that is also a multiple
// of minimumCharacterLength. Note that the integer division between desiredLength
// and minimumCharacterLength is intentional.
desiredLength = (desiredLength / minimumCharacterLength) * minimumCharacterLength;
if (desiredLength < minLength)
{
desiredLength += minimumCharacterLength;
}
if (desiredLength > maxLength)
{
throw new TaupoArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"This string generator cannot generate a string of a length between {0} and {1}.",
minLength,
maxLength));
}
}
StringBuilder sb = new StringBuilder(desiredLength);
while (sb.Length < desiredLength)
{
var next = random.ChooseFrom(this.alphabet);
if (next.Length + sb.Length > desiredLength)
{
next = random.ChooseFrom(this.alphabet.Where(w => w.Length == minimumCharacterLength));
}
sb.Append(next);
}
return(sb.ToString());
}
/// <summary>
/// Generates an arbitrary top load payload based on the maximum version supplied.
/// </summary>
/// <param name="random">Random generator for generating arbitrary payloads</param>
/// <param name="model">The model to add any new types to</param>
/// <param name="version">Maximum version for generated payloads.</param>
/// <returns>A top level payload.</returns>
public static ODataPayloadElement GetRandomPayload(IRandomNumberGenerator random, EdmModel model, ODataVersion version = ODataVersion.V4)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(model, "model");
Func<ODataPayloadElement>[] payloadCalls = new Func<ODataPayloadElement>[]
{
() => { return GetComplexInstanceCollection(random, model, version); },
() => { return GetComplexProperty(random, model, version); },
() => { return GetDeferredLink(); },
() => { return GetLinkCollection(); },
() => { return GetEntityInstance(random, model, version); },
() => { return GetEntitySetInstance(random, model); },
() => { return GetODataErrorPayload(random); },
() => { return GetPrimitiveCollection(random); },
() => { return GetPrimitiveProperty(random, model); },
() => { return GetPrimitiveValue(random, model); },
};
payloadCalls.Concat(new Func<ODataPayloadElement>[]
{
() => { return GetComplexMultiValueProperty(random, model, version); },
() => { return GetPrimitiveMultiValueProperty(random); },
});
var payloadCall = random.ChooseFrom(payloadCalls);
return payloadCall();
}
private static ComplexMultiValueProperty GetComplexMultiValueProperty(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
int numinstances = random.ChooseFrom(new[] { 0, 1, 3 });
var instance = GetComplexInstance(random, model, version);
var instances = GenerateSimilarComplexInstances(random, instance, numinstances, true);
var propertyName = "ComplexMultivalue" + instance.FullTypeName;
var payload = new ComplexMultiValueProperty(propertyName,
new ComplexMultiValue(propertyName, false, instances.ToArray()));
if (model != null)
{
var entityDataType = instance.GetAnnotation <EntityModelTypeAnnotation>().EdmModelType.Definition as IEdmEntityType;
ExceptionUtilities.CheckObjectNotNull(entityDataType, "Complex Instance must have an EntityModelTypeAnnotation with an EntityDataType");
var entityType = model.FindDeclaredType(entityDataType.FullName()) as EdmEntityType;
ExceptionUtilities.CheckObjectNotNull(entityType, "entityType");
if (entityType.FindProperty(propertyName) != null)
{
entityType.AddStructuralProperty(propertyName, (model.FindDeclaredType(instance.FullTypeName) as EdmComplexType).ToTypeReference());
}
payload.WithTypeAnnotation(entityType);
}
return(payload);
}
private static PrimitiveMultiValueProperty GetPrimitiveMultiValueProperty(IRandomNumberGenerator random)
{
var val = random.ChooseFrom(TestValues.CreatePrimitiveCollections(true, true));
var payload = new PrimitiveMultiValueProperty("ArbitraryMultivalue", val);
return(payload);
}
/// <summary>
/// Generates an arbitrary top load payload based on the maximum version supplied.
/// </summary>
/// <param name="random">Random generator for generating arbitrary payloads</param>
/// <param name="model">The model to add any new types to</param>
/// <param name="version">Maximum version for generated payloads.</param>
/// <returns>A top level payload.</returns>
public static ODataPayloadElement GetRandomPayload(IRandomNumberGenerator random, EdmModel model, ODataVersion version = ODataVersion.V4)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(model, "model");
Func <ODataPayloadElement>[] payloadCalls = new Func <ODataPayloadElement>[]
{
() => { return(GetComplexInstanceCollection(random, model, version)); },
() => { return(GetComplexProperty(random, model, version)); },
() => { return(GetDeferredLink()); },
() => { return(GetLinkCollection()); },
() => { return(GetEntityInstance(random, model, version)); },
() => { return(GetEntitySetInstance(random, model)); },
() => { return(GetODataErrorPayload(random)); },
() => { return(GetPrimitiveCollection(random)); },
() => { return(GetPrimitiveProperty(random, model)); },
() => { return(GetPrimitiveValue(random, model)); },
};
payloadCalls.Concat(new Func <ODataPayloadElement>[]
{
() => { return(GetComplexMultiValueProperty(random, model, version)); },
() => { return(GetPrimitiveMultiValueProperty(random)); },
});
var payloadCall = random.ChooseFrom(payloadCalls);
return(payloadCall());
}
private static ComplexInstanceCollection GetComplexInstanceCollection(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
var complex = GetComplexInstance(random, model, version);
int numinstances = random.ChooseFrom(new[] { 0, 1, 3 });
var payload = new ComplexInstanceCollection(GenerateSimilarComplexInstances(random, complex, numinstances).ToArray());
if (model != null)
{
var container = model.EntityContainersAcrossModels().Single() as EdmEntityContainer;
var collectionType = new EdmCollectionType((model.FindDeclaredType(complex.FullTypeName) as EdmComplexType).ToTypeReference());
var function = new EdmFunction(container.Namespace, "GetComplexInstances", collectionType.ToTypeReference());
var functionImport = container.AddFunctionImport("GetComplexInstances", function);
payload.AddAnnotation(new FunctionAnnotation()
{
FunctionImport = functionImport
});
payload.AddAnnotation(new DataTypeAnnotation()
{
EdmDataType = collectionType
});
}
return(payload);
}
/// <summary>
/// Generates random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
int wordCount = random.NextFromRange(2, 10);
int length = random.NextFromRange(minLength, maxLength);
StringBuilder sb = new StringBuilder();
while (sb.Length < length)
{
string word = this.wordGenerator.GenerateString(random, 2, Math.Max(3, length / wordCount));
sb.Append(word);
if (sb.Length < length)
{
sb.Append(' ');
if (random.Next(100) < 30)
{
sb.Append(random.ChooseFrom(glueWords));
sb.Append(' ');
}
}
}
if (maxLength > 0 && sb.Length > maxLength - 1)
{
sb.Length = maxLength - 1;
sb.Append(".");
sb[0] = char.ToUpperInvariant(sb[0]);
}
return sb.ToString();
}
/// <summary>
/// Generates extra operations for a batch response.
/// </summary>
/// <param name="random">Random generator for generating extra payloads.</param>
/// <param name="model">Model to add any generated types to.</param>
/// <param name="version">Maximum version of generated types.</param>
/// <returns></returns>
public static IMimePart[] ExtraResponseOperations(
IRandomNumberGenerator random,
EdmModel model = null,
ODataVersion version = ODataVersion.V4)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
List <ODataResponse> responses = new List <ODataResponse>();
ODataResponse response = null;
for (int x = 0; x < 5; ++x)
{
response = new ODataResponse(new HttpResponseData()
{
StatusCode = (HttpStatusCode)random.Next(500)
})
{
RootElement = random.ChooseFrom(new[] { null, RandomPayloadBuilder.GetRandomPayload(random, model, version) })
};
response.Headers.Add("ResponseHeader", "ResponseHeaderValue");
responses.Add(response);
}
return(responses.ToArray());
}
private static EntityInstance GetEntityInstance(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
var values = TestEntityInstances.CreateEntityInstanceTestDescriptors(model, true);
var payloadDescriptor = random.ChooseFrom(values);
var payload = (EntityInstance)payloadDescriptor.PayloadElement;
return(payload);
}
private static PrimitiveCollection GetPrimitiveCollection(IRandomNumberGenerator random)
{
TestValues.CreatePrimitiveValuesWithMetadata(true);
PrimitiveValue val = random.ChooseFrom(TestValues.CreatePrimitiveValuesWithMetadata(true));
int numItems = random.NextFromRange(1, 3);
var newItems = Enumerable.Range(0, numItems).Select(x => TestValues.GetDifferentPrimitiveValue(val));
var payload = new PrimitiveCollection(newItems.ToArray());
return(payload);
}
/// <summary>
/// Generates random string of specified length.
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
var selectedGenerator = random.ChooseFrom(this.generators, this.weights);
if (selectedGenerator == null)
{
throw new TaupoInvalidOperationException("Unable to select a string generator. Check the weights.");
}
return selectedGenerator.GenerateString(random, minLength, maxLength);
}
/// <summary>
/// Generates random string of specified length.
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
var selectedGenerator = random.ChooseFrom(this.generators, this.weights);
if (selectedGenerator == null)
{
throw new TaupoInvalidOperationException("Unable to select a string generator. Check the weights.");
}
return(selectedGenerator.GenerateString(random, minLength, maxLength));
}
/// <summary>
/// When overridden in a derived class, generates a random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
protected override string GenerateStringCore(IRandomNumberGenerator random, int minLength, int maxLength)
{
this.EnsureAlphabetLoaded();
var minimumCharacterLength = this.alphabet.Min(w => w.Length);
var desiredLength = random.NextFromRange(minLength, maxLength);
// This is an intentionally naive check to determine whether the desired length
// is actually one that this resource string generator can satisfy. Since the minimum
// length of existing alphabets is either 1 or 2, and the alphabet that has
// characters of length 2 has no characters of length 3 or more, then this check works.
if ((desiredLength % minimumCharacterLength) != 0)
{
// Get the closest length to the randomly chosen length that is also a multiple
// of minimumCharacterLength. Note that the integer division between desiredLength
// and minimumCharacterLength is intentional.
desiredLength = (desiredLength / minimumCharacterLength) * minimumCharacterLength;
if (desiredLength < minLength)
{
desiredLength += minimumCharacterLength;
}
if (desiredLength > maxLength)
{
throw new TaupoArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"This string generator cannot generate a string of a length between {0} and {1}.",
minLength,
maxLength));
}
}
StringBuilder sb = new StringBuilder(desiredLength);
while (sb.Length < desiredLength)
{
var next = random.ChooseFrom(this.alphabet);
if (next.Length + sb.Length > desiredLength)
{
next = random.ChooseFrom(this.alphabet.Where(w => w.Length == minimumCharacterLength));
}
sb.Append(next);
}
return sb.ToString();
}
/// <summary>
/// Randomly chooses random number of items from the specified list. It may randomly choose 0 or all items.
/// </summary>
/// <typeparam name="T">List element type.</typeparam>
/// <param name="random">The random number generator.</param>
/// <param name="items">The list to choose from.</param>
/// <returns>Selected items.</returns>
public static IEnumerable <T> ChooseRandomNumberOfItemsFrom <T>(this IRandomNumberGenerator random, IEnumerable <T> items)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(items, "items");
int maxCount = items.Count();
if (maxCount == 0)
{
return(Enumerable.Empty <T>());
}
int count = random.Next(maxCount + 1);
return(random.ChooseFrom(items, count, false));
}
public static QueryValue ChooseRandomEvaluationResult(this IQueryExpressionEvaluator evaluator, QueryExpression queryExpression, IRandomNumberGenerator random, out QueryCollectionValue collection)
{
ExceptionUtilities.CheckArgumentNotNull(evaluator, "evaluator");
ExceptionUtilities.CheckArgumentNotNull(queryExpression, "queryExpression");
ExceptionUtilities.CheckArgumentNotNull(random, "random");
collection = evaluator.Evaluate(queryExpression) as QueryCollectionValue;
ExceptionUtilities.CheckObjectNotNull(collection, "Query unexpectedly evaluated to null or was not a collection: {0}", queryExpression);
ExceptionUtilities.Assert(collection.EvaluationError == null, "Query resulted in evaluation error: {0}", collection.EvaluationError);
if (collection.IsNull || collection.Elements.Count == 0)
{
return(null);
}
return(random.ChooseFrom(collection.Elements));
}
/// <summary>
/// When overridden in a derived class, generates a random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
protected virtual string GenerateStringCore(IRandomNumberGenerator random, int minLength, int maxLength)
{
int length = random.NextFromRange(minLength, maxLength);
var alphabet = this.GetAlphabet();
StringBuilder sb = new StringBuilder(length);
while (sb.Length < length)
{
sb.Append(random.ChooseFrom(alphabet));
}
if (sb.Length > maxLength)
{
sb.Length = maxLength;
}
return sb.ToString();
}
/// <summary>
/// Randomly chooses <paramref name="count"/> number of elements from the specified list.
/// </summary>
/// <typeparam name="T">List element type.</typeparam>
/// <param name="random">The random number generator.</param>
/// <param name="items">The list to choose from.</param>
/// <param name="count">The count of elements to choose.</param>
/// <param name="allowDuplicates">The value indicating if duplicates allowed or not.</param>
/// <returns>Selected items.</returns>
public static IEnumerable <T> ChooseFrom <T>(this IRandomNumberGenerator random, IEnumerable <T> items, int count, bool allowDuplicates)
{
ExceptionUtilities.CheckArgumentNotNull(items, "items");
if (count < 0)
{
throw new TaupoArgumentException("Count cannot be negative.");
}
List <T> values = new List <T>();
for (int i = 0; i < count; i++)
{
T value = random.ChooseFrom(items.Where(item => allowDuplicates || !values.Contains(item)));
values.Add(value);
}
return(values.AsReadOnly());
}
/// <summary>
/// When overridden in a derived class, generates a random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
protected virtual string GenerateStringCore(IRandomNumberGenerator random, int minLength, int maxLength)
{
int length = random.NextFromRange(minLength, maxLength);
var alphabet = this.GetAlphabet();
StringBuilder sb = new StringBuilder(length);
while (sb.Length < length)
{
sb.Append(random.ChooseFrom(alphabet));
}
if (sb.Length > maxLength)
{
sb.Length = maxLength;
}
return(sb.ToString());
}
private static PrimitiveValue GetPrimitiveValue(IRandomNumberGenerator random, EdmModel model = null)
{
var payload = random.ChooseFrom(TestValues.CreatePrimitiveValuesWithMetadata(true));
if (model != null)
{
EdmEntityType entity = model.FindDeclaredType("AllPrimitiveTypesEntity") as EdmEntityType;
if (entity == null)
{
entity = new EdmEntityType("TestModel", "AllPrimitiveTypesEntity");
entity.AddStructuralProperty("StringPropNullable", EdmPrimitiveTypeKind.String, true);
entity.AddStructuralProperty("StringProp", EdmPrimitiveTypeKind.String, false);
entity.AddStructuralProperty("Int32PropNullable", EdmPrimitiveTypeKind.Int32, true);
entity.AddStructuralProperty("Int32Prop", EdmPrimitiveTypeKind.Int32, false);
entity.AddStructuralProperty("BooleanPropNullable", EdmPrimitiveTypeKind.Boolean, true);
entity.AddStructuralProperty("BooleanProp", EdmPrimitiveTypeKind.Boolean, false);
entity.AddStructuralProperty("BytePropNullable", EdmPrimitiveTypeKind.Byte, true);
entity.AddStructuralProperty("ByteProp", EdmPrimitiveTypeKind.Byte, false);
entity.AddStructuralProperty("SBytePropNullable", EdmPrimitiveTypeKind.SByte, true);
entity.AddStructuralProperty("SByteProp", EdmPrimitiveTypeKind.SByte, false);
entity.AddStructuralProperty("Int16PropNullable", EdmPrimitiveTypeKind.Int16, true);
entity.AddStructuralProperty("Int16Prop", EdmPrimitiveTypeKind.Int16, false);
entity.AddStructuralProperty("DecimalPropNullable", EdmPrimitiveTypeKind.Decimal, true);
entity.AddStructuralProperty("DecimalProp", EdmPrimitiveTypeKind.Decimal, false);
entity.AddStructuralProperty("SinglePropNullable", EdmPrimitiveTypeKind.Single, true);
entity.AddStructuralProperty("SingleProp", EdmPrimitiveTypeKind.Single, false);
entity.AddStructuralProperty("Int64PropNullable", EdmPrimitiveTypeKind.Int64, true);
entity.AddStructuralProperty("Int64Prop", EdmPrimitiveTypeKind.Int64, false);
entity.AddStructuralProperty("DoublePropNullable", EdmPrimitiveTypeKind.Double, true);
entity.AddStructuralProperty("DoubleProp", EdmPrimitiveTypeKind.Double, false);
entity.AddStructuralProperty("BinaryPropNullable", EdmPrimitiveTypeKind.Binary, true);
entity.AddStructuralProperty("BinaryProp", EdmPrimitiveTypeKind.Binary, false);
entity.AddStructuralProperty("GuidPropNullable", EdmPrimitiveTypeKind.Guid, true);
entity.AddStructuralProperty("GuidProp", EdmPrimitiveTypeKind.Guid, false);
model.AddElement(entity);
}
payload.WithTypeAnnotation(entity);
}
return(payload);
}
/// <summary>
/// Generates random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
var alphabet = this.GetWordList();
int length = random.NextFromRange(minLength, maxLength);
StringBuilder sb = new StringBuilder(length);
while (sb.Length < length)
{
sb.Append(random.ChooseFrom(alphabet));
}
if (sb.Length > maxLength)
{
sb.Length = maxLength;
}
return sb.ToString();
}
/// <summary>
/// Generates random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
var alphabet = this.GetWordList();
int length = random.NextFromRange(minLength, maxLength);
StringBuilder sb = new StringBuilder(length);
while (sb.Length < length)
{
sb.Append(random.ChooseFrom(alphabet));
}
if (sb.Length > maxLength)
{
sb.Length = maxLength;
}
return(sb.ToString());
}
/// <summary>
/// Generates random string of specified length
/// </summary>
/// <param name="random">The random number generator to use.</param>
/// <param name="minLength">Minimum length of the generated string.</param>
/// <param name="maxLength">Maximum length of the generated string.</param>
/// <returns>Generated string.</returns>
public string GenerateString(IRandomNumberGenerator random, int minLength, int maxLength)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckValidRange(minLength, "minLength", maxLength, "maxLength");
int wordCount = random.NextFromRange(2, 10);
int length = random.NextFromRange(minLength, maxLength);
StringBuilder sb = new StringBuilder();
while (sb.Length < length)
{
string word = this.wordGenerator.GenerateString(random, 2, Math.Max(3, length / wordCount));
sb.Append(word);
if (sb.Length < length)
{
sb.Append(' ');
if (random.Next(100) < 30)
{
sb.Append(random.ChooseFrom(glueWords));
sb.Append(' ');
}
}
}
if (maxLength > 0 && sb.Length > maxLength - 1)
{
sb.Length = maxLength - 1;
sb.Append(".");
sb[0] = char.ToUpperInvariant(sb[0]);
}
return(sb.ToString());
}
private static ComplexMultiValueProperty GetComplexMultiValueProperty(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
int numinstances = random.ChooseFrom(new[] { 0, 1, 3 });
var instance = GetComplexInstance(random, model, version);
var instances = GenerateSimilarComplexInstances(random, instance, numinstances, true);
var propertyName = "ComplexMultivalue" + instance.FullTypeName;
var payload = new ComplexMultiValueProperty(propertyName,
new ComplexMultiValue(propertyName, false, instances.ToArray()));
if (model != null)
{
var entityDataType = instance.GetAnnotation<EntityModelTypeAnnotation>().EdmModelType.Definition as IEdmEntityType;
ExceptionUtilities.CheckObjectNotNull(entityDataType, "Complex Instance must have an EntityModelTypeAnnotation with an EntityDataType");
var entityType = model.FindDeclaredType(entityDataType.FullName()) as EdmEntityType;
ExceptionUtilities.CheckObjectNotNull(entityType, "entityType");
if (entityType.FindProperty(propertyName) != null)
{
entityType.AddStructuralProperty(propertyName, (model.FindDeclaredType(instance.FullTypeName) as EdmComplexType).ToTypeReference());
}
payload.WithTypeAnnotation(entityType);
}
return payload;
}
private static EntityInstance GetEntityInstance(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
var values = TestEntityInstances.CreateEntityInstanceTestDescriptors(model, true);
var payloadDescriptor = random.ChooseFrom(values);
var payload = (EntityInstance)payloadDescriptor.PayloadElement;
return payload;
}
private static ODataErrorPayload GetODataErrorPayload(IRandomNumberGenerator random)
{
var testErrors = random.ChooseFrom(TestErrors.CreateErrorTestDescriptors());
return((ODataErrorPayload)testErrors.PayloadElement);
}
private static EntitySetInstance GetEntitySetInstance(IRandomNumberGenerator random, EdmModel model = null)
{
var payloadDescriptor = random.ChooseFrom(TestFeeds.CreateEntitySetTestDescriptors(model, true));
return((EntitySetInstance)payloadDescriptor.PayloadElement);
}
/// <summary>
/// Generates extra response changesets.
/// </summary>
/// <param name="random">For generating arbitrary changesets.</param>
/// <param name="model">For adding any generated types to.</param>
/// <param name="version">Maximum version of any generated types.</param>
/// <returns>An array of response changesets.</returns>
public static BatchResponseChangeset[] ExtraResponseChangesets(
IRandomNumberGenerator random,
EdmModel model = null,
ODataVersion version = ODataVersion.V4)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
string contentType = HttpUtilities.BuildContentType(MimeTypes.ApplicationXml, Encoding.UTF8.WebName, null);
var responses = ExtraResponseOperations(random, model, version);
List <BatchResponseChangeset> changesets = new List <BatchResponseChangeset>();
for (int x = 0; x < 5; ++x)
{
IEnumerable <IMimePart> operations = Enumerable.Range(0, random.Next(4)).Select(i => random.ChooseFrom(responses));
changesets.Add(BatchPayloadBuilder.ResponseChangeset("changeset_" + Guid.NewGuid().ToString(), contentType, operations.ToArray()));
}
return(changesets.ToArray());
}
private static ComplexInstance GetComplexInstance(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
var values = TestValues.CreateComplexValues(model, true, true);
return(random.ChooseFrom(values));
}
/// <summary>
/// Generates extra request changesets.
/// </summary>
/// <param name="random">For generating arbitrary changesets.</param>
/// <param name="requestManager">For building changesets.</param>
/// <param name="model">For adding any generated types to.</param>
/// <param name="baseUri">Base uri for the changesets.</param>
/// <param name="version">Maximum version of any generated types.</param>
/// <returns>An array of request changesets.</returns>
public static BatchRequestChangeset[] ExtraRequestChangesets(
IRandomNumberGenerator random,
IODataRequestManager requestManager,
EdmModel model,
ODataUri baseUri,
ODataVersion version = ODataVersion.V4
)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
ExceptionUtilities.CheckArgumentNotNull(baseUri, "baseUri");
var headers = new Dictionary<string, string> { { "RequestHeader", "RequestHeaderValue" } };
string mergeContentType = HttpUtilities.BuildContentType(MimeTypes.ApplicationXml, Encoding.UTF8.WebName, null);
var requests = ExtraRequestChangesetOperations(random, requestManager, model, baseUri, version);
List<BatchRequestChangeset> changesets = new List<BatchRequestChangeset>();
for (int x = 0; x < 5; ++x)
{
IEnumerable<IHttpRequest> operations = Enumerable.Range(0, random.Next(10)).Select(i => random.ChooseFrom(requests));
changesets.Add(BatchPayloadBuilder.RequestChangeset("changeset_" + Guid.NewGuid().ToString(), "", operations.ToArray()));
}
return changesets.ToArray();
}
/// <summary>
/// Puts the specified <paramref name="payload"/> into a changeset.
/// </summary>
/// <param name="response">ODataResponse to add to changeset.</param>
/// <param name="random">Random generator used for generating payloads.</param>
/// <param name="model">Model to add generated types to.</param>
/// <param name="operationsBefore">Number of extra operations before payload.</param>
/// <param name="operationsAfter">Number of extra operations after payload.</param>
/// <param name="version">Highest version of allowed features.</param>
/// <returns>An entry payload with an expanded link that contains the specified<paramref name="payload"/>.</returns>
public static BatchResponseChangeset InResponseChangeset <T>(
this ODataResponse response,
IRandomNumberGenerator random,
EdmModel model = null,
int operationsBefore = 0,
int operationsAfter = 0,
ODataVersion version = ODataVersion.V4
) where T : PayloadTestDescriptor
{
ExceptionUtilities.CheckArgumentNotNull(response, "response");
ExceptionUtilities.CheckArgumentNotNull(random, "random");
var extraOperations = BatchUtils.ExtraResponseOperations(random, model, version);
// Build the list of all properties
IEnumerable <IMimePart> operations = Enumerable.Range(0, operationsBefore).Select(i => random.ChooseFrom(extraOperations));
operations.ConcatSingle(response);
operations = operations.Concat(Enumerable.Range(0, operationsAfter).Select(i => random.ChooseFrom(extraOperations)));
var changeset = BatchPayloadBuilder.ResponseChangeset("changeset_" + Guid.NewGuid().ToString(), Encoding.UTF8.WebName, operations.ToArray());
return(changeset);
}
private static PrimitiveMultiValueProperty GetPrimitiveMultiValueProperty(IRandomNumberGenerator random)
{
var val = random.ChooseFrom(TestValues.CreatePrimitiveCollections(true, true));
var payload = new PrimitiveMultiValueProperty("ArbitraryMultivalue", val);
return payload;
}
private static PrimitiveValue GetPrimitiveValue(IRandomNumberGenerator random, EdmModel model = null)
{
var payload = random.ChooseFrom(TestValues.CreatePrimitiveValuesWithMetadata(true));
if (model != null)
{
EdmEntityType entity = model.FindDeclaredType("AllPrimitiveTypesEntity") as EdmEntityType;
if (entity == null)
{
entity = new EdmEntityType("TestModel", "AllPrimitiveTypesEntity");
entity.AddStructuralProperty("StringPropNullable", EdmPrimitiveTypeKind.String, true);
entity.AddStructuralProperty("StringProp", EdmPrimitiveTypeKind.String, false);
entity.AddStructuralProperty("Int32PropNullable", EdmPrimitiveTypeKind.Int32, true);
entity.AddStructuralProperty("Int32Prop", EdmPrimitiveTypeKind.Int32, false);
entity.AddStructuralProperty("BooleanPropNullable", EdmPrimitiveTypeKind.Boolean, true);
entity.AddStructuralProperty("BooleanProp", EdmPrimitiveTypeKind.Boolean, false);
entity.AddStructuralProperty("BytePropNullable", EdmPrimitiveTypeKind.Byte, true);
entity.AddStructuralProperty("ByteProp", EdmPrimitiveTypeKind.Byte, false);
entity.AddStructuralProperty("SBytePropNullable", EdmPrimitiveTypeKind.SByte, true);
entity.AddStructuralProperty("SByteProp", EdmPrimitiveTypeKind.SByte, false);
entity.AddStructuralProperty("Int16PropNullable", EdmPrimitiveTypeKind.Int16, true);
entity.AddStructuralProperty("Int16Prop", EdmPrimitiveTypeKind.Int16, false);
entity.AddStructuralProperty("DecimalPropNullable", EdmPrimitiveTypeKind.Decimal, true);
entity.AddStructuralProperty("DecimalProp", EdmPrimitiveTypeKind.Decimal, false);
entity.AddStructuralProperty("SinglePropNullable", EdmPrimitiveTypeKind.Single, true);
entity.AddStructuralProperty("SingleProp", EdmPrimitiveTypeKind.Single, false);
entity.AddStructuralProperty("Int64PropNullable", EdmPrimitiveTypeKind.Int64, true);
entity.AddStructuralProperty("Int64Prop", EdmPrimitiveTypeKind.Int64, false);
entity.AddStructuralProperty("DoublePropNullable", EdmPrimitiveTypeKind.Double, true);
entity.AddStructuralProperty("DoubleProp", EdmPrimitiveTypeKind.Double, false);
entity.AddStructuralProperty("BinaryPropNullable", EdmPrimitiveTypeKind.Binary, true);
entity.AddStructuralProperty("BinaryProp", EdmPrimitiveTypeKind.Binary, false);
entity.AddStructuralProperty("GuidPropNullable", EdmPrimitiveTypeKind.Guid, true);
entity.AddStructuralProperty("GuidProp", EdmPrimitiveTypeKind.Guid, false);
model.AddElement(entity);
}
payload.WithTypeAnnotation(entity);
}
return payload;
}
/// <summary>
/// Generates extra response changesets.
/// </summary>
/// <param name="random">For generating arbitrary changesets.</param>
/// <param name="model">For adding any generated types to.</param>
/// <param name="version">Maximum version of any generated types.</param>
/// <returns>An array of response changesets.</returns>
public static BatchResponseChangeset[] ExtraResponseChangesets(
IRandomNumberGenerator random,
EdmModel model = null,
ODataVersion version = ODataVersion.V4)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
string contentType = HttpUtilities.BuildContentType(MimeTypes.ApplicationXml, Encoding.UTF8.WebName, null);
var responses = ExtraResponseOperations(random, model, version);
List<BatchResponseChangeset> changesets = new List<BatchResponseChangeset>();
for (int x = 0; x < 5; ++x)
{
IEnumerable<IMimePart> operations = Enumerable.Range(0, random.Next(4)).Select(i => random.ChooseFrom(responses));
changesets.Add(BatchPayloadBuilder.ResponseChangeset("changeset_" + Guid.NewGuid().ToString(), contentType, operations.ToArray()));
}
return changesets.ToArray();
}
/// <summary>
/// Generates extra operations for a batch response.
/// </summary>
/// <param name="random">Random generator for generating extra payloads.</param>
/// <param name="model">Model to add any generated types to.</param>
/// <param name="version">Maximum version of generated types.</param>
/// <returns></returns>
public static IMimePart[] ExtraResponseOperations(
IRandomNumberGenerator random,
EdmModel model = null,
ODataVersion version = ODataVersion.V4)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
List<ODataResponse> responses = new List<ODataResponse>();
ODataResponse response = null;
for (int x = 0; x < 5; ++x)
{
response = new ODataResponse(new HttpResponseData() { StatusCode = (HttpStatusCode)random.Next(500) })
{
RootElement = random.ChooseFrom(new[] { null, RandomPayloadBuilder.GetRandomPayload(random, model, version) })
};
response.Headers.Add("ResponseHeader", "ResponseHeaderValue");
responses.Add(response);
}
return responses.ToArray();
}
private static ComplexInstance GetComplexInstance(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
var values = TestValues.CreateComplexValues(model, true, true);
return random.ChooseFrom(values);
}
private static ODataErrorPayload GetODataErrorPayload(IRandomNumberGenerator random)
{
var testErrors = random.ChooseFrom(TestErrors.CreateErrorTestDescriptors());
return (ODataErrorPayload)testErrors.PayloadElement;
}
/// <summary>
/// Predefined data generator which selects a value from a predefined set of values
/// </summary>
/// <typeparam name="TData">The data type</typeparam>
/// <param name="random">A Random number generator to allow the framework to pick a random value from the set of values</param>
/// <param name="values">The set of allowed values</param>
/// <returns>predefined data generator</returns>
public static IDataGenerator <TData> PredefinedValues <TData>(IRandomNumberGenerator random, params TData[] values)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckCollectionNotEmpty(values, "values");
return(new DelegatedDataGenerator <TData>(() => random.ChooseFrom(values)));
}
private static EntitySetInstance GetEntitySetInstance(IRandomNumberGenerator random, EdmModel model = null)
{
var payloadDescriptor = random.ChooseFrom(TestFeeds.CreateEntitySetTestDescriptors(model, true));
return (EntitySetInstance)payloadDescriptor.PayloadElement;
}
/// <summary>
/// Puts the specified <paramref name="payload"/> into a changeset.
/// </summary>
/// <param name="payload">The payload to be used as content for the expanded link.</param>
/// <param name="verb">The verb associated with the payload.</param>
/// <param name="random">Use of random makes this method non deterministic.</param>
/// <param name="requestManager">Used to construct requests</param>
/// <param name="operationsBefore">Number of extra operations before payload.</param>
/// <param name="operationsAfter">Number of extra operations after payload.</param>
/// <param name="version">Highest version of allowed features</param>
/// <returns>An entry payload with an expanded link that contains the specified <paramref name="payload"/>.</returns>
public static BatchRequestChangeset InRequestChangeset <T>(
this T payload,
HttpVerb verb,
IRandomNumberGenerator random,
IODataRequestManager requestManager,
int operationsBefore = 0,
int operationsAfter = 0,
ODataVersion version = ODataVersion.V4
) where T : PayloadTestDescriptor
{
ExceptionUtilities.CheckArgumentNotNull(payload, "payload");
ExceptionUtilities.CheckArgumentNotNull(verb, "verb");
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
var baseUri = new ODataUri(ODataUriBuilder.Root(new Uri("http://www.odata.org/service.svc")));
var extraOperations = BatchUtils.ExtraRequestChangesetOperations(random, requestManager, (EdmModel)payload.PayloadEdmModel, baseUri, version);
// Build the list of all properties
IEnumerable <IHttpRequest> operations = Enumerable.Range(0, operationsBefore).Select(i => random.ChooseFrom(extraOperations));
operations.ConcatSingle(payload.InRequestOperation(verb, baseUri, requestManager));
operations = operations.Concat(Enumerable.Range(0, operationsAfter).Select(i => extraOperations[extraOperations.Length - 1 - (i % extraOperations.Length)]));
var changeset = BatchPayloadBuilder.RequestChangeset("changeset_" + Guid.NewGuid().ToString(), Encoding.UTF8.WebName, operations.ToArray());
return(changeset);
}
/// <summary>
/// Generates extra request changesets.
/// </summary>
/// <param name="random">For generating arbitrary changesets.</param>
/// <param name="requestManager">For building changesets.</param>
/// <param name="model">For adding any generated types to.</param>
/// <param name="baseUri">Base uri for the changesets.</param>
/// <param name="version">Maximum version of any generated types.</param>
/// <returns>An array of request changesets.</returns>
public static BatchRequestChangeset[] ExtraRequestChangesets(
IRandomNumberGenerator random,
IODataRequestManager requestManager,
EdmModel model,
ODataUri baseUri,
ODataVersion version = ODataVersion.V4
)
{
ExceptionUtilities.CheckArgumentNotNull(random, "random");
ExceptionUtilities.CheckArgumentNotNull(requestManager, "requestManager");
ExceptionUtilities.CheckArgumentNotNull(baseUri, "baseUri");
var headers = new Dictionary <string, string> {
{ "RequestHeader", "RequestHeaderValue" }
};
string mergeContentType = HttpUtilities.BuildContentType(MimeTypes.ApplicationXml, Encoding.UTF8.WebName, null);
var requests = ExtraRequestChangesetOperations(random, requestManager, model, baseUri, version);
List <BatchRequestChangeset> changesets = new List <BatchRequestChangeset>();
for (int x = 0; x < 5; ++x)
{
IEnumerable <IHttpRequest> operations = Enumerable.Range(0, random.Next(10)).Select(i => random.ChooseFrom(requests));
changesets.Add(BatchPayloadBuilder.RequestChangeset("changeset_" + Guid.NewGuid().ToString(), "", operations.ToArray()));
}
return(changesets.ToArray());
}
private static PrimitiveCollection GetPrimitiveCollection(IRandomNumberGenerator random)
{
TestValues.CreatePrimitiveValuesWithMetadata(true);
PrimitiveValue val = random.ChooseFrom(TestValues.CreatePrimitiveValuesWithMetadata(true));
int numItems = random.NextFromRange(1, 3);
var newItems = Enumerable.Range(0, numItems).Select(x => TestValues.GetDifferentPrimitiveValue(val));
var payload = new PrimitiveCollection(newItems.ToArray());
return payload;
}
private static ComplexInstanceCollection GetComplexInstanceCollection(IRandomNumberGenerator random, EdmModel model = null, ODataVersion version = ODataVersion.V4)
{
var complex = GetComplexInstance(random, model, version);
int numinstances = random.ChooseFrom(new[] { 0, 1, 3 });
var payload = new ComplexInstanceCollection(GenerateSimilarComplexInstances(random, complex, numinstances).ToArray());
if (model != null)
{
var container = model.EntityContainersAcrossModels().Single() as EdmEntityContainer;
var collectionType = new EdmCollectionType((model.FindDeclaredType(complex.FullTypeName) as EdmComplexType).ToTypeReference());
var function = new EdmFunction(container.Namespace, "GetComplexInstances", collectionType.ToTypeReference());
var functionImport = container.AddFunctionImport("GetComplexInstances", function);
payload.AddAnnotation(new FunctionAnnotation() { FunctionImport = functionImport });
payload.AddAnnotation(new DataTypeAnnotation() { EdmDataType = collectionType });
}
return payload;
}