public static KeyExpression GetContainingKey(this ContainmentAttribute att, KeyExpression childKey, ResourceType parentType, bool abbreviate)
{
AstoriaTestLog.Compare(childKey.ResourceContainer == att.ChildContainer,
String.Format("ChildKey does not belong to expected set (Expected '{0}', got '{1}'", att.ChildContainer.Name, childKey.ResourceContainer.Name));
List<PropertyExpression> parentProperties = new List<PropertyExpression>();
List<ConstantExpression> parentValues = new List<ConstantExpression>();
foreach (NodeProperty p_prop in att.ParentContainer.BaseType.Key.Properties)
{
string c_name;
if (!att.KeyMapping.TryGetValue(p_prop.Name, out c_name))
AstoriaTestLog.FailAndThrow(String.Format("Parent key property {0} does not appear in derived key mapping", p_prop.Name));
// need to get the offset now
int c_offset = 0;
for (; c_offset < childKey.Properties.Length; c_offset++)
{
if (childKey.Properties[c_offset].Name == c_name)
break;
}
if (c_offset >= childKey.Properties.Length)
AstoriaTestLog.FailAndThrow(String.Format("Could not find property '{0}' in child key", c_name));
NodeProperty c_prop = childKey.Properties[c_offset];
parentProperties.Add(p_prop.Property());
parentValues.Add(new ConstantExpression(childKey.Values[c_offset]));
if (abbreviate)
childKey.IncludeInUri[c_offset] = false;
}
return new KeyExpression(att.ParentContainer, parentType, parentProperties.ToArray(), parentValues.ToArray());
}
//Constructor
public PredicateModel(Workspace w,ResourceContainer container, ResourceProperty p, KeyExpression parentKey, ResourceType resType)
{
_resourceContainer = container;
_workspace = w;
_resType = resType;
_key = parentKey;
_prop = p;
}
private IMappedExpression BuildField(Type type, ref int index, ref IEnumerable <Type> types)
{
// if (type.IsOfGenericType(typeof (Ref<>))) {
// var entityType = type.GetGenericType(typeof (Ref<>)).GetGenericArguments()[0];
// TypeInfo typeInfo = model.Types[entityType];
// KeyInfo keyProviderInfo = typeInfo.KeyInfo;
// TupleDescriptor keyTupleDescriptor = keyProviderInfo.TupleDescriptor;
// KeyExpression entityExpression = KeyExpression.Create(typeInfo, index);
// index += keyTupleDescriptor.Count;
// types = types.Concat(keyTupleDescriptor);
// return Expression.Convert(entityExpression, type);
// }
if (type.IsSubclassOf(typeof(Entity)))
{
TypeInfo typeInfo = model.Types[type];
KeyInfo keyInfo = typeInfo.Key;
TupleDescriptor keyTupleDescriptor = keyInfo.TupleDescriptor;
IMappedExpression expression;
if (isKeyConverter)
{
expression = KeyExpression.Create(typeInfo, index);
}
else
{
var entityExpression = EntityExpression.Create(typeInfo, index, true);
entityExpression.IsNullable = true;
expression = entityExpression;
}
index += keyTupleDescriptor.Count;
types = types.Concat(keyTupleDescriptor);
return(expression);
}
if (type.IsSubclassOf(typeof(Structure)))
{
TypeInfo typeInfo = model.Types[type];
TupleDescriptor tupleDescriptor = typeInfo.TupleDescriptor;
var tupleSegment = new Segment <int>(index, tupleDescriptor.Count);
StructureExpression structureExpression = StructureExpression.CreateLocalCollectionStructure(typeInfo, tupleSegment);
index += tupleDescriptor.Count;
types = types.Concat(tupleDescriptor);
return(structureExpression);
}
if (TypeIsStorageMappable(type))
{
ColumnExpression columnExpression = ColumnExpression.Create(type, index);
types = types.AddOne(type);
index++;
return(columnExpression);
}
throw new NotSupportedException();
}
public override string ToAql()
{
string aql = "REMOVE " + KeyExpression.ToAql();
aql += " IN " + CollectionName;
if (Options.Count > 0)
{
aql += " OPTIONS " + Options.ToString();
}
return(aql);
}
protected override Expression VisitKeyExpression(KeyExpression expression)
{
// TODO: http://code.google.com/p/dataobjectsdotnet/issues/detail?id=336
Expression tupleExpression = Expression.Call(
GetTupleSegmentMethod,
GetTupleExpression(expression),
Expression.Constant(expression.Mapping));
return(Expression.Call(
WellKnownMembers.Key.Create,
Expression.Constant(context.Domain),
Expression.Property(
Expression.Field(itemMaterializationContextParameter, ItemMaterializationContext.SessionFieldInfo),
WellKnownMembers.SessionNodeId),
Expression.Constant(expression.EntityType),
Expression.Constant(TypeReferenceAccuracy.BaseType),
tupleExpression));
}
public override string ToAql()
{
string aql = "REPLACE " + KeyExpression.ToAql();
if (WithExpression != null)
{
aql += " WITH " + WithExpression.ToAql();
}
aql += " IN " + CollectionName;
if (Options.Count > 0)
{
aql += " OPTIONS " + Options.ToString();
}
return(aql);
}
/// <summary>
/// Performs the REMOVE operation on a frame stream
/// </summary>
public IEnumerable <ExecutionFrame> ApplyToFrameStream(
QueryExecutor executor,
IEnumerable <ExecutionFrame> frameStream
)
{
foreach (ExecutionFrame frame in frameStream)
{
JsonValue keyResult = KeyExpression.Evaluate(executor, frame);
// get key & ref
string key;
string rev;
if (keyResult.IsJsonObject)
{
key = keyResult["_key"].AsString;
rev = keyResult["_rev"].AsString;
}
else
{
key = keyResult.AsString;
rev = null;
}
// OLD
JsonObject oldDocument = executor.DataSource.GetDocument(
CollectionName,
key
);
// remove
executor.DataSource.RemoveDocument(
CollectionName,
key,
rev,
Options
);
// update frame
yield return(frame
.AddVariable("OLD", oldDocument));
}
}
/// <summary>
/// Performs the REPLACE operation on a frame stream
/// </summary>
public IEnumerable <ExecutionFrame> ApplyToFrameStream(
QueryExecutor executor,
IEnumerable <ExecutionFrame> frameStream
)
{
foreach (ExecutionFrame frame in frameStream)
{
// get key
JsonValue keyResult = KeyExpression.Evaluate(executor, frame);
string key = keyResult.AsString;
if (keyResult.IsJsonObject)
{
key = keyResult["_key"].AsString;
}
// get document
JsonObject document = keyResult;
if (WithExpression != null)
{
document = WithExpression.Evaluate(executor, frame);
}
// OLD
JsonObject oldDocument = executor.DataSource.GetDocument(
CollectionName,
key
);
// replace & NEW
JsonObject newDocument = executor.DataSource.ReplaceDocument(
CollectionName,
key,
document,
Options
);
// update frame
yield return(frame
.AddVariable("OLD", oldDocument)
.AddVariable("NEW", newDocument));
}
}
public static void EnsureKeyExpressionCompatible(this KeyExpression left, KeyExpression right, Expression expressionPart)
{
if (left == null || right == null)
{
return;
}
if (left.EntityType.IsInterface || right.EntityType.IsInterface)
{
if (left.EntityType.Key.EqualityIdentifier != right.EntityType.Key.EqualityIdentifier)
{
throw new InvalidOperationException(string.Format(
Strings.ExKeysOfXAndXNotCompatible, expressionPart.ToString(true), left.EntityType, right.EntityType));
}
}
else
{
if (left.EntityType.Hierarchy != right.EntityType.Hierarchy)
{
throw new InvalidOperationException(string.Format(
Strings.ExEntitiesXAndXBelongToDifferentHierarchies, expressionPart.ToString(true), left.EntityType, right.EntityType));
}
}
}
protected virtual Expression VisitKeyExpression(KeyExpression expression)
{
return(expression);
}
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 string CreateKeyString(KeyExpression keyExp)
{
System.Collections.Generic.List<string> names = new System.Collections.Generic.List<string>();
System.Collections.Generic.List<object> values = new System.Collections.Generic.List<object>();
foreach (KeyValuePair<PropertyExpression, ConstantExpression> pair in keyExp.EnumerateIncludedPairs())
{
names.Add(pair.Key.Name);
values.Add(pair.Value.Value.ClrValue);
}
return CreateKeyString(names.ToArray(), values.ToArray());
}
public override KeyedResourceInstance GetSingleResourceByKey(KeyExpression keyExpression)
{
ExpNode query = ContainmentUtil.BuildCanonicalQuery(keyExpression);
AstoriaRequest request = this.CreateRequest(query);
if (request.URI.Length > 260) // Can't make this request.
return null;
AstoriaResponse response = request.GetResponse();
if (response.ActualStatusCode == HttpStatusCode.NotFound)
return null;
else if (response.ActualStatusCode == HttpStatusCode.OK)
{
CommonPayload payload = response.CommonPayload;
if (payload.Resources is List<PayloadObject>)
{
List<PayloadObject> payloadObjects = (List<PayloadObject>)payload.Resources;
if (payloadObjects.Count == 1)
return ResourceInstanceUtil.CreateKeyedResourceInstanceFromPayloadObject(keyExpression.ResourceContainer, keyExpression.ResourceType, payloadObjects.First());
else if (payloadObjects.Count == 0 && keyExpression.ResourceContainer is ServiceOperation)
{
// we change serviceoperations into $filter requests, so they come back as empty feeds instead of 404s
return null;
}
}
}
ResponseVerification.LogFailure(response, new TestFailedException("Could not get resource for the given key"));
return null;
}
private static List<ResourceInstanceProperty> CloneRequiredRelationships(ResourceContainer container, ResourceType resourceType, KeyExpression keyExpression)
{
List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>();
//Foreach Navigation Property in dataObject create a bind
Dictionary<ResourceProperty, KeyExpressions> navigationProperties = GetAllAssociatedKeys(container, resourceType, keyExpression);
foreach (ResourceProperty navProperty in navigationProperties.Keys)
{
//ResourceAssociationEnd otherEnd = navProperty.ResourceAssociation.GetOtherEnd(navProperty);
ResourceType navPropertyResourceType = (navProperty.Type is CollectionType ? (navProperty.Type as CollectionType).SubType : navProperty.Type) as ResourceType;
ResourceContainer otherContainer = container.FindDefaultRelatedContainer(navProperty);
bool foreignKeyViolation = false;
foreach (ResourceProperty otherProperty in otherContainer.BaseType.Key.Properties)
{
if (otherProperty.ForeignKeys.Count() > 0)
{
ResourceType otherType = otherProperty.ForeignKeys.First().PrimaryKey.Properties.OfType<ResourceProperty>().First().ResourceType;
if (otherType == container.BaseType)
{
foreignKeyViolation = true;
break;
}
}
}
if (foreignKeyViolation)
continue;
KeyExpressions keyExpressions = navigationProperties[navProperty];
if (navProperty.Type is ResourceType)
{
if (keyExpressions.Count > 0)
{
properties.Add(CreateRefInstanceProperty(keyExpressions[0], otherContainer, navProperty));
}
}
else
{
ResourceInstanceProperty property = CreateCollectionInstanceProperty(keyExpressions, otherContainer, navProperty);
if (property != null)
{
properties.Add(property);
}
}
}
return properties;
}
public override string ToString()
{
return(KeyExpression.ToString() + " : " + ValueExpression.ToString());
}
public virtual KeyedResourceInstance GetSingleResourceByKey(KeyExpression keyExpression)
{
LinqQueryBuilder linqBuilder = new LinqQueryBuilder(this);
ExpNode query = null;
if (this.Settings.HasContainment)
query = ContainmentUtil.BuildCanonicalQuery(keyExpression).Select();
else
{
query = Query.From(
Exp.Variable(keyExpression.ResourceContainer))
.Where(keyExpression)
.Select();
}
IQueryable queryable = this.GetUnderlyingProviderQueryResults(query);
IEnumerator enumerator = queryable.GetEnumerator();
enumerator.MoveNext();
object dataObject = enumerator.Current;
if (dataObject == null)
return null;
return ResourceInstanceUtil.CreateKeyedResourceInstanceByExactClone(keyExpression.ResourceContainer, keyExpression.ResourceType, dataObject);
}
public static KeyedResourceInstance CreateKeyedResourceInstance(KeyExpression exp, ResourceContainer container, params ResourceInstanceProperty[] properties)
{
ResourceType resType = exp.Properties.OfType<ResourceProperty>().First().ResourceType;
ResourceInstanceKey instanceKey = ResourceInstanceKey.ConstructResourceInstanceKey(exp);
return new KeyedResourceInstance(instanceKey, properties);
}
/// <summary>
/// Implements IDataInserter.AddEntity by creating a POST-based insert request and adding it to the batch queue
/// </summary>
/// <param name="key">Key expression for new entity</param>
/// <param name="entity">Update tree for new entity</param>
public void AddEntity(KeyExpression key, KeyedResourceInstance entity)
{
// build the request
//
ExpNode containerQuery = ContainmentUtil.BuildCanonicalQuery(key, true);
AstoriaRequest request = workspace.CreateRequest(containerQuery, entity, RequestVerb.Post);
// set ETagHeaderExpected appropriately
if (key.ResourceType.Properties.Any(p => p.Facets.ConcurrencyModeFixed))
request.ETagHeaderExpected = true;
// add it to the queue
//
queue.Add(request);
// store the content-id
//
contentIDMap[entity] = request.Headers["Content-ID"];
// fire the event
//
if (this.OnAddingEntity != null)
OnAddingEntity(key, entity);
}
public virtual KeyExpression GetRandomExistingKey(ResourceContainer resourceContainer, KeyExpression partialKey)
{
return this.GetRandomExistingKey(resourceContainer, null, partialKey);
}
private RowEntityType FindRowInstance(KeyExpression keyExp)
{
RowEntityType type = FindRowInstance(keyExp.ResourceContainer.Name,
keyExp.Properties.Select(p => p.Name).ToList(),
keyExp.Values.Select(v => v.ClrValue).ToList());
if (type != null)
return type;
throw new TestException(TestResult.Failed, "Could not find row instance for keyExpression: "
+ keyExp.ResourceContainer.Name + "(" + UriQueryBuilder.CreateKeyString(keyExp, false) + ")");
}
private void DataInserter_HandleAddingEntity(KeyExpression key, KeyedResourceInstance entity)
{
AddNewEntity(entity, key.ResourceType);
}
private bool CreateKeyedResourceInstance(ResourceContainer container, ResourceType resourceType, out KeyExpression key, out KeyedResourceInstance newResource)
{
int retryCount = 5;
if (!_existingKeyMap.Keys.Contains(container))
_existingKeyMap.Add(container, new KeyExpressions());
newResource = resourceType.CreateRandomResource(container, new KeyExpressions(), false); // should not make request
key = newResource.ResourceInstanceKey.CreateKeyExpression(container, resourceType);
while (_existingKeyMap[container].Contains(key) && retryCount > 0)
{
newResource.ResourceInstanceKey = ResourceInstanceUtil.CreateUniqueKey(container, resourceType, new KeyExpressions(), new KeyExpressions());
key = newResource.ResourceInstanceKey.CreateKeyExpression(container, resourceType);
retryCount--;
}
if (retryCount == 0)
{
newResource = null;
key = null;
return false;
}
_existingKeyMap[container].Add(key);
_existingEntityMap[key] = newResource;
return true;
}
private static bool compareKeyURI(string uriFound, KeyExpression keyExpected)
{
UriQueryBuilder builder = new UriQueryBuilder(keyExpected.ResourceContainer.Workspace, keyExpected.ResourceContainer.Workspace.ServiceUri);
builder.EscapeUriValues = true;
builder.CleanUpSpecialCharacters = false;
builder.UseBinaryFormatForDates = false;
switch (keyExpected.IncludeInUri.Count(i => i))
{
case 0:
AstoriaTestLog.FailAndThrow("Cannot compare KeyExpression to URI, key has no included values");
return false;
case 1:
// TODO: stop ignoring case
QueryNode query = ContainmentUtil.BuildCanonicalQuery(keyExpected);
string expected = builder.Build(query);
expected = expected.Replace(".0f", "f"); //this is kinda a hack, but TypeData.FormatForKey is going to add the .0, so we need to remove it
expected = expected.Replace(".0D", "D"); //this is kinda a hack, but TypeData.FormatForKey is going to add the .0, so we need to remove it
bool match = uriFound.Equals(expected, StringComparison.InvariantCultureIgnoreCase);
if (!match)
AstoriaTestLog.WriteLineIgnore("Link did not match key, expected '" + expected + "'");
return match;
default:
QueryNode setQuery = ContainmentUtil.BuildCanonicalQuery(keyExpected, true);
Workspace w = keyExpected.ResourceContainer.Workspace;
string setUri = builder.Build(setQuery);
string keySegment = uriFound.Substring(setUri.Length);
string expectedKeySegment = "(" + UriQueryBuilder.CreateKeyString(keyExpected, false) + ")";
if (keySegment.Equals(expectedKeySegment, StringComparison.InvariantCultureIgnoreCase))
return true;
// if not explicitely equal, need to make sure its not due to a re-ordering of the properties
//
List<KeyValuePair<string, int>> predicateLocations = new List<KeyValuePair<string, int>>();
for (int i = 0; i < keyExpected.Values.Length; i++)
{
string predicate = builder.CreateKeyStringPair(keyExpected.Properties[i].Name, keyExpected.Values[i].ClrValue);
int offset = keySegment.IndexOf(predicate);
if (offset < 0)
return false;
predicateLocations.Add(new KeyValuePair<string, int>(predicate, offset));
}
predicateLocations.Sort(delegate(KeyValuePair<string, int> pair1, KeyValuePair<string, int> pair2)
{
return pair1.Value.CompareTo(pair2.Value);
});
expectedKeySegment = "(" + String.Join(",", predicateLocations.Select(pair => pair.Key).ToArray()) + ")";
return keySegment.Equals(expectedKeySegment, StringComparison.InvariantCultureIgnoreCase);
}
}
public virtual void Where()
{
AstoriaTestLog.WriteLineIgnore("Calling Where");
//Sub model - projections
PredicateModel model = new PredicateModel( this.Workspace, this.ResContainer, this.property, this.ParentRelKey, this.ResType );
ModelEngine engine = new ModelEngine( this.Engine, model );
engine.Run();
ExpNode e = model.Result;
this.ParentRelKey = e as KeyExpression;
if (null == _parentKey)
{
/* no keys for resource type*/
this.Reload();
return;
}
int i = this.Engine.Options.Random.Next( 0, 10 );
if (i % 7 == 0)
{
e = ((KeyExpression)e).Predicate;
bFilter = true;
}
if (e != null)
{
if (_query is ScanExpression)
_query = ((ScanExpression)_query).Where( e ) as PredicateExpression;
else if (_query is NavigationExpression)
_query = ((NavigationExpression)_query).Where( e ) as PredicateExpression;
bWhere = true;
IsKey = true;
_action = LastAction.Where;
AstoriaTestLog.WriteLineIgnore( ".Where()" );
}
}
protected virtual KeyExpression GetRandomExistingKey(ResourceContainer resourceContainer, ResourceType resourceType, KeyExpression partialKey)
{
LinqQueryBuilder linqBuilder = new LinqQueryBuilder(this);
QueryNode query = Query.From(Exp.Variable(resourceContainer));
//TODO: Figure out how to make OfType work with astoria dataquerycontext
if (resourceType != null && resourceContainer.Workspace.DataLayerProviderKind != DataLayerProviderKind.InMemoryLinq && resourceType.BaseType != null)
{
query = query.OfType(resourceType);
}
else if (partialKey != null)
{
query = query.Where(partialKey);
}
query = query.Select().Top(50);
linqBuilder.Build(query);
int count = 0;
KeyExpressions keys = new KeyExpressions();
IQueryable objects = linqBuilder.QueryResult;
IEnumerator enumerator = null;
try
{
enumerator = objects.GetEnumerator();
while (enumerator.MoveNext() && count < 50)
{
if (enumerator.Current != null)
{
Type t = enumerator.Current.GetType();
if (AstoriaTestProperties.EdmObjectLayer == ServiceEdmObjectLayer.PocoWithProxy)
t = t.BaseType;
List<ResourceType> types = resourceContainer.ResourceTypes.Where(rt => rt.Name.Equals(t.Name) && rt.Namespace.Equals(t.Namespace)).ToList();
if (types.Count > 0)
{
ResourceType actualResourceType = types.Single();
if (resourceType != null && resourceType != actualResourceType)
continue;
KeyExpression keyExp = GetKeyExpression(resourceContainer, actualResourceType, enumerator.Current);
//If key is something that has approx value
//Then its really a nonfunctional key, excluding it as
//we only want valid keys here
if (!keyExp.IsApproxKeyValue())
{
keys.Add(keyExp);
count++;
}
}
}
}
}
finally
{
IDisposable disposable = (enumerator as IDisposable);
if (null != disposable)
{
disposable.Dispose();
}
}
return keys.Choose();
}
public static bool SpecialChars(KeyExpression keyExp)
{
// Workaround unsupported .:'/ in URI
bool bSpecial = false;
if (keyExp != null)
{
foreach (NodeValue key in keyExp.Values)
{
string x = key.ClrValue.ToString();
if (0 <= x.IndexOfAny(CharsBadRequest) || (key.ClrValue is DateTime))
{
bSpecial = true;
break;
}
}
return bSpecial;
}
else
return true;
}
public virtual KeyExpressions GetExistingAssociatedKeys(ResourceContainer resourceContainer, ResourceProperty property, KeyExpression keyExpression)
{
LinqQueryBuilder linqBuilder = new LinqQueryBuilder(this);
ExpNode query = Query.From(
Exp.Variable(resourceContainer))
.Where(keyExpression)
.OfType(property.ResourceType)
.Nav(new PropertyExpression(property))
.Select();
linqBuilder.Build(query);
ResourceType associatedType = property.Type as ResourceType;
if (property.Type is ResourceCollection)
{
associatedType = (property.Type as ResourceCollection).SubType as ResourceType;
}
IQueryable queryable = linqBuilder.QueryResult;
KeyExpressions keys = new KeyExpressions();
IEnumerator enumerator = queryable.GetEnumerator();
while (enumerator.MoveNext())
{
if (enumerator.Current != null)
{
Type t = enumerator.Current.GetType();
if (AstoriaTestProperties.EdmObjectLayer == ServiceEdmObjectLayer.PocoWithProxy)
t = t.BaseType;
IEnumerable<ResourceType> typesWithName = resourceContainer.Workspace.ServiceContainer.ResourceTypes.Where(rt => (t.Name.Equals(rt.Name)));
IEnumerable<ResourceType> typesWithNamespace = typesWithName.Where(rt2 => rt2.Namespace == t.Namespace).ToList();
ResourceType instanceType = typesWithNamespace.First();
ResourceContainer relatedContainer = resourceContainer.FindDefaultRelatedContainer(property);
keys.Add(GetKeyExpression(relatedContainer, instanceType, enumerator.Current));
}
}
return keys;
}
public static AstoriaRequest BuildGet(Workspace workspace, KeyExpression key)
{
return BuildGet(workspace, key, HttpStatusCode.OK, SerializationFormatKind.Default);
}
public static ResourceInstanceProperty CreateRefInstanceProperty(KeyExpression keyExp, ResourceContainer container, ResourceProperty navProperty)
{
ResourceType navResourceType = navProperty.Type as ResourceType;
ResourceInstanceKey resourceInstanceKey = ResourceInstanceKey.ConstructResourceInstanceKey(keyExp);
return new ResourceInstanceNavRefProperty(navProperty.Name, new AssociationResourceInstance(resourceInstanceKey, AssociationOperation.Add));
}
public KeyedResourceInstance CreateRandomResource(ResourceContainer container, KeyExpression specifiedKey)
{
List<ResourceInstanceProperty> properties = new List<ResourceInstanceProperty>();
foreach (ResourceProperty p in this.Properties.OfType<ResourceProperty>().Where(rp => rp.IsNavigation == false && rp.PrimaryKey == null))
{
ResourceInstanceProperty property = p.CreateRandomResourceInstanceProperty();
properties.Add(property);
}
return ResourceInstanceUtil.CreateKeyedResourceInstance(specifiedKey, container, properties.ToArray());
}
public static Dictionary<ResourceProperty, KeyExpressions> GetAllAssociatedKeys(ResourceContainer container, ResourceType resourceType, KeyExpression keyExpression)
{
Workspace workspace = container.Workspace;
Dictionary<ResourceProperty, KeyExpressions> listOfKeyExpressions = new Dictionary<ResourceProperty, KeyExpressions>();
foreach (ResourceProperty resourceProperty in resourceType.Properties)
{
if (resourceProperty.IsNavigation)
{
KeyExpressions keys = workspace.GetExistingAssociatedKeys(container, resourceProperty, keyExpression);
listOfKeyExpressions.Add(resourceProperty, keys);
}
}
return listOfKeyExpressions;
}
protected override Expression VisitKeyExpression(KeyExpression k)
{
AddColumns(k, k.Mapping.GetItems());
return(k);
}
public static string CreateKeyString(KeyExpression keyExp, bool binaryFormat)
{
Workspace w = keyExp.ResourceContainer.Workspace;
UriQueryBuilder builder = new UriQueryBuilder(w, w.ServiceUri);
builder.UseBinaryFormatForDates = binaryFormat;
builder.CleanUpSpecialCharacters = true;
return builder.CreateKeyString(keyExp);
}
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 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 override KeyExpressions GetExistingAssociatedKeys(ResourceContainer resourceContainer, ResourceProperty property, KeyExpression keyExpression)
{
bool pageSizeChanged = false;
int originalPageSize = this.DataService.ConfigSettings.GetEntitySetPageSize(resourceContainer.Name);
if (originalPageSize < 1000)
{
pageSizeChanged = true;
this.DataService.ConfigSettings.SetEntitySetPageSize(resourceContainer.Name, 100000);
}
ExpNode query = ContainmentUtil.BuildCanonicalQuery(keyExpression).Nav(property.Property()).Select();
AstoriaRequest request = this.CreateRequest(query);
AstoriaResponse response = request.GetResponse();
// normal verification doesn't work here safely due to ETags and No-Content responses
if (response.ActualStatusCode != HttpStatusCode.OK && response.ActualStatusCode != HttpStatusCode.NoContent)
{
ResponseVerification.LogFailure(response, new TestFailedException("Unexpected status code"));
}
ResourceContainer otherResourceContainer = resourceContainer.FindDefaultRelatedContainer(property);
KeyExpressions keyExpressions = GetKeyExpressionsFromPayload(otherResourceContainer, response);
if (pageSizeChanged)
{
this.DataService.ConfigSettings.SetEntitySetPageSize(resourceContainer.Name, originalPageSize);
}
return keyExpressions;
}
/// <summary>
/// Implements IDataInserter.AddEntity by generating a IUpdatable.CreateResource call and multiple IUpdatable.SetValue calls
/// </summary>
/// <param name="key">Key expression for new entity</param>
/// <param name="entity">Update tree for new entity</param>
public void AddEntity(KeyExpression key, KeyedResourceInstance entity)
{
// generate a variable name for this entity and save it
//
int entityID = entityIDs.Count;
entityIDs[entity] = entityID;
string entityObjectName = "entity" + entityID;
// code-gen the CreateResource and SetValue calls
//
code.AppendLine("//Adding entity");
foreach(string line in WriteObject(entityObjectName, entity))
code.AppendLine(line);
code.AppendLine(entityListName + ".Add(" + entityObjectName + ");");
code.AppendLine(string.Empty);
// Fire the event
//
if (this.OnAddingEntity != null)
OnAddingEntity(key, entity);
// ensure that a later Flush/Close will write the SaveChanges call
changesSaved = false;
}
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;
}
protected override Expression VisitKeyExpression(KeyExpression expression)
{
return(expression);
}
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;
}