public void GetNullValuedResourceFromReferenceNavigationProperty() { TestWebRequest request = UnitTestsUtil.GetTestWebRequestInstance(UnitTestsUtil.JsonLightMimeType, "/Customers(0)/BestFriend", typeof(CustomDataContext), null, "GET"); Assert.IsTrue(request.ResponseStatusCode == 204); VerifyEmptyStream(request.GetResponseStream()); request = UnitTestsUtil.GetTestWebRequestInstance(UnitTestsUtil.AtomFormat, "/Customers(0)/BestFriend", typeof(CustomDataContext), null, "GET"); Assert.IsTrue(request.ResponseStatusCode == 204); VerifyEmptyStream(request.GetResponseStream()); }
/// <summary> /// Parses the response as XML and if there's an in-stream error in it it will return it. /// </summary> /// <param name="request">The request from which to read the response.</param> /// <returns>If there was an in-stream error this will return it as an exception instance, otherwise it returns null.</returns> public static Exception ParseResponseInStreamError(this TestWebRequest request) { using (XmlReader reader = XmlReader.Create(request.GetResponseStream())) { return(ParseInStreamError(reader)); } }
public static string GetResponse(string payload, Type contextType, WebServerLocation location, string requestVersion) { string[] segments = payload.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); string boundary = segments[0].Substring(2); using (TestWebRequest request = TestWebRequest.CreateForLocation(location)) { request.RequestVersion = requestVersion; request.DataServiceType = contextType; request.RequestUriString = "/$batch"; request.Accept = UnitTestsUtil.MimeMultipartMixed; request.HttpMethod = "POST"; request.RequestContentType = String.Format("{0}; boundary={1}", UnitTestsUtil.MimeMultipartMixed, boundary); if (request.BaseUri != null) { payload = Regex.Replace(payload, "\\$\\(BaseUri\\)", request.BaseUri.EndsWith("/") ? request.BaseUri : request.BaseUri + "/"); } request.RequestStream = IOUtil.CreateStream(payload); request.SendRequest(); Stream responseStream = request.GetResponseStream(); using (StreamReader reader = new StreamReader(responseStream)) { return(PrepareResponseForFileCompare(reader, request.BaseUri, "$(BaseUri)")); } } }
public void ParseResponseFromRequest(TestWebRequest request, bool matchToExisting) { using (var contentStream = request.GetResponseStream()) { this.ParseBatchContent(contentStream, request.ResponseContentType, true, matchToExisting); } }
private void GetResponse(string uri, string responseFormat, Type contextType, string[] xPathsToVerify, KeyValuePair <string, string>[] headerValues, string httpMethodName, string requestPayload) { using (TestWebRequest request = TestWebRequest.CreateForInProcess()) { request.DataServiceType = contextType; request.RequestUriString = uri; request.Accept = responseFormat; request.HttpMethod = httpMethodName; UnitTestsUtil.SetHeaderValues(request, headerValues); if (requestPayload != null) { request.RequestContentType = responseFormat; request.RequestStream = new MemoryStream(); StreamWriter writer = new StreamWriter(request.RequestStream); writer.Write(requestPayload); writer.Flush(); } request.SendRequest(); Stream responseStream = request.GetResponseStream(); if (xPathsToVerify != null) { UnitTestsUtil.VerifyXPaths(responseStream, responseFormat, xPathsToVerify); } } }
public void OpenTypeMetadataTest() { using (TestWebRequest request = TestWebRequest.CreateForInProcess()) { request.DataServiceType = typeof(CustomRowBasedOpenTypesContext); request.RequestUriString = "/$metadata"; request.SendRequest(); using (Stream responseStream = request.GetResponseStream()) { var document = new System.Xml.XPath.XPathDocument(responseStream); // Ensure the OpenType attribute is there. var expression = System.Xml.XPath.XPathExpression.Compile("//csdl:EntityType[@OpenType]", TestUtil.TestNamespaceManager); var nodeIterator = document.CreateNavigator().Select(expression); int count = 0; while (nodeIterator.MoveNext()) { Assert.AreEqual("true", nodeIterator.Current.SelectSingleNode("@OpenType").Value); count++; } // The OpenType attribute is present at all levels of the type hierarchy; expect it on all types. Assert.AreEqual(3, count); } } }
private static void VerifyStatusCode(string uri, string responseFormat, string etag, Type contextType, int statusCode) { var ifNoneMatch = new KeyValuePair <string, string>("If-None-Match", etag); TestWebRequest request = GetTestWebRequestInstance(responseFormat, uri, contextType, new KeyValuePair <string, string>[] { ifNoneMatch }, "GET"); Assert.IsTrue(request.ResponseStatusCode == statusCode, "Since the etag should match, the status code should be 312"); VerifyEmptyStream(request.GetResponseStream()); request.Dispose(); }
/// <summary>Creates the in-memory response from another TestWebRequest, copying its reponse.</summary> /// <param name="sourceResponse">The request to read the response from.</param> /// <returns>The newly create request object with the response proeprties filled with the data from the request response.</returns> public static InMemoryWebRequest FromResponse(TestWebRequest sourceResponse) { InMemoryWebRequest response = new InMemoryWebRequest(); response.SetResponseStatusCode(sourceResponse.ResponseStatusCode); foreach (var header in GetAllResponseHeaders(sourceResponse)) { response.ResponseHeaders[header.Key] = header.Value; } using (Stream responseStream = sourceResponse.GetResponseStream()) { response.SetResponseStream(responseStream); } return response; }
/// <summary>Creates the in-memory response from another TestWebRequest, copying its reponse.</summary> /// <param name="sourceResponse">The request to read the response from.</param> /// <returns>The newly create request object with the response proeprties filled with the data from the request response.</returns> public static InMemoryWebRequest FromResponse(TestWebRequest sourceResponse) { InMemoryWebRequest response = new InMemoryWebRequest(); response.SetResponseStatusCode(sourceResponse.ResponseStatusCode); foreach (var header in GetAllResponseHeaders(sourceResponse)) { response.ResponseHeaders[header.Key] = header.Value; } using (Stream responseStream = sourceResponse.GetResponseStream()) { response.SetResponseStream(responseStream); } return(response); }
public void MultipleAssociationsToTheSameEntitySetResultInDistinctAssociationSetNames() { using (TestWebRequest request = TestWebRequest.CreateForInProcess()) { request.ServiceType = typeof(DistinctAssociationSetService); request.FullRequestUriString = "http://host/$metadata"; request.HttpMethod = "GET"; request.SendRequest(); string response = new StreamReader(request.GetResponseStream()).ReadToEnd(); //count the number of occurrances of ReferenceProductMetatdatas and VariableProductMetadatas, they should be equal. Regex referenceCountRegex = new Regex("ReferenceProduct_Metadatas"); Regex variableCountRegex = new Regex("VariableProduct_Metadatas"); referenceCountRegex.Matches(response).Count.Should().Be(variableCountRegex.Matches(response).Count); } }
public void InvalidMetadataForEntityHierarchy() { // Create the custom data context using (TestWebRequest request = TestWebRequest.CreateForLocation(WebServerLocation.InProcess)) { request.DataServiceType = typeof(BadMetadataProvider); request.RequestUriString = "/$metadata"; Exception exception = TestUtil.RunCatching(delegate() { request.SendRequest(); request.GetResponseStream(); }); Assert.IsInstanceOfType(exception, typeof(InvalidOperationException)); Assert.AreEqual(true, exception.Message.Contains("IgnoreProperties")); } }
public void RequestUriResourceSetPropertyTest() { Func <Hashtable, XmlDocument, bool> testCallBack = (values, document) => { string responseFormat = (string)values["ResponseFormat"]; string xPath; if (responseFormat == UnitTestsUtil.JsonLightMimeType) { xPath = String.Format("/{0}/{1}/ID", JsonValidator.ArrayString, JsonValidator.ObjectString); } else { Assert.IsTrue(responseFormat == UnitTestsUtil.AtomFormat, "unexpected format"); xPath = "/atom:feed/atom:entry/atom:content/adsm:properties/ads:ID"; } XmlElement order = (XmlElement)document.SelectSingleNode(xPath, TestUtil.TestNamespaceManager); using (TestWebRequest request = TestWebRequest.CreateForLocation(WebServerLocation.InProcess)) { request.RequestUriString = "/Customers(0)/Orders(" + order.InnerText + ")"; request.Accept = responseFormat; request.DataServiceType = typeof(CustomDataContext); request.SendRequest(); UnitTestsUtil.VerifyXPaths(request.GetResponseStream(), responseFormat, new string[] { "/cdc:Order" }, new string[] { JsonValidator.GetJsonTypeXPath(typeof(Order), false /*isArray*/) }, new string[0]); return(true); } }; UnitTestsUtil.VerifyPayload("/Customers(0)/Orders", typeof(CustomDataContext), testCallBack, new string[] { "/cdc:Orders", "/cdc:Orders/cdc:Order" }, new string[] { String.Format("/{0}", JsonValidator.ArrayString), JsonValidator.GetJsonTypeXPath(typeof(Order), true /*isArray*/) }, new string[0]); // TODO: When this is fixed, we should uncomment this test cases //UnitTestsUtil.VerifyInvalidUri("/Customers!1000/Orders", typeof(CustomDataContext)); UnitTestsUtil.VerifyInvalidUri("/Customers(1)/Orders(10000)", typeof(CustomDataContext)); }
public void ProcessGetTest() { foreach (WebServerLocation location in new WebServerLocation[] { WebServerLocation.InProcess, WebServerLocation.InProcessWcf }) { using (TestWebRequest request = TestWebRequest.CreateForLocation(location)) { request.DataServiceType = typeof(CustomDataContext); request.RequestUriString = "/$metadata"; request.SendRequest(); Stream resultStream = request.GetResponseStream(); TextReader reader = new StreamReader(resultStream); string resultText = reader.ReadToEnd(); Assert.IsTrue(resultText.Length > 0); Assert.IsTrue(resultText.Contains("Customers")); request.Dispose(); } } }
public void InvalidMetadataTestCases() { foreach (Type type in GetInvalidTypes()) { // Create the custom data context using (TestWebRequest request = TestWebRequest.CreateForLocation(WebServerLocation.InProcess)) { request.DataServiceType = typeof(TypedCustomDataContext <>).MakeGenericType(type); request.RequestUriString = "/$metadata"; Exception exception = TestUtil.RunCatching(delegate() { request.SendRequest(); request.GetResponseStream(); }); System.Data.Test.Astoria.AstoriaTestLog.IsNotNull(exception, String.Format("The invalid type case should not throw an exception: '{0}'", type.Name)); } } }
public void ParseResponseFromRequest(TestWebRequest request, bool matchToExisting) { using (var contentStream = request.GetResponseStream()) { this.ParseBatchContent(contentStream, request.ResponseContentType, true, matchToExisting); } }
public void PlainSerializersBasicTest() { CombinatorialEngine engine = CombinatorialEngine.FromDimensions( new Dimension("ValidMime", new object[] { true, false }), new Dimension("SpecificMime", new object[] { true, false }), new Dimension("TypeData", TypeData.Values)); Hashtable table = new Hashtable(); while (engine.Next(table)) { bool validMime = (bool)table["ValidMime"]; bool specificMime = (bool)table["SpecificMime"]; TypeData typeData = (TypeData)table["TypeData"]; // If ValidMime is false, whether it's specific or not doesn't matter. if (!validMime && specificMime) { continue; } if (!typeData.IsTypeSupported) { continue; } using (TestWebRequest request = TestWebRequest.CreateForLocation(WebServerLocation.InProcess)) { Type valueType = typeData.ClrType; Type entityType = typeof(TypedEntity <,>).MakeGenericType(typeof(int), valueType); CustomDataContextSetup dataContextSetup = new CustomDataContextSetup(entityType); dataContextSetup.Id = 1; dataContextSetup.MemberValue = typeData.NonNullValue; Type serviceType = dataContextSetup.DataServiceType; request.DataServiceType = serviceType; request.RequestUriString = "/Values(1)/Member/$value"; if (validMime) { request.Accept = TypeData.FindForType(valueType).DefaultContentType; } else { request.Accept = "application/unexpected"; } try { request.SendRequest(); if (!validMime) { Assert.Fail("Request should have failed."); } } catch (WebException) { if (!validMime) { continue; } throw; } string expectedType = request.Accept; Assert.AreEqual(expectedType, TestUtil.GetMediaType(request.ResponseContentType)); Stream stream = request.GetResponseStream(); if (valueType == typeof(byte[])) { byte[] bytes = (byte[])dataContextSetup.MemberValue; for (int i = 0; i < bytes.Length; i++) { Assert.AreEqual(bytes[i], (byte)stream.ReadByte()); } } else { using (StreamReader reader = new StreamReader(stream)) { typeData.VerifyAreEqual(dataContextSetup.MemberValue, typeData.ValueFromXmlText(reader.ReadToEnd(), request.Accept), request.Accept); } } } } }
public void WebDataServiceBaseTypeContainer() { AdHocEntityType customersBase = new AdHocEntityType("CustomerBase"); AdHocEntityType customersDerived = new AdHocEntityType(customersBase) { Name = "CustomerDerived" }; AdHocEntityType referencingType = new AdHocEntityType("ReferencingType"); AdHocEntitySet customerSet = new AdHocEntitySet() { Name = "Customers", Type = customersBase }; AdHocAssociationType associationType = new AdHocAssociationType() { Name = "ReferenceToDerivedCustomerType", Ends = new List <AdHocAssociationTypeEnd>() { new AdHocAssociationTypeEnd() { Multiplicity = "1", RoleName = "Reference", Type = referencingType }, new AdHocAssociationTypeEnd() { Multiplicity = "*", RoleName = "Customer", Type = customersDerived }, } }; AdHocEntitySet referencingSet = new AdHocEntitySet() { Name = "ReferenceHolder", Type = referencingType }; AdHocContainer container = new AdHocContainer() { AssociationSets = new List <AdHocAssociationSet>() { new AdHocAssociationSet() { Name = "ReferenceToDerivedCustomer", Type = associationType, Ends = new List <AdHocAssociationSetEnd>() { new AdHocAssociationSetEnd() { EndType = associationType.Ends[0], EntitySet = referencingSet }, new AdHocAssociationSetEnd() { EndType = associationType.Ends[1], EntitySet = customerSet } }, } }, EntitySets = new List <AdHocEntitySet>() { customerSet, referencingSet }, ExtraEntityTypes = new List <AdHocEntityType>() { customersDerived }, }; associationType.AddNavigationProperties(); AdHocModel model = new AdHocModel(container) { ConceptualNs = TestXmlConstants.EdmV1Namespace }; Assembly assembly = model.GenerateModelsAndAssembly("WebDataServiceBaseTypeContainer", false /* isReflectionProviderBased */); using (TestWebRequest request = TestWebRequest.CreateForInProcess()) { request.DataServiceType = TestUtil.LoadDerivedTypeFromAssembly(assembly, typeof(System.Data.Objects.ObjectContext)); request.RequestUriString = "/$metadata"; request.SendRequest(); using (var s = new StreamReader(request.GetResponseStream())) Trace.WriteLine(s.ReadToEnd()); } using (TestWebRequest request = TestWebRequest.CreateForInProcess()) { request.DataServiceType = typeof(ContextWithBaseType); request.RequestUriString = "/$metadata"; request.SendRequest(); XmlDocument document = request.GetResponseStreamAsXmlDocument(); UnitTestsUtil.VerifyXPaths(document, "//csdl:Schema/csdl:EntityType[@Name='WebDataServiceTest_SimpleBaseType']", "//csdl:Schema/csdl:EntityType[@Name='WebDataServiceTest_ReferencingType']", "//csdl:Schema/csdl:EntityType[@Name='WebDataServiceTest_DerivedType' and @BaseType='AstoriaUnitTests.Tests.WebDataServiceTest_SimpleBaseType']", "//csdl:Schema/csdl:EntityContainer/csdl:EntitySet[@Name='B']", "//csdl:Schema/csdl:EntityContainer/csdl:EntitySet[@Name='R']/csdl:NavigationPropertyBinding[@Path='DerivedReference' and @Target='B']"); } }
public void WebDataServiceCsdlMimeTypes() { object[] targets = new object[] { // BuiltInTypeKind.EdmFunction, // BuiltInTypeKind.ComplexType, // BuiltInTypeKind.EntityContainer, // BuiltInTypeKind.EntityType, BuiltInTypeKind.EdmProperty, }; // Ensure the NorthwindModel service is ready to be used. Trace.WriteLine("NorthwindModel IsValid: " + ServiceModelData.Northwind.IsValid); CombinatorialEngine engine = CombinatorialEngine.FromDimensions( new Dimension("Target", targets), new Dimension("MimeType", new object[] { "", "text/html" })); int schemaCounter = 0; TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values) { BuiltInTypeKind target = (BuiltInTypeKind)values["Target"]; string mimeType = (string)values["MimeType"]; // Create a copy of Northwind model files. schemaCounter++; const bool overwriteTrue = true; string sourceFileName = Path.Combine(TestUtil.NorthwindMetadataDirectory, "Northwind.csdl"); string destFileName = sourceFileName + schemaCounter + ".csdl"; File.Copy(sourceFileName, destFileName, overwriteTrue); File.SetAttributes(destFileName, FileAttributes.Normal); // Add an attribute at specific values. string csdlFileName = destFileName; XmlDocument document = new XmlDocument(); document.Load(csdlFileName); XmlElement element = GetElementForKind(document, target); element.SetAttribute("MimeType", "http://docs.oasis-open.org/odata/ns/metadata", mimeType); document.Save(csdlFileName); using (TestWebRequest request = TestWebRequest.CreateForInProcess()) { // Get the generated CSDL. string connectionString = NorthwindModel.NorthwindContext.ContextConnectionString; try { string northwindConnectionString = connectionString; northwindConnectionString = northwindConnectionString .Replace("Northwind.csdl", "Northwind.csdl" + schemaCounter + ".csdl"); NorthwindModel.NorthwindContext.ContextConnectionString = northwindConnectionString; request.DataServiceType = typeof(NorthwindModel.NorthwindContext); request.RequestUriString = "/$metadata"; Exception exception = TestUtil.RunCatching(request.SendRequest); TestUtil.AssertExceptionExpected(exception, target != BuiltInTypeKind.EdmProperty, mimeType == ""); if (exception != null) { return; } XmlDocument metadataResult = new XmlDocument(TestUtil.TestNameTable); metadataResult.Load(request.GetResponseStream()); Trace.WriteLine(metadataResult.OuterXml); // Get a value using a primitive serializer. request.RequestUriString = "/Customers?$format=atom&$top=1"; request.SendRequest(); XmlDocument customerDocument = SerializationFormatData.Atom.LoadXmlDocumentFromStream(request.GetResponseStream()); XmlElement customerId = TestUtil.AssertSelectSingleElement(customerDocument, "/atom:feed/atom:entry/atom:id"); request.FullRequestUriString = customerId.InnerText + "/CompanyName/$value"; request.SendRequest(); Assert.AreEqual(mimeType, TestUtil.GetMediaType(request.ResponseContentType)); } finally { NorthwindModel.NorthwindContext.ContextConnectionString = connectionString; } } }); }
public void ProcessExceptionTest() { Type[] exceptionTypes = new Type[] { typeof(OutOfMemoryException), typeof(DataServiceException), typeof(FormatException), typeof(DataServiceException), }; // At-End is currently always true, because the IQueryable caching // doesn't give us a good point to fail before content is written out. CombinatorialEngine engine = CombinatorialEngine.FromDimensions( new Dimension(CustomDataContext.ExceptionTypeArgument, exceptionTypes), new Dimension(CustomDataContext.ExceptionAtEndArgument, new object[] { true }), new Dimension("Format", SerializationFormatData.Values), new Dimension("WebServerLocation", new object[] { WebServerLocation.InProcess, WebServerLocation.Local })); TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values) { Type exceptionType = (Type)values[CustomDataContext.ExceptionTypeArgument]; bool exceptionAtEnd = (bool)values[CustomDataContext.ExceptionAtEndArgument]; SerializationFormatData format = (SerializationFormatData)values["Format"]; WebServerLocation location = (WebServerLocation)values["WebServerLocation"]; // The local web server doesn't handle OOF gracefully - skip that case. if (exceptionType == typeof(OutOfMemoryException) && location == WebServerLocation.Local) { return; } // No binary properties in the model. if (format.Name == "Binary") { return; } // We need at least 1024 bytes to be written out for the default // StreamWriter used by the XmlTextWriter to flush out (at which point // we can assume that throwing at the end of the stream caused // a "partial send"). // // However the implementation ends up using an XmlUtf8RawTextWriterIndent // object, with a BUFSIZE of 0x1800 as declared on XmlUtf8RawTextWriter. // // (0x1800 / "Customer 1".Length) + 1 is ideal, but we can make do with much less. int customerCount = (0xA0 / "Customer 1".Length) + 1; values[CustomDataContext.CustomerCountArgument] = customerCount; using (TestWebRequest request = TestWebRequest.CreateForLocation(location)) { request.DataServiceType = typeof(CustomDataContext); request.TestArguments = values; request.Accept = format.MimeTypes[0]; request.RequestUriString = (format.Name == "Text") ? "/Customers(" + customerCount + ")/ID/$value" : "/Customers"; Trace.WriteLine("Requesting " + request.RequestUriString); Stream response = new MemoryStream(); Exception thrownException = null; try { request.SendRequest(); thrownException = new ApplicationException("No exception actually thrown."); } catch (Exception exception) { thrownException = exception; } // InProcess always throws WebException. Look in the inner exception for the right exception type. if (location == WebServerLocation.InProcess && !format.IsPrimitive && exceptionType != typeof(OutOfMemoryException)) { Assert.AreEqual(typeof(WebException), thrownException.GetType(), "InProcess should always throw WebException - Look in TestServiceHost.ProcessException"); thrownException = thrownException.InnerException; } // Exception may be wrapped by TargetInvocationException. if (thrownException is TargetInvocationException) { thrownException = thrownException.InnerException; } TestUtil.CopyStream(request.GetResponseStream(), response); response.Position = 0; if (exceptionAtEnd && !format.IsPrimitive) { // for inprocess, there will be no exception in the payload if (location == WebServerLocation.InProcess) { // Verify the exception type Assert.AreEqual(exceptionType, thrownException.GetType(), "Exception type did not match"); return; } Assert.IsTrue(HasContent(response), "HasContent(response)"); Assert.IsTrue(String.Equals(request.Accept, TestUtil.GetMediaType(request.ResponseContentType), StringComparison.OrdinalIgnoreCase)); if (exceptionType != typeof(OutOfMemoryException)) { string responseText = new StreamReader(response).ReadToEnd(); TestUtil.AssertContains(responseText, "error"); TestUtil.AssertContains(responseText, "message"); } Assert.IsTrue(thrownException is ApplicationException, "No exception thrown."); } else { if (exceptionType == typeof(OutOfMemoryException)) { if (location == WebServerLocation.InProcess) { Assert.IsTrue(thrownException is OutOfMemoryException, "thrownException is OutOfMemoryException"); Assert.IsTrue(exceptionAtEnd || !HasContent(response), "exceptionAtEnd || !HasContent(response)"); } else { Assert.IsTrue(thrownException is WebException, "thrownException is WebException"); } } else { Assert.IsTrue(thrownException is WebException, "thrownException is WebException"); Assert.IsTrue(HasContent(response), "HasContent(response)"); string expected = (location == WebServerLocation.InProcess) ? "text/plain" : "application/xml"; Assert.AreEqual(expected, TestUtil.GetMediaType(request.ResponseContentType)); } } } }); }
// TODO: enable this once we have support for expanding open properties //[TestMethod] public void OpenTypeExpandTest() { CombinatorialEngine engine = CombinatorialEngine.FromDimensions( new Dimension("SerializationFormatData", SerializationFormatData.StructuredValues)); using (TestWebRequest request = TestWebRequest.CreateForInProcess()) { request.DataServiceType = typeof(TypedCustomDataContext <OpenElement>); using (StaticCallbackManager <PopulatingValuesEventArgs <OpenElement> > .RegisterStatic((sender, args) => { var o = new OpenElement(); o.ID = "100"; o.Properties.Add("sampleValue1", new OpenElement() { ID = "101" }); o.Properties.Add("sampleValue2", new OpenElement[] { new OpenElement() { ID = "102" } }); o.Properties.Add("address", new Address() { StreetAddress = "L1", City = "City", State = "S1", PostalCode = "98052" }); o.Properties.Add("primitive", "abc"); o.Properties.Add("thenull", null); args.Values.Add(o); })) { TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values) { SerializationFormatData format = (SerializationFormatData)values["SerializationFormatData"]; request.Accept = format.MimeTypes[0]; XmlDocument document; string[] validation; request.RequestUriString = "/Values('100')"; request.SendRequest(); document = format.LoadXmlDocumentFromStream(request.GetResponseStream()); if (format == SerializationFormatData.Atom) { validation = new string[] { "/atom:entry/atom:link[@title='OpenTypes_OpenElement']", "/atom:entry/atom:content/adsm:properties/ads:ID[text()='100']", "/atom:entry/atom:link[@title='sampleValue1' and @type='application/atom+xml;type=entry']", "/atom:entry/atom:link[@title='sampleValue2' and @type='application/atom+xml;type=feed']", //"/atom:entry/atom:content/ads:address/ads:Line1[text()='L1']", //"/atom:entry/atom:content/ads:address/ads:Line2[@adsm:null='true']", "/atom:entry/atom:content/adsm:properties/ads:primitive[text()='abc']" }; } else { Debug.Assert(format == SerializationFormatData.Json); validation = new string[] { "/Object/__metadata/type[text()='AstoriaUnitTests.Tests.OpenTypes_OpenElement']", "/Object/ID[text()='100']", "/Object/sampleValue1/__deferred", "/Object/sampleValue2/__deferred", //"/Object/address/Line1[text()='L1']", //"/Object/address/Line2[@IsNull='true']", "/Object/primitive[text()='abc']" }; } TestUtil.TraceXml(document); foreach (string v in validation) { TestUtil.AssertSelectSingleElement(document, v); } request.RequestUriString = "/Values('100')?$expand=sampleValue1"; request.SendRequest(); document = format.LoadXmlDocumentFromStream(request.GetResponseStream()); TestUtil.TraceXml(document); if (format == SerializationFormatData.Atom) { TestUtil.AssertSelectSingleElement( document, "/atom:entry/atom:link[@title='sampleValue1']/*/atom:entry/atom:content/adsm:properties/ads:ID[text()='101']"); } else { TestUtil.AssertSelectSingleElement( document, "/Object/sampleValue1/__metadata/type[text()='AstoriaUnitTests.Tests.OpenTypes_OpenElement']"); } request.RequestUriString = "/Values('100')?$expand=sampleValue2"; request.SendRequest(); document = format.LoadXmlDocumentFromStream(request.GetResponseStream()); TestUtil.TraceXml(document); if (format == SerializationFormatData.Atom) { TestUtil.AssertSelectSingleElement( document, "/atom:entry/atom:link[@title='sampleValue2']/*/atom:feed/atom:entry/atom:content/adsm:properties/ads:ID[text()='102']"); } else { TestUtil.AssertSelectSingleElement( document, "/Object/sampleValue2/Array/Object/__metadata/type[text()='AstoriaUnitTests.Tests.OpenTypes_OpenElement']"); } }); } } }
public void EncodingFromAcceptCharsetTest() { // It takes over a minute to run all combinations. CombinatorialEngine engine = CombinatorialEngine.FromDimensions( new Dimension("EncodingData", EncodingData.Values), new Dimension("StringData", StringData.Values), new Dimension("SerializationFormatData", SerializationFormatData.StructuredValues), new Dimension("WebServerLocation", new object[] { WebServerLocation.InProcess })); engine.Mode = CombinatorialEngineMode.EveryElement; TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable table) { EncodingData encodingData = (EncodingData)table["EncodingData"]; StringData stringData = (StringData)table["StringData"]; WebServerLocation location = (WebServerLocation)table["WebServerLocation"]; SerializationFormatData format = (SerializationFormatData)table["SerializationFormatData"]; if (encodingData.Encoding == null) { return; } if (!EncodingHandlesString(encodingData.Encoding, "<>#&;\r\n")) { return; } // Transliteration of ISCII characters and Unicode is possible, but round-tripping from // Unicode will not work because all phonetic sounds share an ISCII value, but have // distinct Unicode points depending on the language. if (encodingData.Name.StartsWith("x-iscii") && stringData.TextScript != null && stringData.TextScript.SupportsIscii) { return; } using (CustomDataContext.CreateChangeScope()) using (TestWebRequest request = TestWebRequest.CreateForLocation(location)) { request.DataServiceType = typeof(CustomDataContext); request.HttpMethod = "POST"; request.RequestUriString = "/Customers"; request.RequestContentType = UnitTestsUtil.JsonLightMimeType; request.SetRequestStreamAsText("{ " + "@odata.type : \"AstoriaUnitTests.Stubs.Customer\" ," + "ID: 100," + "Name: " + System.Data.Test.Astoria.Util.JsonPrimitiveTypesUtil.PrimitiveToString(stringData.Value, typeof(string)) + " }"); request.SendRequest(); request.HttpMethod = "GET"; request.AcceptCharset = encodingData.Name; request.Accept = format.MimeTypes[0]; request.RequestUriString = "/Customers(100)"; bool encoderCanHandleData = EncodingHandlesString(encodingData.Encoding, stringData.Value); Trace.WriteLine("Encoding handles string: " + encoderCanHandleData); Exception exception = TestUtil.RunCatching(request.SendRequest); XmlDocument document = null; Stream byteStream = new MemoryStream(); if (exception == null) { using (Stream stream = request.GetResponseStream()) { IOUtil.CopyStream(stream, byteStream); } byteStream.Position = 0; Trace.WriteLine(TestUtil.BuildHexDump(byteStream)); byteStream.Position = 0; if (format == SerializationFormatData.Atom) { document = new XmlDocument(TestUtil.TestNameTable); using (StreamReader reader = new StreamReader(byteStream, encodingData.Encoding)) { document.Load(reader); } TestUtil.TraceXml(document); XmlElement nameElement = TestUtil.AssertSelectSingleElement(document, "//ads:Name"); if (stringData.Value == null) { Assert.IsTrue(UnitTestsUtil.HasElementNullValue(nameElement, new System.Net.Mime.ContentType(request.ResponseContentType).MediaType)); } else { Assert.AreEqual(stringData.Value, nameElement.InnerText); } } } else { TestUtil.AssertExceptionExpected(exception, !encoderCanHandleData); } } }); }