New format for Propensity Score JSON (subscriptions-project#532)

Following changes are addressed
- Process new format for Propensity score from server
- New strings for subscription state
- send version number in request

Author: sohanirao

src/api/propensity-api.js

@@ -19,13 +19,13 @@
  */
 export const SubscriptionState = {
   // user's subscription state not known.
-  UNKNOWN: 'na',
+  UNKNOWN: 'unknown',
   // user is not a subscriber.
-  NON_SUBSCRIBER: 'no',
+  NON_SUBSCRIBER: 'non_subscriber',
   // user is a subscriber.
-  SUBSCRIBER: 'yes',
+  SUBSCRIBER: 'subscriber',
   // user's subscription has expired.
-  PAST_SUBSCRIBER: 'ex',
+  PAST_SUBSCRIBER: 'past_subscriber',
 }
 
 /**

src/runtime/propensity-server-test.js

@@ -52,9 +52,12 @@ describes.realWin('PropensityServer', {}, env => {
           expect(queries).to.not.be.null;
           expect('cookie' in queries).to.be.true;
           expect(queries['cookie']).to.equal('noConsent');
+          expect('v' in queries).to.be.true;
+          expect(parseInt(queries['v'], 10)).to.equal(
+              propensityServer.version_);
           expect('states' in queries).to.be.true;
           const userState = 'pub1:' + queries['states'].split(':')[1];
-          expect(userState).to.equal('pub1:yes');
+          expect(userState).to.equal('pub1:subscriber');
           const products = decodeURIComponent(queries['states'].split(':')[2]);
           expect(products).to.equal(JSON.stringify(entitlements));
           expect(capturedRequest.credentials).to.equal('include');
@@ -86,6 +89,8 @@ describes.realWin('PropensityServer', {}, env => {
         expect(queries).to.not.be.null;
         expect('cookie' in queries).to.be.true;
         expect(queries['cookie']).to.equal('noConsent');
+        expect('v' in queries).to.be.true;
+        expect(parseInt(queries['v'], 10)).to.equal(propensityServer.version_);
         expect('events' in queries).to.be.true;
         const events = decodeURIComponent(queries['events'].split(':')[2]);
         expect(events).to.equal(JSON.stringify(eventParam));
@@ -115,6 +120,9 @@ describes.realWin('PropensityServer', {}, env => {
           expect(queries).to.not.be.null;
           expect('cookie' in queries).to.be.true;
           expect(queries['cookie']).to.equal('noConsent');
+          expect('v' in queries).to.be.true;
+          expect(parseInt(queries['v'], 10)).to.equal(
+              propensityServer.version_);
           expect('products' in queries).to.be.true;
           expect(queries['products']).to.equal('pub1');
           expect('type' in queries).to.be.true;
@@ -126,19 +134,95 @@ describes.realWin('PropensityServer', {}, env => {
   });
 
   it('should test get propensity', () => {
-    const score = {'values': [42]};
+    const propensityResponse = {
+      'header': {'ok': true},
+      'scores': [
+        {
+          'product': 'pub1',
+          'score': 90,
+        },
+        {
+          'product': 'pub1:premium',
+          'error_message': 'not available',
+        },
+      ],
+    };
+    const response = new Response();
+    const mockResponse = sandbox.mock(response);
+    mockResponse.expects('json').returns(
+        Promise.resolve(propensityResponse)).once();
+    sandbox.stub(Xhr.prototype, 'fetch',
+        () => {
+          return Promise.resolve(response);
+        });
+    return propensityServer.getPropensity('/hello',
+        PropensityApi.PropensityType.GENERAL).then(response => {
+          expect(response).to.not.be.null;
+          const header = response['header'];
+          expect(header).to.not.be.null;
+          expect(header['ok']).to.be.true;
+          const body = response['body'];
+          expect(body).to.not.be.null;
+          expect(body['result']).to.equal(90);
+        });
+  });
+
+  it('should test only get propensity score for pub', () => {
+    const propensityResponse = {
+      'header': {'ok': true},
+      'scores': [
+        {
+          'product': 'pub2',
+          'score': 90,
+        },
+        {
+          'product': 'pub1:premium',
+          'error_message': 'not available',
+        },
+      ],
+    };
+    const response = new Response();
+    const mockResponse = sandbox.mock(response);
+    mockResponse.expects('json').returns(
+        Promise.resolve(propensityResponse)).once();
+    sandbox.stub(Xhr.prototype, 'fetch',
+        () => {
+          return Promise.resolve(response);
+        });
+    return propensityServer.getPropensity('/hello',
+        PropensityApi.PropensityType.GENERAL).then(response => {
+          expect(response).to.not.be.null;
+          const header = response['header'];
+          expect(header).to.not.be.null;
+          expect(header['ok']).to.be.false;
+          const body = response['body'];
+          expect(body).to.not.be.null;
+          expect(body['result']).to.equal('No score available for pub1');
+        });
+  });
+
+  it('should test no propensity score available', () => {
+    const propensityResponse = {
+      'header': {'ok': false},
+      'error': 'Service not available',
+    };
     const response = new Response();
     const mockResponse = sandbox.mock(response);
-    mockResponse.expects('json').returns(Promise.resolve(score)).once();
+    mockResponse.expects('json').returns(
+        Promise.resolve(propensityResponse)).once();
     sandbox.stub(Xhr.prototype, 'fetch',
         () => {
           return Promise.resolve(response);
         });
     return propensityServer.getPropensity('/hello',
         PropensityApi.PropensityType.GENERAL).then(response => {
           expect(response).to.not.be.null;
-          expect('values' in response).to.be.true;
-          expect(response.values[0]).to.equal(42);
+          const header = response['header'];
+          expect(header).to.not.be.null;
+          expect(header['ok']).to.be.false;
+          const body = response['body'];
+          expect(body).to.not.be.null;
+          expect(body['result']).to.equal('Service not available');
         });
   });
 
@@ -164,6 +248,9 @@ describes.realWin('PropensityServer', {}, env => {
           expect(queries).to.not.be.null;
           expect('cookie' in queries).to.be.true;
           expect(queries['cookie']).to.equal('aaaaaa');
+          expect('v' in queries).to.be.true;
+          expect(parseInt(queries['v'], 10)).to.equal(
+              propensityServer.version_);
           expect('products' in queries).to.be.true;
           expect(queries['products']).to.equal('pub1');
           expect('type' in queries).to.be.true;
@@ -197,6 +284,9 @@ describes.realWin('PropensityServer', {}, env => {
           const queries = parseQueryString(queryString);
           expect(queries).to.not.be.null;
           expect('cookie' in queries).to.be.false;
+          expect('v' in queries).to.be.true;
+          expect(parseInt(queries['v'], 10)).to.equal(
+              propensityServer.version_);
           expect('products' in queries).to.be.true;
           expect(queries['products']).to.equal('pub1');
           expect('type' in queries).to.be.true;

src/runtime/propensity-server.js

@@ -37,6 +37,8 @@ export class PropensityServer {
     this.userConsent_ = false;
     /** @private @const {!Xhr} */
     this.xhr_ = new Xhr(win);
+    /** @private @const {number} */
+    this.version_ = 1;
   }
 
   /**
@@ -92,11 +94,11 @@ export class PropensityServer {
       userState = userState + ':' + encodeURIComponent(entitlements);
     }
     let url = ServiceUrl.adsUrl('/subopt/data?states=')
-        + encodeURIComponent(userState);
+        + encodeURIComponent(userState) + '&u_tz=240'
+        + '&v=' + this.version_;
     if (clientId) {
       url = url + '&cookie=' + clientId;
     }
-    url = url + '&u_tz=240';
     return this.xhr_.fetch(url, init);
   }
 
@@ -115,18 +117,71 @@ export class PropensityServer {
       eventInfo = eventInfo + ':' + encodeURIComponent(context);
     }
     let url = ServiceUrl.adsUrl('/subopt/data?events=')
-        + encodeURIComponent(eventInfo);
+        + encodeURIComponent(eventInfo) + '&u_tz=240'
+        + '&v=' + this.version_;
     if (clientId) {
       url = url + '&cookie=' + clientId;
     }
-    url = url + '&u_tz=240';
     return this.xhr_.fetch(url, init);
   }
 
+  /**
+   * @param {JsonObject} response
+   * @return {!../api/propensity-api.PropensityScore}
+   */
+  parsePropensityResponse_(response) {
+    let defaultScore =
+        /** @type {!../api/propensity-api.PropensityScore} */ ({});
+    if (!response['header']) {
+      defaultScore =
+        /** @type {!../api/propensity-api.PropensityScore} */ ({
+          header: {ok: false},
+          body: {result: 'No valid response'},
+        });
+    }
+    const status = response['header'];
+    if (status['ok']) {
+      const scores = response['scores'];
+      let found = false;
+      for (let i = 0; i < scores.length; i++) {
+        const result = scores[i];
+        if (result['product'] == this.publicationId_) {
+          found = true;
+          const scoreStatus = !!result['score'];
+          let value = undefined;
+          if (scoreStatus) {
+            value = result['score'];
+          } else {
+            value = result['error_message'];
+          }
+          defaultScore =
+            /** @type {!../api/propensity-api.PropensityScore} */ ({
+              header: {ok: scoreStatus},
+              body: {result: value},
+            });
+          break;
+        }
+      }
+      if (!found) {
+        const errorMessage = 'No score available for ' + this.publicationId_;
+        defaultScore = /** @type {!../api/propensity-api.PropensityScore} */ ({
+          header: {ok: false},
+          body: {result: errorMessage},
+        });
+      }
+    } else {
+      const errorMessage = response['error'];
+      defaultScore = /** @type {!../api/propensity-api.PropensityScore} */ ({
+        header: {ok: false},
+        body: {result: errorMessage},
+      });
+    }
+    return defaultScore;
+  }
   /**
    * @param {string} referrer
    * @param {string} type
-   * @return {?Promise<JsonObject>}
+   * @return {?Promise<../api/propensity-api.PropensityScore>}
    */
   getPropensity(referrer, type) {
     const clientId = this.getClientId_();
@@ -136,16 +191,14 @@ export class PropensityServer {
     });
     let url = ServiceUrl.adsUrl('/subopt/pts?products=') + this.publicationId_
         + '&type=' + type + '&u_tz=240'
