response_mate 0.3.3 → 0.4.0

data/lib/response_mate/commands/inspect.rb

@@ -2,15 +2,14 @@ class ResponseMate::Commands::Inspect < ResponseMate::Commands::Base
   attr_reader :inspector
   attr_accessor :history
 
-  def initialize(args, options)
-    super(args, options)
+  def run # rubocop:disable Metrics/AbcSize
+    environment = ResponseMate::Environment.new(options[:environment])
+    options[:manifest] = ResponseMate::Manifest.new(options[:requests_manifest],
+                                                    environment)
 
-    @options[:manifest] = ResponseMate::Manifest.new(options[:requests_manifest])
-    @inspector = ResponseMate::Inspector.new(@options)
+    @inspector = ResponseMate::Inspector.new(options)
     @history = []
-  end
 
-  def run
     if args.empty?
       return $stderr.puts 'At least one key has to be specified'.red
     end

data/lib/response_mate/commands/list.rb

@@ -1,15 +1,14 @@
 # Command which performs the operations required by `response_mate list`
 class ResponseMate::Commands::List < ResponseMate::Commands::Base
   # Run the command based on args, options provided
-  def run
+  def run # rubocop:disable Metrics/AbcSize
     environment = ResponseMate::Environment.new(options[:environment])
-    @manifest = ResponseMate::Manifest.new(options[:requests_manifest], environment)
-
-    available_keys = @manifest.requests.map { |r| r.key.to_sym }
+    options[:manifest] = ResponseMate::Manifest.new(options[:requests_manifest],
+                                                    environment)
 
     puts available_keys.join("\n") << "\n\n"
-
     action = ask_action
+
     return if action == :no
 
     perform_action(action, ask_key(available_keys))
@@ -17,6 +16,10 @@ class ResponseMate::Commands::List < ResponseMate::Commands::Base
 
   private
 
+  def available_keys
+    options[:manifest].requests.map { |r| r.key.to_sym }
+  end
+
   def ask_action
     choose do |menu|
       menu.prompt = 'Want to perform any of the actions above?'
@@ -34,9 +37,9 @@ class ResponseMate::Commands::List < ResponseMate::Commands::Base
   def perform_action(action, key)
     case action
     when :record
-      ResponseMate::Recorder.new(manifest: @manifest).record([key])
+      ResponseMate::Recorder.new(options).record([key])
     when :inspect
-      ResponseMate::Inspector.new(manifest: @manifest).inspect_key(key)
+      ResponseMate::Inspector.new(options).inspect_key(key)
     end
   end
 end

data/lib/response_mate/commands/record.rb

@@ -3,9 +3,8 @@ class ResponseMate::Commands::Record < ResponseMate::Commands::Base
   # Run the command based on args, options provided
   def run
     environment = ResponseMate::Environment.new(options[:environment])
-    manifest = ResponseMate::Manifest.new(options[:requests_manifest], environment)
-
-    options[:manifest] = manifest
+    options[:manifest] = ResponseMate::Manifest.new(options[:requests_manifest],
+                                                    environment)
 
     recorder = ResponseMate::Recorder.new(options)
 

data/lib/response_mate/connection.rb

@@ -14,7 +14,7 @@ class ResponseMate::Connection
 
   # Performs the supplied request
   # @param {ResponseMate::Request} The request to be performed
-  def fetch(request)
+  def fetch(request) # rubocop:disable Metrics/AbcSize
     uri = URI.parse(request[:url])
 
     if request[:params]
@@ -23,10 +23,8 @@ class ResponseMate::Connection
       uri.query = query
     end
 
-    verb = request[:verb] || 'GET'
-
     client.headers = request[:headers] if request[:headers]
-    client.send verb.downcase.to_sym, uri.to_s
+    client.send request[:verb].downcase.to_sym, uri.to_s
   rescue Faraday::Error::ConnectionFailed
     puts "Is a server up and running at #{request[:path]}?".red
     exit 1

data/lib/response_mate/core.rb

@@ -1,17 +1,18 @@
 # The main module of the tool contains configuration code and some constants
 module ResponseMate
   class OutputDirError < StandardError; end
+  class ManifestMissing < StandardError; end
   class KeysNotFound < StandardError; end
 
   # Methods handled by response_mate
-  HTTP_METHODS = %w[GET POST PUT PATCH DELETE HEAD OPTIONS]
+  HTTP_METHODS = Faraday::Connection::METHODS
 
   # Responsible for keeping initialization configuration values
   class Configuration
     attr_accessor :output_dir, :requests_manifest, :environment
 
     def initialize
