public void Test_NoStore_ResultsIn_ExpiredResourceAndPragmaNoCache()
        {
            var request = new HttpRequestMessage(HttpMethod.Get, TestUrl);

            request.Headers.Add(HttpHeaderNames.Accept, "text/xml");
            var entityTagHeaderValue = new TimedEntityTagHeaderValue("\"12345678\"");
            var cachingHandler       = new CachingHandler("test", "1.0.0", new HttpConfiguration())
            {
                ETagValueGenerator         = (x, y) => entityTagHeaderValue,
                CacheControlHeaderProvider = (r, c) =>
                {
                    return(new CacheControlHeaderValue()
                    {
                        NoStore = true,
                        NoCache = true
                    });
                }
            };
            var response = request.CreateResponse(HttpStatusCode.Accepted);

            cachingHandler.AddCaching(new CacheKey(TestUrl, new string[0]), request, response)();
            Assert.IsTrue(response.Headers.Pragma.Any(x => x.Name == "no-cache"), "no-cache not in pragma");
        }
        public static void AddCaching(string method,
                                      bool existsInStore,
                                      bool addVaryHeader,
                                      bool addLastModifiedHeader,
                                      bool alreadyHasLastModified,
                                      string[] varyByHeader)
        {
            // setup
            var mocks   = new MockRepository();
            var request = new HttpRequestMessage(new HttpMethod(method), TestUrl);

            request.Headers.Add(HttpHeaderNames.Accept, "text/xml");
            request.Headers.Add(HttpHeaderNames.AcceptLanguage, "en-GB");
            var entityTagStore       = mocks.StrictMock <IEntityTagStore>();
            var entityTagHeaderValue = new TimedEntityTagHeaderValue("\"12345678\"");
            var cachingHandler       = new CachingHandler("test", "1.0.0", new HttpConfiguration(), entityTagStore, varyByHeader)
            {
                AddLastModifiedHeader = addLastModifiedHeader,
                AddVaryHeader         = addVaryHeader,
                ETagValueGenerator    = (x, y) => entityTagHeaderValue
            };


            var entityTagKey = new CacheKey(TestUrl, new[] { "text/xml", "en-GB" }, TestUrl + "/*");

            entityTagStore.Expect(x => x.TryGetValue(Arg <CacheKey> .Matches(etg => etg.ResourceUri == TestUrl),
                                                     out Arg <TimedEntityTagHeaderValue> .Out(entityTagHeaderValue).Dummy)).Return(existsInStore);

            if (!existsInStore)
            {
                entityTagStore.Expect(
                    x => x.AddOrUpdate(Arg <CacheKey> .Matches(etk => etk == entityTagKey),
                                       Arg <TimedEntityTagHeaderValue> .Matches(ethv => ethv.Tag == entityTagHeaderValue.Tag)));
            }

            var response = new HttpResponseMessage();

            response.Content = new ByteArrayContent(new byte[0]);
            if (alreadyHasLastModified)
            {
                response.Content.Headers.Add(HttpHeaderNames.LastModified, DateTimeOffset.Now.ToString("r"));
            }

            var cachingContinuation = cachingHandler.AddCaching(entityTagKey, request, response);

            mocks.ReplayAll();

            // run
            cachingContinuation();

            // verify

            // test kast modified only if it is GET and PUT
            if (addLastModifiedHeader && method.IsIn("PUT", "GET"))
            {
                Assert.That(response.Content.Headers.Any(x => x.Key == HttpHeaderNames.LastModified),
                            "LastModified does not exist");
            }
            if (!addLastModifiedHeader && !alreadyHasLastModified)
            {
                Assert.That(!response.Content.Headers.Any(x => x.Key == HttpHeaderNames.LastModified),
                            "LastModified exists");
            }
            mocks.VerifyAll();
        }