@cendarsoss/pusher-js 8.4.11

package/spec/config/karma/config.ci.js

@@ -0,0 +1,25 @@
+var config = {
+  browserStack: {
+    startTunnel: true,
+    timeout: 1800,
+  },
+  browsers: ['ChromeHeadless', 'FirefoxHeadless'],
+  customLaunchers: {
+    bs_safari_12: {
+      base: 'BrowserStack',
+      os_version: "Mojave",
+      browser: "Safari",
+      browser_version: "12",
+      os: "OS X"
+    }
+  }
+};
+if (process.env.CI === 'full' && browserStackCredsAvailable()) {
+  config.browsers.push('bs_safari_12');
+}
+
+function browserStackCredsAvailable() {
+  return process.env.BROWSER_STACK_USERNAME && process.env.BROWSER_STACK_ACCESS_KEY
+}
+
+module.exports = config;

package/spec/config/karma/config.common.js

@@ -0,0 +1,50 @@
+const { merge } = require('webpack-merge');
+const webpackConfig = require('../../../webpack/config.shared');
+
+var browserList;
+if (process.env.MINIMAL_INTEGRATION_TESTS) {
+  browserList = ['ChromeHeadless'];
+} else {
+  browserList = ['ChromeHeadless', 'FirefoxHeadless'];
+}
+
+module.exports = {
+  basePath: '../../../',
+  frameworks: ["jasmine"],
+
+  reporters: ['verbose'],
+
+  webpack: merge({}, webpackConfig, {
+    mode: 'development',
+    resolve: {
+      modules: [
+        'src/runtimes/web',
+        'spec/javascripts/helpers'
+      ]
+    },
+    externals: {
+      testenv: "'web'"
+    }
+  }),
+  port: 9876,
+  runnerPort: 9100,
+  colors: true,
+  autoWatch: true,
+
+  browsers: browserList,
+  captureTimeout: 10e3,
+  browserNoActivityTimeout: 3e4,
+  browserDisconnectTimeout: 3e4,
+  browserDisconnectTolerance: 3,
+
+  singleRun: true,
+  client: {
+    captureConsole: false,
+    jasmine: {
+      // This new behaviour in jasmine is enabled by default but, some of our
+      // old tests rely on sequential execution.
+      // @todo Enable random order execution (i.e. remove this flag) and fix tests that are broken
+      random: false
+    }
+  }
+};

package/spec/config/karma/config.integration.js

@@ -0,0 +1,26 @@
+const { merge } = require('webpack-merge');
+const webpack = require('webpack');
+const commonConfig = require('./config.common');
+
+module.exports = merge({}, commonConfig, {
+  files: [
+    '**/spec/javascripts/integration/index.web.js'
+  ],
+  preprocessors: {
+    '**/spec/javascripts/integration/index.web.js': ['webpack']
+  },
+
+  webpack: {
+    resolve: {
+      modules: ['spec/javascripts/helpers/web'],
+      alias: {
+        integration: 'web/integration'
+      }
+    },
+    plugins: [
+      new webpack.DefinePlugin({
+        'process.env.MINIMAL_INTEGRATION_TESTS': JSON.stringify(process.env.MINIMAL_INTEGRATION_TESTS),
+      })
+    ],
+  }
+});

package/spec/config/karma/config.unit.js

@@ -0,0 +1,10 @@
+const { merge } = require('webpack-merge');
+const commonConfig = require('./config.common');
+
+
+module.exports = merge(commonConfig, {
+  files: ['**/spec/javascripts/unit/index.web.js'],
+  preprocessors: {
+    '**/spec/javascripts/unit/index.web.js': ['webpack']
+  },
+});

package/spec/config/karma/config.worker.js

