pretender-rails 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1203f9df04b877d6a7ad3cc32daca9b01a1fd844
+  data.tar.gz: 723f9bc1e3792b40e644dcb043ae20e2b7826939
+SHA512:
+  metadata.gz: 0f946042676557f164c3f72d722cb0bff9fb30c134adb2b23557785dbd414199dc803332d729318d32a26bb1ee7faf1cffae22bc679d993a544986619517d687
+  data.tar.gz: 3a6a9d11965883cc5eb568f466c0cfb528c60846b3dabfa4c95f3bbd3e48254f482af6420a4fa093442ad9b2b19126acf3bed354f87f78b610e06ddf79334308

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pretender-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Chase McCarthy
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+# Pretender Rails
+
+Stub clientside calls to external services.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pretender-rails'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pretender-rails
+
+## Usage
+
+```ruby
+Pretender.server.stub('get', 'https://api.github.com/repos/code0100fun/pretender-rails', [200, {}, {name: "mock-repo"}.to_json])
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/pretender-rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/pretender-rails.rb

@@ -0,0 +1,10 @@
+require "pretender/rails/version"
+require "pretender/rails/server"
+require "pretender/rails/middleware"
+require "pretender/rails/railtie"
+require "pretender/rails/engine"
+
+module Pretender
+  module Rails
+  end
+end

data/lib/pretender/rails/cucumber.rb

@@ -0,0 +1,18 @@
+require 'cucumber'
+require 'capybara/cucumber'
+
+module Pretender
+  module Rails
+    module CucumberHelper
+      def stub(method, route, response)
+        Pretender.server.stub(method, route, response)
+      end
+    end
+  end
+end
+
+World(Pretender::Rails::CucumberHelper)
+
+After do
+  Pretender.server.shutdown(page)
+end

data/lib/pretender/rails/engine.rb

@@ -0,0 +1,6 @@
+module Pretender
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/pretender/rails/middleware.rb

@@ -0,0 +1,20 @@
+module Pretender
+  module Rails
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        status, headers, env = @app.call(env)
+        if headers['Content-Type'].to_s.include?("text/html")
+          body = Pretender.server.inject(env.body)
+          headers['Content-Length'] = Rack::Utils.bytesize(body.to_s).to_s
+          return [status, headers, [body]]
+        end
+
+        [status, headers, env]
+      end
+    end
+  end
+end

data/lib/pretender/rails/railtie.rb

@@ -0,0 +1,9 @@
+module Pretender
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "pretender.configure_rails_initialization" do
+        ::Rails.application.middleware.use Pretender::Rails::Middleware
+      end
+    end
+  end
+end

data/lib/pretender/rails/server.rb

@@ -0,0 +1,75 @@
+module Pretender
+  def self.server
+    @_server ||= ::Pretender::Rails::Server.new
+  end
+
+  module Rails
+    class Server
+      Stub = Struct.new(:method, :route, :response)
+      attr_accessor :session
+
+      def inject(body)
+        unless stubs.empty?
+          head_pos = body.index('</head>')
+          body.insert(head_pos, scripts) if head_pos
+        end
+        body
+      end
+
+      def shutdown(page)
+        stubs.clear
+        page.execute_script('typeof(server) !== "undefined" && server.shutdown();')
+      end
+
+      def stub(method, route, response)
+        stub = Stub.new(method, route, response)
+        stubs.unshift stub
+        stub
+      end
+
+      private
+
+      def stubs
+        @_stubs ||= []
+      end
+
+      def routes
+        stubs.map do |stub|
+          "this.#{stub.method}('#{stub.route}', function(request) { return #{stub.response.to_json}; });"
+        end.join("\n")
+      end
+
+      def load_script(path)
+        open(path).read
+      end
+
+      def scripts
+        [dependencies_script, server_script].join("\n")
+      end
+
+      def dependencies_script
+        [javascript_include_tag('fake_xml_http_request.js'),
+         javascript_include_tag('route-recognizer.js'),
+         javascript_include_tag('pretender.js')].join("\n")
+      end
+
+      def javascript_include_tag(url)
+        "<script src=\"/assets/#{url}\"></script>"
+      end
+
+      def server_script
+        <<-JS
+<script>
+  var server = new Pretender(function(){
+    #{routes}
+    this.get('*any', this.passthrough);
+    this.post('*any', this.passthrough);
+    this.put('*any', this.passthrough);
+    this.delete('*any', this.passthrough);
+  });
+</script>
+        JS
+      end
+    end
+  end
+end

data/lib/pretender/rails/version.rb

@@ -0,0 +1,5 @@
+module Pretender
+  module Rails
+    VERSION = "0.0.2"
+  end
+end

data/pretender-rails.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pretender/rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pretender-rails"
+  spec.version       = Pretender::Rails::VERSION
+  spec.authors       = ["Chase McCarthy"]
+  spec.email         = ["chase@code0100fun.com"]
+  spec.summary       = %q{Stub clientside ajax requests using pretender}
+  spec.description   = %q{Injects pretender into all HTML requests when a route has been stubbed}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/vendor/assets/javascripts/fake_xml_http_request.js

@@ -0,0 +1,497 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  global.FakeXMLHttpRequest = factory()
+}(this, function () { 'use strict';
+
+  /**
+   * Minimal Event interface implementation
+   *
+   * Original implementation by Sven Fuchs: https://gist.github.com/995028
+   * Modifications and tests by Christian Johansen.
+   *
+   * @author Sven Fuchs (svenfuchs@artweb-design.de)
+   * @author Christian Johansen (christian@cjohansen.no)
+   * @license BSD
+   *
+   * Copyright (c) 2011 Sven Fuchs, Christian Johansen
+   */
+
+  var _Event = function Event(type, bubbles, cancelable, target) {
+    this.type = type;
+    this.bubbles = bubbles;
+    this.cancelable = cancelable;
+    this.target = target;
+  };
+
+  _Event.prototype = {
+    stopPropagation: function () {},
+    preventDefault: function () {
+      this.defaultPrevented = true;
+    }
+  };
+
+  /*
+    Used to set the statusText property of an xhr object
+  */
+  var httpStatusCodes = {
+    100: "Continue",
+    101: "Switching Protocols",
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    300: "Multiple Choice",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    305: "Use Proxy",
+    307: "Temporary Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Request Entity Too Large",
+    414: "Request-URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Requested Range Not Satisfiable",
+    417: "Expectation Failed",
+    422: "Unprocessable Entity",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported"
+  };
+
+
+  /*
+    Cross-browser XML parsing. Used to turn
+    XML responses into Document objects
+    Borrowed from JSpec
+  */
+  function parseXML(text) {
+    var xmlDoc;
+
+    if (typeof DOMParser != "undefined") {
+      var parser = new DOMParser();
+      xmlDoc = parser.parseFromString(text, "text/xml");
+    } else {
+      xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
+      xmlDoc.async = "false";
+      xmlDoc.loadXML(text);
+    }
+
+    return xmlDoc;
+  }
+
+  /*
+    Without mocking, the native XMLHttpRequest object will throw
+    an error when attempting to set these headers. We match this behavior.
+  */
+  var unsafeHeaders = {
+    "Accept-Charset": true,
+    "Accept-Encoding": true,
+    "Connection": true,
+    "Content-Length": true,
+    "Cookie": true,
+    "Cookie2": true,
+    "Content-Transfer-Encoding": true,
+    "Date": true,
+    "Expect": true,
+    "Host": true,
+    "Keep-Alive": true,
+    "Referer": true,
+    "TE": true,
+    "Trailer": true,
+    "Transfer-Encoding": true,
+    "Upgrade": true,
+    "User-Agent": true,
+    "Via": true
+  };
+
+  /*
+    Adds an "event" onto the fake xhr object
+    that just calls the same-named method. This is
+    in case a library adds callbacks for these events.
+  */
+  function _addEventListener(eventName, xhr){
+    xhr.addEventListener(eventName, function (event) {
+      var listener = xhr["on" + eventName];
+
+      if (listener && typeof listener == "function") {
+        listener(event);
+      }
+    });
+  }
+
+  function EventedObject() {
+    this._eventListeners = {};
+    var events = ["loadstart", "progress", "load", "abort", "loadend"];
+    for (var i = events.length - 1; i >= 0; i--) {
+      _addEventListener(events[i], this);
+    }
+  };
+
+  EventedObject.prototype = {
+    /*
+      Duplicates the behavior of native XMLHttpRequest's addEventListener function
+    */
+    addEventListener: function addEventListener(event, listener) {
+      this._eventListeners[event] = this._eventListeners[event] || [];
+      this._eventListeners[event].push(listener);
+    },
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's removeEventListener function
+    */
+    removeEventListener: function removeEventListener(event, listener) {
+      var listeners = this._eventListeners[event] || [];
+
+      for (var i = 0, l = listeners.length; i < l; ++i) {
+        if (listeners[i] == listener) {
+          return listeners.splice(i, 1);
+        }
+      }
+    },
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's dispatchEvent function
+    */
+    dispatchEvent: function dispatchEvent(event) {
+      var type = event.type;
+      var listeners = this._eventListeners[type] || [];
+
+      for (var i = 0; i < listeners.length; i++) {
+        if (typeof listeners[i] == "function") {
+          listeners[i].call(this, event);
+        } else {
+          listeners[i].handleEvent(event);
+        }
+      }
+
+      return !!event.defaultPrevented;
+    },
+
+    /*
+      Triggers an `onprogress` event with the given parameters.
+    */
+    _progress: function _progress(lengthComputable, loaded, total) {
+      var event = new _Event('progress');
+      event.target = this;
+      event.lengthComputable = lengthComputable;
+      event.loaded = loaded;
+      event.total = total;
+      this.dispatchEvent(event);
+    }
+  }
+
+  /*
+    Constructor for a fake window.XMLHttpRequest
+  */
+  function FakeXMLHttpRequest() {
+    EventedObject.call(this);
+    this.readyState = FakeXMLHttpRequest.UNSENT;
+    this.requestHeaders = {};
+    this.requestBody = null;
+    this.status = 0;
+    this.statusText = "";
+    this.upload = new EventedObject();
+  }
+
+  FakeXMLHttpRequest.prototype = new EventedObject();
+
+  // These status codes are available on the native XMLHttpRequest
+  // object, so we match that here in case a library is relying on them.
+  FakeXMLHttpRequest.UNSENT = 0;
+  FakeXMLHttpRequest.OPENED = 1;
+  FakeXMLHttpRequest.HEADERS_RECEIVED = 2;
+  FakeXMLHttpRequest.LOADING = 3;
+  FakeXMLHttpRequest.DONE = 4;
+
+  var FakeXMLHttpRequestProto = {
+    UNSENT: 0,
+    OPENED: 1,
+    HEADERS_RECEIVED: 2,
+    LOADING: 3,
+    DONE: 4,
+    async: true,
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's open function
+    */
+    open: function open(method, url, async, username, password) {
+      this.method = method;
+      this.url = url;
+      this.async = typeof async == "boolean" ? async : true;
+      this.username = username;
+      this.password = password;
+      this.responseText = null;
+      this.responseXML = null;
+      this.requestHeaders = {};
+      this.sendFlag = false;
+      this._readyStateChange(FakeXMLHttpRequest.OPENED);
+    },
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's setRequestHeader function
+    */
+    setRequestHeader: function setRequestHeader(header, value) {
+      verifyState(this);
+
+      if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {
+        throw new Error("Refused to set unsafe header \"" + header + "\"");
+      }
+
+      if (this.requestHeaders[header]) {
+        this.requestHeaders[header] += "," + value;
+      } else {
+        this.requestHeaders[header] = value;
+      }
+    },
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's send function
+    */
+    send: function send(data) {
+      verifyState(this);
+
+      if (!/^(get|head)$/i.test(this.method)) {
+        if (this.requestHeaders["Content-Type"]) {
+          var value = this.requestHeaders["Content-Type"].split(";");
+          this.requestHeaders["Content-Type"] = value[0] + ";charset=utf-8";
+        } else {
+          this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
+        }
+
+        this.requestBody = data;
+      }
+
+      this.errorFlag = false;
+      this.sendFlag = this.async;
+      this._readyStateChange(FakeXMLHttpRequest.OPENED);
+
+      if (typeof this.onSend == "function") {
+        this.onSend(this);
+      }
+
+      this.dispatchEvent(new _Event("loadstart", false, false, this));
+    },
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's abort function
+    */
+    abort: function abort() {
+      this.aborted = true;
+      this.responseText = null;
+      this.errorFlag = true;
+      this.requestHeaders = {};
+
+      if (this.readyState > FakeXMLHttpRequest.UNSENT && this.sendFlag) {
+        this._readyStateChange(FakeXMLHttpRequest.DONE);
+        this.sendFlag = false;
+      }
+
+      this.readyState = FakeXMLHttpRequest.UNSENT;
+
+      this.dispatchEvent(new _Event("abort", false, false, this));
+      if (typeof this.onerror === "function") {
+          this.onerror();
+      }
+    },
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's getResponseHeader function
+    */
+    getResponseHeader: function getResponseHeader(header) {
+      if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+        return null;
+      }
+
+      if (/^Set-Cookie2?$/i.test(header)) {
+        return null;
+      }
+
+      header = header.toLowerCase();
+
+      for (var h in this.responseHeaders) {
+        if (h.toLowerCase() == header) {
+          return this.responseHeaders[h];
+        }
+      }
+
+      return null;
+    },
+
+    /*
+      Duplicates the behavior of native XMLHttpRequest's getAllResponseHeaders function
+    */
+    getAllResponseHeaders: function getAllResponseHeaders() {
+      if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+        return "";
+      }
+
+      var headers = "";
+
+      for (var header in this.responseHeaders) {
+        if (this.responseHeaders.hasOwnProperty(header) && !/^Set-Cookie2?$/i.test(header)) {
+          headers += header + ": " + this.responseHeaders[header] + "\r\n";
+        }
+      }
+
+      return headers;
+    },
+
+    /*
+      Places a FakeXMLHttpRequest object into the passed
+      state.
+    */
+    _readyStateChange: function _readyStateChange(state) {
+      this.readyState = state;
+
+      if (typeof this.onreadystatechange == "function") {
+        this.onreadystatechange();
+      }
+
+      this.dispatchEvent(new _Event("readystatechange"));
+
+      if (this.readyState == FakeXMLHttpRequest.DONE) {
+        this.dispatchEvent(new _Event("load", false, false, this));
+        this.dispatchEvent(new _Event("loadend", false, false, this));
+      }
+    },
+
+
+    /*
+      Sets the FakeXMLHttpRequest object's response headers and
+      places the object into readyState 2
+    */
+    _setResponseHeaders: function _setResponseHeaders(headers) {
+      this.responseHeaders = {};
+
+      for (var header in headers) {
+        if (headers.hasOwnProperty(header)) {
+            this.responseHeaders[header] = headers[header];
+        }
+      }
+
+      if (this.async) {
+        this._readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
+      } else {
+        this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;
+      }
+    },
+
+    /*
+      Sets the FakeXMLHttpRequest object's response body and
+      if body text is XML, sets responseXML to parsed document
+      object
+    */
+    _setResponseBody: function _setResponseBody(body) {
+      verifyRequestSent(this);
+      verifyHeadersReceived(this);
+      verifyResponseBodyType(body);
+
+      var chunkSize = this.chunkSize || 10;
+      var index = 0;
+      this.responseText = "";
+
+      do {
+        if (this.async) {
+          this._readyStateChange(FakeXMLHttpRequest.LOADING);
+        }
+
+        this.responseText += body.substring(index, index + chunkSize);
+        index += chunkSize;
+      } while (index < body.length);
+
+      var type = this.getResponseHeader("Content-Type");
+
+      if (this.responseText && (!type || /(text\/xml)|(application\/xml)|(\+xml)/.test(type))) {
+        try {
+          this.responseXML = parseXML(this.responseText);
+        } catch (e) {
+          // Unable to parse XML - no biggie
+        }
+      }
+
+      if (this.async) {
+        this._readyStateChange(FakeXMLHttpRequest.DONE);
+      } else {
+        this.readyState = FakeXMLHttpRequest.DONE;
+      }
+    },
+
+    /*
+      Forces a response on to the FakeXMLHttpRequest object.
+
+      This is the public API for faking responses. This function
+      takes a number status, headers object, and string body:
+
+      ```
+      xhr.respond(404, {Content-Type: 'text/plain'}, "Sorry. This object was not found.")
+
+      ```
+    */
+    respond: function respond(status, headers, body) {
+      this._setResponseHeaders(headers || {});
+      this.status = typeof status == "number" ? status : 200;
+      this.statusText = httpStatusCodes[this.status];
+      this._setResponseBody(body || "");
+    }
+  };
+
+  for (var property in FakeXMLHttpRequestProto) {
+    FakeXMLHttpRequest.prototype[property] = FakeXMLHttpRequestProto[property];
+  }
+
+  function verifyState(xhr) {
+    if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {
+      throw new Error("INVALID_STATE_ERR");
+    }
+
+    if (xhr.sendFlag) {
+      throw new Error("INVALID_STATE_ERR");
+    }
+  }
+
+
+  function verifyRequestSent(xhr) {
+      if (xhr.readyState == FakeXMLHttpRequest.DONE) {
+          throw new Error("Request done");
+      }
+  }
+
+  function verifyHeadersReceived(xhr) {
+      if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {
+          throw new Error("No headers received");
+      }
+  }
+
+  function verifyResponseBodyType(body) {
+      if (typeof body != "string") {
+          var error = new Error("Attempted to respond to fake XMLHttpRequest with " +
+                               body + ", which is not a string.");
+          error.name = "InvalidBodyException";
+          throw error;
+      }
+  }
+  var fake_xml_http_request = FakeXMLHttpRequest;
+
+  return fake_xml_http_request;
+
+}));