fixed casing for parameters

Author: pedrosilva0111

Gruntfile.js

@@ -74,7 +74,7 @@ module.exports = function(grunt) {
       unitBrowsers: {
         options: {
           // Run tests on all the browsers on the system.
-          frameworks: ['jasmine', 'detectBrowsers'],
+          frameworks: ['jasmine-ajax', 'jasmine', 'detectBrowsers'],
           detectBrowsers: {
             enabled: true,
             // Don't try to load phantomJS, it may not exist.
@@ -87,7 +87,7 @@ module.exports = function(grunt) {
       },
       integrationBrowsers: {
         options: { // Same options as for unitBrowsers.
-          frameworks: ['jasmine', 'detectBrowsers'],
+          frameworks: ['jasmine-ajax', 'jasmine', 'detectBrowsers'],
           detectBrowsers: {
             enabled: true,
             usePhantomJS: false,

karma.conf.js

@@ -4,7 +4,7 @@
 module.exports = function(config) {
   config.set({
     basePath: '',
-    frameworks: ['jasmine'],
+    frameworks: ['jasmine-ajax', 'jasmine'],
     // Automatically run tests for files matching these regex.
     files: [
       // ----------------- Third Party Dependencies ----------------------------
@@ -19,16 +19,20 @@ module.exports = function(config) {
       // ------------------------ Source Files ---------------------------------
       {pattern: 'src/logging.js'},
       {pattern: 'src/storage/**.js'},
-      {pattern: 'src/eventProcessor/**.js'},
+      {pattern: 'src/eventProcessor/EventProcessorInterface.js'},
+      {pattern: 'src/eventProcessor/generateUniqueId.js'},
+      {pattern: 'src/eventProcessor/GoogleAnalyticsEventProcessor.js'},
       {pattern: 'src/config/configProcessors.js'},
       {pattern: 'src/config/setup.js'},
       {pattern: 'src/main.js'},
       // ------------------------- Test Files ----------------------------------
+      'test/unit/mocks.js',
       'test/unit/**/*_test.js',
     ],
     preprocessors: {'**/*.js': ['googmodule']},
     plugins: [
       require('karma-jasmine'),
+      require('karma-jasmine-ajax'),
       require('karma-detect-browsers'),
       require('karma-chrome-launcher'),
       require('karma-firefox-launcher'),

package.json

@@ -20,6 +20,7 @@
     "grunt": "~1.2.1",
     "grunt-karma": "~4.0.0",
     "jasmine": "~3.5.0",
+    "jasmine-ajax": "~4.0.0",
     "jasmine-core": "~3.5.0",
     "karma": "~5.1.0",
     "karma-chrome-launcher": "~3.1.0",
@@ -28,6 +29,7 @@
     "karma-googmodule-preprocessor": "~1.0.1",
     "karma-ie-launcher": "~1.0.0",
     "karma-jasmine": "~3.3.1",
+    "karma-jasmine-ajax": "~0.1.13",
     "karma-jasmine-html-reporter": "~1.5.4",
     "karma-safari-launcher": "~1.0.0",
     "karma-spec-reporter": "~0.0.32"

src/eventProcessor/GoogleAnalyticsEventProcessor.js

@@ -1,5 +1,6 @@
 goog.module('measurementLibrary.eventProcessor.GoogleAnalyticsEventProcessor');
 
+const uniqueId = goog.require('measurementLibrary.eventProcessor.generateUniqueId');
 const logging = goog.require('measurementLibrary.logging');
 
 /**
@@ -8,11 +9,11 @@ const logging = goog.require('measurementLibrary.logging');
  * @const {!Object<string,boolean>}
  */
 const TOP_LEVEL_PARAMS = {
-  'client_id': true,
-  'user_id': true,
-  'timestamp_micros': true,
-  'user_properties': true,
-  'non_personalized_ads': true,
+  'client_id': 'clientId',
+  'user_id': 'userId',
+  'timestamp_micros': 'timestampMircos',
+  'user_properties': 'userProperties',
+  'non_personalized_ads': 'nonPersonalizedAds',
 };
 
 /**
@@ -135,16 +136,16 @@ class GoogleAnalyticsEventProcessor {
      * @private @const {!Object<string, boolean>}
      */
     this.automaticParams_ = {
-      'page_path': true,
-      'page_location': true,
-      'page_title': true,
-      'user_id': true,
-      'client_id': true,
+      'page_path': 'page_path',
+      'page_location': 'page_location',
+      'page_title': 'page_title',
+      'user_id': 'userId',
+      'client_id': 'clientId',
     };
 
     // Add user provided params to automatic param list
     for (let i = 0; i < userAutomaticParams.length; ++i) {
-      this.automaticParams_[userAutomaticParams[i]] = true;
+      this.automaticParams_[userAutomaticParams[i]] = userAutomaticParams[i];
     }
 
     /**
@@ -187,6 +188,47 @@ class GoogleAnalyticsEventProcessor {
     return 'googleAnalytics';
   }
 
+  /**
+   * Gets value stored in the global model under a given key.
+   * Only accesses the globel model if the given key is an automatic parameter.
+   * @param {string} key
+   * @param {{get:function(string):*, set:function(string, *)}} modelInterface
+   *    An interface to load or save short term page data from the data layer.
+   * @return {*} value
+   * @private
+   */
+  getFromGlobalScope_(key, modelInterface) {
+    if (this.automaticParams_[key]) {
+      return modelInterface.get(this.automaticParams_[key]);
+    }
+    return undefined;
+  }
+
+  /**
+   * Gets the ID associated with the current client.
+   * First queries the global model followed by long term storage if not yet
+   * found for `clientId`. If no previous ID exists, a new one is generated
+   * and stored for future use in both the global model and long term storage.
+   * @param {!StorageInterface} storageInterface An interface to an object to
+   *    load or save persistent data with.
+   * @param {{get:function(string):*, set:function(string, *)}} modelInterface
+   *    An interface to load or save short term page data from the data layer.
+   * @return {string}
+   * @private
+   */
+  getClientId_(storageInterface, modelInterface) {
+    let clientId = this.getFromGlobalScope_('client_id', modelInterface);
+    if (!clientId || typeof clientId !== 'string') {
+      clientId = storageInterface.load('clientId');
+      if (!clientId || typeof clientId !== 'string') {
+        clientId = uniqueId.generateUniqueId();
+        storageInterface.save('clientId', clientId, this.clientIdExpires_);
+      }
+      modelInterface.set('clientId', clientId);
+    }
+    return clientId;
+  }
+
   /**
    * Builds the POST request URL using `measurement_id` and `api_secret`
    * query parameters if available
@@ -212,6 +254,27 @@ class GoogleAnalyticsEventProcessor {
     return this.measurementUrl_;
   }
 
+  /**
+   * Adds a key value pair to JSON POST request if value is defined.
+   * If the key is a top level parameter, the pair will be added at the topmost
+   * level of the JSON.
+   * If not, the pair is interpreted as an event parameter and added to the
+   * params object within the JSON.
+   * @param {!Object<string, *>} json
+   * @param {string} key
+   * @param {*} value
+   * @private
+   */
+  addKeyValuePairToJson_(json, key, value) {
+    if (value !== undefined) {
+      if (TOP_LEVEL_PARAMS[key]) {
+        json[TOP_LEVEL_PARAMS[key]] = value;
+      } else if (!TOP_LEVEL_PARAMS[key]) {
+        json.events[0].params[key] = value;
+      }
+    }
+  }
+
   /**
    * Processes events pushed to the data layer by constructing and sending JSON
    * POST requests to Google Analytics.
@@ -226,7 +289,34 @@ class GoogleAnalyticsEventProcessor {
    * @export
    */
   processEvent(storageInterface, modelInterface, eventName, eventOptions) {
-    // TODO(kjgalvan):: constructs and sends JSON POST requests to GA
+    const xhr = new XMLHttpRequest();
+    xhr.open('POST', this.buildRequestUrl_());
+
+    const json = {
+      events: [{'name': eventName, 'params': {}}],
+    };
+
+    for (const key in this.automaticParams_) {
+      let value;
+      if (key === 'client_id') {
+        value = this.getClientId_(storageInterface, modelInterface);
+      } else {
+        value = this.getFromGlobalScope_(key, modelInterface);
+      }
+      this.addKeyValuePairToJson_(json, key, value);
+    }
+
+    for (const key in eventOptions) {
+      this.addKeyValuePairToJson_(json, key, eventOptions[key]);
+    }
+
+    if (logging.DEBUG) {
+      xhr.onload = () => {
+        logging.log(xhr.responseText, logging.LogLevel.INFO);
+      };
+    }
+
+    xhr.send(JSON.stringify(json));
   }
 
   /**
@@ -243,7 +333,7 @@ class GoogleAnalyticsEventProcessor {
    * @export
    */
   persistTime(key, value) {
-    if (key === 'client_id') {
+    if (key === 'clientId') {
       return this.clientIdExpires_;
     } else {
       return -1;

src/eventProcessor/generateUniqueId.js

@@ -0,0 +1,37 @@
+goog.module('measurementLibrary.eventProcessor.generateUniqueId');
+
+/**
+ * Returns a cryptographically secure random number generator if
+ * available.
+ * @return {function(!Uint32Array):!Uint32Array|undefined}
+ */
+function getCryptoRandomValues() {
+  let getRandomValues;
+  if (window.crypto) {
+    getRandomValues = window.crypto.getRandomValues.bind(crypto);
+  } else if (window.msCrypto) {
+    getRandomValues = window.msCrypto.getRandomValues
+        .bind(window.msCrypto); // IE11
+  }
+  return getRandomValues;
+}
+
+/**
+ * Generates a unique ID in the format [uint32].[timestamp]
+ * @param {(function(!Uint32Array):!Uint32Array|null)=} randomNumberGenerator
+ * @return {string}
+ */
+function generateUniqueId(randomNumberGenerator = getCryptoRandomValues()) {
+  let uint32;
+  if (randomNumberGenerator) {
+    uint32 = randomNumberGenerator(new Uint32Array(1))[0];
+  } else {
+    uint32 = (Math.random() * (0xFFFFFFFF)) >>> 0;
+  }
+  const timestamp = Math.floor(new Date().getTime() / 1000);
+  return `${uint32}.${timestamp}`;
+}
+
+exports = {
+  generateUniqueId,
+};

test/unit/GoogleAnalyticsEventProcessor/constructor_test.js

@@ -1,4 +1,4 @@
-goog.module('measurementLibrary.eventProcessor.testing.GoogleAnalyticsEventProcessor.constructor');
+goog.module('measurementLibrary.testing.eventProcessor.GoogleAnalyticsEventProcessor.constructor');
 goog.setTestOnly();
 
 const GoogleAnalyticsEventProcessor = goog.require('measurementLibrary.eventProcessor.GoogleAnalyticsEventProcessor');
@@ -12,8 +12,8 @@ describe('The `constructor` of GoogleAnalyticsEventProcessor', () => {
     'page_path': true,
     'page_location': true,
     'page_title': true,
-    'user_id': true,
-    'client_id': true,
+    'userId': true,
+    'clientId': true,
   };
 
   it('does not have a default arguments for ' +
@@ -72,7 +72,7 @@ describe('The `constructor` of GoogleAnalyticsEventProcessor', () => {
       automatic_params: ['custom_param'],
     });
 
-    expect(eventProcessor.automaticParams_['client_id']).toBeTrue();
+    expect(eventProcessor.automaticParams_['clientId']).toBeTrue();
     expect(eventProcessor.automaticParams_['custom_param']).toBeTrue();
   });
 

test/unit/GoogleAnalyticsEventProcessor/getClientId_test.js

@@ -0,0 +1,72 @@
+goog.module('measurementLibrary.testing.eventProcessor.GoogleAnalyticsEventProcessor.getClientId');
+goog.setTestOnly();
+
+const uniqueId = goog.require('measurementLibrary.eventProcessor.generateUniqueId');
+const GoogleAnalyticsEventProcessor = goog.require('measurementLibrary.eventProcessor.GoogleAnalyticsEventProcessor');
+const {MockStorage, MockModelInterface} = goog.require('measurementLibrary.testing.mocks');
+
+
+describe('The `getClientId_` method ' +
+    'of GoogleAnalyticsEventProcessor', () => {
+  const mockStoredId = 'stored_clientId';
+  const mockModelId = 'model_clientId';
+  const mockGeneratedId = 'generated_clientId';
+  const eventProcessor = new GoogleAnalyticsEventProcessor();
+  let mockStorage;
+  let mockModelInterface;
+  let generateUniqueId;
+
+  // mock the unique ID module
+  beforeAll(() => {
+    generateUniqueId = uniqueId.generateUniqueId;
+    uniqueId.generateUniqueId = () => {
+      return mockGeneratedId;
+    };
+  });
+
+  it('generates a client id when no id is present in model or storage ' +
+      'and adds it to the current model and storage', () => {
+    mockStorage = new MockStorage({'clientId': undefined});
+    mockModelInterface =
+        new MockModelInterface({'clientId': undefined});
+
+    expect(eventProcessor.getClientId_(mockStorage, mockModelInterface))
+        .toBe(mockGeneratedId);
+    expect(mockModelInterface.get('clientId')).toBe(mockGeneratedId);
+    expect(mockStorage.load('clientId')).toBe(mockGeneratedId);
+  });
+
+  it('loads client id from storage when no id is present in model ' +
+      'and adds it to the current model', () => {
+    mockStorage = new MockStorage({'clientId': mockStoredId});
+    mockModelInterface =
+        new MockModelInterface({'clientId': undefined});
+
+    expect(eventProcessor.getClientId_(mockStorage, mockModelInterface))
+        .toBe(mockStoredId);
+    expect(mockModelInterface.get('clientId')).toBe('stored_clientId');
+  });
+
+  it('loads client id from model if present', () => {
+    mockStorage = new MockStorage({'clientId': undefined});
+    mockModelInterface =
+        new MockModelInterface({'clientId': mockModelId});
+
+    expect(eventProcessor.getClientId_(mockStorage, mockModelInterface))
+        .toBe(mockModelId);
+  });
+
+  it('loads client id from model even if there is a ' +
+      'different client id in storage', () => {
+    mockStorage = new MockStorage({'clientId': mockStoredId});
+    mockModelInterface =
+        new MockModelInterface({'clientId': mockModelId});
+
+    expect(eventProcessor.getClientId_(mockStorage, mockModelInterface))
+        .toBe(mockModelId);
+  });
+
+  afterAll(() => {
+    uniqueId.generateUniqueId = generateUniqueId;
+  });
+});

test/unit/GoogleAnalyticsEventProcessor/persistTime_test.js

@@ -21,17 +21,17 @@ describe('The `persistTime` method ' +
     return expect(eventProcessor.persistTime(key, ''));
   }
 
-  it('returns default when key is not client_id', () => {
+  it('returns default when key is not clientId', () => {
     expectPersistTime('test').toBe(-1);
   });
 
-  describe('When key is client_id', () => {
+  describe('When key is clientId', () => {
     it('returns two years when client_id_expires is not set', () => {
-      expectPersistTime('client_id').toBe(2 * 365 * 24 * 60 * 60);
+      expectPersistTime('clientId').toBe(2 * 365 * 24 * 60 * 60);
     });
 
     it('returns overridden number when client_id_expires is set', () => {
-      expectPersistTime('client_id', /* clientIdExpires */ 0).toBe(0);
+      expectPersistTime('clientId', /* clientIdExpires */ 0).toBe(0);
     });
   });
 });