response_mate 0.1.14 → 0.2.0

data/lib/response_mate/manifest.rb

@@ -3,12 +3,10 @@
 class ResponseMate::Manifest
   include ResponseMate::ManifestParser
 
-  attr_accessor :filename, :requests, :requests_text, :base_url, :oauth,
-    :default_headers, :environment, :name
+  attr_accessor :filename, :requests, :requests_text, :environment, :name
 
   def initialize(filename, environment = nil)
     @filename = filename || ResponseMate.configuration.requests_manifest
-    @oauth = ResponseMate::Oauth.new
     @environment = environment
     parse
   end
@@ -28,35 +26,25 @@ class ResponseMate::Manifest
 
   def parse
     preprocess_manifest
-    @request_hashes = YAML.load(requests_text)
-    @base_url = @request_hashes['base_url']
-    @requests = @request_hashes['requests'].map { |rh| ResponseMate::Request.new(rh) }
-    @default_headers = @request_hashes['default_headers']
-    @name = @request_hashes['name'] || filename
+    @request_hashes = YAML.load(requests_text).deep_symbolize_keys
+    @name = @request_hashes[:name] || filename
+    @requests = @request_hashes[:requests].
+      map(&:deep_symbolize_keys!).
+      map { |rh| ResponseMate::Request.new(rh).normalize! }
   end
 
-  class << self
-    def parse_request(request)
-      return parse_request_string(request) if request.is_a? String
-      parse_request_hash(request) if request.is_a? Hash
-    end
-
-    def parse_request_hash(hash)
-      self::DEFAULT_REQUEST.merge(hash.symbolize_keys)
-    end
+  def requests_for_keys(keys)
+    if keys.present?
+      existing_keys = requests.map(&:key)
+      missing_keys = keys - existing_keys
 
-    def parse_request_string(request_string)
-      raise ArgumentError if request_string !~ self::REQUEST_MATCHER
-      { verb: $~[:verb] || self::DEFAULT_REQUEST[:verb] }
-        .merge(extract_path_query($~[:path]))
-    end
+      if missing_keys.present?
+        raise ResponseMate::KeysNotFound.new(missing_keys.join(','))
+      end
 
-    def extract_path_query(str)
-      parsed = Addressable::URI.parse(str)
-      {
-        path: parsed.path,
-        params: parsed.query_values
-      }
+      requests.select! do |r|
+        keys.include? r.key
+      end
     end
   end
 end

data/lib/response_mate/recorder.rb

@@ -3,37 +3,26 @@
 module ResponseMate
   # Handles recording requests
   class Recorder
-    include ResponseMate::ManifestParser
-
-    attr_accessor :base_url, :conn, :manifest, :oauth, :keys
+    attr_accessor :conn, :manifest, :keys
 
     def initialize(args = {})
       @manifest = args[:manifest]
-
-      @keys = args[:keys]
-      @base_url = args[:base_url] || manifest.base_url
-
-      @conn = ResponseMate::Connection.new(base_url)
-      @conn.set_headers_from_manifest(manifest)
+      @conn = ResponseMate::Connection.new
     end
 
-    def record
-      requests = manifest.requests
-      requests.select! { |r| keys.include? r.key } if keys.present?
-      requests.each do |request|
-        process request.key, request
-      end
+    def record(keys)
+      requests = keys.empty? ? manifest.requests : manifest.requests_for_keys(keys)
+
+      requests.each { |request| process request }
     end
 
     private
 
-    def process(key, request)
+    def process(request)
       meta = request.meta
-      request = ResponseMate::Manifest.parse_request(request.request)
+      puts request.to_cli_format
 
-      puts "[#{key}] #{request[:verb]}".cyan_on_black.bold << " #{request[:path]}"
-      puts "\tparams #{request[:params]}" if request[:params].present?
-      ResponseMate::Tape.new.write(key, request, conn.fetch(request), meta)
+      ResponseMate::Tape.new.write(request.key, request, conn.fetch(request), meta)
     end
   end
 end

