public AstoriaServiceHost(Workspace workspace, string webDataServicePrefixName, string machineName, AstoriaDatabase database) : base(workspace, webDataServicePrefixName, machineName, database) { if (AstoriaTestProperties.Host == Host.IDSH || AstoriaTestProperties.Host == Host.IDSH2) { if (AstoriaTestProperties.HostAuthenicationMethod != "None") { AstoriaTestLog.FailAndThrow("Test implementations of IDSH do not support authentication"); } } waitHandleName = waitHandlePrefix + identifier; serviceInstanceName = this.WebDataServicePrefixName + "_" + identifier; exeName = serviceName + this.WebDataServicePrefixName; if (ProcessHelper.IsLocalMachine(this.MachineName)) { DestinationFolder = Path.Combine(serviceHostFolder, serviceInstanceName); DestinationFolder_Local = DestinationFolder; ExecutablePath = Path.Combine(DestinationFolder, exeName + ".exe"); localExecutablePath = ExecutablePath; } else { string remoteMachineLocalPath = IISHelper.GetLocalMachineWWWRootSharePath(this.MachineName); DestinationFolder_Local = Path.Combine(IISHelper.GetLocalMachineWWWRootSharePath(this.MachineName), serviceInstanceName); DestinationFolder = Path.Combine(IISHelper.GetWWWRootSharePath(this.MachineName), serviceInstanceName); ExecutablePath = Path.Combine(DestinationFolder, exeName + ".exe"); localExecutablePath = Path.Combine(DestinationFolder_Local, exeName + ".exe"); } rootUri = Uri.UriSchemeHttp + "://" + this.MachineName + ":7777"; }
public void VerifyClient(QueryModel qm) { WebDataCtxWrapper ctx = new WebDataCtxWrapper(new Uri(qm.Workspace.ServiceUri)); ctx.Credentials = CredentialCache.DefaultNetworkCredentials; try { UriQueryBuilder ub = new UriQueryBuilder(qm.Workspace, ""); string ruri = ub.Build(qm.QueryResult); string uriRel = ruri.Substring(ruri.LastIndexOf(".svc/") + 5); if ((ctx.BaseUri + "/" + uriRel).Length > 260) { return; } AstoriaTestLog.WriteLineIgnore(ctx.BaseUri + "/" + uriRel); ResolveClientType(qm.Workspace, ctx, qm.ResultType); object enumerable = ExecuteQuery(ctx, qm.ResultType, uriRel, "sync"); Verify(qm.Workspace, qm.QueryResult, (IEnumerable)enumerable, qm.ResType, null, qm.IsCount); } catch (Exception e) { AstoriaTestLog.FailAndContinue(e); } }
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; } } }
private void VerifyLoadProperty(object entity, string propertyName, WebDataCtxWrapper Context) { Uri entityUri = null; if (Context.TryGetUri(entity, out entityUri)) { Uri navigationPropertyURI = new Uri(String.Format("{0}/{1}", entityUri.OriginalString, propertyName));; Type navPropType = entity.GetType().GetProperty(propertyName).PropertyType; if (navPropType.IsGenericType) { navPropType = navPropType.GetGenericArguments()[0]; } WebDataCtxWrapper baselineCOntext = new WebDataCtxWrapper(Context.BaseUri); baselineCOntext.Credentials = CredentialCache.DefaultCredentials; QueryOperationResponse qoResponse = baselineCOntext.ExecuteOfT(navPropType, navigationPropertyURI) as QueryOperationResponse; IEnumerator enumerator = qoResponse.GetEnumerator(); while (enumerator.MoveNext()) { object baselineEntity = enumerator.Current; Uri navPropEntityURI = null; if (baselineCOntext.TryGetUri(baselineEntity, out navPropEntityURI)) { AstoriaTestLog.IsNotNull(Context.TryGetEntityOfT(navPropType, navPropEntityURI), "Could not find entity in Navigation property "); } } } }
internal static object GetSingleValueFromIQueryable(IQueryable querable, bool throwOnError) { object val = null; IEnumerator enumerator = querable.GetEnumerator(); bool moved = enumerator.MoveNext(); if (!moved && throwOnError) { throw new TestFailedException("Expected to find one result but none exist in Iqueryable"); } else if (!moved && !throwOnError) { AstoriaTestLog.WriteLine("Error occured, cannot find a result in IQueryable"); AstoriaTestLog.FailureFound = true; } else { val = enumerator.Current; } moved = enumerator.MoveNext(); if (moved && throwOnError) { throw new TestFailedException("Expected to find one result but found 2 exist in Iqueryable"); } else if (moved && !throwOnError) { AstoriaTestLog.WriteLine("Expected to find one result but found 2 exist in Iqueryable"); AstoriaTestLog.FailureFound = true; } return(val); }
protected override void VerifyEntry(XmlNode entry) { //TODO: Astoria always returns type="application/xml" so this section is incomplete wrt spec and assunes xml content XmlNodeList contentNodes = entry.SelectNodes("atom:content", this.FormatVerifier.XmlNamespaceManager); if (contentNodes.Count != 1) { AstoriaTestLog.FailAndContinue(new TestFailedException("4.1.3 Content element: is missing")); } else { XmlNode contentNode = contentNodes[0]; bool srcFound = contentNode.Attributes["src"] != null; if (contentNode.Attributes["type"] != null && contentNode.Attributes["type"].Value != "application/xml") { AstoriaTestLog.FailAndContinue(new TestFailedException("4.1.3 Content element: type is not 'application/xml' (only supported value in v1 astoria)")); } if (contentNode.ChildNodes.Count != 1 && !srcFound) { AstoriaTestLog.FailAndContinue(new TestFailedException("4.1.3.3 Content element: More than node found for conent root node.")); } } }
protected override void VerifyEntry(XmlNode entry) { XmlNodeList categoryNodes = entry.SelectNodes("atom:category", this.FormatVerifier.XmlNamespaceManager); foreach (XmlNode categoryNode in categoryNodes) { XmlAttribute termAttrib = categoryNode.Attributes["term"]; if (termAttrib == null) { AstoriaTestLog.FailAndContinue(new TestFailedException("No term attribute found for Category node")); } /*else * { * bool typeFound = false; * foreach (NodeType nodeType in _formatVerifier.Request.Workspace.Types.Where(t => t.ClrType.FullName == termAttrib.Value)) * { * typeFound = true; * break; * } * * if( !typeFound ) * AstoriaTestLog.FailAndContinue(new TestFailedException("term attribute value (" + termAttrib.Value + ")is not valid type")); * }*/ } }
public static void VerifyConcurrency(AstoriaResponse response) { if (response.Request.ETagHeaderExpected) { if (!response.ETagHeaderFound && !RequestUtil.ExpectEmptyHeaders(response)) { AstoriaTestLog.FailAndThrow("Missing ETag header in response"); } } else if (response.ETagHeaderFound) { if (string.IsNullOrEmpty(response.ETagHeader)) { if (Versioning.Server.BugFixed_NullETagWhenTypeHasNoConcurrency) { AstoriaTestLog.FailAndThrow("Unexpected null ETag header in response"); } else { AstoriaTestLog.WriteLine("Ignoring unexpected null ETag header in response due to known bug"); } } else { AstoriaTestLog.FailAndThrow("Unexpected ETag header in response: '" + response.ETagHeader + "'"); } } }
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 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()); } }
public void Verify(string payload) { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(payload); XmlNode authorNode = xmlDocument.SelectNodes("atom:author", _formatVerifier.XmlNamespaceManager)[0]; // atom:author elements MUST contain exactly one atom:name element. XmlNodeList childNodes = authorNode.SelectNodes("atom:name", _formatVerifier.XmlNamespaceManager); if (childNodes.Count != 1) { AstoriaTestLog.FailAndContinue(new TestFailedException("3.2.1 atomPersonConstruct element: Not exactly 1 name node found for atomPersonConstruct.")); } // atom:author elements MAY contain exactly one atom:uri element. childNodes = authorNode.SelectNodes("atom:uri", _formatVerifier.XmlNamespaceManager); if (childNodes.Count > 1) { AstoriaTestLog.FailAndContinue(new TestFailedException("3.2.1 atomPersonConstruct element: Greater than 1 uri node found for atomPersonConstruct.")); } // atom:author elements MAY contain exactly one atom:email element. childNodes = authorNode.SelectNodes("atom:email", _formatVerifier.XmlNamespaceManager); if (childNodes.Count > 1) { AstoriaTestLog.FailAndContinue(new TestFailedException("3.2.1 atomPersonConstruct element: Greater than 1 email node found for atomPersonConstruct.")); } }
protected override void Verify() { if (!Applies(Response)) { return; } AstoriaRequest request = Response.Request; if (!request.SnapshotForUpdate) { return; } try { Verify(request); } catch (Exception e) { AstoriaTestLog.WriteLineIgnore("Pre-update snapshot:"); AstoriaTestLog.WriteLineIgnore(request.BeforeUpdatePayload.RawPayload); AstoriaTestLog.WriteLineIgnore("--------------------"); AstoriaTestLog.WriteLineIgnore("Post-update snapshot:"); AstoriaTestLog.WriteLineIgnore(request.AfterUpdatePayload.RawPayload); throw new TestFailedException("Update verification failed", null, null, e); } }
private static void CompareEdmType(IEdmType edmEdmType, IEdmType dataWebEdmType, bool isReflectionBasedProvider, out int numberOfNavProps) { if (edmEdmType == null) { throw new ArgumentNullException("edmEdmType"); } if (dataWebEdmType == null) { throw new ArgumentNullException("dataWebEdmType"); } AstoriaTestLog.IsTrue(edmEdmType.TypeKind == EdmTypeKind.Entity || edmEdmType.TypeKind == EdmTypeKind.Complex, "Only structural type expected - " + edmEdmType.TypeKind.ToString()); AstoriaTestLog.IsTrue(edmEdmType.TypeKind == dataWebEdmType.TypeKind, "BuiltInTypeKind must be the name"); if (edmEdmType.TypeKind == EdmTypeKind.Entity) { List <IEdmStructuralProperty> edmKeyMembers = ((IEdmEntityType)edmEdmType).Key().ToList(); List <IEdmStructuralProperty> dataWebKeyMembers = ((IEdmEntityType)dataWebEdmType).Key().ToList(); AstoriaTestLog.IsTrue(edmKeyMembers.Count == dataWebKeyMembers.Count, "Key members count must match"); foreach (IEdmStructuralProperty member1 in edmKeyMembers) { // make sure the member with the same name in the key members list // Other comparisions will be done in the member comparison AstoriaTestLog.IsTrue(dataWebKeyMembers.Any(p => p.Name == member1.Name)); } } CompareMembers((IEdmStructuredType)edmEdmType, (IEdmStructuredType)dataWebEdmType, isReflectionBasedProvider, out numberOfNavProps); }
//--------------------------------------------------------------------- // Replaces existing method code with that from embedded resources. //--------------------------------------------------------------------- protected string ReplaceCode(string existingCode, string methodRegex, string resourceName) { // Find embedded resource. foreach (string fullName in GetType().Assembly.GetManifestResourceNames()) { if (fullName.Contains(resourceName)) { // Replace type resolver. using (StreamReader reader = new StreamReader(GetType().Assembly.GetManifestResourceStream(fullName), true)) { // Read new code from resources. string newCode = reader.ReadToEnd(); // Find method signature in existing code and replace Regex method = new Regex(methodRegex, RegexOptions.Singleline); if (method.Match(existingCode).Success) { return(method.Replace(existingCode, newCode)); } AstoriaTestLog.FailAndThrow("Test error: unable to match " + methodRegex + " in embedded code: " + existingCode); return(null); } } } AstoriaTestLog.FailAndThrow("Test error: unable to find embedded resource: " + existingCode); return(null); }
internal static Workspaces GetWorkspacesFilteredByTestProperties(Action <Workspace> beforeWorkspaceCreate) { if (_workspaceCreationFailed) { throw new TestFailedException("Workspaces failed on creation previously"); } if (_filteredWorkspaces == null) { try { _filteredWorkspaces = CreateFilteredWorkspaces(AstoriaTestProperties.DataLayerProviderKinds, AstoriaTestProperties.MaxPriority, true, beforeWorkspaceCreate); } catch (System.Reflection.ReflectionTypeLoadException typeloadException) { _workspaceCreationFailed = true; AstoriaTestLog.WriteLine("LoaderExceptions:"); foreach (Exception exc in typeloadException.LoaderExceptions) { AstoriaTestLog.FailAndContinue(exc); } throw typeloadException; } catch (Exception exc) { _workspaceCreationFailed = true; throw; } } return(_filteredWorkspaces); }
private static void CompareMembers(IEdmStructuredType edmEdmType, IEdmStructuredType dataWebEdmType, bool isReflectionBasedProvider, out int totalNavProps) { // find the number of nav properties on this type (not the base type). This will help us to determine how many associations // be generated totalNavProps = edmEdmType.DeclaredProperties.OfType <IEdmNavigationProperty>().Count(); AstoriaTestLog.IsTrue(edmEdmType.DeclaredProperties.Count() == dataWebEdmType.DeclaredProperties.Count(), "Number of members must match"); foreach (IEdmProperty member1 in edmEdmType.DeclaredProperties) { IEdmProperty member2 = dataWebEdmType.FindProperty(member1.Name); AstoriaTestLog.IsNotNull(member2); // WCF DS server will always write DateTimeOffset as the data type, if the backend model has DateTime as the data type string edmMemberTypeName = member1.Type.FullName(); if (edmMemberTypeName == "Edm.DateTime") { AstoriaTestLog.IsTrue(member2.Type.FullName() == "Edm.DateTimeOffset", "For DateTime properties in the model, we should generate"); } else { AstoriaTestLog.IsTrue(edmMemberTypeName == member2.Type.FullName(), "Type must match"); } AstoriaTestLog.IsTrue(member1.Type.IsNullable == member2.Type.IsNullable, "nullability must match"); // TODO: if its a navigation, compare referential constraint! } }
//--------------------------------------------------------------------- // Adds code from embedded resources to data service source file. //--------------------------------------------------------------------- protected void InjectCode(Workspace w, params string[] resourceNames) { foreach (string resourceName in resourceNames) { // Find embedded resource. bool found = false; foreach (string fullName in GetType().Assembly.GetManifestResourceNames()) { if (fullName.Contains(resourceName)) { // Append contents to service code. using (StreamReader reader = new StreamReader(GetType().Assembly.GetManifestResourceStream(fullName), true)) { w.GlobalAdditionalCode += reader.ReadToEnd(); found = true; break; } } } if (!found) { AstoriaTestLog.FailAndThrow("Test error: embedded resource not found!"); } } }
public void LogResponse() { StringBuilder builder = new StringBuilder(); LogResponse(builder, true, false); AstoriaTestLog.WriteIgnore(builder.ToString()); }
// Print out the WCF configuration option values if different from default setting public void LogConfigSetting() { if (!_TransferMode.Equals("Buffered") || _MaxBufferSize != 2147483647 || _MaxReceivedMessageSize != 2147483647 || _MaxRequestLength != 2097151 || !_TransportSecurityMode.Equals("TransportCredentialOnly") || !_CloseTimeout.Equals("00:01:00") || !_OpenTimeout.Equals("00:01:00") || !_ReceiveTimeout.Equals("00:10:00") || !_SendTimeout.Equals("00:01:00") || !_AspNetCompatibilityEnabled) { AstoriaTestLog.WriteLineIgnore("WCF Configuration Settings:"); AstoriaTestLog.WriteLineIgnore("_TransferMode: " + _TransferMode); AstoriaTestLog.WriteLineIgnore("_MaxBufferSize: " + _MaxBufferSize); AstoriaTestLog.WriteLineIgnore("_MaxReceivedMessageSize: " + _MaxReceivedMessageSize); AstoriaTestLog.WriteLineIgnore("_MaxRequestLength: " + _MaxRequestLength); AstoriaTestLog.WriteLineIgnore("_TransportSecurityMode: " + _TransportSecurityMode); AstoriaTestLog.WriteLineIgnore("_CloseTimeout: " + _CloseTimeout); AstoriaTestLog.WriteLineIgnore("_OpenTimeout: " + _OpenTimeout); AstoriaTestLog.WriteLineIgnore("_ReceiveTimeout: " + _ReceiveTimeout); AstoriaTestLog.WriteLineIgnore("_SendTimeout: " + _SendTimeout); AstoriaTestLog.WriteLineIgnore("_AspNetCompatibilityEnabled: " + _AspNetCompatibilityEnabled); } }
public virtual void CompareSingleValue(object expected, bool stripQuotes, bool valueUri) { if (this.Resources == null && expected == null) { return; } PayloadSimpleProperty simpleProperty = this.Resources as PayloadSimpleProperty; if (simpleProperty == null) { AstoriaTestLog.FailAndThrow("Payload did not represent a single value"); } if (expected == null) { if (!simpleProperty.IsNull) { AstoriaTestLog.FailAndContinue(new TestFailedException("Compare failed - Expected: null, got: " + simpleProperty.Value)); } } else { ComparePrimitiveValuesObjectAndString(expected, expected.GetType(), simpleProperty.Value, valueUri, this.Format, false); } }
// Turns a resource type into an MLE. private static void MakeMLE(Workspace w, string typeName) { // Add blob attribute. ResourceType type = w.ServiceContainer.ResourceTypes.Where(p => p.Name == typeName).First(); type.Facets.Add(NodeFacet.Attribute(new BlobsAttribute(type))); AstoriaTestLog.WriteLineIgnore("MLE type: " + type.Name); }
public void LogRequest() { StringBuilder builder = new StringBuilder(); LogRequest(builder, !Workspace.Settings.SuppressTrivialLogging); AstoriaTestLog.WriteIgnore(builder.ToString()); }
private void VerifyInsertResponse(ResourceType type, PayloadObject inserted, PayloadObject returned) { // need to 'follow' deferred links to ensure that they're correct // doesn't need to match exactly AstoriaTestLog.AreEqual(inserted.Type, returned.Type, "Types do not match"); VerifyProperties(type, inserted, returned, true, (rp => !rp.Facets.ServerGenerated)); }
/// <summary> /// Constructs a new CodeGeneratingDataInserter for the given workspace /// </summary> /// <param name="w">the worspace to add data to</param> public CodeGeneratingDataInserter(Workspace w) { if (w.DataLayerProviderKind != DataLayerProviderKind.InMemoryLinq && w.DataLayerProviderKind != DataLayerProviderKind.NonClr) { AstoriaTestLog.FailAndThrow("CodeGeneratingDataInserter only supported for InMemory and NonClr workspaces"); } workspace = w; }
//--------------------------------------------------------------------- // Sends and verifies request for all possible access rights. //--------------------------------------------------------------------- public void TestAccess(string container) { // Save current state. HttpStatusCode normalStatusCode = ExpectedStatusCode; #if !ClientSKUFramework for (uint i = 0; i <= (uint)Microsoft.OData.Service.EntitySetRights.All; i++) { // Set entity set access right. Workspace.DataService.ConfigSettings.SetEntitySetAccessRule(container, (Microsoft.OData.Service.EntitySetRights)i); // Calculate minimum access needed for request to succeed. Microsoft.OData.Service.EntitySetRights minAccess = Microsoft.OData.Service.EntitySetRights.All; switch (Verb) { case RequestVerb.Post: minAccess = Microsoft.OData.Service.EntitySetRights.WriteAppend; break; case RequestVerb.Get: minAccess = Microsoft.OData.Service.EntitySetRights.ReadSingle; break; case RequestVerb.Put: minAccess = Microsoft.OData.Service.EntitySetRights.WriteReplace | Microsoft.OData.Service.EntitySetRights.ReadSingle; break; case RequestVerb.Patch: minAccess = Microsoft.OData.Service.EntitySetRights.WriteMerge | Microsoft.OData.Service.EntitySetRights.ReadSingle; break; case RequestVerb.Delete: minAccess = Microsoft.OData.Service.EntitySetRights.WriteDelete | Microsoft.OData.Service.EntitySetRights.ReadSingle; break; default: AstoriaTestLog.FailAndThrow("Test issue - unknown request verb (2)"); break; } // Calculate expected status code. ExpectedStatusCode = i == 0 ? HttpStatusCode.NotFound : (i & (uint)minAccess) == (uint)minAccess ? normalStatusCode : HttpStatusCode.Forbidden; // Send and verify request. AstoriaResponse response = SendAndVerify(null); // Delete the entity if it was created to avoid "key already exists" collisions. if (response.Headers.ContainsKey("Location")) { string newEntity = response.Headers["Location"]; Workspace.DataService.ConfigSettings.SetEntitySetAccessRule(container, Microsoft.OData.Service.EntitySetRights.WriteDelete | Microsoft.OData.Service.EntitySetRights.ReadSingle); BlobsRequest.MLE(Workspace, Format, RequestVerb.Delete, null, HttpStatusCode.NoContent, newEntity).SendAndVerify(null); } } #endif // Restore previous state. ExpectedStatusCode = normalStatusCode; #if !ClientSKUFramework Workspace.DataService.ConfigSettings.SetEntitySetAccessRule(container, Microsoft.OData.Service.EntitySetRights.All); #endif }
public static T Execute <T>(Func <T> f, bool inWebRequest, out System.Net.WebException exc) { exc = null; for (int i = 0; i < SocketExceptionRetries; i++) { try { exc = null; return(TrustedMethods.ReturnFuncResult <T>(f)); } catch (WebException ex) { exc = ex; if (ex.InnerException is SocketException) { HandleSocketException(inWebRequest, (SocketException)exc.InnerException); } else { if (inWebRequest) { return(default(T)); // it will handle this } if (ex.Status == WebExceptionStatus.Timeout && CatchTimeouts) { HandleWebRequestTimeout(inWebRequest, ex); } else { throw ex; } } } catch (Exception ex) { if (ex.InnerException == null || !(ex.InnerException is System.Net.WebException)) { throw ex; } exc = (WebException)ex.InnerException; if (exc.InnerException != null && (exc.InnerException is SocketException)) { HandleSocketException(inWebRequest, (SocketException)exc.InnerException); } else if (exc.Status == WebExceptionStatus.Timeout && CatchTimeouts) { HandleWebRequestTimeout(inWebRequest, exc); } else { throw ex; } } } AstoriaTestLog.FailAndThrow("Repeated socket exceptions encountered, consequences unpredictable."); return(default(T)); }
private void VerifyQueryResponse(ResourceType type, PayloadObject fromInsert, PayloadObject fromQuery) { bool keyShouldMatch = true; if (type.Key.Properties.Any(p => p.Facets.FixedLength)) { foreach (NodeProperty property in type.Key.Properties.Where(p => p.Facets.FixedLength)) { // this may not always be correct for all types, but it seems to work most of the time; int length; if (property.Facets.MaxSize.HasValue) { length = property.Facets.MaxSize.Value; } else if (property.Type == Clr.Types.Decimal) { length = property.Facets.Precision.Value + property.Facets.Scale.Value; } else { continue; } string value = null; if (fromInsert.PayloadProperties.Any(p => p.Name == property.Name)) { value = (fromInsert[property.Name] as PayloadSimpleProperty).Value; } else { value = fromInsert.CustomEpmMappedProperties[property.Name]; } if (value != null && value.Length < length) { keyShouldMatch = false; } } } if (keyShouldMatch) { AstoriaTestLog.AreEqual(fromInsert.AbsoluteUri, fromQuery.AbsoluteUri, "fromInsert.AbsoluteUri != fromQuery.AbsoluteUri", false); } else { AstoriaTestLog.IsFalse(fromInsert.AbsoluteUri == fromQuery.AbsoluteUri, "fromInsert.AbsoluteUri == fromQuery.AbsoluteUri, despite fixed-length string"); } // leave it to the concurrency tests to check the more involved etags if (!type.Properties.Any(p => p.Facets.ConcurrencyModeFixed && p.Facets.FixedLength)) { AstoriaTestLog.AreEqual(fromInsert.ETag, fromQuery.ETag, "fromInsert.ETag != fromQuery.ETag", false); } VerifyProperties(type, fromInsert, fromQuery, false, rp => true); }
public static void Verify(APICallLogBuilder callLogBuilder, AstoriaResponse response, params ComplexType[] types) { if (!response.Request.LogAPICalls) { AstoriaTestLog.FailAndThrow("Cannot verify call order when the request did not log the calls"); } Verify(callLogBuilder, response, Equal, types); }
public static BatchResponse ParseBatchResponse(BatchRequest batchRequest, StringReader reader, string boundary) { // even if content-id is specified, we may not get it back in error cases. This doesn't feel entirely correct, it seems like there should // always be a 1-1 mapping that explicitly honors content-id's // TODO: responses / requests without content IDs should be matched up in order within changeset only // changesets should have the right number of responses too BatchResponse response = null;// new BatchResponse(batchRequest); List <ResponseFragment> unmatchedFragments = new List <ResponseFragment>(); List <AstoriaRequest> unmatchedRequests = batchRequest.Requests .Union(batchRequest.Changesets.SelectMany(changeset => changeset.AsEnumerable())) .ToList(); foreach (ResponseFragment fragment in ParseBatchResponse(reader, boundary)) { AstoriaRequest request = null; if (fragment.ContentID != null) { request = unmatchedRequests .FirstOrDefault(r => r.Headers.ContainsKey("Content-ID") && r.Headers["Content-ID"].Equals(fragment.ContentID)); } if (request == null) { unmatchedFragments.Add(fragment); } else { unmatchedRequests.Remove(request); response.Responses.Add(FragmentToResponse(request, fragment)); } } if (unmatchedFragments.Any()) { if (unmatchedFragments.Count < unmatchedRequests.Count) { AstoriaTestLog.WriteLine("Warning: recieved fewer batch response fragments than expected"); } else if (unmatchedFragments.Count > unmatchedRequests.Count) { AstoriaTestLog.FailAndThrow("Recieved more batch fragments than expected"); } for (int i = 0; i < unmatchedFragments.Count; i++) { response.Responses.Add(FragmentToResponse(unmatchedRequests[i], unmatchedFragments[i])); } } return(response); }
public static void VerifySpecificResponseVersion(AstoriaResponse response, int major, int minor) { if (response.DataServiceVersion == null) { AstoriaTestLog.FailAndThrow("Data service version should always be specified in response"); } AstoriaTestLog.IsTrue(response.DataServiceVersion.StartsWith(major + "." + minor), String.Format("Unexpected value in response's DataServiceVersion header: {0}, expected: {1}.{2}", response.DataServiceVersion, major, minor)); }