-      @output_dir = './output/responses/'
+      @output_dir = './'
       @requests_manifest = './requests.yml'
       @environment = './environment.yml'
     end

data/lib/response_mate/environment.rb

@@ -3,26 +3,26 @@
 # is a Hash which will be used for the rendering of the requests manifest as a
 # [Mustace template](http://mustache.github.io/mustache.5.html).
 class ResponseMate::Environment
-  attr_accessor :filename, :env, :environment_text
+  attr_accessor :filename, :env
 
   delegate :[], to: :env
 
   def initialize(filename)
     @filename = filename || ResponseMate.configuration.environment
-    @env = {}
     parse
   end
 
+  # Check for environment file existence
+  # @return [TrueClass|FalseClass]
+  def exists?
+    File.exist? filename
+  end
+
   private
 
+  # Set the env to the parsed YAML environment file
   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)
+    return @env = {} unless exists?
+    @env = ::YAML.load_file(filename)
   end
 end

data/lib/response_mate/exporter.rb

@@ -13,8 +13,9 @@ module ResponseMate
 
     # Returns the compatible transformed resource
     def export
-      @handler = "ResponseMate::Exporters::#{format.capitalize}".safe_constantize.
-        new manifest, environment, resource
+      @handler = "ResponseMate::Exporters::#{format.capitalize}".safe_constantize.new manifest,
+                                                                                      environment,
+                                                                                      resource
       handler.export
     end
   end

data/lib/response_mate/exporters/postman/environment.rb

@@ -20,7 +20,7 @@ class ResponseMate::Exporters::Postman
     private
 
     def build_structure
