//---------------------------------------------------------------------
// Constructs AstoriaRequest and sets.
//---------------------------------------------------------------------
private BlobsRequest(Workspace w, SerializationFormatKind format, RequestVerb verb, string uri, HttpStatusCode expectedStatusCode) : base(w)
{
// Common settings for MLEs and MRs.
base.IsBlobRequest = true;
base.Verb = verb;
base.ExpectedStatusCode = expectedStatusCode;
// Construct request URI.
if (uri.Contains("(*)"))
{
// Replace (*) with random key.
string relativeURI = uri.Remove(0, w.ServiceUri.Length + 1);
ResourceContainer container = w.ServiceContainer.ResourceContainers[relativeURI.Substring(0, relativeURI.IndexOf("(*)"))];
KeyExpression key = null;
try { key = w.GetRandomExistingKey(container, container.BaseType); } catch(Exception e) { AstoriaTestLog.Skip("Unable to get random key"); }
base.Query = ContainmentUtil.BuildCanonicalQuery(key);
base.URI += relativeURI.Substring(relativeURI.IndexOf("(*)") + 3);
}
else
{
// Deterministic URI.
base.URI = uri;
}
LastURI = base.URI;
}
public static AstoriaRequest BuildRandomRequest(Workspace workspace, RequestVerb verb, SerializationFormatKind format)
{
IEnumerable<ResourceContainer> safeContainers =
workspace.ServiceContainer.ResourceContainers
.Where(c => IsSafeOperation(verb, c));
if (verb != RequestVerb.Get)
safeContainers = safeContainers.Where(c => c.ResourceTypes.Any(t => IsSafeOperation(verb, c, t)));
fxList<ResourceContainer> containers = new fxList<ResourceContainer>(safeContainers);
if (!containers.Any())
return null;
AstoriaRequest request = null;
while (request == null && containers.Any())
{
ResourceContainer container = null;
ResourceType type = null;
KeyExpression key = null;
while (container == null && containers.Any())
{
container = containers.Choose();
if (verb == RequestVerb.Get)
{
key = workspace.GetRandomExistingKey(container);
if (key == null)
{
containers.Remove(container);
container = null;
}
}
else
{
fxList<ResourceType> types = new fxList<ResourceType>(container.ResourceTypes.Where(t => IsSafeOperation(verb, container, t)));
if (!types.Any())
{
containers.Remove(container);
container = null;
}
if (verb != RequestVerb.Delete)
type = types.Choose();
else
{
while (key == null && types.Any())
{
type = types.Choose();
key = workspace.GetRandomExistingKey(container, type);
if (key == null)
types.Remove(type);
}
if (key == null)
{
containers.Remove(container);
container = null;
}
}
}
}
// if we ran out of containers before finding one that would work
//
if (container == null)
return null;
// if the Build___ method returns null, we'll come back around with a different container/key
//
switch (verb)
{
case RequestVerb.Get:
request = BuildGet(workspace, key, HttpStatusCode.OK, format);
break;
case RequestVerb.Post:
request = BuildInsert(workspace, container, type, HttpStatusCode.Created, format);
break;
case RequestVerb.Put:
case RequestVerb.Patch:
request = BuildUpdate(workspace, container, type, (verb == RequestVerb.Put), HttpStatusCode.NoContent, format);
break;
case RequestVerb.Delete:
request = BuildDelete(workspace, key, HttpStatusCode.NoContent, format);
break;
default:
throw new ArgumentException("Unsupported verb: " + verb.ToString());
}
}
// might be null, but we did our best
//
return request;
}
public static AstoriaRequest BuildUpdate(Workspace workspace, ResourceContainer container, ResourceType resourceType,
bool replace, HttpStatusCode expectedStatusCode, SerializationFormatKind format, out KeyExpression modifiedKey)
{
modifiedKey = workspace.GetRandomExistingKey(container, resourceType);
return BuildUpdate(workspace, modifiedKey, replace, expectedStatusCode, format);
}