@@ -0,0 +1,34 @@
+/*
+Takes + modifies existing Karma config + the name of the suite,
+i.e. 'unit' or 'integration'.
+Sorts out the module resolution for this build and changes
+the testenv.
+*/
+module.exports = function(config, suite) {
+  config.frameworks = ["jasmine-web-worker"];
+  config.files = [
+    '**/spec/javascripts/'+suite+'/index.worker.js'
+  ];
+
+  config.preprocessors = {
+    '**/spec/javascripts/node_modules/**/*.ts': ['webpack'],
+    '**/spec/javascripts/helpers/**/*.js': ['webpack']
+  };
+
+  var index = '**/spec/javascripts/'+suite+'/index.worker.js';
+  config.preprocessors[index] = ['webpack'];
+
+  config.webpack.resolve.modules = [
+    'node_modules',
+    'web_modules',
+    'src',
+    'src/runtimes/worker',
+    'src/runtimes',
+    'spec/javascripts/helpers'
+  ]
+  config.webpack.resolve.alias = {
+    'dom/dependencies': 'worker/mock-dom-dependencies',
+  }
+  config.webpack.externals.testenv = "'worker'";
+  return config;
+}

package/spec/config/karma/integration.js

@@ -0,0 +1,24 @@
+const { merge } = require('webpack-merge');
+var config = require('./config.integration');
+
+if (process.env.CI) {
+  var ci = require('./config.ci');
+  config = merge(config, ci);
+  config.browsers = ci.browsers;
+}
+
+if (process.env.WORKER === 'true') {
+  config = require('./config.worker')(config, 'integration');
+  config.webpack.resolve.alias = {
+    pusher_integration: 'core/pusher.js',
+    integration: 'node/integration',
+    'dom/dependencies': 'worker/mock-dom-dependencies',
+    'dom/dependency_loader': 'worker/mock-dom-dependencies',
+  };
+  if (process.env.CI) config.browsers = ['bs_chrome_74'];
+}
+
+module.exports = function(suite) {
+  config.logLevel = suite.LOG_INFO,
+  suite.set(config);
+};

package/spec/config/karma/unit.js

@@ -0,0 +1,20 @@
+const { merge } = require('webpack-merge');
+var config = require('./config.unit');
+
+if (process.env.CI) {
+  var ci = require('./config.ci');
+  config = merge(config, ci);
+  config.browsers = ci.browsers;
+}
+
+if (process.env.WORKER === 'true') {
+  config = require('./config.worker')(config, 'unit');
+
+  // only run worker test on Chrome for CI
+  if (process.env.CI) config.browsers = ['bs_chrome_74'];
+}
+
+module.exports = function(suite) {
+  config.logLevel = suite.LOG_WARN;
+  suite.set(config);
+};

package/spec/javascripts/helpers/mocks.js

