response_mate 0.1.1

data/lib/response_mate/commands/export.rb

@@ -0,0 +1,29 @@
+module ResponseMate
+  module Commands
+    class ResponseMate::Commands::Export < Base
+
+      def initialize(args, options)
+        super(args, options)
+        @type = args.first || 'requests'
+
+        @options[:manifest] = ResponseMate::Manifest.new(options[:requests_manifest])
+      end
+
+      def run
+        unless options[:format].present?
+          @options[:format] = choose { |menu|
+            menu.prompt = 'Please pick one of the available formats'
+            menu.choice(:postman)
+          }.to_s
+        end
+
+        output = ResponseMate::Exporter.new(options).export
+        if options[:pretty]
+          puts JSON.pretty_generate(output)
+        else
+          puts output.to_json
+        end
+      end
+    end
+  end
+end

data/lib/response_mate/commands/inspect.rb

@@ -0,0 +1,42 @@
+module ResponseMate
+  module Commands
+    class ResponseMate::Commands::Inspect < Base
+      attr_reader :inspector
+      attr_accessor :history
+
+      def initialize(args, options)
+        super(args, options)
+
+        @options[:manifest] = ResponseMate::Manifest.new(options[:requests_manifest])
+        @inspector = ResponseMate::Inspector.new(@options)
+        @history = []
+      end
+
+      def run
+        if options[:interactive]
+          interactive
+        else
+          args.each do |key|
+            inspector.inspect_key(key)
+          end
+        end
+      end
+
+      def interactive
+        loop do
+          input = ask('response_mate> ')
+          case input
+          when 'history'
+            input = choose { |menu|
+              menu.prompt = 'Replay any?'
+              menu.choices(*([:no] + history))
+            }.to_s
+          else
+            history << input
+          end
+          inspector.inspect_interactive(input)
+        end
+      end
+    end
+  end
+end

data/lib/response_mate/commands/list.rb

