public override KeyExpressions GetAllExistingKeysOfType(ResourceContainer resourceContainer, ResourceType resourceType) { if (!DataGenerator.Done) { return(DataGenerator.GetAllGeneratedKeys(resourceContainer, resourceType)); } bool rightsChanged = false; EntitySetRights oldRights = this.DataService.ConfigSettings.GetEntitySetAccessRule(resourceContainer.Name); if ((EntitySetRights.ReadMultiple & oldRights) == 0) { rightsChanged = true; this.DataService.ConfigSettings.SetEntitySetAccessRule(resourceContainer.Name, EntitySetRights.All); } KeyExpressions keys = SocketExceptionHandler.Execute <KeyExpressions>( () => GetAllExistingKeysBase(resourceContainer)); if (rightsChanged) { this.DataService.ConfigSettings.SetEntitySetAccessRule(resourceContainer.Name, oldRights); } if (resourceType == null) { return(keys); } return(new KeyExpressions(keys.Where(k => k.ResourceType.Equals(resourceType)))); }
private static void VerifyLinksPayload(Workspace w, CommonPayload payload, LinqQueryBuilder linqBuilder) { ArrayList expectedEntities = CommonPayload.CreateList(linqBuilder.QueryResult); if (payload == null) { AstoriaTestLog.AreEqual(expectedEntities.Count, 0, "Unexpected null $ref payload"); } else { KeyExpressions expectedKeys = new KeyExpressions(); foreach (object o in expectedEntities) { KeyExpression keyExp = w.CreateKeyExpressionFromProviderObject(o); expectedKeys.Add(keyExp); } List <string> linksFound = new List <string>(); if (payload.Resources == null) { linksFound.Add(payload.Value); } else { foreach (PayloadObject o in (payload.Resources as List <PayloadObject>)) { if (o.PayloadProperties.Any(p => p.Name == "uri")) { linksFound.Add((o["uri"] as PayloadSimpleProperty).Value); } } } AstoriaTestLog.AreEqual(expectedKeys.Count, linksFound.Count, "Number of expected entities does not match number of links found"); foreach (string link in linksFound) { KeyExpression match = null; foreach (KeyExpression expectedKey in expectedKeys) { if (compareKeyURI(link, expectedKey)) { match = expectedKey; break; } } if (match != null) { expectedKeys.Remove(match); } else { AstoriaTestLog.WriteLineIgnore("Unexpected URI: '" + link + "'"); AstoriaTestLog.FailAndThrow("Unexpected URI found in $ref payload"); } } } }
public void GetKeyExpression() { if (_resType.Name.Contains("Order_Details_Extended") || _resourceContainer.Name.Contains("Order_Details_Extended")) { this.Result = null; return; } if (_resType.Name != _resourceContainer.BaseType.Name) { KeyExpressions keyExp2 = _resourceContainer.Workspace.GetExistingAssociatedKeys(_resourceContainer, _prop, _key); if (null == keyExp2 || keyExp2.Count == 0) /* no keys for resource type*/ return { ; } foreach (KeyExpression ke in keyExp2) { bool bSpecial = SpecialChars(ke); if (bSpecial) { this.Result = null; break; } else { this.Result = ke; AstoriaTestLog.WriteLineIgnore("Predicate from container :" + _resType.Name); break; } } }
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); } UriQueryBuilder uriQueryBuilder = new UriQueryBuilder(this, this.ServiceUri); ExpNode query = Query.From( Exp.Variable(resourceContainer)) .Where(keyExpression) //.OfType(property.ResourceType) .Nav(new PropertyExpression(property)) .Select(); string uri = uriQueryBuilder.Build(query); ResourceType associatedResourceType = property.Type as ResourceType; if (property.Type is CollectionType) { associatedResourceType = (property.Type as CollectionType).SubType as ResourceType; } Type type = this._resourceTypeToWorkspaceTypeList[associatedResourceType]; MethodInfo method = this.GetType().GetMethod("ClientExecuteWrapper", new Type[] { typeof(string), typeof(ResourceContainer) }); MethodInfo genMethod = method.MakeGenericMethod(new Type[] { type }); IEnumerable o = (IEnumerable)genMethod.Invoke(this, new object[] { uri, resourceContainer.FindDefaultRelatedContainer(property) }); KeyExpressions keys = new KeyExpressions(); //IEnumerator enumerator = o.GetEnumerator(); foreach (object current in o) { if (current != null) { //Type t = enumerator.Current.GetType(); Type t = current.GetType(); IEnumerable <ResourceType> typesWithName = this.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, current)); } } if (pageSizeChanged) { this.DataService.ConfigSettings.SetEntitySetPageSize(resourceContainer.Name, originalPageSize); } return(keys); }
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)); }
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 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); }
public static ResourceInstanceProperty CreateCollectionInstanceProperty(KeyExpressions keyExps, ResourceContainer container, ResourceProperty navProperty) { ResourceType navResourceType = (navProperty.Type as CollectionType).SubType as ResourceType; List <AssociationResourceInstance> associationNodes = new List <AssociationResourceInstance>(); foreach (KeyExpression associatedKey in keyExps) { ResourceInstanceKey resourceInstanceKey = ResourceInstanceKey.ConstructResourceInstanceKey(associatedKey); associationNodes.Add(new AssociationResourceInstance(resourceInstanceKey, AssociationOperation.Add)); } if (associationNodes.Count > 0) { ResourceInstanceNavColProperty navigationProperty = new ResourceInstanceNavColProperty(navProperty.Name, associationNodes.ToArray()); return(navigationProperty); } return(null); }
public static KeyExpressions GetAllExistingKeys(Workspace w, ResourceContainer resourceContainer, ResourceType resourceType) { IEnumerable <ContainmentAttribute> attributes = GetContainmentAttributes(w.ServiceContainer, ca => ca.ChildContainer == resourceContainer); // should we pick one path at random? just use the first? determine which is shortest? ContainmentAttribute att = attributes.FirstOrDefault(); if (att == null) { QueryNode query = Query.From( Exp.Variable(resourceContainer)) .Select(); if (resourceType != null) { query = query.OfType(resourceType); } return(w.GetAllExistingKeys(query, resourceContainer)); } // recursively get all the parent container's keys // since we don't know the exact parent type, don't use one // KeyExpressions parentKeys = GetAllExistingKeys(w, att.ParentContainer, null); // we're doing some extra work by re-determining the parent key's access path, // but it would be hard to keep it around // KeyExpressions childKeys = new KeyExpressions(); foreach (KeyExpression parentKey in parentKeys) { // we don't necessarily need a canonical path QueryNode q = BuildQuery(parentKey, false); q = q.Nav(att.ParentNavigationProperty.Property()).Select(); if (resourceType != null) { q = q.OfType(resourceType); } foreach (KeyExpression childKey in w.GetAllExistingKeys(q, resourceContainer)) { childKeys.Add(childKey); } } return(childKeys); }
internal static ResourceInstanceKey CreateUniqueKey(ResourceContainer container, ResourceType resType, KeyExpressions relatedForeignKeys, KeyExpressions existingKeys) { KeyExpressions possibleRelatedForeignKeys = new KeyExpressions(); Workspace workspace = container.Workspace; int keysGenerated = 0; bool keyTrying = true; ResourceInstanceKey resourceInstanceKey = null; do { possibleRelatedForeignKeys = new KeyExpressions(); resourceInstanceKey = TryCreateUniqueResourceInstanceKey(container, resType, possibleRelatedForeignKeys); KeyExpression keyExpression = resourceInstanceKey.CreateKeyExpression(container, resType); // need to make sure its not a duplicate // if (existingKeys == null) { KeyedResourceInstance o = workspace.GetSingleResourceByKey(keyExpression); if (o == null) { keyTrying = false; } } else { keyTrying = existingKeys.Contains(keyExpression); } keysGenerated++; if (keysGenerated > 25) { throw new Microsoft.Test.ModuleCore.TestFailedException("Unable to create a unique key"); } }while (keyTrying); relatedForeignKeys.Add(possibleRelatedForeignKeys); return(resourceInstanceKey); }
public KeyExpressions Diff(KeyExpressions keyExpressions) { KeyExpressions diffKeyExpressions = new KeyExpressions(); foreach (KeyExpression keyExp in keyExpressions) { bool found = false; foreach (KeyExpression keyExp2 in this) { if (keyExp2.Equals(keyExp)) { found = true; break; } } if (found == false) { diffKeyExpressions.Add(keyExp); } } return(diffKeyExpressions); }
private static ResourceInstanceKey TryCreateUniqueResourceInstanceKey(ResourceContainer container, ResourceType resType, KeyExpressions relatedForeignKeys) { Workspace workspace = container.Workspace; List <ResourceInstanceSimpleProperty> keyProperties = new List <ResourceInstanceSimpleProperty>(); Dictionary <ResourceProperty, ResourceProperty> foreignKeyMap = resType.Key.Properties.OfType <ResourceProperty>() .Where(p => p.ForeignKeys.Any()) .ToDictionary(p => p, p => p.ForeignKeys.First().PrimaryKey.Properties.OfType <ResourceProperty>().First()); Dictionary <string, ResourceProperty> reverseForeignKeyMap = new Dictionary <string, ResourceProperty>(); foreach (KeyValuePair <ResourceProperty, ResourceProperty> pair in foreignKeyMap) { reverseForeignKeyMap[pair.Value.Name] = pair.Key; } Dictionary <ResourceProperty, object> propertyValues = new Dictionary <ResourceProperty, object>(); List <ResourceProperty> constrainedProperties = new List <ResourceProperty>(); foreach (ResourceProperty property in resType.Key.Properties.OfType <ResourceProperty>()) { if (foreignKeyMap.ContainsKey(property)) { constrainedProperties.Add(property); } else { NodeValue obj = (property.Type as PrimitiveType).CreateRandomValueForFacets(property.Facets); propertyValues[property] = obj.ClrValue; } } foreach (ResourceProperty currentProperty in constrainedProperties) { if (propertyValues.ContainsKey(currentProperty)) { continue; } ResourceProperty foreignProperty = foreignKeyMap[currentProperty]; ResourceContainer foreignContainer = container.FindDefaultRelatedContainer(foreignProperty.ResourceType); KeyExpression foreignKey = relatedForeignKeys.Where(k => k.ResourceContainer == foreignContainer).FirstOrDefault(); if (foreignKey == null) { KeyExpressions foreignKeys = workspace.GetAllExistingKeysOfType(foreignContainer, foreignProperty.ResourceType); while (foreignKey == null && foreignKeys.Any()) { foreignKey = foreignKeys.Choose(); // ensure that for every property in the key, it matches any local values for (int i = 0; i < foreignKey.Properties.Length; i++) { string keyPropertyName = foreignKey.Properties[i].Name; ResourceProperty localProperty; if (reverseForeignKeyMap.TryGetValue(keyPropertyName, out localProperty)) { object keyValue = foreignKey.Values[i].ClrValue; object localValue; if (propertyValues.TryGetValue(localProperty, out localValue)) { if (localValue != keyValue) { foreignKeys.Remove(foreignKey); foreignKey = null; break; } } } } } if (foreignKey == null) { AstoriaTestLog.FailAndThrow("Could not find an appropriate foreign key"); } relatedForeignKeys.Add(foreignKey); } for (int i = 0; i < foreignKey.Properties.Length; i++) { NodeProperty p = foreignKey.Properties[i]; if (p.Name == foreignProperty.Name) { propertyValues[currentProperty] = foreignKey.Values[i].ClrValue; } else if (p.ForeignKeys.Count() > 0) { string foreign = p.ForeignKeys.First().PrimaryKey.Properties.OfType <ResourceProperty>().First().Name; ResourceProperty localProperty; if (reverseForeignKeyMap.TryGetValue(foreign, out localProperty)) { propertyValues[localProperty] = foreignKey.Values[i].ClrValue; } } } } foreach (ResourceProperty property in resType.Key.Properties.OfType <ResourceProperty>()) { if (!propertyValues.ContainsKey(property)) { propertyValues[property] = (object)null; } } foreach (KeyValuePair <ResourceProperty, object> pair in propertyValues) { keyProperties.Add(new ResourceInstanceSimpleProperty(pair.Key.Facets, pair.Key.Name, pair.Value)); } ResourceInstanceKey resourceInstanceKey = new ResourceInstanceKey(container, resType, keyProperties.ToArray()); return(resourceInstanceKey); }
public KeyedResourceInstance CreateRandomResource(ResourceContainer container, KeyExpressions existingKeys) { return(CreateRandomResource(container, existingKeys, true)); }
public static KeyExpressions Except(this KeyExpressions keys, IEnumerable <KeyExpression> toOmit) { return(new KeyExpressions(keys.Where(k => !toOmit.Contains(k)))); }
internal KeyedResourceInstance CreateRandomResource(ResourceContainer container, KeyExpressions existingKeys, bool populateNavProps) { KeyExpressions relatedForeignKeys = new KeyExpressions(); ResourceInstanceKey key = ResourceInstanceUtil.CreateUniqueKey(container, this, relatedForeignKeys, existingKeys); List <ResourceInstanceProperty> properties = new List <ResourceInstanceProperty>(); // populate the non-key, non-navigation properties // foreach (ResourceProperty p in this.Properties.OfType <ResourceProperty>().Where(rp => rp.IsNavigation == false && rp.PrimaryKey == null)) { if (p.Facets.IsIdentity) { continue; } ResourceInstanceProperty property = p.CreateRandomResourceInstanceProperty(); properties.Add(property); } if (populateNavProps) { // populate the navigation properties, but don't go by key, as some foreign keys MAY NOT HAVE ASSOCIATED NAVIGATION PROPERTIES // foreach (ResourceProperty p in this.Properties.OfType <ResourceProperty>().Where(rp => rp.IsNavigation)) { // find a key for this navigation property KeyExpression navPropKey = null; foreach (KeyExpression keyExp in relatedForeignKeys) { //if (p.Type.Equals(keyExp.ResourceType) // || p.Type is ResourceType && (p.Type as ResourceType).BaseTypes.Contains(keyExp.ResourceType)) if (p.OtherAssociationEnd.ResourceType.Equals(keyExp.ResourceType)) { navPropKey = keyExp; break; } } ResourceContainer associatedContainer = container.FindDefaultRelatedContainer(p); if (navPropKey == null) { if (p.OtherAssociationEnd.ResourceType.Key.Properties.OfType <ResourceProperty>() .Where(rp => rp.ForeignKeys.Any()) .Any(rp => rp.ForeignKeys.First().PrimaryKey.Properties.OfType <ResourceProperty>().First().ResourceType.Equals(this))) { // this association has a fk back to the current type, so it cannot be based on any existing entity AstoriaTestLog.WriteLineIgnore("Skipping nav prop '{0}.{1}' due to foreign key constraint on entity being created", this.Name, p.Name); continue; } else { navPropKey = associatedContainer.Workspace.GetRandomExistingKey(associatedContainer, p.OtherAssociationEnd.ResourceType); } } if (navPropKey != null) { if (p.OtherAssociationEnd.Multiplicity == Multiplicity.Many) { properties.Add(ResourceInstanceUtil.CreateCollectionInstanceProperty(new KeyExpressions(navPropKey), navPropKey.ResourceContainer, p)); } else { properties.Add(ResourceInstanceUtil.CreateRefInstanceProperty(navPropKey, navPropKey.ResourceContainer, p)); } } } } return(ResourceInstanceUtil.CreateKeyedResourceInstance(key.CreateKeyExpression(container, this), container, properties.ToArray())); }
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 BuildDelete(Workspace workspace, KeyExpressions existingKeys, HttpStatusCode expectedStatusCode) { return(BuildDelete(workspace, existingKeys, expectedStatusCode, SerializationFormatKind.Default)); }
internal static ResourceInstanceKey CreateUniqueKey(ResourceContainer container, ResourceType resType, KeyExpressions relatedForeignKeys) { return(CreateUniqueKey(container, resType, relatedForeignKeys, null)); }