-      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      timestamp = Time.now.strftime('%Y%m%d%H%M%S')
 
       out.merge!(
         id: SecureRandom.uuid,

data/lib/response_mate/manifest.rb

@@ -10,29 +10,17 @@ class ResponseMate::Manifest
     parse
   end
 
-  # Parse the requests manifest
-  # @return [Array] of requests
-  def parse
-    preprocess_manifest
-    @request_hashes = YAML.load(requests_text).deep_symbolize_keys
-    @name = @request_hashes[:name] || filename
-    @description = @request_hashes[:description] || ''
-    @requests = @request_hashes[:requests].
-      map(&:deep_symbolize_keys!).
-      map { |rh| ResponseMate::Request.new(rh).normalize! }
-  end
-
   # Filters requests based on the supplied Array of keys
   # @param [Array] keys The keys to lookup for matching requests
   # @return [Array] of matching requests
   def requests_for_keys(keys)
-    return [] if keys.empty?
+    return [] if keys.blank?
 
     existing_keys = requests.map(&:key)
     missing_keys = keys - existing_keys
 
     if missing_keys.present?
-      fail ResponseMate::KeysNotFound.new(missing_keys.join(','))
+      fail ResponseMate::KeysNotFound.new(missing_keys.join(', '))
     end
 
     requests.select! do |r|
@@ -42,18 +30,69 @@ class ResponseMate::Manifest
 
   private
 
+  # Parse the requests manifest
+  # @return [Array] of requests
+  def parse
+    preprocess_manifest
+    parsed_manifest = YAML.load(@requests_text).deep_symbolize_keys
+    @name = parsed_manifest.fetch(:name, filename)
+    @description = parsed_manifest.fetch(:description, '')
+    check_requests(parsed_manifest)
+    @requests = parsed_manifest.
+      fetch(:requests, []). # rubocop:disable Style/MultilineOperationIndentation
+      map(&:deep_symbolize_keys!). # rubocop:disable Style/MultilineOperationIndentation
+      map { |rh| ResponseMate::Request.new(rh).normalize! } # rubocop:disable Style/MultilineOperationIndentation
+  end
+
   # Parse the manifest file as a template
   # @return [String] The manifest text parsed as a template
   def preprocess_manifest
     begin
       @requests_text = File.read filename
     rescue Errno::ENOENT
-      puts filename.red << ' does not seem to exist'
-      exit 1
+      raise ResponseMate::ManifestMissing.new(filename)
     end
 
-    if environment.present? # rubocop:disable Style/GuardClause
-      @requests_text = Mustache.render(@requests_text, environment.try(:env) || {})
-    end
+    process_mustache! if environment.present? && mustache?
+  end
+
+  # Check if the manifest file is a Mustache template
+  def mustache?
+    requests_text =~ /{{.*}}/
+  end
+
+  # Evaluate Mustache template
+  def process_mustache!
+    check_environment
+
+    @requests_text = Mustache.render(requests_text, environment.env)
+  end
+
+  def check_environment
+    return if environment.exists?
+
+    warning = 'The specified requests file is a template, but no environment file is found.'
+    guide = <<-GUIDE
+    The environment file holds any variables you wish to be interpolated.
+    You may specify a different environment file using the -e [file.yml] option.
+    Default: environment.yml
+    GUIDE
+
+    STDERR.puts warning.yellow, guide
+  end
+
+  def check_requests(parsed_manifest)
+    return if parsed_manifest.key? :requests
+
+    gemspec = Gem::Specification.find_by_name('response_mate')
+    example_manifest = "#{gemspec.homepage}/blob/master/requests.yml.sample"
+
+    warning = 'The specified requests file contains no requests.'
+    guide = <<-GUIDE
+    To declare requests place them under the :requests key.
+    Example manifest: #{example_manifest}
+    GUIDE
+
+    STDERR.puts warning.yellow, guide
   end
 end

data/lib/response_mate/request.rb

@@ -5,9 +5,10 @@ class ResponseMate::Request < OpenStruct
 
   # Make sure all defined requests in the manifest have complete
   # information for {ResponseMate::Connection#fetch}
-  def normalize!
-    unless ResponseMate::HTTP_METHODS.include? request[:verb]
-      request[:verb] = 'GET'
+  def normalize! # rubocop:disable Metrics/AbcSize
+    request[:verb] = begin
+      (ResponseMate::HTTP_METHODS & [request.fetch(:verb, 'GET').downcase.to_sym]).first ||
+      'GET'
     end
 
     if request[:url] !~ /{{.*?}}/  # Avoid encoding unprocessed mustache tags
@@ -18,8 +19,9 @@ class ResponseMate::Request < OpenStruct
   end
 
   # @return [String] Output string suitable for a terminal
-  def to_cli_format
-    out = "[#{key}] #{request[:verb]}".cyan_on_black.bold << " #{request[:url]}"
+  def to_cli_format # rubocop:disable Metrics/AbcSize
+    out = ["[#{key.yellow}] ", request[:verb].to_s.upcase.colorize(:cyan).on_black.bold,
+           " #{request[:url]}"].join
     out << "\tparams #{request[:params]}" if request[:params].present?
     out
   end

data/lib/response_mate/tape.rb

@@ -1,7 +1,7 @@
 # Responsible for the recorded responses as files
 class ResponseMate::Tape
   # Writes the tape as a file
-  def write(key, request, response, meta = {}, output_dir = nil)
+  def write(key, request, response, meta = {}, output_dir = nil) # rubocop:disable Metrics/AbcSize
     output_dir ||= ResponseMate.configuration.output_dir
 
     output_path = File.join output_dir, "#{key}.yml"
@@ -22,21 +22,22 @@ class ResponseMate::Tape
       f << file_content.to_yaml
     end
   rescue Errno::ENOENT
-    raise ResponseMate::OutputDirError
+    raise ResponseMate::OutputDirError.new(output_dir)
   end
 
   private
 
   def _utf8_encode(object)
-    case object
-    when String
-      object.force_encoding('UTF-8')
-    when Hash
-      object.each do |k, v| # rubocop:disable Lint/UnusedBlockArgument
-        k = _utf8_encode(v) # rubocop:disable Lint/UselessAssignment
-        v = _utf8_encode(v) # rubocop:disable Lint/UselessAssignment
+    if object.respond_to? :force_encoding
+      object.force_encoding('UTF-8').encode!
+    elsif object.is_a? Hash
+      object.reduce({}) do |h, (k, v)|
+        key = k.dup unless k.is_a? Symbol
+
+        h[_utf8_encode(key)] = _utf8_encode(v)
+        h
       end
-    when Array
+    elsif object.respond_to? :each
       object.each { |v| _utf8_encode(v) }
     end
   end

data/lib/response_mate/version.rb

@@ -1,4 +1,4 @@
 module ResponseMate
   # Gem version
-  VERSION = '0.3.3'
+  VERSION = '0.4.0'
 end

data/response_mate.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'thor', '~> 0.19'
   spec.add_dependency 'awesome_print'
   spec.add_dependency 'activesupport'
-  spec.add_dependency 'colored'
+  spec.add_dependency 'colorize', '> 0.7.5'
   spec.add_dependency 'faraday'
   spec.add_dependency 'faraday_middleware'
   spec.add_dependency 'addressable'

data/spec/lib/response_mate/commands/list_spec.rb

@@ -3,9 +3,11 @@ require 'spec_helper'
 describe ResponseMate::Commands::List do
   include_context 'stubbed_requests'
 
-  subject { ResponseMate::Commands::List.new([], {}) }
+  let(:options) { {} }
   let(:cmd_output) { capture(:stdout) { subject.run } }
 
+  subject(:command) { ResponseMate::Commands::List.new([], options) }
+
   describe '#run' do
     before { subject.stub(:ask_action).and_return(:no) }
 
@@ -23,6 +25,47 @@ describe ResponseMate::Commands::List do
           quietly { cmd_output }
           expect(File.basename(output_files.call.last)).to eq('user_friends.yml')
         end
+
+        describe 'output directory' do
+          context 'when the output_dir option is specified' do
+            let(:custom_output_dir) do
+              File.expand_path('spec/source/other_output_dir')
+            end
+
+            let(:options) { { output_dir: custom_output_dir } }
+
+            context 'and it exists' do
+              let(:output_files) { -> { Dir[custom_output_dir + '/*'] } }
+
+              after { output_files.call.each { |file| File.delete(file) } }
+
+              it 'places the tapes in the specified directory' do
+                quietly { command.run }
+
+                expect(output_files.call.size).to eq(1)
+              end
+            end
+
+            context 'and it does not exist' do
+              let(:custom_output_dir) do
+                File.expand_path('spec/source/i_do_not_exist')
+              end
+
+              it 'raises ResponeMate::OutputDirError' do
+                expect { quietly { command.run } }.to raise_error(ResponseMate::OutputDirError,
+                                                                  /#{custom_output_dir}/)
+              end
+            end
+          end
+
+          context 'when the output_dir options is not specified' do
+            it 'places the tapes in the default output directory' do
+              quietly { command.run }
+
+              expect(output_files.call.size).to eq(1)
+            end
+          end
+        end
       end
     end
 

data/spec/lib/response_mate/commands/record_spec.rb

@@ -10,8 +10,10 @@ describe ResponseMate::Commands::Record do
       end
 
       describe 'output files' do
+        subject { output_files.call }
+
         it 'creates on for each request' do
-          expect(output_files.call).to have_exactly(2).items
+          expect(subject.size).to eq(2)
         end
       end
     end
@@ -24,7 +26,7 @@ describe ResponseMate::Commands::Record do
       let(:cmd_with_output_dir) do
         quietly do
           ResponseMate::Commands::Record.new([], keys: [],
-                                                 output_dir: [other_output_dir]).run
+                                                 output_dir: other_output_dir).run
         end
       end
 
@@ -34,8 +36,8 @@ describe ResponseMate::Commands::Record do
         before { cmd_with_output_dir }
         after { output_files.call.each { |file| File.delete(file) } }
 
-        it 'created the tapes in the specified directory' do
-          expect(output_files.call).to have_exactly(2).items
+        it 'creates the tapes in the specified directory' do
+          expect(output_files.call.size).to eq(2)
         end
       end
 
@@ -45,7 +47,8 @@ describe ResponseMate::Commands::Record do
         end
 
         it 'raises ResponeMate::OutputDirError' do
-          expect { cmd_with_output_dir }.to raise_error(ResponseMate::OutputDirError)
+          expect { cmd_with_output_dir }.to raise_error(ResponseMate::OutputDirError,
+                                                        /#{other_output_dir}/)
         end
       end
     end
@@ -54,7 +57,7 @@ describe ResponseMate::Commands::Record do
       it 'creates the tapes in the default output directory' do
         quietly { ResponseMate::Commands::Record.new([], keys: []).run }
 
-        expect(output_files.call).to have_exactly(2).items
+        expect(output_files.call.size).to eq(2)
       end
     end
 
@@ -67,7 +70,7 @@ describe ResponseMate::Commands::Record do
         end
 
         it 'creates an output response file' do
-          expect(output_files.call).to have_exactly(1).items
+          expect(output_files.call.size).to eq(1)
         end
 
         describe 'output response file' do
@@ -76,7 +79,7 @@ describe ResponseMate::Commands::Record do
           end
 
           it 'has the right file extension' do
-            expect(File.exist?(output_filename)).to be_true
+            expect(File.exist?(output_filename)).to be(true)
           end
 
           describe 'YAML content' do
@@ -91,13 +94,9 @@ describe ResponseMate::Commands::Record do
               expect(subject[:request][:verb]).to be_present
             end
 
-            it 'contains the original request path' do
-              pending
-            end
+            xit 'contains the original request path'
 
-            it 'contains the original request params' do
-              pending
-            end
+            xit 'contains the original request params'
 
             it 'contains the response status' do
               expect(subject[:response][:status]).