mocktopus 0.0.4

data/lib/mocktopus/app.rb

@@ -0,0 +1,142 @@
+require 'sinatra'
+require_relative '../../ascii.rb'
+
+LOGGER.info 'initialized mocktopus app'
+$input_container = Mocktopus::InputContainer.new
+$mock_api_call_container = Mocktopus::MockApiCallContainer.new
+
+error_example = {
+  "uri" => "/domain/domain.com/users",
+  "headers" => {
+    "whitelisting_key_here" => "value"
+  },
+  "body" => {
+    "name" => "the mocktopus",
+    "email" => "the_mocktopus@the_mocktopus.com"
+  },
+  "verb" => "POST",
+  "response" => {
+    "code" => "202",
+    "delay"=> 5000,
+    "headers" => {},
+    "body" => "Thanks!"
+  }
+}
+
+post '/mocktopus/inputs/:name' do
+  LOGGER.info("received new input named #{params[:name]}")
+  begin
+    body = JSON.parse(request.body.read().to_s)
+  rescue
+    status 400
+    content_type :json
+    error_hash = { 'message' => 'inputs must be created with a valid json descripiton', 'example' => error_example }
+    body error_hash.to_json
+    return
+  end
+  LOGGER.debug("body: #{body.inspect()}")
+
+  LOGGER.debug("creating response object from #{body['response']}")
+  response = Mocktopus::Response.new(body['response'])
+
+  LOGGER.debug("creating input object from #{body.inspect}, #{response.inspect}")
+  input = Mocktopus::Input.new(body, response)
+
+  LOGGER.info("added input #{params[:name]} successfully")
+  $input_container.add(params[:name], input)
+end
+
+get '/mocktopus/inputs' do
+  LOGGER.info("all inputs requested")
+  all_inputs = $input_container.all()
+  LOGGER.debug("found #{all_inputs.size()} inputs")
+  return_inputs = {}
+  all_inputs.each do |k,v|
+    return_inputs[k] = v.to_hash
+  end
+  content_type :json
+  return_inputs.to_json
+end
+
+get '/mocktopus/inputs/:name' do
+  LOGGER.info("retrieving input by name #{params[:name]}")
+  input = $input_container.get_by(params[:name])
+  if (input != nil)
+    input.to_hash.to_json
+  else
+    status 405
+    body "input not found"
+  end
+end
+
+get '/mocktopus/mock_api_calls' do
+  $mock_api_call_container.all.to_json
+end
+
+delete '/mocktopus/mock_api_calls' do
+  $mock_api_call_container.delete_all
+  status 200
+  body "success"
+end
+
+delete '/mocktopus/inputs' do
+  LOGGER.info("deleting all inputs")
+  $input_container.delete_all()
+end
+
+delete '/mocktopus/inputs/:name' do
+  LOGGER.info("deleting input by name #{params[:name]}")
+  $input_container.delete_by(params[:name])
+end
+
+# # # catch all for 404s
+not_found do
+  path = request.path
+  verb = request.request_method
+  request_headers = env.inject({}){|acc, (k,v)| acc[$1.downcase] = v if k =~ /^http_(.*)/i; acc}
+  unless(verb.downcase == "get" || verb.downcase == "delete")
+    request_headers.merge!({ "content_type" => request.content_type})
+  end
+  body = request.body.read.to_s
+  log_path = path
+  unless (request.env['rack.request.query_hash'].nil? || request.env['rack.request.query_hash'].empty?)
+    log_path += '?'
+    request.env['rack.request.query_hash'].keys.each do |k|
+      log_path += k
+      log_path += '='
+      log_path += request.env['rack.request.query_hash'][k]
+      log_path += '&' unless k == request.env['rack.request.query_hash'].keys.last      
+    end
+  end
+
+  $mock_api_call_container.add(Mocktopus::MockApiCall.new(log_path, verb, request_headers, body))
+
+  LOGGER.info("not_found catch all invoked")
+  start_time = Time.now.to_f
+  LOGGER.debug("looking for a match with path #{request.fullpath}, verb #{verb}, headers #{request_headers}, body #{body}")
+  match = $input_container.match(path, verb, request_headers, body, request.env['rack.request.query_hash'])
+  LOGGER.debug("match lookup complete")
+  if (match.nil?)
+    LOGGER.info("match not found.  sending 428")
+    status 428
+    content_type :json
+    body_detail = { 
+      'message' => 'match not found',
+      'call' => {
+        'path' => request.fullpath,
+        'verb' => verb,
+        'headers' => request_headers,
+        'body' => body
+      }
+    }
+    body body_detail.to_json
+  else
+    LOGGER.info("match found #{match.inspect}")
+    sleep(match.response.delay/1000)
+    status match.response.code
+    headers match.response.headers
+    body match.response.body
+  end
+  end_time = Time.now.to_f
+  LOGGER.info("not_found catch all completed in #{((end_time - start_time) * 1000)} milliseconds")
+end

