@snowplow/react-native-tracker 1.3.0 → 2.0.0

package/example/e2e/helpers/microCommands.js

@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2020-2023 Snowplow Analytics Ltd. All rights reserved.
+ *
+ * This program is licensed to you under the Apache License Version 2.0,
+ * and you may not use this file except in compliance with the Apache License Version 2.0.
+ * You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the Apache License Version 2.0 is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
+ */
+
+const Micro = require('./microHelpers.js');
+
+const microUrl = '0.0.0.0';
+const microPort = '9090';
+const microGood = '/micro/good';
+const microBad = '/micro/bad';
+const microReset = '/micro/reset';
+
+async function getMicroGood() {
+  const good = await Micro.requestJson(microUrl, microPort, microGood);
+  return good;
+}
+
+async function getMicroBad() {
+  const bad = await Micro.requestJson(microUrl, microPort, microBad);
+  return bad;
+}
+
+async function resetMicro() {
+  await Micro.request(microUrl, microPort, microReset);
+}
+
+/**
+ * setTimeout promise
+ *
+ * @param {number} millis The milliseconds to wait
+ */
+function sleep(millis) {
+  return new Promise(resolve => {
+    setTimeout(() => resolve('done sleeping!'), millis);
+  });
+}
+
+/**
+ * Asserts no bad events
+ *
+ */
+function assertNoBadEvents() {
+  return getMicroBad().then(res => {
+    expect(res.length).toBe(0);
+  });
+}
+
+/**
+ * Asserts on the number of events having a given schema
+ *
+ * ```
+ * eventsWithSchema("iglu:com.acme/test_event/jsonschema/1-0-0", 2);
+ * ```
+ *
+ * @param {string} schema The event's schema to match
+ * @param {number} [n=1] The expected number of matching events
+ */
+function eventsWithSchema(schema, n = 1) {
+  n = parseInt(n, 10);
+  return getMicroGood().then(arr => {
+    const res = Micro.matchBySchema(arr, schema);
+    expect(res.length).toBe(n);
+  });
+}
+
+/**
+ * Asserts on the number of events having a given type
+ *
+ * ```
+ * eventsWithEventType("struct", 7);
+ * ```
+ *
+ * @param {string} eventType The event's type to match
+ * @param {number} [n=1] The expected number of matching events
+ */
+function eventsWithEventType(eventType, n = 1) {
+  n = parseInt(n, 10);
+  return getMicroGood().then(arr => {
+    const res = Micro.matchByEventType(arr, eventType);
+    expect(res.length).toBe(n);
+  });
+}
+
+/**
+ * Asserts on the number of events having a given set of properties (schema, values, contexts, parameters)
+ *
+ * ```
+ * eventsWithProperties({
+ *     schema: "iglu:com.acme/test_event/jsonschema/1-0-0",
+ *     values: {
+ *         testProperty: true
+ *     },
+ *     header: "the: header"
+ *     contexts: [{
+ *         schema: "iglu:com.acme/test_context/jsonschema/1-0-0",
+ *         data: {
+ *             "testCoProp": 0,
+ *         }
+ *     }],
+ *     parameters: {
+ *         user_id: "tester",
+ *         name_tracker: "myTrackerName"
+ *     }
+ * }, 3);
+ * ```
+ *
+ * @param {Object} eventOptions The options to match against
+ * @param {number} [n=1] The expected number of matching events
+ */
+function eventsWithProperties(eventOptions, n = 1) {
+  n = parseInt(n, 10);
+  return getMicroGood().then(arr => {
+    const res = Micro.matchEvents(arr, eventOptions);
+    expect(res.length).toBe(n);
+  });
+}
+
+/**
+ * Asserts on the number of events having a given HTTP request header
+ *
+ * ```
+ * eventsWithHeader("Connection: keep-alive", 2);
+ * ```
+ *
+ * @param {string} header The request header to match
+ * @param {number} [n=1] The expected number of matching events
+ */
+function eventsWithHeader(header, n = 1) {
+  n = parseInt(n, 10);
+  return getMicroGood().then(arr => {
+    const res = Micro.matchByHeader(arr, header);
+    expect(res.length).toBe(n);
+  });
+}
+
+module.exports = {
+  assertNoBadEvents,
+  eventsWithSchema,
+  eventsWithEventType,
+  eventsWithProperties,
+  eventsWithHeader,
+  resetMicro,
+  sleep,
+};

package/example/e2e/helpers/microHelpers.js