@@ -0,0 +1,48 @@
+module ResponseMate
+  module Commands
+    class ResponseMate::Commands::List < Base
+      attr_accessor :type
+
+      def initialize(args, options)
+        super(args, options)
+        @type = args.first || 'requests'
+
+        @options[:manifest] = ResponseMate::Manifest.new(options[:requests_manifest])
+      end
+
+      def run
+        if type == 'requests'
+          choices = options[:manifest].requests.map { |r| r.key.to_sym }
+        elsif type == 'recordings'
+          choices = Dir.glob('output/responses/*.yml').map do |f|
+            File.basename(f).gsub(/\.yml/, '').to_sym
+          end
+        end
+
+        puts choices.join "\n"
+        puts "\n\n"
+        action = choose { |menu|
+          menu.prompt = 'Want to perform any of the actions above?'
+          menu.choices(:record, :inspect, :no)
+        }
+
+        unless action == :no
+          key = choose { |menu|
+            menu.prompt = 'Which one?'
+            menu.choices(*choices)
+          }.to_s
+        end
+
+        if key
+          case action
+          when :record
+            ResponseMate::Recorder.new({ manifest: options[:manifest], keys: [key] }).
+              record
+          when :inspect
+            ResponseMate::Inspector.new(manifest: options[:manifest]).inspect_key(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/response_mate/commands/record.rb

@@ -0,0 +1,27 @@
+module ResponseMate
+  module Commands
+    # Handles the invocation of the record command
+    class ResponseMate::Commands::Record < Base
+      def initialize(args, options)
+        super(args, options)
+        @options = options.dup
+      end
+
+      def run
+        environment = ResponseMate::Environment.new(options[:environment])
+
+        manifest = ResponseMate::Manifest.
+          new(options[:requests_manifest], environment)
+
+        options[:manifest] = manifest
+        recorder = ResponseMate::Recorder.new(options)
+
+        recorder.record
+
+        File.open(ResponseMate.configuration.output_dir + '.last_recording', 'w') do |f|
+          f << Time.current
+        end
+      end
+    end
+  end
+end

data/lib/response_mate/commands/setup.rb

@@ -0,0 +1,24 @@
+module ResponseMate
+  module Commands
+    # Handles the invocation of the setup command
+    class ResponseMate::Commands::Setup < Base
+      attr_accessor :output_dir
+
+      def initialize(args, options)
+        super(args, options)
+        @options = options.dup
+
+        @output_dir = if args.present?
+          args.first
+        else
+          ResponseMate.configuration.output_dir
+        end
+      end
+
+      def run
+        FileUtils.mkdir_p(output_dir)
+        puts "[Setup] Initialized empty directory #{output_dir}"
+      end
+    end
+  end
+end

data/lib/response_mate/connection.rb

@@ -0,0 +1,36 @@
+class ResponseMate::Connection
+  delegate :params, to: :client
+  delegate(*(ResponseMate::ManifestParser::HTTP_VERBS), to: :client)
+
+  attr_accessor :client, :base_url
+
+  def initialize(base_url = nil)
+    @base_url = base_url
+    @client = Faraday.new do |c|
+      c.use FaradayMiddleware::FollowRedirects, limit: 5
+      c.adapter Faraday.default_adapter
+    end
+
+    client.headers.merge(ResponseMate::DEFAULT_HEADERS)
+    client.url_prefix = base_url if base_url
+  end
+
+  def fetch(request)
+    client.params = request[:params] if !request[:params].nil?
+    unless base_url || request[:path] =~ /^http:\/\//
+      request[:path] = 'http://' + request[:path]
+    end
+    client.send request[:verb].downcase.to_sym, "#{base_url}#{request[:path]}"
+  rescue Faraday::Error::ConnectionFailed
+    puts "Is a server up and running at #{request[:path]}?".red
+    exit 1
+  end
+
+  def set_headers_from_manifest(manifest)
+    if manifest.try(:[], 'default_headers')
+      manifest['default_headers'].each_pair do |k, v|
+        client.headers[ResponseMate::Helpers.headerize(k)] = v
+      end
+    end
+  end
+end

data/lib/response_mate/core.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+# The main module of the tool contains configuration code and some constats
+module ResponseMate
+  class OutputDirError < StandardError; end
+
+  DEFAULT_HEADERS = {
+    'User-Agent' => 'Response-Mate'
+  }
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  class Configuration
+    attr_accessor :output_dir, :requests_manifest, :oauth_manifest, :environment
+
+    def initialize
+      @output_dir = './output/responses/'
+      @requests_manifest = './requests.yml'
+      @oauth_manifest = './oauth.yml'
+      @environment = './environment.yml'
+    end
+  end
+
+  def self.setup
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+  end
+end

data/lib/response_mate/environment.rb

@@ -0,0 +1,22 @@
+class ResponseMate::Environment
+  attr_accessor :filename, :env, :environment_text
+
+  delegate :[], to: :env
+
+  def initialize(filename)
+    @filename = filename || ResponseMate.configuration.environment
+    @env = {}
+    parse
+  end
+
+  def parse
+    begin
+      @environment_text = File.read filename
+    rescue Errno::ENOENT
+      puts filename.red << ' does not seem to exist'
+      exit 1
+    end
+
+    @env = YAML.load(environment_text)
+  end
+end

data/lib/response_mate/exporter.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+module ResponseMate
+  class Exporter
+    attr_accessor :format, :handler, :manifest
+
+    def initialize(args = {})
+      @format = args[:format]
+      @manifest = args[:manifest]
+    end
+
+    def export
+      @handler = "ResponseMate::Exporters::#{format.capitalize}".safe_constantize.
+        new manifest
+      handler.export
+    end
+  end
+end

data/lib/response_mate/exporters/postman.rb

@@ -0,0 +1,61 @@
+module ResponseMate::Exporters
+  # Handles exporting to postman format
+  # Example output
+  # https://www.getpostman.com/collections/dbc0521911e45471ff4a
+  class Postman
+    include ResponseMate::ManifestParser
+
+    attr_accessor :manifest, :out
+
+    def initialize(manifest)
+      @manifest = manifest
+      @out = {}
+    end
+
+    def export
+      build_structure
+      build_requests
+      out
+    end
+
+    private
+
+    def build_structure
+      out.merge!(
+        id: SecureRandom.uuid,
+        name: 'latest_export',
+        requests: [],
+        order: [],
+        timestamp: Time.now.to_i
+      )
+    end
+
+    def build_requests
+      manifest.requests.each do |request|
+        req = ResponseMate::Manifest.parse_request(request.request)
+        url = if req['params'].present?
+                "#{req['path']}?#{req['params'].to_query}"
+              else
+                req['path']
+              end
+
+        out_req = {
+          id: SecureRandom.uuid,
+          collectionId: out[:id],
+          data: [],
+          description: '',
+          method: req['verb'],
+          name: request['key'],
+          url: url,
+          version: 2,
+          responses: [],
+          dataMode: 'params',
+          headers: request['headers'] || manifest.default_headers
+        }
+
+        out[:order] << out_req[:id]
+        out[:requests] << out_req
+      end
+    end
+  end
+end

data/lib/response_mate/helpers/application.rb

@@ -0,0 +1,3 @@
+module ResponseMate::Helpers
+  def self.headerize(string); string.split('_').map(&:capitalize).join('-') end
+end

data/lib/response_mate/http.rb

@@ -0,0 +1,41 @@
+module ResponseMate::Http
+  STATUS_CODES = {
+    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 Choices',
+    301  => 'Moved Permanently',
+    302  => 'Moved Temporarily',
+    303  => 'See Other',
+    304  => 'Not Modified',
+    305  => 'Use Proxy',
+    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 Time-out',
+    409  => 'Conflict',
+    410  => 'Gone',
+    411  => 'Length Required',
+    412  => 'Precondition Failed',
+    413  => 'Request Entity Too Large',
+    414  => 'Request-URI Too Large',
+    415  => 'Unsupported Media Type',
+    500  => 'Internal Server Error',
+    501  => 'Not Implemented',
+    502  => 'Bad Gateway',
+    503  => 'Service Unavailable',
+    504  => 'Gateway Time-out',
+    505  => 'HTTP Version not supported'
+  }
+end

data/lib/response_mate/inspector.rb

@@ -0,0 +1,54 @@
+class ResponseMate::Inspector
+  attr_accessor :conn, :base_url, :oauth, :manifest, :print_type
+
+  def initialize(args = {})
+    @manifest = args[:manifest]
+    @oauth = ResponseMate::Oauth.new
+    @base_url = args[:base_url] || manifest.base_url
+    @print_type = args[:print] || 'raw'
+
+    if !args[:interactive]
+      @conn = ResponseMate::Connection.new(base_url)
+      @conn.set_headers_from_manifest(manifest)
+    else
+      @conn = ResponseMate::Connection.new
+    end
+  end
+
+  def inspect_key(key, options = {})
+    request = manifest.requests.find { |r| r.key == key }
+    request = ResponseMate::Manifest.parse_request(request.request)
+
+    puts "[#{key}] #{request[:verb]}".cyan_on_black.bold <<  " #{request[:path]}"
+    puts "\tparams #{request[:params]}" if request[:params].present?
+
+    print(conn.fetch(request))
+  end
+
+  def inspect_interactive(input)
+    request = ResponseMate::Manifest.parse_request(input)
+    print(conn.fetch(request))
+  end
+
+  def print(response)
+    __send__ "print_#{print_type}", response
+  end
+
+  def print_raw(response)
+    puts "\n"
+    status = "#{response.status} #{ResponseMate::Http::STATUS_CODES[response.status]}"
+    puts "HTTP/1.1 #{status}"
+    response.headers.each_pair do |k, v|
+      puts "#{ResponseMate::Helpers.headerize(k)}: #{v}"
+    end
+    puts response.body
+  end
+
+  def print_pretty(response)
+    ap(
+      status: response.status,
+      headers: response.headers,
+      body: response.body
+    )
+  end
+end