data/lib/mocktopus/cli.rb

@@ -0,0 +1,31 @@
+require 'thor'
+
+module Mocktopus
+  class CLI < Thor
+    include Thor::Actions
+
+    desc "start", "starts the mocktopus"
+    method_option :port, :desc => "specifies the port to run the mocktopus"
+    def start(*args)
+      port_option = args.include?('-p') ? '' : ' -p 8081'
+      args = args.join(' ')
+      command = "bundle exec thin -R #{ENV['CONFIG_RU'] || 'config.ru'} start#{port_option} #{args}"
+      run_command(command)
+    end
+
+    desc "stop", "stops the mocktopus"
+    def stop
+      command = "bundle exec thin stop"
+      run_command(command)
+    end
+
+    map 's' => :start
+
+    private
+
+    def run_command(command)
+      system(command)
+    end
+    
+  end
+end

data/lib/mocktopus/input.rb

@@ -0,0 +1,107 @@
+require 'net/http'
+require 'json'
+require 'uri'
+require 'rack'
+
+module Mocktopus
+
+  class Input
+
+    class Error < Exception
+    end
+
+    class ValidationError < Error
+    end
+
+    attr_accessor :uri,
+    :headers,
+    :body,
+    :url_parameters,
+    :verb,
+    :response
+
+    def initialize(hash, response)
+
+      uri_object = nil
+      begin                                                               
+        uri_object = URI.parse(hash['uri'])
+      rescue URI::InvalidURIError
+        begin
+          uri_object = URI.parse(URI::encode(hash['uri']))
+        rescue URI::InvalidURIError                                   
+          raise ValidationError, "Input uri \"#{hash['uri']}\" is not a valid uri" 
+        end
+      end
+
+      @uri = uri_object.path
+      @url_parameters = Rack::Utils.parse_nested_query(uri_object.query)
+      @headers = hash['headers']
+      #need to transform body from inferred json/hash to string (if applicable)
+      body = ''
+      begin
+        body = JSON.pretty_generate(hash['body'])
+      rescue
+        body = hash['body']
+      end
+      @body = body
+      @verb = hash['verb'].upcase
+      @response = response
+
+      validate_instance_variables
+
+      LOGGER.debug("initialized input object from hash #{hash.inspect()}")
+    end
+
+    def to_hash
+      uri_with_parameters = ''
+      if(@url_parameters != nil && @url_parameters.length > 0)
+        @url_parameters.each do |k,v| 
+          if (uri_with_parameters.empty?)
+            uri_with_parameters ="#{@uri}?"
+          else
+            uri_with_parameters = "#{uri_with_parameters}&"
+          end
+          uri_with_parameters = "#{uri_with_parameters}#{k}=#{v}"
+        end
+      else
+        uri_with_parameters = @uri
+      end
+
+      {
+        'uri'  => uri_with_parameters,
+        'verb' => @verb,
+        'headers' => @headers,
+        'body' => @body,
+        'response' => @response.to_hash
+      }
+    end
+
+    def to_s
+      self.to_hash.to_json
+    end
+
+    private
+    def validate_instance_variables
+
+      unless @headers.nil?
+        @headers.each do |key, value|
+          unless String.eql? key.class and String.eql? value.class
+            raise ValidationError, "\"#{key}\" => \"#{value}\" is not a valid header"
+          end
+        end
+      end
+
+      unless @response.nil?
+        unless Mocktopus::Response.eql? @response.class
+          raise ValidationError, "\"#{@response}\" is not a response object"
+        end
+      end
+
+      unless %w{ OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT PATCH}.include? @verb
+        raise ValidationError, "\"#{@verb}\" is not a valid verb"
+      end
+    end
+
+  end
+
+end

data/lib/mocktopus/input_container.rb