@@ -0,0 +1,274 @@
+var EventsDispatcher = require('core/events/dispatcher').default;
+
+var Mocks = {
+  getScriptRequest: function() {
+    return {
+      send: jasmine.createSpy("send"),
+      cleanup: jasmine.createSpy("cleanup")
+    };
+  },
+
+  getDocument: function() {
+    return {
+      location: {
+        protocol: "http:"
+      },
+
+      getElementsByTagName: jasmine.createSpy("getElementsByTagName"),
+      createElement: jasmine.createSpy("createElement"),
+      addEventListener: jasmine.createSpy("addEventListener")
+    };
+  },
+
+  getDocumentElement: function() {
+    return {
+      setAttribute: jasmine.createSpy("setAttribute"),
+      addEventListener: jasmine.createSpy("addEventListener"),
+      insertBefore: jasmine.createSpy("insertBefore"),
+      appendChild: jasmine.createSpy("appendChild")
+    };
+  },
+
+  getXHR: function() {
+    return {
+      open: jasmine.createSpy("open"),
+      send: jasmine.createSpy("send"),
+      abort: jasmine.createSpy("abort"),
+      setRequestHeader: jasmine.createSpy("setRequestHeader")
+    };
+  },
+
+  getWebSocket: function() {
+    return {
+      send: jasmine.createSpy("send"),
+      close: jasmine.createSpy("close")
+    };
+  },
+
+  getHTTPSocket: function() {
+    var socket = new EventsDispatcher();
+    socket.close = jasmine.createSpy("close");
+    socket.sendRaw = jasmine.createSpy("sendRaw");
+    socket.onChunk = jasmine.createSpy("onChunk");
+    socket.onClose = jasmine.createSpy("onClose");
+    socket.reconnect = jasmine.createSpy("sendRaw");
+    return socket;
+  },
+
+  getHTTPRequest: function(method, url) {
+    var request = new EventsDispatcher();
+    request.start = jasmine.createSpy("start");
+    request.close = jasmine.createSpy("close");
+    request.method = method;
+    request.url = url;
+    return request;
+  },
+
+  getJSONPSender: function() {
+    return {
+      send: jasmine.createSpy("send")
+    };
+  },
+
+  getTimeline: function() {
+    return {
+      log: jasmine.createSpy("log"),
+      error: jasmine.createSpy("error"),
+      info: jasmine.createSpy("info"),
+      debug: jasmine.createSpy("debug"),
+      send: jasmine.createSpy("send"),
+      isEmpty: jasmine.createSpy("isEmpty"),
+      generateUniqueID: jasmine.createSpy("generateUniqueID")
+    };
+  },
+
+  getTimelineSender: function() {
+    var sender = {
+      send: jasmine.createSpy("send")
+    };
+
+    return sender;
+  },
+
+  getTransport: function() {
+    var transport = new EventsDispatcher();
+
+    transport.handlesActivityChecks = jasmine.createSpy("handlesActivityChecks")
+      .and.returnValue(false);
+    transport.supportsPing = jasmine.createSpy("supportsPing")
+      .and.returnValue(false);
+    transport.initialize = jasmine.createSpy("initialize")
+      .and.callFake(function() {
+        transport.state = "initializing";
+        transport.emit("initializing");
+      });
+    transport.connect = jasmine.createSpy("connect");
+    transport.send = jasmine.createSpy("send")
+      .and.returnValue(true);
+    transport.ping = jasmine.createSpy("ping");
+    transport.close = jasmine.createSpy("close");
+    transport.state = undefined;
+
+    return transport;
+  },
+
+  getWorkingTransport: function() {
+    var transport = new EventsDispatcher();
+
+    transport.handlesActivityChecks = jasmine
+      .createSpy('handlesActivityChecks')
+      .and.returnValue(false);
+    transport.supportsPing = jasmine
+      .createSpy('supportsPing')
+      .and.returnValue(false);
+    transport.initialize = jasmine
+      .createSpy('initialize')
+      .and.callFake(function() {
+        transport.state = 'initializing';
+        transport.emit('initializing');
+        setTimeout(() => {
+          transport.state = 'initialized';
+          transport.emit('initialized');
+        }, 0);
+      });
+    transport.connect = jasmine.createSpy('connect').and.callFake(function() {
+      transport.state = 'open';
+      transport.emit('open');
+      setTimeout(() => {
+        transport.emit('message', {
+          data: JSON.stringify({
+            event: 'pusher:connection_established',
+            data: {
+              socket_id: '123.456',
+              activity_timeout: 120
+            }
+          })
+        });
+      }, 0);
+    });
+    transport.send = jasmine.createSpy('send').and.returnValue(true);
+    transport.ping = jasmine.createSpy('ping');
+    transport.close = jasmine.createSpy('close');
+    transport.state = undefined;
+    return transport;
+  },
+
+  getTransportManager: function(alive) {
+    return {
+      isAlive: jasmine.createSpy("isAlive").and.returnValue(alive !== false),
+      reportDeath: jasmine.createSpy("reportDeath")
+    };
+  },
+
+  getAssistantToTheTransportManager: function(transport) {
+    return {
+      createConnection: jasmine.createSpy("createConnection")
+        .and.returnValue(transport || this.getTransport()),
+      isSupported: jasmine.createSpy("isSupported")
+        .and.returnValue(true)
+    };
+  },
+
+  getTransportClass: function(supported, transport) {
+    var klass = {};
+
+    klass.isSupported = jasmine.createSpy("isSupported")
+      .and.returnValue(supported);
+    klass.createConnection = jasmine.createSpy("createConnection")
+      .and.returnValue(transport || this.getTransport());
+
+    return klass;
+  },
+
+  getHandshake: function(transport, callback) {
+    return {
+      close: jasmine.createSpy("close"),
+
+      _transport: transport,
+      _callback: callback
+    };
+  },
+
+  getStrategy: function(isSupported) {
+    var strategy = new EventsDispatcher();
+
+    strategy._abort = jasmine.createSpy();
+    strategy._forceMinPriority = jasmine.createSpy();
+    strategy._callback = null;
+
+    strategy.isSupported = jasmine.createSpy("isSupported")
+      .and.returnValue(isSupported);
+    strategy.connect = jasmine.createSpy("connect")
+      .and.callFake(function(minPriority, callback) {
+        strategy._callback = callback;
+        return {
+          abort: strategy._abort,
+          forceMinPriority: strategy._forceMinPriority
+        };
+      });
+
+    return strategy;
+  },
+
+  getStrategies: function(isSupportedList) {
+    var strategies = [];
+    for (var i = 0; i < isSupportedList.length; i++) {
+      strategies.push(this.getStrategy(isSupportedList[i]));
+    }
+    return strategies;
+  },
+
+  getConnection: function() {
+    var connection = new EventsDispatcher();
+
+    connection.initialize = jasmine.createSpy("initialize");
+    connection.connect = jasmine.createSpy("connect");
+    connection.handlesActivityChecks = jasmine.createSpy("handlesActivityChecks")
+      .and.returnValue(false);
+    connection.supportsPing = jasmine.createSpy("supportsPing")
+      .and.returnValue(false);
+    connection.send = jasmine.createSpy("send")
+      .and.returnValue(true);
+    connection.ping = jasmine.createSpy("ping")
+      .and.returnValue(true);
+    connection.send_event = jasmine.createSpy("send_event")
+      .and.returnValue(true);
+    connection.close = jasmine.createSpy("close");
+
+    return connection;
+  },
+
+  getConnectionManager: function(socket_id) {
+    var manager = new EventsDispatcher();
+    manager.socket_id = socket_id || "1.1";
+    manager.connect = jasmine.createSpy("connect");
+    manager.disconnect = jasmine.createSpy("disconnect");
+    manager.send_event = jasmine.createSpy("send_event");
+    manager.isUsingTLS = jasmine.createSpy("isUsingTLS").and.returnValue(false);
+    return manager;
+  },
+
+  getPusher: function(config) {
+    var pusher = new EventsDispatcher();
+    pusher.config = config;
+    pusher.unsubscribe = jasmine.createSpy("unsubscribe");
+    pusher.send_event = jasmine.createSpy("send_event");
+    return pusher;
+  },
+
+  getChannel: function(name) {
+    var channel = new EventsDispatcher();
+    channel.name = name;
+    channel.authorize = jasmine.createSpy("authorize");
+    channel.cancelSubscription = jasmine.createSpy("cancelSubscription");
+    channel.disconnect = jasmine.createSpy("disconnect");
+    channel.handleEvent = jasmine.createSpy("handleEvent");
+    channel.reinstateSubscription = jasmine.createSpy("reinstateSubscription");
+    channel.subscribe = jasmine.createSpy("subscribe");
+    channel.unsubscribe = jasmine.createSpy("unsubscribe");
+    return channel;
+  },
+
+};
+
+module.exports = Mocks;

