Пример #1
0
        [Ignore] // Remove Atom
        // [TestMethod, TestCategory("Partition1")]
        public void CanOverrideAcceptHeaderToBatchRequestWithQueryItem()
        {
            StringBuilder batchQueryOperation = new StringBuilder();

            batchQueryOperation.AppendLine("GET Customers(1)/Address?Override-Accept=" + UnitTestsUtil.JsonLightMimeType + " HTTP/1.1");
            batchQueryOperation.AppendLine("Host: host");
            batchQueryOperation.AppendLine("Accept: " + UnitTestsUtil.MimeApplicationXml);

            var test = new SimpleBatchTestCase
            {
                RequestPayload               = new BatchInfo(new BatchQuery(new Operation(batchQueryOperation.ToString()))),
                ResponseStatusCode           = 202,
                ResponseETag                 = default(string),
                ResponseVersion              = V4,
                RequestDataServiceVersion    = V4,
                RequestMaxDataServiceVersion = V4,
            };

            foreach (var serviceType in Services)
            {
                using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                {
                    request.HttpMethod         = "POST";
                    request.RequestUriString   = "/$batch?Override-Batch-Accept=" + UnitTestsUtil.JsonLightMimeType;
                    request.DataServiceType    = serviceType;
                    request.Accept             = UnitTestsUtil.MimeMultipartMixed;
                    request.RequestVersion     = test.RequestDataServiceVersion.ToString();
                    request.RequestMaxVersion  = test.RequestMaxDataServiceVersion.ToString();
                    request.ForceVerboseErrors = true;
                    if (test.RequestPayload == null)
                    {
                        request.RequestContentLength = 0;
                    }
                    else
                    {
                        const string boundary = "batch-set";
                        request.RequestContentType = String.Format("{0}; boundary={1}", UnitTestsUtil.MimeMultipartMixed, boundary);
                        request.SetRequestStreamAsText(BatchRequestWritingUtils.GetBatchText(test.RequestPayload, boundary));
                    }

                    TestUtil.RunCatching(request.SendRequest);

                    // expect 202 as $batch request does not honor query string Accept header
                    Assert.AreEqual(test.ResponseStatusCode, request.ResponseStatusCode);
                    // The following response header is written in ProcessingRequest/OnStartProcessingRequest
                    Assert.AreEqual(UnitTestsUtil.JsonLightMimeType, request.ResponseHeaders["Override-Batch-Accept"]);

                    string response = request.GetResponseStreamAsText();
                    if (serviceType == typeof(ModifyHeaderOnStartProcessingRequestTestService))
                    {
                        Assert.IsTrue(response.Contains("Content-Type: application/json;odata.metadata=minimal;"));
                    }
                    else
                    {
                        // ProcessingRequest which sets the Aceept header is not called for inner requests
                        Assert.IsTrue(response.Contains("Content-Type: application/xml;charset=utf-8"));
                    }
                }
            }
        }
Пример #2
0
            public void CheckRelationshipLinkForDeleteOperationForEntityCollection()
            {
                // CreateChangeScope will make sure that changes are preserved after every SendRequest.
                // By default the data source is created for every request
                using (UnitTestsUtil.CreateChangeScope(typeof(CustomDataContext)))
                {
                    using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                    {
                        request.ServiceType = typeof(RelationshipLinksService);

                        request.RequestUriString = "/Customers(1)/Orders/$ref";
                        request.HttpMethod       = "GET";
                        request.SendRequest();
                        var response1 = request.GetResponseStreamAsText();

                        request.RequestUriString = "/Customers(1)/Orders/$ref?$id=Orders(1)";
                        request.HttpMethod       = "DELETE";
                        request.SendRequest();

                        var response = request.GetResponseStreamAsText();
                        Assert.IsTrue(response != null);
                        Assert.IsTrue(request.ResponseStatusCode == 204);

                        request.RequestUriString = "/Customers(1)/Orders/$ref";
                        request.HttpMethod       = "GET";
                        request.SendRequest();
                        var response2 = request.GetResponseStreamAsText();

                        Assert.IsTrue(response1 != response2);
                    }
                }
            }
        public void QueryWithBothMinimalAndFullMetadataShouldNotCauseDuplicateIdentities()
        {
            // Repro for: EntityDescriptor identity/links key order changes for json DataServiceContext
            using (TestUtil.MetadataCacheCleaner())
                using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                {
                    // using the row-based context because it intentionally puts OrderDetail's key properties in non-alphabetical order in the OM.
                    request.DataServiceType = typeof(CustomRowBasedContext);
                    request.StartService();

                    DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);

                    JsonLightTestUtil.ConfigureContextForJsonLight(ctx);

                    ConfigureContextForSendingRequest2Verification(ctx);

                    var firstOrderDetail          = ctx.CreateQuery <OrderDetail>("OrderDetails").First();
                    var firstOrderDetailProjected = ctx.CreateQuery <OrderDetail>("OrderDetails").Select(od => new OrderDetail {
                        Quantity = od.Quantity
                    }).First();

                    Assert.IsNotNull(firstOrderDetail);
                    Assert.IsNotNull(firstOrderDetailProjected);
                    Assert.AreEqual(1, ctx.Entities.Count);
                }
        }