@@ -0,0 +1,90 @@
+require 'json'
+
+module Mocktopus
+
+  class InputContainer
+
+    def initialize
+      @inputs = {}
+    end
+
+    def add(name, input)
+      @inputs[name] = input
+    end
+
+    def get_by(name)
+      @inputs[name]
+    end
+
+    def all
+      @inputs
+    end
+
+    def delete_all
+      @inputs = {}
+    end
+
+    def delete_by(name)
+      @inputs.delete(name)
+    end
+
+    def delete_by_input(input)
+      first_match = @inputs.select{|k, v| v == input}.keys.first
+      self.delete_by(first_match)
+    end
+
+    def match(path, verb, headers, body, url_parameters)
+      self.find_match(path, verb, headers, body, url_parameters, @inputs.values)
+    end
+
+    def find_match(path, verb, headers, body, url_parameters, inputs)
+      result = nil
+      matches = inputs.select{|v| URI.decode(v.uri).eql?(URI.decode(path)) && 
+                                                  headers_match?(headers, v.headers) && 
+                                                  bodies_match?(v.body, body) && 
+                                                  v.verb.eql?(verb) && 
+                                                  v.url_parameters.eql?(url_parameters) }
+      case matches.size
+        when 0
+          result = nil
+        when 1
+          result = matches.first
+        else
+          result = pop_first_input(matches)
+      end
+      return result
+    end
+
+    private
+    def headers_match?(input_headers, match_headers)
+      match = true
+      if (match_headers != nil)
+        match_headers.each do |k,v|
+          if(input_headers[k.downcase.gsub("-", "_")].nil?)
+            match = false
+          elsif !input_headers[k.downcase.gsub("-", "_")].eql? v
+            match = false
+          end
+        end
+      end
+      return match
+    end
+
+    def bodies_match?(input_body, match_body)
+      match = false
+      if (input_body.eql? match_body)
+        match = true
+      elsif (input_body.to_s.gsub(/\s+/, "").hash.eql?(match_body.to_s.gsub(/\s+/, "").hash))
+        match = true
+      end
+      return match
+    end
+
+    def pop_first_input(matches)
+      result = matches.first
+      self.delete_by_input(result)
+      return result
+    end
+  end
+
+end

data/lib/mocktopus/mock_api_call.rb

@@ -0,0 +1,42 @@
+require 'time'
+require 'json'
+
+module Mocktopus
+
+  class MockApiCall
+
+    attr_accessor :timestamp,
+      :path,
+      :verb,
+      :headers,
+      :body
+
+    def initialize(path, verb, headers, body)
+      @timestamp = Time.now.utc.iso8601(10)
+      @path = path
+      @verb = verb
+      @headers = headers
+      begin
+        @body = JSON.parse(body)
+      rescue
+        @body = body
+      end
+    end
+
+    def to_hash
+      {
+        'timestamp' => @timestamp,
+        'path' => @path,
+        'verb' => @verb,
+        'headers' => @headers,
+        'body' => @body
+      }
+    end
+
+    def to_s
+      self.to_hash.to_json
+    end
+
+  end
+
+end

data/lib/mocktopus/mock_api_call_container.rb

@@ -0,0 +1,20 @@
+module Mocktopus
+
+  class MockApiCallContainer
+    def initialize
+      @calls = []
+    end
+
+    def add(mock_api_call)
+      @calls << mock_api_call
+    end
+
+    def all
+      @calls.collect(&:to_hash)
+    end
+
+    def delete_all
+      @calls = []
+    end
+  end
+end

data/lib/mocktopus/response.rb

@@ -0,0 +1,64 @@
+require 'json'
+
+module Mocktopus
+
+  class Response
+
+    class Error < Exception
+    end
+
+    class ValidationError < Error
+    end
+
+    attr_accessor :code,
+            :headers,
+            :body,
+            :delay
+
+    def initialize(hash)
+      LOGGER.debug("initializing response object")
+      @code = hash['code']
+      @headers = hash['headers']
+      @body = hash['body']
+      @delay = hash['delay'].to_f || 0
+
+      begin
+        @body = JSON.pretty_generate(@body)
+      rescue JSON::GeneratorError
+        @body = @body.to_s
+      end
+
+      validate_instance_variables()
+
+      LOGGER.debug("initialized response object from hash #{hash.inspect()}")
+    end
+
+  def to_hash
+    {
+      'code' => @code,
+      'headers' => @headers,
+      'body' => @body,
+      'delay' => @delay
+    }
+  end
+
+    private
+    def validate_instance_variables
+
+      if(@code.nil? || !(@code.to_i.between?(100,599) ))
+        raise ValidationError, "\"#{@code}\" is not a valid return code."
+      end
+
+      unless @headers.nil?
+        @headers.each do |key, value|
+          unless String.eql? key.class and String.eql? value.class
+            raise ValidationError, "\"#{key}\" => \"#{value}\" is not a valid header"
+          end
+        end
+      end
+
+    end
+
+  end
+
+end