package/spec/javascripts/helpers/node/integration.js

@@ -0,0 +1,33 @@
+var base64encode = require('core/base64').default;
+var Runtime = require('runtime').default
+var Collections = require('core/utils/collections');
+var util = require('core/util').default;
+
+exports.API_URL = "http://localhost:3000";
+exports.API_EU_URL = "http://localhost:3001";
+
+exports.describe = function(name, body) {
+  describe(name + " (integration)", body);
+};
+
+exports.getRandomName = function(prefix) {
+  return prefix + "_" + util.now() + "_" + Math.floor(Math.random() * 1000000);
+};
+
+exports.sendAPIMessage = function(request) {
+  var params = {
+    channel: request.channel,
+    event: request.event,
+    data: request.data
+  };
+
+  var query = Collections.map(
+    Collections.flatten(Collections.encodeParamsObject(params)),
+    util.method("join", "=")
+  ).join("&");
+
+  url = request.url + ("/" + 2 + "?" + query);
+  var xhr = Runtime.createXHR();
+  xhr.open("GET", url, true);
+  xhr.send()
+};

package/spec/javascripts/helpers/node/mock-dom-dependencies.ts

@@ -0,0 +1 @@
+export var Dependencies = {}

package/spec/javascripts/helpers/pusher_integration.js