Пример #4
0
        public void CallbackSuccessQueryTest()
        {
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.DataServiceType = typeof(CustomDataContext);
                List <string> requestUris = new List <string>()
                {
                    "/Customers(1)/ID?$format=json&$callback=foo",
                    "/Customers(1)/Orders/$ref?$format=json&$callback=foo",
                    "/Customers/?$expand=Orders&$select=ID,Name,Orders&$top=3&$skip=1&$orderby=ID&$filter=Orders/any(p:p/ID%20ne%200)&$format=json&$callback=foo",
                    "/Customers/?$format=json&$callback=foo&$filter=Orders/all(p:p/ID%20ge%200)&inlinecount=allpages",
                };

                foreach (var requestUri in requestUris)
                {
                    request.RequestUriString = requestUri;

                    request.SendRequest();
                    var actualText = request.GetResponseStreamAsText();
                    Assert.IsTrue(actualText.StartsWith("foo("));
                    Assert.IsTrue(actualText.EndsWith(")"));
                    Assert.IsTrue(request.ResponseHeaders["content-type"].StartsWith("text/javascript;odata.metadata=minimal;"));
                    Assert.AreEqual(200, request.ResponseStatusCode);
                }
            }
        }
Пример #5
0
        public void CallbackFailOnAtomXml()
        {
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.DataServiceType = typeof(CustomDataContext);
                List <string> requestUriStrings = new List <string>()
                {
                    "/Customers(1)?$callback=foo",
                    "/Customers(1)/Address?$callback=foo",
                };

                foreach (string requestUriString in requestUriStrings)
                {
                    try
                    {
                        request.RequestUriString = requestUriString;
                        request.Accept           = "application/atom+xml,application/xml";
                        request.SendRequest();
                        Assert.Fail("Request should have failed because our server defaults to ATOM/XML, which does not support $callback.");
                    }
                    catch (WebException)
                    {
                        var actualText = request.GetResponseStreamAsText();
                        Assert.IsFalse(actualText.StartsWith("foo("));
                        Assert.IsTrue(actualText.Contains("is not compatible with the $callback query option."));

                        Assert.IsTrue(request.ResponseHeaders["content-type"].StartsWith("application/xml"));
                        Assert.AreEqual(400, request.ResponseStatusCode);
                    }
                }
            }
        }
        public void SetDollarFormatInAddQueryOption()
        {
            using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
            {
                web.DataServiceType = typeof(DollarFormatTestService);
                web.StartService();
                DataServiceContext ctx     = new DataServiceContext(web.ServiceRoot, ODataProtocolVersion.V4);
                List <string>      options = new List <string>()
                {
                    "atom",
                    "json",
                    "jsonlight",
                    "xml",
                };

                foreach (string option in options)
                {
                    try
                    {
                        ctx.CreateQuery <Customer>("Customers").AddQueryOption("$format", option).Execute();
                    }
                    catch (NotSupportedException e)
                    {
                        Assert.AreEqual(DataServicesClientResourceUtil.GetString("ALinq_FormatQueryOptionNotSupported"), e.Message);
                    }
                }
            }
        }
Пример #7
0
        public void Dev10Type_ClientQueryTupleWithALinq()
        {
            using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
            {
                web.DataServiceType = typeof(Dev10TypeDef.Dev10TypeEntitySet <Dev10TypeDef.EntityWithTupleProperty>);
                web.StartService();
                string baseUri = web.BaseUri;

                DataServiceContext context = new DataServiceContext(new Uri(baseUri));
                var query = from t in context.CreateQuery <Dev10TypeDef.EntityWithTupleProperty>("Entities")
                            where t.ComplexTuple.Item1 == "value 1"
                            select t;
                try
                {
                    string queryUri = query.ToString();
                    Assert.Fail("Client ALINQ with Tuple failed to throw");
                }
                catch (Exception ex)
                {
                    Exception innerEx = ex;
                    while (innerEx.InnerException != null)
                    {
                        innerEx = innerEx.InnerException;
                    }
                    Assert.AreEqual("The type 'System.Tuple`2[System.String,System.String]' is not supported by the client library.", innerEx.Message);
                }
            }
        }