data/lib/response_mate/request.rb

@@ -1,4 +1,37 @@
 # coding: utf-8
 
 class ResponseMate::Request < OpenStruct
+  delegate :[], to: :request
+
+  def normalize!
+    unless ResponseMate::ManifestParser::HTTP_VERBS.include? self.request[:verb]
+      self.request[:verb] = 'GET'
+    end
+
+    self.request[:url] = URI.encode(adjust_scheme(request[:url], request[:scheme]))
+
+    self
+  end
+
+  def to_cli_format
+    out = "[#{key}] #{request[:verb]}".cyan_on_black.bold << " #{request[:url]}"
+    out << "\tparams #{request[:params]}" if request[:params].present?
+    out
+  end
+
+  def to_hash
+    marshal_dump[:request]
+  end
+
+  private
+
+  def adjust_scheme(uri, scheme)
+    scheme = %w[http https].include?(scheme) ? scheme : 'http'
+
+    if uri !~ /\Ahttp(s)?/
+      "#{scheme}://#{uri}"
+    else
+      uri
+    end
+  end
 end

data/lib/response_mate/tape.rb

@@ -2,12 +2,17 @@
 
 class ResponseMate::Tape
   def write(key, request, response, meta = {})
-    File.open("#{ResponseMate.configuration.output_dir}#{key}.yml", 'w') do |f|
+    output_dir = ResponseMate.configuration.output_dir
+    output_path = File.join output_dir, "#{key}.yml"
+
+    File.open(output_path, 'w') do |f|
       file_content = {
-        request: request.select { |_, v| !v.nil? },
-        status: response.status,
-        headers: response.headers.to_hash,
-        body: response.body
+        request: request.to_hash.select { |_, v| !v.nil? },
+        response: {
+          status: response.status,
+          headers: response.headers,
+          body: response.body
+        }
       }
 
       file_content.merge!(meta: meta) if meta.present?
@@ -17,4 +22,11 @@ class ResponseMate::Tape
   rescue Errno::ENOENT
     raise ResponseMate::OutputDirError
   end
+
+  class << self
+    def load(key)
+      YAML.load_file(File.join(ResponseMate.configuration.output_dir, "#{key}.yml")).
+        symbolize_keys
+    end
+  end
 end

data/lib/response_mate/version.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 module ResponseMate
-  VERSION = '0.1.14'
+  VERSION = '0.2.0'
 end

data/lib/response_mate.rb

@@ -10,6 +10,8 @@ require 'highline/import'
 require 'mustache'
 require 'ostruct'
 
+autoload :YAML, 'yaml'
+
 require 'response_mate/version'
 
 require 'response_mate/commands/base'
@@ -28,7 +30,6 @@ require 'response_mate/core'
 require 'response_mate/request'
 require 'response_mate/environment'
 require 'response_mate/manifest'
-require 'response_mate/oauth'
 require 'response_mate/tape'
 require 'response_mate/recorder'
 require 'response_mate/inspector'

data/response_mate.gemspec

@@ -22,14 +22,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'pry-remote'
-  spec.add_development_dependency 'pry-nav'
-  spec.add_development_dependency 'rspec', '~> 2.14'
   spec.add_development_dependency 'fakefs'
-  spec.add_development_dependency 'rubocop'
 
-  spec.add_dependency 'thor', '~> 0.18.1'
+  spec.add_dependency 'thor', '~> 0.19'
   spec.add_dependency 'awesome_print'
   spec.add_dependency 'activesupport'
   spec.add_dependency 'colored'

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

