Better support stale-while-revalidate option

Author: Embraser01

index.js

@@ -36,7 +36,7 @@ const understoodStatuses = new Set([
 const errorStatusCodes = new Set([
     500,
     502,
-    503, 
+    503,
     504,
 ]);
 
@@ -255,8 +255,16 @@ module.exports = class CachePolicy {
         // the stored response is either:
         // fresh, or allowed to be served stale
         if (this.stale()) {
-            const allowsStale = requestCC['max-stale'] &&
-                (true === requestCC['max-stale'] || requestCC['max-stale'] > this.age() - this.maxAge());
+            let allowsStale = false;
+            if (requestCC['max-stale'] && !this._rescc['must-revalidate']) {
+                if (requestCC['max-stale'] === true || requestCC['max-stale'] > this.age() - this.maxAge()) {
+                    allowsStale = true;
+                }
+            // Allow stale-while-revalidate queries to be served stale
+            // even if must-revalidate is set as the revalidation should be happening in the background
+            } else if (this.useStaleWhileRevalidate()) {
+                allowsStale = true;
+            }
 
             if (!allowsStale) {
                 return false;

test/okhttptest.js

@@ -210,6 +210,81 @@ describe('okhttp tests', function() {
         assert.equal(cache.timeToLive(), 260000);
     });
 
+    it('stale-while-revalidate satisfies when stale', function() {
+        const cache = new CachePolicy(
+            { headers: {} },
+            {
+                headers: {
+                    age: 120,
+                    'cache-control': 'max-age=60, stale-while-revalidate=200',
+                },
+            },
+            { shared: false }
+        );
+
+        assert(cache.stale());
+        assert(cache.useStaleWhileRevalidate());
+        assert(cache.satisfiesWithoutRevalidation({ headers: {} }));
+    });
+
+    it('stale-while-revalidate satisfies when stale and must-revalidate', function() {
+        const cache = new CachePolicy(
+            { headers: {} },
+            {
+                headers: {
+                    age: 120,
+                    'cache-control': 'max-age=60, stale-while-revalidate=200, must-revalidate',
+                },
+            },
+            { shared: false }
+        );
+
+        assert(cache.stale());
+        assert(cache.satisfiesWithoutRevalidation({ headers: {} }));
+    });
+
+    it('stale-while-revalidate work with max-stale', function() {
+        const cache = new CachePolicy(
+            { headers: {} },
+            {
+                headers: {
+                    age: 100,
+                    'cache-control': 'max-age=60, stale-while-revalidate=200',
+                },
+            },
+            { shared: false }
+        );
+
+        assert(cache.stale());
+        assert(cache.satisfiesWithoutRevalidation({
+            headers: {
+                'cache-control': 'max-stale',
+            }
+        }));
+        assert(!cache.satisfiesWithoutRevalidation({
+            headers: {
+                'cache-control': 'max-stale=40',
+            }
+        }));
+    });
+
+    it('stale-while-revalidate not satisfies when stale and expired', function() {
+        const cache = new CachePolicy(
+            { headers: {} },
+            {
+                headers: {
+                    age: 260,
+                    'cache-control': 'max-age=60, stale-while-revalidate=200',
+                },
+            },
+            { shared: false }
+        );
+
+        assert(cache.stale());
+        assert(!cache.useStaleWhileRevalidate());
+        assert(!cache.satisfiesWithoutRevalidation({ headers: {} }));
+    });
+
     it('max age preferred over lower shared max age', function() {
         const cache = new CachePolicy(
             { headers: {} },