Пример #8
0
        public void FilterNavigationWithAnyAll_TypeCasts()
        {
            using (OpenWebDataServiceHelper.AcceptAnyAllRequests.Restore())
            {
                OpenWebDataServiceHelper.AcceptAnyAllRequests.Value = true;
                using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                {
                    request.DataServiceType = typeof(CustomDataContext);
                    request.StartService();

                    string[] filters = new string[]
                    {
                        "Orders/all(o: o/Customer/AstoriaUnitTests.Stubs.CustomerWithBirthday/Birthday gt 1911-04-22T15:20:45.907Z)",
                        "Orders/all(o: isof(o/Customer, 'AstoriaUnitTests.Stubs.CustomerWithBirthday') and cast(o/Customer, 'AstoriaUnitTests.Stubs.CustomerWithBirthday')/Birthday gt 1911-04-22T15:20:45.907Z)",
                        "Orders/all(o: isof(o/Customer, 'AstoriaUnitTests.Stubs.CustomerWithBirthday') and cast(o/Customer, 'AstoriaUnitTests.Stubs.CustomerWithBirthday')/Orders/any())",
                        "isof(Orders/any(),'Edm.Boolean') and ID eq 1",
                        "isof(Orders/any(o: $it/ID eq 2),'Edm.Boolean') and isof(Orders/all(o: $it/ID eq 2),'Edm.Boolean') and ID eq 1",
                    };

                    foreach (var filter in filters)
                    {
                        request.RequestUriString = "/Customers?$format=atom&$filter=" + filter;
                        Exception e = TestUtil.RunCatching(request.SendRequest);
                        Assert.IsNull(e, "Not expecting exception.");

                        var      xdoc = request.GetResponseStreamAsXDocument();
                        XElement customerWithBirthday = xdoc.Root.Elements(XName.Get("{http://www.w3.org/2005/Atom}entry")).Single();
                        XElement typeName             = customerWithBirthday.Elements(XName.Get("{http://www.w3.org/2005/Atom}category")).Single();
                        Assert.IsTrue(typeName.Attribute("term").Value.EndsWith("CustomerWithBirthday"), "typeName.Attribute(\"term\").Value.EndsWith(\"CustomerWithBirthday\")");
                    }
                }
            }
        }
        private static void RunEndToEndSmokeTestWithClient(Action <DataServiceContext> customize = null)
        {
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.DataServiceType = typeof(KeyAsSegmentService);

                request.StartService();

                DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4)
                {
                    UrlConventions = DataServiceUrlConventions.KeyAsSegment
                };
                if (customize != null)
                {
                    customize(ctx);
                }

                var customer   = ctx.CreateQuery <Customer>("Customers").Where(c => c.ID == 0).Single();
                var descriptor = ctx.GetEntityDescriptor(customer);

                var baseUri = request.ServiceRoot.AbsoluteUri;
                Assert.AreEqual(baseUri + "/Customers/0", descriptor.Identity.OriginalString);
                Assert.AreEqual(baseUri + "/Customers/0", descriptor.EditLink.OriginalString);
                Assert.AreEqual(baseUri + "/Customers/0/BestFriend/$ref", descriptor.LinkInfos[0].AssociationLink.OriginalString);
                Assert.AreEqual(baseUri + "/Customers/0/BestFriend", descriptor.LinkInfos[0].NavigationLink.OriginalString);
                Assert.AreEqual(baseUri + "/Customers/0/Orders/$ref", descriptor.LinkInfos[1].AssociationLink.OriginalString);
                Assert.AreEqual(baseUri + "/Customers/0/Orders", descriptor.LinkInfos[1].NavigationLink.OriginalString);
            }
        }
Пример #10
0
        public void HttpContextServiceHost()
        {
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.DataServiceType = typeof(CustomDataContext);

                string[] invalidUris = new string[]
                {
                    "/Customers?$top=1&$top=2",
                    "/Customers?$top=1&$top=",
                    // "/Customers?$top=1&$top", - System.UriTemplateHelpers.ParseQueryString drops the empty argument
                    "/Customers?$top",
                    "/Customers?$foo",
                    "/Customers?$top=1&%20$top=1",
                    "/Customers?$top=1&$top%20=1",
                };

                CombinatorialEngine engine = CombinatorialEngine.FromDimensions(
                    new Dimension("uri", invalidUris));
                TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values)
                {
                    request.RequestUriString = (string)values["uri"];
                    Exception exception      = TestUtil.RunCatching(request.SendRequest);
                    TestUtil.AssertExceptionExpected(exception, true);
                    TestUtil.AssertExceptionStatusCode(exception, 400, "400 error expected for invalid query options " + request.RequestUriString);
                });
            }
        }
Пример #11
0
        public void CallbackSuccessQueryKeywordTest()
        {
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.DataServiceType = typeof(CallbackQueryOptionTestService);
                request.StartService();

                request.RequestUriString = "/ReturnNullServiceOperation?$callback=foo";
                request.SendRequest();
                Assert.AreEqual(204, request.ResponseStatusCode);

                request.RequestUriString = "/Customers(1)/ID/$value?$callback=foo";
                request.SendRequest();
                Assert.AreEqual(200, request.ResponseStatusCode);
                Assert.AreEqual("foo(1)", request.GetResponseStreamAsText());
                Assert.AreEqual("text/javascript;charset=utf-8", request.ResponseHeaders["content-type"]);

                request.RequestUriString = "/Customers/$count?$callback=foo";
                request.SendRequest();
                Assert.AreEqual(200, request.ResponseStatusCode);
                var actualText = request.GetResponseStreamAsText();
                Assert.IsTrue(actualText.StartsWith("foo("));
                Assert.IsTrue(actualText.EndsWith(")"));
                Assert.AreEqual("text/javascript;charset=utf-8", request.ResponseHeaders["content-type"]);
            }
        }