@@ -0,0 +1,61 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ResponseMate::Commands::Inspect do
+  include_context 'stubbed_requests'
+
+  describe '#run' do
+    context 'when no keys are specified' do
+      it 'displays help message' do
+        error_output = nil
+
+        quietly do
+          error_output = capture(:stderr) do
+            ResponseMate::Commands::Inspect.new([], {}).run
+          end
+        end
+
+        expect(error_output.strip).to eq("At least one key has to be specified".red)
+      end
+    end
+
+    context 'when key is specified' do
+      let(:mock_request) do
+        ResponseMate::Request.new(key: 'user_issues',
+                                  request: {
+                                    verb: 'GET',
+                                    host: 'www.someapi.com',
+                                    path: '/user/42/issues' }).normalize!
+      end
+
+      let(:captured_output) do
+        output = nil
+
+        quietly do
+          output = capture(:stdout) do
+            ResponseMate::Commands::Inspect.new(['user_issues'], {}).run
+          end
+        end
+        output.strip
+      end
+
+      it 'displays the key, host, path, verb of the request' do
+        expect(captured_output).to include(mock_request.to_cli_format)
+      end
+
+      it 'includes the response status' do
+        expect(captured_output).
+          to include(":status => #{fake_response_user_issues[:status].to_s}")
+      end
+
+      it 'includes the response body' do
+        expect(captured_output).to include(%(:body => "#{fake_response_user_issues[:body]}"))
+      end
+
+      it 'includes the response headers' do
+        expect(captured_output).to include(fake_response_user_issues[:headers].values.last)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ResponseMate::Commands::List do
+  include_context 'stubbed_requests'
+
+  subject { ResponseMate::Commands::List.new([], {}) }
+  let(:cmd_output) { capture(:stdout) { subject.run } }
+
+  describe '#run' do
+    before { subject.stub(:ask_action).and_return(:no) }
+
+    it 'lists all available keys' do
+      expect(cmd_output).to eq("user_issues\nuser_friends\n\n")
+    end
+
+    context 'when record is selected' do
+      before { subject.stub(:ask_action).and_return(:record) }
+
+      context 'and the 2nd key is selected' do
+        before { subject.stub(:ask_key).and_return('user_friends') }
+
+        it 'is recorded' do
+          quietly { cmd_output }
+          expect(File.basename(output_files.call.last)).to eq('user_friends.yml')
+        end
+      end
+    end
+
+    context 'when inspect is selected' do
+      before { subject.stub(:ask_action).and_return(:inspect) }
+
+      context 'and the 2nd key is selected' do
+        before { subject.stub(:ask_key).and_return('user_friends') }
+
+        describe 'inspection' do
+          it 'contains the response status' do
+            expect(cmd_output).to match(/:status/)
+          end
+
+          it 'contains the response headers' do
+            expect(cmd_output).to match(/:headers/)
+          end
+
+          it 'contains the response body' do
+            expect(cmd_output).to match(/:body/)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe ResponseMate::Commands::Record do
+  include_context 'stubbed_requests'
+
+  describe '#run' do
+    context 'with keys option unspecified' do
+      before do
+        quietly { ResponseMate::Commands::Record.new([], { keys: [] }).run }
+      end
+
+      describe 'output files' do
+        it 'creates on for each request' do
+          expect(output_files.call).to have_exactly(2).items
+        end
+      end
+    end
+
+    context 'with keys option specified' do
+      context 'when the requested key exists' do
+        before do
+          quietly do
+            ResponseMate::Commands::Record.new([], { keys: ['user_issues'] }).run
+          end
+        end
+
+        it 'creates an output response file' do
+          expect(output_files.call).to have_exactly(1).items
+        end
+
+        describe 'output response file' do
+          let(:output_filename) do
+            File.join(ResponseMate.configuration.output_dir, 'user_issues.yml')
+          end
+
+          it 'has the right file extension' do
+            expect(File.exists?(output_filename)).to be_true
+          end
+
+          describe 'YAML content' do
+            let(:output_content) { File.read(output_filename) }
+            subject { YAML.load(output_content) }
+
+            it 'is valid' do
+              expect { subject }.to_not raise_error
+            end
+
+            it 'contains the original request verb' do
+              expect(subject[:request][:verb]).to be_present
+            end
+
+            it 'contains the original request path' do
+              pending
+            end
+
+            it 'contains the original request params' do
+              pending
+            end
+
+            it 'contains the response status' do
+              expect(subject[:response][:status]).
+                to eql(fake_response_user_issues[:status])
+            end
+
+            it 'includes the response headers' do
+              expect(subject[:response][:headers]).
+                to eql(fake_response_user_issues[:headers])
+            end
+
+            it 'includes the response body' do
+              expect(subject[:response][:body]).
+                to eql(fake_response_user_issues[:body])
+            end
+          end
+        end
+      end
+
+      context 'when the requested key does not exist' do
+        subject do
+          ResponseMate::Commands::Record.new([], { keys: ['non_existing_key'] }).run
+        end
+
+        it 'raises ResponseMate::KeysNotFound'do
+          expect { subject }.to raise_error(ResponseMate::KeysNotFound)
+        end
+      end
+    end
+  end
+end

