mountebank 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28dab8b97e649b767668d619c7191b32adf00892
+  data.tar.gz: b2b56fb2f48c9e17352787ceba40fb247b03d904
+SHA512:
+  metadata.gz: e8bce7de8fc1cf24bbed4b1e078e6461592be9097f72c3b74020009f387167404055f6ad6cb34a551ce52c3d53f1fcba82d1138e19ffdb665dc86a71c25c038c
+  data.tar.gz: 408b93156be0b075bab836f8009c4be23d4efb00eb07089e1316aebd9d12367f0c04766fa00716fed3d406700537dfe0d4f87a6c9986b4c48f07d8e1fe6aa9ab

data/.env

@@ -0,0 +1,2 @@
+MOUNTEBANK_SERVER=127.0.0.1
+MOUNTEBANK_PORT=2525

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Michael Cheng
+
+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,129 @@
+# Mountebank
+
+A simple Ruby library that lets you manage your [Mountebank test server](http://www.mbtest.org/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mountebank'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mountebank
+
+## Usage
+
+### Pre-Requisite
+
+Install Mountebank:
+
+```
+npm install -g mountebank --production
+```
+
+Start Mountebank:
+
+```
+mb --allowInjection
+```
+
+I recommend reading the [Mountebank documentation](http://www.mbtest.org/docs/api/overview) for a deeper understanding of their API.
+
+### Initialization
+
+1. Add these to you environment hash (eg. add to your `.env` file)
+	
+	```
+MOUNTEBANK_SERVER=127.0.0.1
+MOUNTEBANK_PORT=2525
+```
+
+2. Include the lib in your `spec_helper`.
+
+	```ruby
+include 'mountebank'
+```
+
+### Get all available imposters
+
+```ruby
+Mountebank.imposters
+```
+
+### Create Imposter
+
+```ruby
+port = 4545
+protocol = Mountebank::Imposter::PROTOCOL_HTTP
+imposter = Mountebank::Imposter.create(port, protocol)
+```
+
+### Create Imposter with Stub
+
+```ruby
+port = 4545
+protocol = Mountebank::Imposter::PROTOCOL_HTTP
+imposter = Mountebank::Imposter.build(port, protocol)
+
+# Create a response
+status_code = 200
+headers = {"Content-Type" => "application/json"}
+body = {foo:"bar"}.to_json
+response = Mountebank::Stub::HttpResponse.create(status_code, headers, body)
+
+imposter.add_stub(response)
+imposter.save!
+```
+
+Check the URL:
+```
+curl http://127.0.0.1:4545
+```
+
+### Get all stubs
+
+```ruby
+imposter = Mountbank.imposters.first
+puts imposter.stubs
+```
+
+### Create Imposter with Stub & Predicate
+
+```ruby
+port = 4545
+protocol = Mountebank::Imposter::PROTOCOL_HTTP
+imposter = Mountebank::Imposter.build(port, protocol)
+
+# Create a response
+status_code = 200
+headers = {"Content-Type" => "application/json"}
+body = {foo:"bar2"}.to_json
+response = Mountebank::Stub::HttpResponse.create(status_code, headers, body)
+
+# Create a predicate
+data = {equals: {path:"/test"}}
+predicate = Mountebank::Stub::Predicate.new(data)
+
+imposter.add_stub(response, predicate)
+imposter.save!
+```
+
+Check the URL:
+```
+curl http://127.0.0.1:4545/test
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/CoderKungfu/mountebank/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,13 @@
+require "bundler/gem_tasks"
+require 'dotenv/tasks'
+
+require 'rspec/core/rake_task'
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+  t.verbose = false
+end
+
+task :default => [:dotenv, :spec]
+

data/lib/mountebank.rb

@@ -0,0 +1,34 @@
+require "mountebank/version"
+require "mountebank/helper"
+require "mountebank/network"
+require "mountebank/imposter"
+require "mountebank/stub"
+require "mountebank/stub/response"
+require "mountebank/stub/http_response"
+require "mountebank/stub/https_response"
+require "mountebank/stub/tcp_response"
+require "mountebank/stub/proxy_response"
+require "mountebank/stub/predicate"
+require "json"
+
+module Mountebank
+  extend self
+
+  def self.imposters
+    imposters = []
+
+    response = Network.get('/imposters')
+    if response.success?
+      response.body[:imposters].each do |imposter|
+        imposters << Mountebank::Imposter.new(imposter)
+      end
+    end
+
+    imposters
+  end
+
+  def self.reset
+    response = Network.delete('/imposters')
+    response.success?
+  end
+end

data/lib/mountebank/helper.rb

@@ -0,0 +1,39 @@
+require 'faraday'
+
+module Mountebank
+  class Helper
+    # Convert Ruby Hash keys into symbols
+    # Source: https://gist.github.com/Integralist/9503099
+    def self.symbolize(obj)
+      return obj.reduce({}) do |memo, (k, v)|
+        memo.tap { |m| m[k.to_sym] = symbolize(v) }
+      end if obj.is_a? Hash
+
+      return obj.reduce([]) do |memo, v|
+        memo << symbolize(v); memo
+      end if obj.is_a? Array
+
+      obj
+    end
+  end
+
+  class SymbolizeKeys < ::Faraday::Middleware
+    def initialize(app = nil, options = {})
+      super(app)
+      @options = options
+      @content_types = Array(options[:content_type])
+    end
+
+    def call(environment)
+      @app.call(environment).on_complete do |env|
+        if env[:body].is_a? Hash
+          env[:body] = Helper.symbolize(env[:body])
+        end
+      end
+    end
+  end
+
+  if ::Faraday::Middleware.respond_to? :register_middleware
+    ::Faraday::Response.register_middleware :symbolize_keys => lambda { Mountebank::SymbolizeKeys }
+  end
+end

data/lib/mountebank/imposter.rb

@@ -0,0 +1,132 @@
+module Mountebank
+  class Imposter
+    attr_reader :port, :protocol, :name, :stubs, :requests, :matches, :mode
+
+    PROTOCOL_HTTP = 'http'
+    PROTOCOL_HTTPS = 'https'
+    PROTOCOL_SMTP = 'smtp'
+    PROTOCOL_TCP = 'tcp'
+
+    PROTOCOLS = [
+      PROTOCOL_HTTP,
+      PROTOCOL_HTTPS,
+      PROTOCOL_SMTP,
+      PROTOCOL_TCP
+    ]
+
+    CREATE_PARAMS_HTTP = [:protocol, :port, :name, :stubs]
+    CREATE_PARAMS_HTTPS = [:protocol, :port, :name, :stubs]
+    CREATE_PARAMS_TCP = [:protocol, :mode, :mode, :name, :stubs]
+    CREATE_PARAMS_SMTP = [:protocol, :port, :name]
+
+    def initialize(data={})
+      set_attributes(data)
+    end
+
+    def self.build(port, protocol=PROTOCOL_HTTP, options={})
+      raise 'Invalid port number' unless port.is_a? Integer
+      raise 'Invalid protocol' unless PROTOCOLS.include?(protocol)
+
+      data = {port: port, protocol: protocol}.merge(options)
+      Mountebank::Imposter.new(data)
+    end
+
+    def save!
+      delete!
+      response = Network.post('/imposters', replayable_data)
+      return reload if response.success?
+
+      false
+    end
+
+    def self.create(port, protocol=PROTOCOL_HTTP, options={})
+      self.build(port, protocol, options).save!
+    end
+
+    def self.find(port)
+      imposter_data = Imposter.get_imposter_config(port)
+      return Mountebank::Imposter.new(imposter_data) unless imposter_data.empty?
+
+      false
+    end
+
+    def self.delete(port)
+      response = Network.delete("/imposters/#{port}")
+      response.success? && !response.body.empty?
+    end
+
+    def delete!
+      Imposter.delete(@port)
+    end
+
+    def reload
+      data = Imposter.get_imposter_config(@port)
+      set_attributes(data) unless data.empty?
+
+      self
+    end
+
+    def add_stub(response=nil, predicate=nil)
+      responses, predicates = [], []
+
+      if response.is_a? Array
+        responses + response
+      elsif response.is_a? Mountebank::Stub::Response
+        responses << response
+      end
+
+      if predicate.is_a? Array
+        predicates + predicate
+      elsif predicate.is_a? Mountebank::Stub::Predicate
+        predicates << predicate
+      end
+
+      @stubs << Mountebank::Stub.create(responses, predicates)
+    end
+
+    def replayable_data
+      data = serializable_hash
+      data.delete(:requests)
+      data.delete(:matches)
+
+      data
+    end
+
+    def to_json(*args)
+      serializable_hash.to_json(*args)
+    end
+
+    private
+
+    def serializable_hash
+      data = {port: @port, protocol: @protocol, name: @name}
+      data[:stubs] = @stubs unless @stubs.empty?
+      data[:requests] = @requests unless @requests.empty?
+      data[:matches] = @matches unless @matches.empty?
+      data[:mode] = @mode unless @mode.nil?
+
+      data
+    end
+
+    def self.get_imposter_config(port)
+      response = Network.get("/imposters/#{port}")
+      response.success? ? response.body : []
+    end
+
+    def set_attributes(data)
+      @port = data[:port]
+      @protocol = data[:protocol]
+      @name = data[:name] || "imposter_#{@port}"
+      @stubs = []
+      if data[:stubs].respond_to?(:each)
+        data[:stubs].each do |stub|
+          stub = Mountebank::Stub.new(stub) unless stub.is_a? Mountebank::Stub
+          @stubs << stub
+        end
+      end
+      @requests = data[:requests] || []
+      @matches = data[:matches] || []
+      @mode = data[:mode] || nil
+    end
+  end
+end

data/lib/mountebank/network.rb

@@ -0,0 +1,51 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Mountebank
+  class Network
+    def self.connection
+      @conn ||= Faraday.new(url: mountebank_server_uri) do |conn|
+        conn.request :json
+        conn.response :symbolize_keys, :content_type => /\bjson$/
+        conn.response :json, :content_type => /\bjson$/
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def self.get(uri)
+      connection.get(uri)
+    end
+
+    def self.post(uri, data)
+      connection.post do |req|
+        req.url uri
+        req.body = data
+      end
+    end
+
+    def self.put(uri, data)
+      connection.put do |req|
+        req.url uri
+        req.body = data
+      end
+    end
+
+    def self.delete(uri)
+      connection.delete do |req|
+        req.url uri
+      end
+    end
+
+    def self.mountebank_server
+      ENV['MOUNTEBANK_SERVER'] || 'localhost'
+    end
+
+    def self.mountebank_server_port
+      ENV['MOUNTEBANK_PORT'] || '2525'
+    end
+
+    def self.mountebank_server_uri
+      "http://#{mountebank_server}:#{mountebank_server_port}"
+    end
+  end
+end