Пример #12
0
        public void CallbackFailOnCUDRequest()
        {
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.DataServiceType  = typeof(CustomDataContext);
                request.RequestUriString = "/Customers(1)?$format=json&$callback=foo";

                List <string> methods = new List <string>()
                {
                    "POST", "PUT", "DELETE"
                };
                request.RequestStream = new MemoryStream(new byte[] { 1, 2, 3, });

                foreach (string method in methods)
                {
                    try
                    {
                        request.HttpMethod = method;
                        request.SendRequest();
                        Assert.Fail("Request should have failed because it was not a GET request.");
                    }
                    catch (WebException)
                    {
                        var actualText = request.GetResponseStreamAsText();
                        Assert.IsFalse(actualText.StartsWith("foo("));
                        Assert.IsTrue(actualText.Contains("$callback can only be specified on GET requests."));

                        Assert.IsTrue(request.ResponseHeaders["content-type"].StartsWith("application/json"));
                        Assert.AreEqual(400, request.ResponseStatusCode);
                    }
                }
            }
        }
Пример #13
0
        public void Dev10Type_ClientDynamicExpand()
        {
            using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
            {
                web.DataServiceType = typeof(Dev10TypeDef.Dev10TypeEntitySet_Expand);
                web.StartService();
                string baseUri = web.BaseUri;

                DataServiceContext context = new DataServiceContext(new Uri(baseUri));
                var query = context.CreateQuery <Dev10TypeDef.EntityWithDynamicNavigation>("Parents").Expand("Children");
                try
                {
                    var results = query.ToList();
                    Assert.Fail("Exception failed to be thrown.");
                }
                catch (Exception ex)
                {
                    Exception innerEx = ex;
                    while (innerEx.InnerException != null)
                    {
                        innerEx = innerEx.InnerException;
                    }

                    Assert.IsTrue(innerEx.Message.Contains("Internal Server Error. The type 'AstoriaUnitTests.Tests.UnitTestModule+Dev10TypeTests+EntityWithDynamicInterface' is not supported."), ex.InnerException.Message);
                }
            }
        }
Пример #14
0
        public void CallBackInBatchRequestTest()
        {
            StringBuilder batchQueryOperation = new StringBuilder();

            batchQueryOperation.AppendLine("GET Customers(1)/Address?$callback=foo HTTP/1.1");
            batchQueryOperation.AppendLine("Host: host");
            batchQueryOperation.AppendLine("Accept: " + UnitTestsUtil.JsonMimeType);
            batchQueryOperation.AppendLine("Override-Accept: " + UnitTestsUtil.JsonLightMimeType);

            var testCase = new SimpleBatchTestCase
            {
                RequestPayload = new BatchInfo(new BatchQuery(new Operation(batchQueryOperation.ToString()))),
                ExpectedResponsePayloadContains = new[]
                {
                    "Content-Type: text/javascript;odata.metadata=minimal;odata.streaming=true;IEEE754Compatible=false;charset=utf-8",
                    "foo({\"@odata.context\":",
                    "\"StreetAddress\":\"Line1\",\"City\":\"Redmond\",\"State\":\"WA\",\"PostalCode\":\"98052\"})",
                },
                ResponseStatusCode = 202,
                ResponseETag       = default(string),
            };

            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.HttpMethod         = "POST";
                request.RequestUriString   = "/$batch";
                request.DataServiceType    = typeof(CustomDataContext);
                request.Accept             = UnitTestsUtil.MimeMultipartMixed;
                request.ForceVerboseErrors = true;

                const string boundary = "batch-set";
                request.RequestContentType = String.Format("{0}; boundary={1}", UnitTestsUtil.MimeMultipartMixed, boundary);
                request.SetRequestStreamAsText(BatchRequestWritingUtils.GetBatchText(testCase.RequestPayload, boundary));

                // callback in inner GET request should succeed
                request.SendRequest();
                string response = request.GetResponseStreamAsText();
                Assert.AreEqual(testCase.ResponseStatusCode, request.ResponseStatusCode);
                Assert.IsTrue(request.ResponseContentType.StartsWith("multipart/mixed; boundary=batchresponse_"));
                foreach (string str in testCase.ExpectedResponsePayloadContains)
                {
                    Assert.IsTrue(response.Contains(str), String.Format("The response:\r\n{0}\r\nDoes not contain the string:\r\n{1}.", response, str));
                }

                // callback with $batch should fail
                try
                {
                    request.RequestUriString = "/$batch?$callback=bar";
                    request.SendRequest();
                    Assert.Fail("Request should have failed because it was not a GET request.");
                }
                catch (WebException)
                {
                    Assert.IsTrue(request.GetResponseStreamAsText().Contains("$callback can only be specified on GET requests."));
                    Assert.IsTrue(request.ResponseHeaders["content-type"].StartsWith("application/xml"));
                    Assert.AreEqual(400, request.ResponseStatusCode);
                }
            }
        }
Пример #15
0
 public static void ClassInitialize(TestContext context)
 {
     changeScope         = EFFK.CustomObjectContextPOCOProxy.CreateChangeScope();
     web                 = TestWebRequest.CreateForInProcessWcf();
     web.DataServiceType = typeof(EFFK.CustomObjectContextPOCOProxy);
     OpenWebDataServiceHelper.ForceVerboseErrors = true;
     web.StartService();
 }