@@ -0,0 +1,346 @@
+/*
+ * Copyright (c) 2020-2023 Snowplow Analytics Ltd. All rights reserved.
+ *
+ * This program is licensed to you under the Apache License Version 2.0,
+ * and you may not use this file except in compliance with the Apache License Version 2.0.
+ * You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the Apache License Version 2.0 is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
+ */
+
+const http = require('http');
+
+/**
+ * Makes an http get request
+ *
+ * @param {string} url
+ * @param {string} port
+ * @param {string} path
+ */
+function request(url, port, path) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: url,
+      port: port,
+      path: path,
+    };
+    try {
+      http.get(options, res => {
+        let data = '';
+        res.on('data', d => (data += d));
+        res.on('end', () => resolve(data));
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+/**
+ * Returns a JSON parsed response from an http request
+ *
+ * @param {string} url
+ * @param {string} port
+ * @param {string} path
+ */
+function requestJson(url, port, path) {
+  return request(url, port, path).then(g => JSON.parse(g));
+}
+
+/**
+ * Filters an array of Snowplow events based on eventType
+ *
+ * ```
+ * matchByEventType(goodEventsArray, "page_view");
+ *
+ * ```
+ * @param {Array} eventsArray An array of Snowplow events
+ * @param {string} eventType The eventType to match
+ * @returns {Array} An array with the matching events
+ */
+function matchByEventType(eventsArray, eventType) {
+  return eventsArray.filter(hasEventType(eventType));
+}
+
+/**
+ * Filters an array of Snowplow events based on schema
+ *
+ * ```
+ * matchBySchema(goodEventsArray, "iglu:com.acme/test_event/jsonschema/1-0-0");
+ * ```
+ *
+ * @param {Array} eventsArray An array of Snowplow events
+ * @param {string} schema The schema to match
+ * @returns {Array} An array with the matching events
+ */
+function matchBySchema(eventsArray, schema) {
+  return eventsArray.filter(hasSchema(schema));
+}
+
+/**
+ * Filters an array of unstructured Snowplow events based on data values
+ *
+ * ```
+ * matchByVals(goodEventsArray, {targetUrl: "https://docs.snowplowanalytics.com/"});
+ * ```
+ *
+ * @param {Array} eventsArray An array of unstructured Snowplow events
+ * @param {Object} valsObj The object having as keys the data fields to match
+ * @returns {Array} An array with the matching events
+ */
+function matchByVals(eventsArray, valsObj) {
+  return eventsArray.filter(hasValues(valsObj));
+}
+
+/**
+ * Filters an array of Snowplow events based on parameter values
+ *
+ * ```
+ * matchByParams(goodEventsArray,
+ *               {
+ *                   event: "struct",
+ *                   se_category: "Mixes",
+ *                   se_action: "Play",
+ *               });
+ * ```
+ *
+ * @param {Array} eventsArray An array of Snowplow events
+ * @param {Object} paramsObj An object having as keys the event parameters to match
+ * @returns {Array} An array with the matching events
+ */
+function matchByParams(eventsArray, paramsObj) {
+  return eventsArray.filter(hasParams(paramsObj));
+}
+
+/**
+ * Filters an array of Snowplow events based on an array of attached contexts
+ *
+ * ```
+ * matchByContexts(goodEventsArray,
+ *                 [{
+ *                     schema: "iglu:com.acme/a_test_context/jsonschema/1-0-0",
+ *                     data: {"testprop": 0}
+ *                 },{
+ *                     schema: "iglu:com.acme/b_test_context/jsonschema/1-0-0"
+ *                 }]);
+ * ```
+ *
+ * @param {Array} eventsArray An array of Snowplow events
+ * @param {Array} expectedContextsArray An array of contexts
+ * @returns {Array} An array with the matching events
+ */
+function matchByContexts(eventsArray, expectedContextsArray) {
+  return eventsArray.filter(hasContexts(expectedContextsArray));
+}
+
+/**
+ * Filters an array of Snowplow events based on the request headers
+ *
+ * ```
+ * matchByHeader(goodEventsArray, "Connection: keep-alive");
+ *
+ * ```
+ * @param {Array} eventsArray An array of Snowplow events
+ * @param {string} header The HTTP request header to match
+ * @returns {Array} An array with the matching events
+ */
+function matchByHeader(eventsArray, header) {
+  return eventsArray.filter(hasHeader(header));
+}
+
+/**
+ * Filters an array of Snowplow events based on event's Properties
+ *
+ * ```
+ * matchEvents(goodEventsArray,
+ *             {
+ *                 schema: "iglu:com.acme/test_event/jsonschema/1-0-0",
+ *                 values: {
+ *                     testProperty: true
+ *                 },
+ *                 contexts: [{
+ *                     schema: "iglu:com.acme/test_context/jsonschema/1-0-0",
+ *                     data: {
+ *                         testCoProp: 0,
+ *                     }
+ *                 }],
+ *                 parameters: {
+ *                     user_id: "tester",
+ *                     name_tracker: "myTrackerName"
+ *                 },
+ *                 header: 'the: header',
+ *             });
+ * ```
+ *
+ * @param {Array} microEvents An array of Snowplow events
+ * @param {Properties} eventProps The event properties to match against
+ * @returns {Array} An array with the matching events
+ */
+function matchEvents(microEvents, eventProps) {
+  if (Object.prototype.toString.call(microEvents) !== '[object Array]') {
+    microEvents = [microEvents];
+  }
+
+  let res = microEvents;
+
+  if (eventProps.eventType) {
+    res = matchByEventType(res, eventProps.eventType);
+  }
+
+  if (eventProps.schema) {
+    res = matchBySchema(res, eventProps.schema);
+  }
+
+  if (eventProps.values) {
+    res = matchByVals(res, eventProps.values);
+  }
+
+  if (eventProps.contexts) {
+    res = matchByContexts(res, eventProps.contexts);
+  }
+
+  if (eventProps.parameters) {
+    res = matchByParams(res, eventProps.parameters);
+  }
+
+  if (eventProps.header) {
+    res = matchByHeader(res, eventProps.header);
+  }
+
+  return res;
+}
+
+function hasEventType(evType) {
+  return function (ev) {
+    return ev.eventType === evType;
+  };
+}
+
+function hasSchema(schema) {
+  return function (ev) {
+    if (ev.eventType === 'unstruct') {
+      let unstruct_ev = ev.event.unstruct_event;
+
+      return unstruct_ev.data.schema === schema;
+    } else {
+      return false;
+    }
+  };
+}
+
+function hasValues(values) {
+  return function (ev) {
+    if (ev.eventType === 'unstruct') {
+      let unstruct_ev = ev.event.unstruct_event;
+      let data = unstruct_ev.data.data;
+
+      return (
+        Object.keys(values).every(keyIncludedIn(data)) &&
+        Object.keys(values).every(comparesIn(values, data))
+      );
+    } else {
+      return false;
+    }
+  };
+}
+
+function hasParams(expectParams) {
+  return function (ev) {
+    let actualParams = ev.event;
+
+    return (
+      Object.keys(expectParams).every(keyIncludedIn(actualParams)) &&
+      Object.keys(expectParams).every(comparesIn(expectParams, actualParams))
+    );
+  };
+}
+
+function hasContexts(expCoArr) {
+  return function (ev) {
+    let evCo = ev.event.contexts;
+
+    if (evCo.hasOwnProperty('data')) {
+      let actCoArr = evCo.data;
+
+      return compare(expCoArr, actCoArr);
+    } else {
+      return false;
+    }
+  };
+}
+
+function hasHeader(header) {
+  return function (ev) {
+    return ev.rawEvent.context.headers.includes(header);
+  };
+}
+
+function keyIncludedIn(obj) {
+  return function (key) {
+    return Object.keys(obj).includes(key);
+  };
+}
+
+function comparesIn(expected, actual) {
+  return function (key) {
+    let expValue = expected[key];
+    let actValue = actual[key];
+
+    return compare(expValue, actValue);
+  };
+}
+
+/**
+ * A function to deep compare (equality for primitive data types and containership for Objects and Arrays)
+ *
+ * ```
+ * compare(1, 1);  // true
+ * compare(1, "1");  // false
+ * compare([1, 2], [3, 1, 2]);  // true
+ * compare({a:1, b:2}, {b:2, c:3, a:1});  // true
+ * compare([1, [2]], [[3, 2], 1, 4]);  // true
+ * compare({a: [1, 2], b: {c:3}}, {b: {d:4, c:3}, a:[3, 2, 1]});  // true
+ * ```
+ *
+ * @param {*} expVal The expected value
+ * @param {*} actVal The actual value
+ * @returns {Boolean} Whether the expVal is equal to or deeply contained in actVal
+ */
+function compare(expVal, actVal) {
+  let expType = Object.prototype.toString.call(expVal);
+  let actType = Object.prototype.toString.call(actVal);
+
+  if (expVal === null) {
+    return actVal === null;
+  } else if (expType !== actType) {
+    return false;
+  } else if (expType === '[object Array]') {
+    return expVal.every(function (e) {
+      return actVal.some(function (a) {
+        return compare(e, a);
+      });
+    });
+  } else if (expType === '[object Object]') {
+    return Object.keys(expVal).every(function (k) {
+      return Object.keys(actVal).includes(k) && compare(expVal[k], actVal[k]);
+    });
+  } else {
+    return expVal === actVal;
+  }
+}
+
+module.exports = {
+  matchByEventType,
+  matchBySchema,
+  matchByVals,
+  matchByParams,
+  matchByContexts,
+  matchByHeader,
+  matchEvents,
+  compare,
+  request,
+  requestJson,
+};