//---------------------------------------------------------------------
// 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;
}
//Constructor
public QueriesModel(Workspace workspace, SerializationFormatKind kind, string queryType)
: base()
{
_workspace = workspace;
_kind = kind;
_queryType = queryType;
}
//Constructor
public QueryModel(Workspace workspace, SerializationFormatKind kind, QueryModel parent)
: base( parent )
{
_workspace = workspace;
_kind = kind;
_parent = parent;
}
public static AstoriaRequest BuildInsert(Workspace workspace, ResourceContainer container, ResourceType type,
HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
KeyExpression createdKey;
return(BuildInsert(workspace, container, type, expectedStatusCode, format, out createdKey));
}
//---------------------------------------------------------------------
// 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;
}
//---------------------------------------------------------------------
// Constructs request to MR.
//---------------------------------------------------------------------
public static BlobsRequest MRR(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = SerializationFormatKind.PlainText;
rq.ContentType = "audio/mp3";
rq.Accept = (verb == RequestVerb.Get ? "*/*" : SerializationFormatKinds.ContentTypeFromKind(format));
rq.Payload = payload;
// Append $value, if needed.
if (uri.StartsWith("$") || uri.EndsWith(")"))
{
rq.URI += "/$value";
// Expect dummy ETags from stream provider.
byte[] hash = new System.Security.Cryptography.MD5CryptoServiceProvider().ComputeHash(System.Text.Encoding.ASCII.GetBytes(rq.URI));
if ((hash[0] & 3) > 1)
{
rq.ETagHeaderExpected = true;
}
}
return(rq);
}
//Constructor
public QueryModel(Workspace workspace, SerializationFormatKind kind, QueryModel parent)
: base(parent)
{
_workspace = workspace;
_kind = kind;
_parent = parent;
}
//Constructor
public QueriesModel(Workspace workspace, SerializationFormatKind kind, string queryType)
: base()
{
_workspace = workspace;
_kind = kind;
_queryType = queryType;
}
//---------------------------------------------------------------------
public static BlobsPayload Parse(SerializationFormatKind format, AstoriaResponse response)
{
switch (format)
{
case SerializationFormatKind.Atom: return new BlobsPayload.Atom(response.Payload);
case SerializationFormatKind.JSON: return new BlobsPayload.JSON(response.Payload);
default:
AstoriaTestLog.FailAndThrow("Unknown serialization format kind: " + format.ToString());
return null;
}
}
//---------------------------------------------------------------------
// Constructs request to MLE.
//---------------------------------------------------------------------
public static BlobsRequest MLE(Workspace w, SerializationFormatKind format, RequestVerb verb, BlobsPayload payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format);
rq.Accept = rq.ContentType;
rq.Payload = (payload != null ? payload.ToString() : null);
return rq;
}
//---------------------------------------------------------------------
public static BlobsPayload Parse(SerializationFormatKind format, AstoriaResponse response)
{
switch (format)
{
case SerializationFormatKind.Atom: return(new BlobsPayload.Atom(response.Payload));
case SerializationFormatKind.JSON: return(new BlobsPayload.JSON(response.Payload));
default:
AstoriaTestLog.FailAndThrow("Unknown serialization format kind: " + format.ToString());
return(null);
}
}
//---------------------------------------------------------------------
// Constructs request to MLE.
//---------------------------------------------------------------------
public static BlobsRequest MLE(Workspace w, SerializationFormatKind format, RequestVerb verb, BlobsPayload payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format);
rq.Accept = rq.ContentType;
rq.Payload = (payload != null ? payload.ToString() : null);
return(rq);
}
public static UpdatePayloadBuilder CreateUpdatePayloadBuilder(Workspace w, SerializationFormatKind format, RequestVerb requestVerb)
{
switch (format)
{
case SerializationFormatKind.Atom:
case SerializationFormatKind.Default:
case SerializationFormatKind.PlainXml:
return new AtomUpdatePayloadBuilder(w, requestVerb);
case SerializationFormatKind.JSON:
return new JsonUpdatePayloadBuilder(w, requestVerb);
default:
throw new ArgumentException("Could not create a payload builder for format: " + format.ToString());
}
}
public static UpdatePayloadBuilder CreateUpdatePayloadBuilder(Workspace w, SerializationFormatKind format, RequestVerb requestVerb)
{
switch (format)
{
case SerializationFormatKind.Atom:
case SerializationFormatKind.Default:
case SerializationFormatKind.PlainXml:
return(new AtomUpdatePayloadBuilder(w, requestVerb));
case SerializationFormatKind.JSON:
return(new JsonUpdatePayloadBuilder(w, requestVerb));
default:
throw new ArgumentException("Could not create a payload builder for format: " + format.ToString());
}
}
public static AstoriaRequest BuildInsert(Workspace workspace, ResourceContainer container, ResourceType type,
HttpStatusCode expectedStatusCode, SerializationFormatKind format, out KeyExpression createdKey)
{
KeyedResourceInstance newResource = type.CreateRandomResource(container);
if (newResource == null)
{
newResource = ResourceInstanceUtil.CreateKeyedResourceInstanceByClone(container, type);
if (newResource == null)
{
createdKey = null;
return(null);
}
}
QueryNode query;
if (!type.Key.Properties.Any(p => p.Facets.ServerGenerated) && newResource.ResourceInstanceKey != null)
{
createdKey = newResource.ResourceInstanceKey.CreateKeyExpression(container, type);
query = ContainmentUtil.BuildCanonicalQuery(createdKey, true);
}
else
{
createdKey = null;
// the key is unknown, must be server generated
// in this case, lets hope that containment is a non-issue
query =
Query.From(Exp.Variable(container))
.Select();
if (!container.Facets.TopLevelAccess && expectedStatusCode == HttpStatusCode.Created)
{
expectedStatusCode = HttpStatusCode.BadRequest;
}
}
AstoriaRequest request = workspace.CreateRequest();
request.Verb = RequestVerb.Post;
request.Query = query;
request.UpdateTree = newResource;
request.ExpectedStatusCode = expectedStatusCode;
request.Format = format;
return(request);
}
/// <summary>Gets a valid MIME type for the specified <paramref name="kind"/>.</summary>
/// <param name="kind"><see cref="SerializationFormatKind"/> to get MIME type for.</param>
/// <returns>A valid MIME type for the specified <paramref name="kind"/>.</returns>
public static string ContentTypeFromKind(SerializationFormatKind kind)
{
switch (kind)
{
case SerializationFormatKind.JSON:
return JsonMimeType;
case SerializationFormatKind.Atom:
return AtomMimeType;
case SerializationFormatKind.PlainXml:
return XmlMimeType;
case SerializationFormatKind.PlainText:
return MimeTextPlain;
default:
Debug.Assert(kind == SerializationFormatKind.Default);
return AtomMimeType;
}
}
//---------------------------------------------------------------------
// Constructs request with $ref. Assumes parent(*)/child URI format.
//---------------------------------------------------------------------
public static BlobsRequest LNK(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = (URI.Length == 0 ? LastURI : URI[0]);
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format == SerializationFormatKind.JSON ? SerializationFormatKind.JSON : SerializationFormatKind.PlainXml);
rq.Accept = rq.ContentType;
// Adjust link in payload, if needed.
if (!string.IsNullOrEmpty(payload))
{
rq.Payload = string.Format(format == SerializationFormatKind.JSON ?
@"{{""odata.id"": ""{0}"" }}" :
@"<ref xmlns='http://docs.oasis-open.org/odata/ns/metadata' id=""{0}"" />",
payload);
}
return(rq);
}
/// <summary>Gets a valid MIME type for the specified <paramref name="kind"/>.</summary>
/// <param name="kind"><see cref="SerializationFormatKind"/> to get MIME type for.</param>
/// <returns>A valid MIME type for the specified <paramref name="kind"/>.</returns>
public static string ContentTypeFromKind(SerializationFormatKind kind)
{
switch (kind)
{
case SerializationFormatKind.JSON:
return(JsonMimeType);
case SerializationFormatKind.Atom:
return(AtomMimeType);
case SerializationFormatKind.PlainXml:
return(XmlMimeType);
case SerializationFormatKind.PlainText:
return(MimeTextPlain);
default:
Debug.Assert(kind == SerializationFormatKind.Default);
return(AtomMimeType);
}
}
//---------------------------------------------------------------------
// Constructs request to MR.
//---------------------------------------------------------------------
public static BlobsRequest MRR(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = URI.Length == 0 ? LastURI : URI[0];
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = SerializationFormatKind.PlainText;
rq.ContentType = "audio/mp3";
rq.Accept = (verb == RequestVerb.Get ? "*/*" : SerializationFormatKinds.ContentTypeFromKind(format));
rq.Payload = payload;
// Append $value, if needed.
if (uri.StartsWith("$") || uri.EndsWith(")"))
{
rq.URI += "/$value";
// Expect dummy ETags from stream provider.
byte[] hash = new System.Security.Cryptography.MD5CryptoServiceProvider().ComputeHash(System.Text.Encoding.ASCII.GetBytes(rq.URI));
if ((hash[0] & 3) > 1)
rq.ETagHeaderExpected = true;
}
return rq;
}
public static AstoriaRequest BuildInsert(Workspace workspace, ResourceContainer container, ResourceType type,
HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
KeyExpression createdKey;
return BuildInsert(workspace, container, type, expectedStatusCode, format, out createdKey);
}
public static AstoriaRequest BuildUpdate(Workspace workspace, ResourceContainer container, ResourceType resourceType,
bool replace, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
KeyExpression modifiedKey;
return BuildUpdate(workspace, container, resourceType, replace, expectedStatusCode, format, out modifiedKey);
}
public static AstoriaRequest BuildGet(Workspace workspace, ResourceContainer container, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
if (!container.Facets.TopLevelAccess && expectedStatusCode == HttpStatusCode.OK)
expectedStatusCode = HttpStatusCode.BadRequest;
QueryNode query = Query.From(Exp.Variable(container)).Select();
return BuildGet(workspace, query, expectedStatusCode, format);
}
public static AstoriaRequest BuildGet(Workspace workspace, QueryNode query, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
AstoriaRequest request = workspace.CreateRequest();
request.Verb = RequestVerb.Get;
request.Query = query;
request.ExpectedStatusCode = expectedStatusCode;
request.Format = format;
return request;
}
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));
}
public static AstoriaRequest BuildDelete(Workspace workspace, KeyExpressions existingKeys, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
KeyExpression deletedKey;
return(BuildDelete(workspace, existingKeys, expectedStatusCode, format, out deletedKey));
}
public static void ComparePrimitiveValuesObjectAndString(object expected, Type expectedType, string actual, bool valueUri, SerializationFormatKind serializationKind, bool throwOnError)
{
object actualObject = DeserializeStringToObject(actual, expectedType, valueUri, serializationKind);
string expectedStr = "null";
if (expected != null)
{
expectedStr = AstoriaUnitTests.Data.TypeData.XmlValueFromObject(expected);
}
string errorMessage = String.Format("Error Primitive Value of type:{0} not equal: \r\n\tExpected:\t{1} \r\n\tActual:\t{2}", expectedType.Name, expectedStr, actual);
//Fixups
if (expected != null && expectedType.Equals(typeof(string)))
{
if (actualObject != null)
{
actualObject = (actualObject as string).Trim();
}
expected = (expected as string).Trim();
}
if (expectedType == typeof(System.Xml.Linq.XElement))
{
expectedStr = null;
if (expected != null)
{
System.Xml.Linq.XElement xElement = expected as System.Xml.Linq.XElement;
expectedStr = xElement.ToString();
}
AstoriaTestLog.AreEqual(expectedStr, actual, errorMessage);
}
else if (expectedType == typeof(Single) || expectedType == typeof(Double))
{
if (serializationKind == SerializationFormatKind.JSON)
{
if (expectedType == typeof(Double))
{
Double d;
if (expected != null)
{
d = Convert.ToDouble(expected);
expectedStr = d.ToString("r", System.Globalization.CultureInfo.InvariantCulture);
}
if (actual != null)
{
if (double.TryParse(actual, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out d))
{
actual = d.ToString("r", CultureInfo.InvariantCulture.NumberFormat);
}
}
}
else if (expectedType == typeof(Single))
{
Single s;
if (expected != null)
{
s = Convert.ToSingle(expected);
expectedStr = s.ToString("r", System.Globalization.CultureInfo.InvariantCulture);
}
if (actual != null)
{
if (Single.TryParse(actual, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat, out s))
{
actual = s.ToString("r", CultureInfo.InvariantCulture.NumberFormat);
}
}
}
}
//Fixup
if (expectedStr == "null")
{
expectedStr = null;
}
if (expectedStr != null && actual != null)
{
expectedStr = expectedStr.Trim();
actual = actual.Trim();
}
if (throwOnError)
{
if (expectedStr != null)
{
AstoriaTestLog.Compare(expectedStr.Equals(actual), errorMessage);
}
else
{
AstoriaTestLog.Compare(actual == null, errorMessage);
}
}
else
{
AstoriaTestLog.AreEqual(expectedStr, actual, errorMessage);
}
}
#if !ClientSKUFramework
//For some reason byte[] comparision is not working correctly
else if ((expectedType == typeof(byte[]) || expectedType == typeof(System.Data.Linq.Binary)) && valueUri)
{
string expectedBytesStr = null;
if (expected == null)
{
expectedBytesStr = null;
}
else if (expectedType == typeof(byte[]))
{
expectedBytesStr = (new System.Text.UTF8Encoding()).GetString((byte[])expected);
}
else if (expectedType == typeof(System.Data.Linq.Binary))
{
System.Data.Linq.Binary binary = expected as System.Data.Linq.Binary;
expectedBytesStr = (new System.Text.UTF8Encoding()).GetString((byte[])binary.ToArray());
}
if (throwOnError)
{
if (expected == null)
{
AstoriaTestLog.Compare(null == actual, errorMessage);
}
else
{
AstoriaTestLog.Compare(expectedBytesStr.Equals(actual), errorMessage);
}
}
else
{
AstoriaTestLog.AreEqual(expectedBytesStr, actual, errorMessage);
}
}
#endif
else if (expectedType == typeof(byte[]) && valueUri == false)
{
AreBytesEqual((byte[])expected, (byte[])actualObject, throwOnError);
}
else
{
if (throwOnError)
{
bool objectsEqual = true;
if (expected == null)
{
if (actualObject != null)
{
objectsEqual = false;
}
}
else
{
objectsEqual = expected.Equals(actualObject);
}
AstoriaTestLog.Compare(objectsEqual, errorMessage);
}
else
{
AstoriaTestLog.AreEqual(expected, actualObject, errorMessage);
}
}
}
public static void ComparePrimitiveValuesStringAndString(string expected, Type expectedType, string actual, bool valueUri, SerializationFormatKind serializationKind, bool throwOnError)
{
object expectedObject = DeserializeStringToObject(expected, expectedType, valueUri, serializationKind);
ComparePrimitiveValuesObjectAndString(expectedObject, expectedType, actual, valueUri, serializationKind, throwOnError);
}
internal static object DeserializeStringToObject(string val, Type valType, bool valueUri, SerializationFormatKind serializationKind)
{
object rehydratedObject = null;
if (val == null)
{
rehydratedObject = null;
}
else
{
if (valueUri)
{
if (valType == typeof(byte[]))
{
if (val != null)
{
return(new UTF8Encoding().GetBytes(val));
}
return(null);
}
#if !ClientSKUFramework
else if (valType == typeof(System.Data.Linq.Binary))
{
byte[] bytes = new UTF8Encoding().GetBytes(val);
System.Data.Linq.Binary binary = new System.Data.Linq.Binary(bytes);
return(binary);
}
#endif
else
{
rehydratedObject = AstoriaUnitTests.Data.TypeData.ObjectFromXmlValue(val, valType);
}
}
else if (serializationKind == SerializationFormatKind.JSON)
{
//Special case that seems to be failing
if (valType == typeof(DateTime) && val.Equals("null", StringComparison.InvariantCulture))
{
rehydratedObject = null;
}
else
{
rehydratedObject = System.Data.Test.Astoria.Util.JsonPrimitiveTypesUtil.StringToPrimitive(val, valType);
}
}
else //xml
{
rehydratedObject = AstoriaUnitTests.Data.TypeData.ObjectFromXmlValue(val, valType);
}
}
return(rehydratedObject);
}
public static AstoriaRequest BuildDelete(Workspace workspace, KeyExpressions existingKeys, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
KeyExpression deletedKey;
return BuildDelete(workspace, existingKeys, expectedStatusCode, format, out deletedKey);
}
public static AstoriaRequest BuildUpdate(Workspace workspace, KeyExpression modifiedKey, bool replace, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
if (modifiedKey == null)
return null;
ResourceContainer container = modifiedKey.ResourceContainer;
ResourceType resourceType = modifiedKey.ResourceType;
if (replace && resourceType.Properties.Any(p => p.Facets.IsIdentity))
return null;
string keyString = UriQueryBuilder.CreateKeyString(modifiedKey, false);
if (expectedStatusCode == HttpStatusCode.NoContent && (keyString.Contains("/") || keyString.Contains(Uri.EscapeDataString("/"))))
expectedStatusCode = HttpStatusCode.BadRequest;
QueryNode query = ContainmentUtil.BuildCanonicalQuery(modifiedKey);
List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>();
string[] propertiesToSkip;
//Skip because setting the birthdate to a random Datetime won't work due to contraints
//if (resourceType.Name == "Employees")
// propertiesToSkip = new string[] { "BirthDate" };
////Skipping because it has some weird constraint on it
//else if (resourceType.Name == "Order_Details")
// propertiesToSkip = new string[] { "Discount" };
//else
// propertiesToSkip = new string[] { };
foreach (ResourceProperty resourceProperty in resourceType.Properties.OfType<ResourceProperty>()
.Where(p => !p.IsNavigation
&& p.PrimaryKey == null
&& !p.Facets.IsIdentity))
//&& !p.IsComplexType
//&& !propertiesToSkip.Contains(p.Name)))
{
properties.Add(resourceProperty.CreateRandomResourceInstanceProperty());
}
if (!properties.Any())
return null;
KeyedResourceInstance resourceInstance = new KeyedResourceInstance(
ResourceInstanceKey.ConstructResourceInstanceKey(modifiedKey),
properties.ToArray());
AstoriaRequest request = workspace.CreateRequest();
request.Verb = replace ? RequestVerb.Put : RequestVerb.Patch;
request.Query = query;
request.UpdateTree = resourceInstance;
request.ExpectedStatusCode = expectedStatusCode;
request.Format = format;
if (modifiedKey.ResourceType.Properties.Any(p => p.Facets.ConcurrencyModeFixed))
{
request.Headers[ConcurrencyUtil.IfMatchHeader] = modifiedKey.ETag;
request.ETagHeaderExpected = true;
}
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);
}
public static AstoriaRequest BuildDelete(Workspace workspace, KeyExpression toDelete, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
QueryNode query = ContainmentUtil.BuildCanonicalQuery(toDelete);
AstoriaRequest request = workspace.CreateRequest();
request.Verb = RequestVerb.Delete;
request.Query = query;
request.Format = format;
request.ExpectedStatusCode = expectedStatusCode;
if (toDelete.ResourceType.Properties.Any(p => p.Facets.ConcurrencyModeFixed))
{
request.Headers[ConcurrencyUtil.IfMatchHeader] = toDelete.ETag;
}
return(request);
}
public static AstoriaRequest BuildDelete(Workspace workspace, KeyExpressions existingKeys, HttpStatusCode expectedStatusCode, SerializationFormatKind format, out KeyExpression deletedKey)
{
deletedKey = existingKeys.Choose();
if (deletedKey == null)
{
AstoriaTestLog.WriteLine("Cannot build DELETE request, no existing keys");
return(null);
}
existingKeys.Remove(deletedKey);
return(BuildDelete(workspace, deletedKey, expectedStatusCode, format));
}
public static AstoriaRequest BuildDelete(Workspace workspace, KeyExpressions existingKeys, HttpStatusCode expectedStatusCode, SerializationFormatKind format, out KeyExpression deletedKey)
{
deletedKey = existingKeys.Choose();
if (deletedKey == null)
{
AstoriaTestLog.WriteLine("Cannot build DELETE request, no existing keys");
return null;
}
existingKeys.Remove(deletedKey);
return BuildDelete(workspace, deletedKey, expectedStatusCode, format);
}
public static AstoriaRequest BuildUpdate(Workspace workspace, KeyExpression modifiedKey, bool replace, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
if (modifiedKey == null)
{
return(null);
}
ResourceContainer container = modifiedKey.ResourceContainer;
ResourceType resourceType = modifiedKey.ResourceType;
if (replace && resourceType.Properties.Any(p => p.Facets.IsIdentity))
{
return(null);
}
string keyString = UriQueryBuilder.CreateKeyString(modifiedKey, false);
if (expectedStatusCode == HttpStatusCode.NoContent && (keyString.Contains("/") || keyString.Contains(Uri.EscapeDataString("/"))))
{
expectedStatusCode = HttpStatusCode.BadRequest;
}
QueryNode query = ContainmentUtil.BuildCanonicalQuery(modifiedKey);
List <ResourceInstanceProperty> properties = new List <ResourceInstanceProperty>();
string[] propertiesToSkip;
//Skip because setting the birthdate to a random Datetime won't work due to contraints
//if (resourceType.Name == "Employees")
// propertiesToSkip = new string[] { "BirthDate" };
////Skipping because it has some weird constraint on it
//else if (resourceType.Name == "Order_Details")
// propertiesToSkip = new string[] { "Discount" };
//else
// propertiesToSkip = new string[] { };
foreach (ResourceProperty resourceProperty in resourceType.Properties.OfType <ResourceProperty>()
.Where(p => !p.IsNavigation &&
p.PrimaryKey == null &&
!p.Facets.IsIdentity))
//&& !p.IsComplexType
//&& !propertiesToSkip.Contains(p.Name)))
{
properties.Add(resourceProperty.CreateRandomResourceInstanceProperty());
}
if (!properties.Any())
{
return(null);
}
KeyedResourceInstance resourceInstance = new KeyedResourceInstance(
ResourceInstanceKey.ConstructResourceInstanceKey(modifiedKey),
properties.ToArray());
AstoriaRequest request = workspace.CreateRequest();
request.Verb = replace ? RequestVerb.Put : RequestVerb.Patch;
request.Query = query;
request.UpdateTree = resourceInstance;
request.ExpectedStatusCode = expectedStatusCode;
request.Format = format;
if (modifiedKey.ResourceType.Properties.Any(p => p.Facets.ConcurrencyModeFixed))
{
request.Headers[ConcurrencyUtil.IfMatchHeader] = modifiedKey.ETag;
request.ETagHeaderExpected = true;
}
return(request);
}
public static AstoriaRequest BuildDelete(Workspace workspace, KeyExpression toDelete, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
QueryNode query = ContainmentUtil.BuildCanonicalQuery(toDelete);
AstoriaRequest request = workspace.CreateRequest();
request.Verb = RequestVerb.Delete;
request.Query = query;
request.Format = format;
request.ExpectedStatusCode = expectedStatusCode;
if (toDelete.ResourceType.Properties.Any(p => p.Facets.ConcurrencyModeFixed))
request.Headers[ConcurrencyUtil.IfMatchHeader] = toDelete.ETag;
return request;
}
public static AstoriaRequest BuildUpdate(Workspace workspace, ResourceContainer container, ResourceType resourceType,
bool replace, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
KeyExpression modifiedKey;
return(BuildUpdate(workspace, container, resourceType, replace, expectedStatusCode, format, out modifiedKey));
}
public static AstoriaRequest BuildGet(Workspace workspace, ResourceContainer container, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
if (!container.Facets.TopLevelAccess && expectedStatusCode == HttpStatusCode.OK)
{
expectedStatusCode = HttpStatusCode.BadRequest;
}
QueryNode query = Query.From(Exp.Variable(container)).Select();
return(BuildGet(workspace, query, expectedStatusCode, format));
}
public static AstoriaRequest BuildGet(Workspace workspace, KeyExpression key, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
QueryNode query = ContainmentUtil.BuildCanonicalQuery(key);
string keyString = UriQueryBuilder.CreateKeyString(key, false);
if ((expectedStatusCode == System.Net.HttpStatusCode.OK) && (keyString.Contains("/") || keyString.Contains(Uri.EscapeDataString("/"))))
{
expectedStatusCode = System.Net.HttpStatusCode.BadRequest;
}
return(BuildGet(workspace, query, expectedStatusCode, format));
}
public static AstoriaRequest BuildGet(Workspace workspace, QueryNode query, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
AstoriaRequest request = workspace.CreateRequest();
request.Verb = RequestVerb.Get;
request.Query = query;
request.ExpectedStatusCode = expectedStatusCode;
request.Format = format;
return(request);
}
public static AstoriaRequest BuildGet(Workspace workspace, KeyExpression key, HttpStatusCode expectedStatusCode, SerializationFormatKind format)
{
QueryNode query = ContainmentUtil.BuildCanonicalQuery(key);
string keyString = UriQueryBuilder.CreateKeyString(key, false);
if ((expectedStatusCode == System.Net.HttpStatusCode.OK) && (keyString.Contains("/") || keyString.Contains(Uri.EscapeDataString("/"))))
expectedStatusCode = System.Net.HttpStatusCode.BadRequest;
return BuildGet(workspace, query, expectedStatusCode, format);
}
public static AstoriaRequest BuildInsert(Workspace workspace, ResourceContainer container, ResourceType type,
HttpStatusCode expectedStatusCode, SerializationFormatKind format, out KeyExpression createdKey)
{
KeyedResourceInstance newResource = type.CreateRandomResource(container);
if (newResource == null)
{
newResource = ResourceInstanceUtil.CreateKeyedResourceInstanceByClone(container, type);
if(newResource == null)
{
createdKey = null;
return null;
}
}
QueryNode query;
if (!type.Key.Properties.Any(p => p.Facets.ServerGenerated) && newResource.ResourceInstanceKey != null)
{
createdKey = newResource.ResourceInstanceKey.CreateKeyExpression(container, type);
query = ContainmentUtil.BuildCanonicalQuery(createdKey, true);
}
else
{
createdKey = null;
// the key is unknown, must be server generated
// in this case, lets hope that containment is a non-issue
query =
Query.From(Exp.Variable(container))
.Select();
if (!container.Facets.TopLevelAccess && expectedStatusCode == HttpStatusCode.Created)
expectedStatusCode = HttpStatusCode.BadRequest;
}
AstoriaRequest request = workspace.CreateRequest();
request.Verb = RequestVerb.Post;
request.Query = query;
request.UpdateTree = newResource;
request.ExpectedStatusCode = expectedStatusCode;
request.Format = format;
return request;
}
//---------------------------------------------------------------------
// Constructs request with $ref. Assumes parent(*)/child URI format.
//---------------------------------------------------------------------
public static BlobsRequest LNK(Workspace w, SerializationFormatKind format, RequestVerb verb, string payload, HttpStatusCode expectedStatusCode, params string[] URI)
{
string uri = (URI.Length == 0 ? LastURI : URI[0]);
BlobsRequest rq = new BlobsRequest(w, format, verb, uri, expectedStatusCode);
// Specific request properties.
rq.Format = format;
rq.ContentType = SerializationFormatKinds.ContentTypeFromKind(format == SerializationFormatKind.JSON ? SerializationFormatKind.JSON : SerializationFormatKind.PlainXml);
rq.Accept = rq.ContentType;
// Adjust link in payload, if needed.
if (!string.IsNullOrEmpty(payload))
{
rq.Payload = string.Format(format == SerializationFormatKind.JSON ?
@"{{""odata.id"": ""{0}"" }}" :
@"<ref xmlns='http://docs.oasis-open.org/odata/ns/metadata' id=""{0}"" />",
payload);
}
return rq;
}
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;
}