Пример #16
0
 public static void ClassInitialize(TestContext context)
 {
     TestUtil.ClearConfiguration();
     request             = (HttpBasedWebRequest)TestWebRequest.CreateForInProcessWcf();
     request.ServiceType = typeof(OpenWebDataService <CustomDataContext>);
     request.StartService();
     serviceRoot = request.ServiceRoot;
 }
Пример #17
0
 public void HttpContextServiceHostQueryStringTest()
 {
     using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
     {
         request.DataServiceType  = typeof(CustomDataContext);
         request.RequestUriString = "/Customers?$orderby=";
         request.SendRequest();
     }
 }
        private TestWebRequest SetupRequest()
        {
            var request = TestWebRequest.CreateForInProcessWcf();

            request.DataServiceType   = typeof(ModifyErrorMessageInHandleExceptionService);
            request.RequestUriString  = "/ThisDoesNotExist";
            request.RequestMaxVersion = "4.0";
            return(request);
        }
Пример #19
0
        [Ignore] // Remove Atom
        // [TestMethod]
        public void ResponseHeadersAndStreamExceptionTest()
        {
            // Execute a query using a variety of methods (including sync, async, batch) and verify the response headers and payloads
            using (PlaybackService.OverridingPlayback.Restore())
                using (PlaybackService.ProcessRequestOverride.Restore())
                    using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                    {
                        request.ServiceType = typeof(PlaybackService);
                        request.StartService();

                        TestUtil.RunCombinations(((IEnumerable <QueryMode>)Enum.GetValues(typeof(QueryMode))), (queryMode) =>
                        {
                            bool isBatchQuery = queryMode == QueryMode.BatchAsyncExecute || queryMode == QueryMode.BatchAsyncExecuteWithCallback || queryMode == QueryMode.BatchExecute;
                            PlaybackService.ProcessRequestOverride.Value = (r) => { throw new InvalidOperationException("ResponseHeadersAndStreamExceptionTest -- Bad Request."); };

                            DataServiceContext context            = new DataServiceContext(new Uri(request.BaseUri));
                            HttpTestHookConsumer testHookConsumer = new HttpTestHookConsumer(context, false);

                            DataServiceQuery <Customer> query = context.CreateQuery <Customer>("Customers");
                            Exception ex = null;
                            try
                            {
                                foreach (var o in DataServiceContextTestUtil.ExecuteQuery(context, query, queryMode))
                                {
                                }
                            }
                            catch (Exception e)
                            {
                                ex = e;
                            }

                            // Verify response headers
                            Assert.AreEqual(1, testHookConsumer.ResponseHeaders.Count, "Wrong number of response headers being tracked by the test hook.");
                            Dictionary <string, string> actualResponseHeaders = testHookConsumer.ResponseHeaders[0];
                            Assert.AreEqual("InternalServerError", actualResponseHeaders["__HttpStatusCode"]);

                            // Verify response stream
                            Assert.AreEqual(1, testHookConsumer.ResponseWrappingStreams.Count, "Unexpected number of response streams tracked by the test hook.");
                            string actualResponsePayload = testHookConsumer.ResponseWrappingStreams[0].GetLoggingStreamAsString();
                            if (queryMode == QueryMode.BatchExecute)
                            {
                                Assert.AreEqual("", actualResponsePayload, "In batch the client calls the hook to get the stream but never reads from it.");
                            }
                            else
                            {
                                TestUtil.AssertContains(actualResponsePayload, "System.InvalidOperationException: ResponseHeadersAndStreamExceptionTest -- Bad Request.");
                            }

                            // Sanity check on the count of request streams, but not verifying them here. That functionality is tested more fully in another test method.
                            int expectedRequestStreamsCount = isBatchQuery ? 1 : 0;
                            Assert.AreEqual(expectedRequestStreamsCount, testHookConsumer.RequestWrappingStreams.Count, "Unexpected number of request streams.");
                        });
                    }
        }
Пример #20
0
 /// <summary>
 /// Create a TestWebRequest using <paramref name="dataServiceType"/> and <paramref name="uri"/>.
 /// Execute the request and extract the IQueryable generated from the service
 /// </summary>
 /// <param name="dataServiceType">The context type for the service</param>
 /// <param name="uri">The uri for this request</param>
 /// <returns>An IQueryable object representing the Queryable for this request</returns>
 public static IQueryable CreateRequestAndGetQueryable(Type dataServiceType, string uri)
 {
     TestUtil.ClearMetadataCache();
     using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
     {
         request.ServiceType      = typeof(ExpressionDataService <>).MakeGenericType(dataServiceType);
         request.RequestUriString = uri;
         request.SendRequest();
         return(lastQueryable);
     }
 }
