//Constructor
internal MemberExpression(ExpNode caller, PropertyInfo property, ExpNode[] args)
: base(property.Name)
{
_caller = caller;
_arguments = args;
_property = property;
}
public MemberBindExpression(ExpNode sourceProperty, TypedMemberExpression targetProperty)
: base("MemberBindExpression")
{
SourceProperty = sourceProperty;
TargetProperty = targetProperty;
//SourceProperty = new PropertyExpression(
}
//Overrides
public override Object Clone()
{
//TODO: Override in each derived exp class
ExpNode clone = (ExpNode)base.Clone();
return(clone);
}
//Constructor
internal MethodExpression(ExpNode caller, MethodInfo method, ExpNode[] args)
: base(method.Name)
{
_caller = caller;
_arguments = args;
_methodinfo = method;
}
public override string Build(ExpNode node)
{
string serviceName;
string queryUri = base.Build(node);
return(this.Workspace.ServiceUri + "/" + queryUri);
}
public ResourceProperty GetPropertyFromQuery()
{
if (!(Query_Internal is ProjectExpression))
{
return(null);
}
ProjectExpression projection = (ProjectExpression)Query_Internal;
if (!projection.Projections.Any())
{
return(null);
}
ExpNode node = projection.Projections.First;
if (node is NestedPropertyExpression)
{
return((node as NestedPropertyExpression).PropertyExpressions.Last().Property as ResourceProperty);
}
if (node is PropertyExpression)
{
return((node as PropertyExpression).Property as ResourceProperty);
}
return(null);
}
/// <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 void DirectedTests()
{
QueryModel model = new QueryModel(_workspace, SerializationFormatKind.Atom, null);
ModelEngine engine = new ModelEngine(model);
engine.Options.WeightScheme = WeightScheme.Custom;
engine.Options.Timeout = 100;
engine.RunUntil(delegate()
{
return(engine.Models.Actions.AllCovered);
});
//engine.RunScenario(model.Actions.Find("From", "Where", " Navigation","Select","Expand"));
//engine.RunUntil(delegate()
//{
// return model.Actions.Accessed > 4;
//});
_query = model.QueryResult;
_container = model.ResContainer;
_pType = model.ResultType;
if (_query != null || _pType != null)
{
VerifyClient(model);
}
}
public void VerifyServer(ExpNode q)
{
AstoriaTestLog.WriteLineIgnore("Verify server query");
try
{
UriQueryBuilder ub = new UriQueryBuilder(_workspace, "");
string ruri = ub.Build(q);
AstoriaTestLog.WriteLineIgnore(ruri);
AstoriaRequest request = _workspace.CreateRequest(q);
request.Format = _kind;
if (request.URI.Length > 260)
{
return;
}
AstoriaResponse response = request.GetResponse();
response.Verify();
}
catch (Exception e)
{
AstoriaTestLog.WriteLineIgnore(e.ToString());
}
}
//Constructor
public NewExpression(ExpNode input, params ExpNode[] arguments)
: base(input)
{
_target = input;
_arguments = new Nodes <ExpNode>(this, arguments);
//_type = target.Type;
}
public AstoriaRequest EntitySetTopLevel(ResourceContainer container)
{
ExpNode q = Query.From(
Exp.Variable(container))
.Select();
return(_workspace.CreateRequest(q));
}
protected void Visit(ExpNode caller, ExpNode node, XmlElement parentNode)
{
nodeStack.Push(node);
if (node == null)
{
throw new ArgumentNullException("node");
}
if (node is KeyedResourceInstance && (!(node is AssociationResourceInstance)))
{
KeyedResourceInstance e = (KeyedResourceInstance)node;
CreateEntryElement(e, parentNode);
}
else if (node is AssociationResourceInstance)
{
AssociationResourceInstance e = (AssociationResourceInstance)node;
if (caller == null)
{
CreateLinkPayload(e, parentNode);
}
else
{
CreateBinding(e, parentNode);
}
}
//Below are two special cases
else if (caller == null && node is ResourceInstanceSimpleProperty)
{
this.VisitResourceInstanceSimpleProperty(node as ResourceInstanceSimpleProperty, parentNode);
}
else if (caller == null && node is ResourceInstanceComplexProperty)
{
this.VisitResourceInstanceComplexProperty(node as ResourceInstanceComplexProperty, parentNode);
}
else if (caller == null && node is ResourceInstanceNavRefProperty)
{
ResourceInstanceNavRefProperty navRef = node as ResourceInstanceNavRefProperty;
AssociationResourceInstance associationResourceInstance = navRef.TreeNode as AssociationResourceInstance;
if (associationResourceInstance != null && associationResourceInstance.Operation == AssociationOperation.Remove)
{
this.CreateUnBinding(parentNode);
}
else
{
throw new Exception("Unknown node type:" + navRef.TreeNode.GetType());
}
}
else if (caller == null && node is ResourceInstanceCollection)
{
ResourceInstanceCollection collection = node as ResourceInstanceCollection;
CreateLinksElement(collection, null);
}
else
{
throw new Exception("Unknown node type: " + node.GetType());
}
nodeStack.Pop();
}
public AstoriaRequest SingleEntityKeyedTopLevel(ResourceContainer container, KeyExpression keyExp)
{
ExpNode q = Query.From(
Exp.Variable(container))
.Where(keyExp)
.Select();
return(_workspace.CreateRequest(q));
}
public AstoriaRequest SingleEntityKeyedNavProp(ResourceContainer container, KeyExpression keyExp, ResourceProperty property)
{
ExpNode q = Query.From(
Exp.Variable(container))
.Where(keyExp)
.Select(new PropertyExpression(property, false));
return(_workspace.CreateRequest(q));
}
public AstoriaRequest EntitySetNavProp(ResourceContainer container, KeyExpression keyExp, ResourceProperty property)
{
ExpNode q = Query.From(
Exp.Variable(container))
.Where(keyExp)
.Nav(property.Property());
return(_workspace.CreateRequest(q));
}
public AstoriaRequest PrimitivePropertyValue(ResourceContainer container, KeyExpression keyExp, ResourceProperty property)
{
ExpNode q = Query.From(
Exp.Variable(container))
.Where(keyExp)
.Select(new PropertyExpression(property, true));
return(_workspace.CreateRequest(q));
}
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 void ExecuteLinq(Workspace workspace, ExpNode q, ResourceContainer container)
{
try
{
ExecuteLinq(workspace, q, container, false, null);
}
catch (Exception e)
{
AstoriaTestLog.FailAndContinue(e);
}
}
public override KeyExpressions GetAllExistingKeys(ExpNode query, ResourceContainer resourceContainer)
{
if (DataGenerator.Done)
{
return(base.GetAllExistingKeys(query, resourceContainer));
}
else
{
return(DataGenerator.GetAllGeneratedKeys(resourceContainer, null));
}
}
public AstoriaRequest EntitySetTopLevelWithSingleExpand(ResourceContainer container, ResourceProperty property)
{
PropertyExpression[] expandValues = new PropertyExpression[] { new PropertyExpression(property) };
ExpNode q = Query.From(
Exp.Variable(container))
.Expand(expandValues)
.Select();
return(_workspace.CreateRequest(q));
}
public void Skip()
{
int i = NextSkipValue();
if (_query is OrderByExpression)
{
_query = ((OrderByExpression)_query).Skip(i) as SkipExpression;
}
bSkip = true;
_action = LastAction.Skip;
bIsOption = true;
AstoriaTestLog.WriteLineIgnore(".Skip(" + i.ToString() + ")");
}
public static MethodExpression Ceiling(this ExpNode arg)
{
System.Reflection.MethodInfo methodInfo;
if (arg.Type is ClrDecimal)
{
methodInfo = typeof(Math).GetMethod("Ceiling", new Type[] { typeof(System.Decimal) });
}
else
{
methodInfo = typeof(Math).GetMethod("Ceiling", new Type[] { typeof(System.Double) });
}
return(new MethodExpression(null, methodInfo, new ExpNode[] { arg }));
}
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 string BuildMemberOrMethodExpression(ExpNode node, ExpNode caller, ExpNode[] arguments, string name)
{
string instance = null;
string args = "";
string actualName = null;
if (caller != null)
{
instance = this.Visit(node, caller);
}
if (name.ToLowerInvariant() == "contains")
{
actualName = "contains";
args = this.Visit(node, arguments[0]);
return(string.Format("{0}({1},{2})", actualName, instance, args));
}
else
{
actualName = name.ToLowerInvariant();
if (arguments != null && arguments.Length > 0)
{
for (int i = 0; i < arguments.Length; i++)
{
args += this.Visit(node, arguments[i]) + ", ";
}
args = args.Substring(0, args.Length - 2);
if (instance == null)
{
return(string.Format("{0}({1})", actualName, args));
}
else
{
return(string.Format("{0}({1},{2})", actualName, instance, args));
}
}
else
{
return(string.Format("{0}({1})", actualName, instance));
}
}
}
public void Sort(bool bAsc)
{
//Sub model - sort
SortModel model = new SortModel(this._workspace, _fromContainer.BaseType);
ModelEngine engine = new ModelEngine(this.Engine, model);
engine.Run();
PropertyExpression[] ordervalues = model.SortResult;
if (_query is TopExpression)
{
_query = ((TopExpression)_query).Sort(ordervalues, bAsc) as OrderByExpression;
}
else if (_query is SkipExpression)
{
_query = ((SkipExpression)_query).Sort(ordervalues, bAsc) as OrderByExpression;
}
else if (_query is CountExpression)
{
_query = ((CountExpression)_query).Sort(ordervalues, bAsc) as OrderByExpression;
}
else if (_query is ExpandExpression)
{
_query = ((ExpandExpression)_query).Sort(ordervalues, bAsc) as OrderByExpression;
}
else if (_query is NavigationExpression)
{
_query = ((NavigationExpression)_query).Sort(ordervalues, bAsc) as OrderByExpression;
}
else if (_query is PredicateExpression)
{
_query = ((PredicateExpression)_query).Sort(ordervalues, bAsc) as OrderByExpression;
}
else if (_query is ScanExpression)
{
_query = ((ScanExpression)_query).Sort(ordervalues, bAsc) as OrderByExpression;
}
bSort = true;
_action = LastAction.OrderBy;
bIsOption = true;
AstoriaTestLog.WriteLineIgnore(".OrderBy(" + ordervalues.ToString() + ")");
}
public static void VerifyLinq(Workspace workspace, ExpNode q, IQueryable results)
{
//verify if the results are ok before building the URI
System.Collections.ArrayList list = new System.Collections.ArrayList();
foreach (object element in results)
{
list.Add(element);
}
//UriQueryBuilder ub = new UriQueryBuilder(workspace, "");
// string ruri = ub.Build(q);
//System.Uri uri = new Uri(workspace.ServiceUri);
// string uriRel = ruri.Substring(ruri.IndexOf("/") + 1);
// AstoriaTestLog.WriteLineIgnore(uri.ToString() + uriRel);
AstoriaRequest request = workspace.CreateRequest(q);
request.Format = SerializationFormatKind.Atom;
try
{
AstoriaResponse response = request.GetResponse();
//response.VerifyHttpStatusCodeOk(response.StatusCode);
CommonPayload payload = response.CommonPayload;
if (payload.Value != null)
{
payload.CompareValue(results, false, false);
}
else
{
payload.Compare(results);
}
//AstoriaTestLog.AreEqual(response.ContentType, SerializationFormatKinds.ContentTypeFromKind(response.OriginalRequest.SerializationKind),
//"Content-Type does not match Accept header request");
}
catch (Exception e)
{
AstoriaTestLog.FailAndContinue(e);
}
}
public void Navigation()
{
bool bfound = false;
int j = 0;
ResourceType _navType = null;
while (!bfound && j < from.Properties.Count)
{
int i = this.Engine.Options.Random.Next(0, from.Properties.Count);
ResourceProperty _property = (ResourceProperty)from.Properties[i];
if (_property.IsNavigation && _property.Type is CollectionType && this.ResContainer.BaseType.Properties.Contains(_property))
{
if (_query is PredicateExpression)
{
_query = ((PredicateExpression)_query).Nav(_property.Property()) as NavigationExpression;
if (_property.Type is CollectionType)
{
_navType = (ResourceType)((ResourceCollection)_property.Type).SubType;
_pType = _navType.ClientClrType;
}
else if (_property.Type is ResourceType)
{
_navType = (ResourceType)_property.Type;
_pType = _property.Type.ClrType;
}
this.ResType = _navType;
bNav = true;
bfound = true;
_action = LastAction.Nav;
property = _property;
this.ResType = _navType; //update the resourceType
AstoriaTestLog.WriteLineIgnore(".Nav(" + _property.Property().Name + ")");
IsKey = false;
}
}
j++;
}
}
public static void ExecuteLinq(Workspace workspace, ExpNode q, ResourceContainer container, bool bSingle, ExpNode altq)
{
System.Uri uri = new Uri(workspace.ServiceUri);
WebDataCtxWrapper ctx = new WebDataCtxWrapper(uri);
ctx.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
ctx.MergeOption = MergeOption.NoTracking;
Type resType = container.BaseType.ClientClrType;
ResolveClientType(workspace, ctx, resType);
Type cType = typeof(WebDataCtxWrapper);
MethodInfo mi = cType.GetMethod("CreateQuery", new Type[] { typeof(string) });
Type pType = container.BaseType.ClientClrType;
MethodInfo miConstructed = mi.MakeGenericMethod(pType);
string uri2 = container.Name;
AstoriaTestLog.WriteLineIgnore(workspace.ServiceUri + "/" + uri2);
object[] args = { uri2 };
object query = miConstructed.Invoke(ctx, args);
LinqQueryBuilder lb = new LinqQueryBuilder(workspace, (IQueryable)query);
string uri3 = lb.Build(q);
AstoriaTestLog.WriteLineIgnore("Linq expression: " + lb.QueryExpression);
//if (bSingle)
//{
// var single = lb.QueryResultSingle;
// VerifyLinqSingle(workspace, altq, single, container);
//}
//else
//{
var queryable = lb.QueryResult;
VerifyLinq(workspace, q, (IQueryable)queryable);
//}
}
public void Count()
{
if (_query is TopExpression)
{
_query = ((TopExpression)_query).Count(true) as CountExpression;
}
else if (_query is OrderByExpression)
{
_query = ((OrderByExpression)_query).Count(true) as CountExpression;
}
else if (_query is ScanExpression)
{
_query = ((ScanExpression)_query).Count(true) as CountExpression;
}
else if (_query is NavigationExpression)
{
_query = ((NavigationExpression)_query).Count(true) as CountExpression;
}
else if (_query is SkipExpression)
{
_query = ((SkipExpression)_query).Count(true) as CountExpression;
}
else if (_query is NavigationExpression)
{
_query = ((NavigationExpression)_query).Count(true) as CountExpression;
}
else if (_query is ExpandExpression)
{
_query = ((ExpandExpression)_query).Count(true) as CountExpression;
}
else if (_query is PredicateExpression)
{
_query = ((PredicateExpression)_query).Count(true) as CountExpression;
}
IsCount = true;
_action = LastAction.Count;
bIsOption = true;
AstoriaTestLog.WriteLineIgnore(".Count");
}
public void Top()
{
int i = NextTopValue();
if (_query is OrderByExpression)
{
_query = ((OrderByExpression)_query).Top(i) as TopExpression;
}
else if (_query is CountExpression)
{
_query = ((CountExpression)_query).Top(i) as TopExpression;
}
else if (_query is ExpandExpression)
{
_query = ((ExpandExpression)_query).Top(i) as TopExpression;
}
else if (_query is NavigationExpression)
{
_query = ((NavigationExpression)_query).Top(i) as TopExpression;
}
else if (_query is SkipExpression)
{
_query = ((SkipExpression)_query).Top(i) as TopExpression;
}
else if (_query is PredicateExpression)
{
_query = ((PredicateExpression)_query).Top(i) as TopExpression;
}
else if (_query is ScanExpression)
{
_query = ((ScanExpression)_query).Top(i) as TopExpression;
}
iTop = i;
bTop = true;
_action = LastAction.Top;
bIsOption = true;
AstoriaTestLog.WriteLineIgnore(".Top(" + i.ToString() + ")");
}