data/spec/lib/response_mate/core_spec.rb

@@ -13,10 +13,6 @@ describe ResponseMate::Configuration do
     it 'assigns @requests_manifest' do
       expect(subject.requests_manifest).to be_present
     end
-
-    it 'assigns @oauth_manifest' do
-      expect(subject.oauth_manifest).to be_present
-    end
   end
 end
 
@@ -45,7 +41,6 @@ describe ResponseMate do
         ResponseMate.setup do |config|
           config.output_dir        = 'foo'
           config.requests_manifest = 'bar'
-          config.oauth_manifest    = 'koko'
         end
       end
 
@@ -53,14 +48,12 @@ describe ResponseMate do
         ResponseMate.setup do |config|
           config.output_dir        = './output/responses/'
           config.requests_manifest = './requests.yml.erb'
-          config.oauth_manifest    = './oauth.yml'
         end
       end
 
       it 'properly assigns ivars' do
         expect(ResponseMate.configuration.output_dir).to eq('foo')
         expect(ResponseMate.configuration.requests_manifest).to eq('bar')
-        expect(ResponseMate.configuration.oauth_manifest).to eq('koko')
       end
     end
   end

data/spec/lib/response_mate/recorder_spec.rb

@@ -1,104 +1,74 @@
 # coding: utf-8
 require 'spec_helper'
 
-# TODO: This spec needs some love
-describe ResponseMate::Recorder, fakefs: true do
-  pending '.initialize' do
-    let(:subject) { ResponseMate::Recorder.new }
-
-    context 'args[:requests_manifest] is present' do
-      let(:subject) { ResponseMate::Recorder.new(requests_manifest: 'lala.yml') }
-
-      it 'assigns @requests_manifest to that argument' do
-        expect(subject.requests_manifest).to eq('lala.yml')
-      end
-    end
-
-    pending 'args[:requests_manifest] is not present' do
-      let(:subject) { ResponseMate::Recorder.new }
+describe ResponseMate::Recorder do
+  include_context 'stubbed_requests'
+
+  let(:user_issues_request) do
+    ResponseMate::Request.new(
+      key: 'user_issues',
+      request: {
+        url: 'www.someapi.com/user/42/issues'
+      }).normalize!
+  end
 
-      it 'assigns @requests_manifest to ResponseMate.configuration.requests_manifest' do
-        expect(subject.requests_manifest).
-          to eq(ResponseMate.configuration.requests_manifest)
-      end
-    end
+  let(:user_friends_request) do
+    ResponseMate::Request.new(
+      key: 'user_friends',
+      request: {
+        url: 'www.someapi.com/user/42/friends',
+        params: {
+          trusty: 'yes',
+          since: 'childhood'
+        }
+      }).normalize!
+  end
 
-    context 'args[:base_url] is present' do
-      let(:subject) { ResponseMate::Recorder.new(base_url: 'http://example.com') }
+  let(:requests) { [user_issues_request, user_friends_request] }
+  let(:manifest) { double(requests: requests) }
 
-      it 'assigns @base_url to that argument' do
-        expect(subject.base_url).to eq('http://example.com')
-      end
-    end
+  describe '.initialize' do
+    context 'when initialization option :manifest is present' do
+      let(:subject) { ResponseMate::Recorder.new(manifest: manifest) }
 