Пример #21
0
        public void CanOverloadUpdateRequestWithHeader()
        {
            foreach (var serviceType in Services)
            {
                using (CustomDataContext.CreateChangeScope())
                {
                    using (TestWebRequest webRequest = TestWebRequest.CreateForInProcessWcf())
                    {
                        // get an existing customer before sending PUT requests
                        webRequest.HttpMethod       = "GET";
                        webRequest.ServiceType      = serviceType;
                        webRequest.RequestUriString = "/Customers(1)";
                        webRequest.Accept           = UnitTestsUtil.JsonLightMimeType;
                        TestUtil.RunCatching(webRequest.SendRequest);
                        Assert.IsTrue(webRequest.ResponseContentType.ToLower().Contains(UnitTestsUtil.JsonLightMimeType.ToLower()));

                        // all the subsequent requests are PUT requests with specified Accept and Content-Type headers
                        webRequest.HttpMethod         = "PUT";
                        webRequest.Accept             = UnitTestsUtil.JsonLightMimeType;
                        webRequest.RequestContentType = "application/json";

                        // update the customer and send the correct ETag in query string header - should succeed
                        webRequest.RequestUriString = "/Customers(1)/Name?Override-If-Match=" + webRequest.ResponseETag;
                        webRequest.IfMatch          = "SomeBadValue";
                        webRequest.SetRequestStreamAsText("{\"value\": \"Name1\"}");
                        TestUtil.RunCatching(webRequest.SendRequest);
                        Assert.AreEqual(204, webRequest.ResponseStatusCode);
                        string eTag = webRequest.ResponseETag;

                        // update the customer and send ETag with reversed guid in query string header - should fail
                        // Length of a GUID is 36
                        string correctGuid  = webRequest.ResponseETag.Substring(webRequest.ResponseETag.IndexOf('"') + 1, 36);
                        string reversedGuid = string.Concat(correctGuid.ToArray().Reverse());
                        webRequest.RequestUriString = "/Customers(1)/Name?Override-If-Match=" + webRequest.ResponseETag.Replace(correctGuid, reversedGuid);
                        webRequest.IfMatch          = eTag;
                        webRequest.SetRequestStreamAsText("{\"value\": \"Name2\"}");
                        TestUtil.RunCatching(webRequest.SendRequest);
                        Assert.AreEqual(412, webRequest.ResponseStatusCode);

                        // update the customer and send prefer header return=representation in query string - expect 200
                        webRequest.RequestUriString = "/Customers(1)/Name?Override-Prefer=return=representation";
                        webRequest.IfMatch          = eTag;
                        webRequest.SetRequestStreamAsText("{\"value\": \"Name3\"}");
                        TestUtil.RunCatching(webRequest.SendRequest);
                        Assert.AreEqual(200, webRequest.ResponseStatusCode);
                        Assert.IsTrue(webRequest.GetResponseStreamAsText().Contains("TheTest/$metadata#Customers(1)/Name\",\"value\":\"Name3\""));
                    }
                }
            }
        }
Пример #22
0
        private static void RunNegativeActionTestWithAtom(TestCase testCase)
        {
            // These tests are specific to Atom and don't apply to JSON Light.
            // Any JSON Light negative cases are covered by ODL reader tests. See ODL tests OperationReaderJsonLightTests and ODataJsonLightDeserializerTests.
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                using (PlaybackService.ProcessRequestOverride.Restore())
                {
                    request.ServiceType = typeof(AstoriaUnitTests.Stubs.PlaybackService);
                    request.StartService();

                    PlaybackService.ProcessRequestOverride.Value = (req) =>
                    {
                        // These tests intentionally don't set the base URI of the context, so we need to also remove the xml:base attribute that is automatically
                        // generated by the PayloadGenerator. Otherwise another parsing error will occur before we hit the actual errors we are trying to validate.
                        string payload          = PayloadGenerator.Generate(testCase.ResponsePayloadBuilder, ODataFormat.Atom);
                        string xmlBaseAttribute = @"xml:base=""/""";
                        payload = payload.Remove(payload.IndexOf(xmlBaseAttribute), xmlBaseAttribute.Length);

                        req.SetResponseStreamAsText(payload);
                        req.ResponseHeaders.Add("Content-Type", "application/atom+xml");
                        req.SetResponseStatusCode(200);
                        return(req);
                    };

                    Uri uri = new Uri(request.ServiceRoot + "/" + testCase.RequestUriString);
                    DataServiceContext ctx = new DataServiceContext(null, ODataProtocolVersion.V4);
                    ctx.EnableAtom = true;

                    QueryOperationResponse <CustomerEntity> qor = (QueryOperationResponse <CustomerEntity>)ctx.Execute <CustomerEntity>(uri);
                    Assert.IsNotNull(qor);
                    Assert.IsNull(qor.Error);

                    IEnumerator <CustomerEntity> entities = qor.GetEnumerator();

                    Exception exception = AstoriaTest.TestUtil.RunCatching(delegate()
                    {
                        while (entities.MoveNext())
                        {
                            CustomerEntity c    = entities.Current;
                            EntityDescriptor ed = ctx.GetEntityDescriptor(c);
                            IEnumerable <OperationDescriptor> actualDescriptors = ed.OperationDescriptors;
                        }
                    });

                    Assert.IsNotNull(exception);
                    Assert.AreEqual(testCase.ExpectedErrorMessage, exception.Message);
                }
        }
