Idea for Matching on query params for mocks

mock-query.js

import Ember from 'ember';
import FactoryGuy from 'ember-data-factory-guy';
import $ from 'jquery';

function MockQuery(url, modelName, queryParams) {
  this.succeed      = true;
  this.url          = url;
  this.modelName    = modelName;
  this.responseJson = convertForBuild(modelName, []);
  MockQuery.registerEndpointWithParams(url, $.param(queryParams), this);
  var urlRegEx = new RegExp(url + '\/?$');

  $.mockjax(function(requestSettings) {
    // needs to match url
    if(!urlRegEx.test(requestSettings.url)) { return false; }
    // needs to match json dataType
    if(requestSettings.dataType !== 'json') { return false; }
    if(requestSettings.type     !== 'GET')  { return false; }
    // needs to lookup based on queryParams and url
    var queryString = $.param(requestSettings.data);
    var mockQuery = MockQuery.lookupEndpointWithParams(requestSettings.url, queryString);
    if(!mockQuery) { return false; }
    return mockQuery.handler.call(this, requestSettings);
  });
}

MockQuery.__endpoints__ = {};

MockQuery.registerEndpointWithParams = function registerEndpointWithParams(url, queryString, mockQuery) {
  var endpoints = MockQuery.__endpoints__;
  if(!endpoints[url]) { endpoints[url] = {}; }
  return endpoints[url][queryString] = mockQuery;
};

MockQuery.lookupEndpointWithParams = function lookupEndpointWithParams(url, queryString) {
  return MockQuery.__endpoints__[url][queryString];
};

MockQuery.clear = function clear() {
  MockQuery.__endpoints__ = {};
};

MockQuery.prototype = {

  get status() {
    return this._status || 200;
  },

  set status(value) {
    return this._status = value;
  },

  get responseText() {
    return this.succeed ? this.responseJson : this.errors;
  },

  get errors() {
    return this._errors || {};
  },

  set errors(value) {
    return this._errors = FactoryGuy.getFixtureBuilder().convertResponseErrors(value);
  },

  get handler() {
    var mockQuery = this;
    return function handler(settings) {
      return _handler.call(this, mockQuery, settings);
    };
  },

  returnsModels(models) {
    if (models) {
      Ember.assert('argument ( models ) must be an array - found type:' + Ember.typeOf(models), Ember.typeOf(models) === 'array');
    } else {
      models = [];
    }

    var json = models.map(function (model) {
      return {id: model.id, type: model.constructor.modelName};
    });

    this.responseJson = convertForBuild(this.modelName, json);

    return this;
  },

  returnsJSON(json) {
    this.responseJson = json;
    return this;
  },

  returnsExistingIds(ids) {
    var store  = FactoryGuy.getStore();
    var models = ids.map( function(id) { return store.peekRecord(this.modelName, id); });
    this.returnsModels(models);
    return this;
  },

  andFail(options = {}) {
    this.succeed = false;
    this.status = options.status || 500;
    if (options.response) { this.errors = options.response; }
    return this;
  }
};

function convertForBuild(modelName, json) {
  return FactoryGuy.getFixtureBuilder().convertForBuild(modelName, json);
}

function _handler(mockQuery, settings) {
  if(!queryParamsMatchIfNeeded(mockQuery, settings.data)) { return false; }
  var request = {};
  request.responseText = mockQuery.responseText;
  request.status = mockQuery.status || 200;
  return request;
}

function queryParamsMatchIfNeeded(mockQuery, requestQueryParams) {
  if (!mockQuery.succeed || !mockQuery.queryParams) { return true; }
  return queryParamsMatch(this.queryParams, requestQueryParams);
}

function queryParamsMatch(paramsA, paramsB) {
  var paramsAKeys = Object.keys(paramsA);
  if(paramsAKeys.length !== Object.keys(paramsB).length) {
    return false;
  }
  return paramsAKeys.every(function(paramName) {
    var requestParam = paramsB[paramName];
    return requestParam != null && paramsA[paramName] === requestParam;
  });
}

export default function handleQueryRequest(modelName, queryParams) {
  if (queryParams) {
    Ember.assert('The second argument ( queryParams ) must be an object', Ember.typeOf(queryParams) === 'object');
  }

  var url = this.buildURL(modelName);
  return new MockQuery(url, modelName, queryParams);
}

export { MockQuery };