@@ -0,0 +1 @@
+module.exports = require('./pusher_integration_class').default;

package/spec/javascripts/helpers/pusher_integration_class.ts

@@ -0,0 +1,12 @@
+import Pusher from '../../../src/core/pusher';
+import {ScriptReceiverFactory} from '../../../src/runtimes/web/dom/script_receiver_factory';
+
+export default class PusherIntegration extends Pusher {
+
+  static Integration : any = {
+    ScriptReceivers: new ScriptReceiverFactory(
+      "_pusher_integration_script_receivers",
+      "Pusher.Integration.ScriptReceivers"
+    )}
+
+}

package/spec/javascripts/helpers/timers/promises.js

@@ -0,0 +1,9 @@
+
+const setTimeoutPromise = (duration) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, duration);
+    });
+}
+export default {
+    setTimeout: setTimeoutPromise
+};

package/spec/javascripts/helpers/waitsFor.js

@@ -0,0 +1,37 @@
+let interval = 50;
+
+/**
+ * waitsFor backports the jasmine@1.x.x waitsFor feature to keep old tests working
+ *
+ * @deprecated You shouldn't use this for writing new tests
+ *
+ * @param {Function} condition
+ * @param {string} reason
+ * @param {number} timeout
+ * @returns
+ */
+module.exports = async (condition, reason, timeout) => {
+  if (typeof condition !== 'function') {
+    throw new Error('Condition is not a function');
+  }
+
+  if (typeof reason !== 'string') {
+    throw new Error('Reason is not a string');
+  }
+
+  if (typeof timeout !== 'number') {
+    throw new Error('Timeout is not a number');
+  }
+
+  while (timeout >= 0) {
+    if (condition()) {
+      return;
+    }
+
+    await new Promise(r => setTimeout(r, interval));
+
+    timeout -= interval;
+  }
+
+  throw new Error(`waitsFor on "${reason}" timed out`);
+};

package/spec/javascripts/helpers/web/integration.js

@@ -0,0 +1,44 @@
+var base64encode = require('core/base64').default;
+var util = require('core/util').default;
+var ScriptReceiverFactory = require('dom/script_receiver_factory').ScriptReceiverFactory;
+var Collections = require('core/utils/collections');
+var JSONPRequest = require('dom/jsonp_request').default;
+var ScriptReceivers = require('dom/script_receiver_factory').ScriptReceivers;
+
+exports.API_URL = "http://localhost:3000";
+exports.API_EU_URL = "http://localhost:3001";
+
+exports.describe = function(name, body) {
+  if (navigator.userAgent.match(/phantomjs/i)) {
+    // Don't run integration tests from Guard
+    return;
+  }
+
+  describe(name + " (integration)", body);
+};
+
+exports.getRandomName = function(prefix) {
+  return prefix + "_" + util.now() + "_" + Math.floor(Math.random() * 1000000);
+};
+
+exports.sendAPIMessage = function(request) {
+  var Pusher = window.Pusher;
+  var jsonpRequest = new JSONPRequest(request.url, {
+    channel: request.channel,
+    event: request.event,
+    data: request.data
+  });
+  var receiver = Pusher.Integration.ScriptReceivers.create(function() {
+    Pusher.Integration.ScriptReceivers.remove(receiver);
+  });
+  jsonpRequest.send(receiver);
+};
+
+function encodeParamsObject(data) {
+  return Collections.mapObject(data, function(value) {
+    if (typeof value === "object") {
+      value = JSON.stringify(value);
+    }
+    return encodeURIComponent(base64.encode(value.toString()));
+  });
+}

package/spec/javascripts/helpers/worker/mock-dom-dependencies.js

@@ -0,0 +1 @@
+exports.Dependencies = {}