-    context 'args[:base_url] is not present' do
-      it 'assigns @base_url to the one found in the manifest' do
-        expect(subject.base_url).to eq('http://koko.com')
+      it 'assigns manifest to that argument' do
+        expect(subject.manifest).to eq(manifest)
       end
     end
 
-    it 'calls #parse_requests_manifest' do
-      ResponseMate::Recorder.any_instance.should_receive :parse_requests_manifest
-      subject
-    end
-
-    it 'calls #initialize_connection' do
-      ResponseMate::Recorder.any_instance.should_receive :initialize_connection
-      subject
+    it 'creates a new instance of ResponseMate::Connection' do
+      expect(subject.conn).to be_a(ResponseMate::Connection)
     end
   end
 
-  pending '#record', fakefs: false do
-    before do
-      FakeFS.deactivate!
-      FileUtils.cp 'spec/fixtures/two_keys.yml.erb', 'two_keys.yml.erb'
-      ResponseMate::Oauth.any_instance.stub(:token).and_return 'some_token'
-    end
+  describe '#record' do
+    let(:subject) { ResponseMate::Recorder.new(manifest: manifest) }
 
-    after do
-      FileUtils.rm ['two_keys.yml.erb'] + Dir.glob('output/responses/*.yml')
+    before do
+      allow(manifest).to receive(:requests_for_keys).and_return([user_issues_request])
     end
 
-    let(:subject) { ResponseMate::Recorder.new(requests_manifest: 'two_keys.yml.erb') }
-
-    describe 'output file' do
-      before do
-        subject.stub(:fetch).and_return(double(status: 200, headers: 'koko', body: 'foo'))
-        subject.record
-      end
-
-      let(:response) { YAML::load_file 'output/responses/one.yml' }
-
-      it 'is named after the recording key and ends in .yml' do
-        expect(Dir.glob('output/responses/*.yml').map { |f| File.basename f }).
-          to eq(%w(one.yml two.yml))
-      end
-
-      it 'contains response status' do
-        expect(response[:status]).to eq(200)
-      end
-
-      it 'contains response headers' do
-        expect(response[:headers]).to eq('koko')
+    context 'with a single key specified' do
+      it 'only records this key' do
+        subject.should_receive(:process).with(user_issues_request)
+        subject.record('user_issues')
       end
+    end
 
-      it 'contains response body' do
-        expect(response[:body]).to eq('foo')
+    context 'with no keys specified' do
+      it 'records all keys in the manifest' do
+        quietly { subject.record([]) }
+        expect(output_files.call).to have_exactly(2).items
       end
+    end
+  end
 
-      describe 'request' do
-        it 'contains verb' do
-          expect(response[:request][:verb]).to be_present
-        end
-
-        it 'contains path' do
-          expect(response[:request][:path]).to be_present
-        end
+  describe '#process' do
+    let(:subject) { ResponseMate::Recorder.new(manifest: manifest) }
 
-        it 'contains params' do
-          expect(response[:request][:params]).to be_present
-        end
-      end
+    it 'writes a new ResponseMate::Tape for the specified request' do
+      ResponseMate::Tape.any_instance.should_receive(:write)
+      quietly { subject.send :process, user_issues_request }
     end
   end
 end

data/spec/source/environment.yml

@@ -0,0 +1 @@
+oauth_token: some_valid_token

data/spec/source/requests.yml

@@ -0,0 +1,20 @@
+default_headers: &default_headers
+  accept: 'application/vnd.someapi+json; version=3'
+  authorization: 'Bearer {{oauth_token}}'
+
+requests:
+  -
+    key: user_issues
+    request:
+      url: 'www.someapi.com/user/42/issues'
+      headers:
+        <<: *default_headers
+
+  - key: user_friends
+    request:
+      url: 'www.someapi.com/user/42/friends'
+      headers:
+        <<: *default_headers
+      params:
+        trusty: 'yes'
+        since: 'childhood'