-        + '&ref=' + referrer;
+        + '&ref=' + referrer
+        + '&v=' + this.version_;
     if (clientId) {
       url = url + '&cookie=' + clientId;
     }
     return this.xhr_.fetch(url, init).then(result => result.json())
-        .then(score => {
-          if (!score) {
-            score = "{'values': [-1]}";
-          }
-          return score;
+        .then(response => {
+          return this.parsePropensityResponse_(response);
         });
   }
 }

src/runtime/propensity-test.js

@@ -127,7 +127,10 @@ describes.realWin('Propensity', {}, env => {
         () => {
           return new Promise(resolve => {
             setTimeout(() => {
-              resolve({'values': [42]});
+              resolve({
+                'header': {'ok': true},
+                'body': {'result': 42},
+              });
             }, 10);
           });
         });

src/runtime/propensity.js

@@ -57,23 +57,7 @@ export class Propensity {
       type = PropensityApi.PropensityType.GENERAL;
     }
     return this.propensityServer_.getPropensity(this.win_.document.referrer,
-        type).then(result => {
-          // TODO(sohanirao): Match HTTP interface
-          let propensityScore = undefined;
-          const score = result && result['values'];
-          if (!score) {
-            propensityScore = {
-              header: {ok: false},
-              body: {result: 'no score available'},
-            };
-          } else {
-            propensityScore = {
-              header: {ok: true},
-              body: {result: score[0]},
-            };
-          }
-          return propensityScore;
-        });
+        type);
   }
 
   /** @override */

src/runtime/runtime-test.js

@@ -1447,9 +1447,9 @@ describes.realWin('ConfiguredRuntime', {}, env => {
         () => Promise.resolve(propensityResponse));
     return runtime.getPropensityModule().then(propensity => {
       expect(propensity).to.not.be.null;
-      propensity.sendSubscriptionState('na');
+      propensity.sendSubscriptionState('unknown');
       propensity.sendEvent('expired');
-      expect(sendSubscriptionStateStub).to.be.calledWithExactly('na');
+      expect(sendSubscriptionStateStub).to.be.calledWithExactly('unknown');
       expect(eventStub).to.be.calledWithExactly('expired');
       return propensity.getPropensity().then(score => {
         expect(score).to.not.be.null;