Пример #23
0
        public void ErrorResponseContentTypeHasCharset()
        {
            // regression tests for these bugs :
            // [GQL Failure, ODataLib integration] Server does not write charset in content-type header on error responses
            // [GQL Failure, Astoria-ODataLib Integration] ContentType provided to DataService.HandleException does not match final header value in $batch
            CombinatorialEngine engine = CombinatorialEngine.FromDimensions(
                new Dimension(CustomDataContext.ExceptionTypeArgument, new object[] { typeof(FormatException) }),
                new Dimension(CustomDataContext.ExceptionAtEndArgument, new object[] { true }),
                new Dimension("verbose", new bool[] { true, false }),
                new Dimension("Accept", new string[] { "application/atom", UnitTestsUtil.JsonLightMimeType }),
                new Dimension("Charset", new string[] { null, Encoding.UTF8.WebName, "iso-8859-1" }));

            TestUtil.RunCombinatorialEngineFail(engine, delegate(Hashtable values)
            {
                bool verbose = (bool)values["verbose"];
                using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                {
                    int customerCount = (0xA0 / "Customer 1".Length) + 1;
                    string accept     = values["Accept"].ToString();
                    object charset    = values["Charset"];
                    values[CustomDataContext.CustomerCountArgument] = customerCount;

                    if (charset == null)
                    {
                        charset = Encoding.UTF8.WebName;
                    }
                    else
                    {
                        request.AcceptCharset = charset.ToString();
                    }

                    request.Accept             = accept;
                    request.TestArguments      = values;
                    request.ForceVerboseErrors = verbose;
                    request.DataServiceType    = typeof(CustomDataContext);
                    request.RequestUriString   = "/NonExistantSet";
                    Exception exception        = TestUtil.RunCatching(request.SendRequest);

                    string responseType        = string.Equals(accept, "application/atom") ? "application/xml" : UnitTestsUtil.JsonLightMimeType + ";odata.streaming=true;IEEE754Compatible=false";
                    string expectedContentType = string.Format("{0};charset={1}", responseType, charset.ToString());

                    Assert.IsNotNull(exception, "Expecting an exception, but no exception was thrown");
                    Assert.AreEqual(expectedContentType, request.ResponseContentType, true /*ignoreCase*/);
                }
            });
        }
        private void RunQueryTest(List <DollarFormatTestCase> testCases, string RequestMaxVersion = "4.0;")
        {
            using (TestWebRequest webRequest = TestWebRequest.CreateForInProcessWcf())
            {
                webRequest.HttpMethod      = "GET";
                webRequest.DataServiceType = typeof(DollarFormatTestService);

                foreach (var testCase in testCases)
                {
                    webRequest.RequestUriString  = testCase.UriString;
                    webRequest.RequestMaxVersion = RequestMaxVersion;

                    TestUtil.RunCatching(webRequest.SendRequest);
                    Assert.AreEqual(testCase.ExpectedStatusCode, webRequest.ResponseStatusCode);
                    Assert.AreEqual(testCase.ExpectedContentType, webRequest.ResponseHeaders["Content-Type"]);
                }
            }
        }
Пример #25
0
            public void SendMoreThan100RequestsInBatch()
            {
                using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
                {
                    request.DataServiceType = typeof(CustomDataContext);
                    BatchWebRequest batchRequest = new BatchWebRequest();

                    for (int i = 0; i < 101; i++)
                    {
                        InMemoryWebRequest getRequest = new InMemoryWebRequest();
                        getRequest.RequestUriString = "Customers(1)";
                        batchRequest.Parts.Add(getRequest);
                    }

                    batchRequest.SendRequest(request);
                    Assert.IsFalse(batchRequest.Parts.Any(p => p.ResponseStatusCode != 200), "All the requests should succeed");
                }
            }
Пример #26
0
        /// <summary>
        /// Runs a non-batch test over the the Services defined.
        /// </summary>
        /// <param name="configureRequest">Action to configure the request.</param>
        /// <param name="validateResponse">Action to validate the test results.</param>
        public static void RunTest(Action <TestWebRequest> configureRequest, Action <TestWebRequest> validateResponse)
        {
            foreach (var serviceType in Services)
            {
                using (TestWebRequest webRequest = TestWebRequest.CreateForInProcessWcf())
                {
                    // Default settings
                    webRequest.HttpMethod      = "GET";
                    webRequest.DataServiceType = serviceType;

                    // Apply test's settings
                    configureRequest(webRequest);

                    TestUtil.RunCatching(webRequest.SendRequest);
                    validateResponse(webRequest);
                }
            }
        }
Пример #27
0
        public void VerifyODataLibIsUsedForWritingTopLevelErrors()
        {
            // Only ODL knows about json lite serialization, so we know ODL is being used if the json lite error was serialized correctly.
            const string expectedJsonLitePayload = @"{""error"":{""code"":"""",""message"":""Resource not found for the segment 'Customers'.""}}";

            using (TestWebRequest r = TestWebRequest.CreateForInProcessWcf())
            {
                r.DataServiceType  = typeof(CustomDataContext);
                r.RequestUriString = "/Customers(-2345354)";
                r.HttpMethod       = "GET";
                r.Accept           = "application/json;odata.metadata=minimal";
                TestUtil.RunCatching(() => r.SendRequest());

                string responsePayload = r.GetResponseStreamAsText();
                Assert.AreEqual(404, r.ResponseStatusCode);
                Assert.AreEqual(expectedJsonLitePayload, responsePayload);
            }
        }
Пример #28
0
        public void CallbackOptionValueTest()
        {
            using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
            {
                request.DataServiceType = typeof(CustomDataContext);
                Dictionary <string, string> testCases = new Dictionary <string, string>()
                {
                    // empty callback option
                    { "?$format=json&$callback=", string.Empty },

                    // example callback option values from JQuery and DataJS
                    { "?$callback=parent.handleJSONP_0&$format=json", "parent.handleJSONP_0" },
                    { "?$callback=jQuery18209805240577502099_1348783118115&$format=json&_=1348783118119", "jQuery18209805240577502099_1348783118115" },

                    // callback option values in special character/format
                    { "?$format=json&$callback=null", "null" },
                    { "?$callback=" + Uri.EscapeDataString("A string with characters :%*+,/.") + "&$format=json", "A string with characters :%*+,/." },
                    { "?$callback=" + "<script>$.getJSON(\"http://something.com\",function (data) {alert(data.value);});</script>" + "&$format=json", "<script>$.getJSON(\"http://something.com\",function (data) {alert(data.value);});</script>" },
                };

                foreach (var testCase in testCases)
                {
                    request.RequestUriString = "/Customers(1)" + testCase.Key;

                    request.SendRequest();
                    var actualText = request.GetResponseStreamAsText();
                    if (testCase.Value.Length == 0)
                    {
                        // We don't do JSONP for empty callback value
                        Assert.IsTrue(actualText.StartsWith(testCase.Value + "{"));
                        Assert.IsTrue(actualText.EndsWith("}"));
                        Assert.IsTrue(request.ResponseHeaders["content-type"].StartsWith("application/json;odata.metadata=minimal;"));
                    }
                    else
                    {
                        Assert.IsTrue(actualText.StartsWith(testCase.Value + "({"));
                        Assert.IsTrue(actualText.EndsWith("})"));
                        Assert.IsTrue(request.ResponseHeaders["content-type"].StartsWith("text/javascript;odata.metadata=minimal;"));
                    }

                    Assert.AreEqual(200, request.ResponseStatusCode);
                }
            }
        }
Пример #29
0
        private void QueryDev10TypeService <T>(bool expectException, string exceptionMessage)
            where T : new()
        {
            using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
            {
                web.DataServiceType = typeof(Dev10TypeDef.Dev10TypeEntitySet <T>);
                web.StartService();
                string baseUri = web.BaseUri;

                DataServiceContext context = new DataServiceContext(new Uri(baseUri));

                try
                {
                    var query  = context.CreateQuery <T>("Entities");
                    var result = query.Execute();
                    Assert.IsFalse(expectException);
                    Assert.AreEqual(result.Count(), 3);
                }
                catch (Exception ex)
                {
                    // is exception expected?
                    Assert.IsTrue(expectException, "exception was not expected");
                    if (!String.IsNullOrEmpty(exceptionMessage))
                    {
                        Exception innerEx = ex;
                        while (innerEx.InnerException != null)
                        {
                            innerEx = innerEx.InnerException;
                        }

                        if (exceptionMessage.StartsWith("Contains:"))
                        {
                            exceptionMessage = exceptionMessage.Substring(9);
                            Assert.IsTrue(innerEx.Message.Contains(exceptionMessage), innerEx.Message);
                        }
                        else
                        {
                            Assert.AreEqual(ex.Message, exceptionMessage);
                        }
                    }
                }
            }
        }
        public void SetDollarFormatInBuildingRequest()
        {
            using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
            {
                web.DataServiceType = typeof(DollarFormatTestService);
                web.StartService();

                DataServiceContext ctx     = new DataServiceContext(web.ServiceRoot, ODataProtocolVersion.V4);
                List <string>      options = new List <string>()
                {
                    // "atom",  It will be enabled by finishing
                    // "json",  enable the json case by involving proper EDM model in DataServiceContext.
                    "xml",
                };
                string option = string.Empty;
                ctx.BuildingRequest += (sender, arg) => arg.RequestUri = new Uri(arg.RequestUri.AbsoluteUri + "?$format=" + option);

                foreach (string s in options)
                {
                    try
                    {
                        option = s;
                        ctx.Execute <Customer>(new Uri(web.ServiceRoot + "/Customers"));
                        ctx.CreateQuery <Customer>("Customers");
                        //  Assert.IsTrue(option == "json");
                    }
                    catch (DataServiceQueryException e)
                    {
                        if (option == "xml")
                        {
                            TestUtil.AssertContains(e.InnerException.Message, "A supported MIME type could not be found that matches the acceptable MIME types for the request.");
                            Assert.AreEqual(415, e.Response.StatusCode);
                        }
                        else
                        {
                            // Assert.AreEqual("atom", option);
                            // Assert.AreEqual(DataServicesClientResourceUtil.GetString("DataServiceClientFormat_ValidServiceModelRequiredForAtom"), e.InnerException.Message);
                        }
                    }
                }
            }
        }