ruby-resty 0.1.0 → 0.2.0

data/spec/lib/resty/options_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Resty::Options do
+  context "command line options" do
+    let(:options) { Resty::Options.new(host: "foo.com", headers: ["key:star", "type:ninja"],
+                                          username: "leeroy", password: "jenkins", alias: "nyan") }
+
+    it "returns host" do
+      expect(options.host).to eq("foo.com")
+    end
+
+    it "returns headers" do
+      expect(options.headers).to eq(key: "star", type: "ninja")
+    end
+
+    it "doesn't read config file" do
+      options.should have_received(:load_config_file).never
+    end
+
+    it "returns username" do
+      expect(options.username).to eq("leeroy")
+    end
+
+    it "returns password" do
+      expect(options.password).to eq("jenkins")
+    end
+
+    context "empty headers" do 
+      let(:options) { Resty::Options.new({}) }
+
+      it "returns empty hash" do
+        expect(options.headers).to eq({})
+      end
+    end
+  end
+
+  context "config file" do
+    context "all values exist" do
+      before(:each) do
+        YAML.stubs(:load_file).returns({"nyan" => { "host" => "nyan.cat", "username" => "leeroy",
+                                                    "headers" => {"header" => "value"},
+                                                    "password" => "jenkins"} } )
+        File.stubs(:exist?).returns(true)
+        @options = Resty::Options.new(alias: "nyan")
+      end
+
+      it "returns host" do
+        expect(@options.host).to eq("nyan.cat")
+      end
+
+      it "returns headers" do
+        expect(@options.headers).to eq("header" => "value")
+      end
+
+      it "returns username" do
+        expect(@options.username).to eq("leeroy")
+      end
+
+      it "returns password" do
+        expect(@options.password).to eq("jenkins")
+      end
+
+      it "loads YAML file" do
+        YAML.should have_received(:load_file).with("#{Dir.home}/.ruby_resty.yml")
+      end
+    end
+
+    context "headers don't exist" do
+      before(:each) do
+        YAML.stubs(:load_file).returns({"nyan" => { "host" => "nyan.cat" } } )
+        File.stubs(:exist?).returns(true)
+        @options = Resty::Options.new(alias: "nyan")
+      end
+
+      it "returns host" do
+        expect(@options.host).to eq("nyan.cat")
+      end
+
+      it "returns headers" do
+        expect(@options.headers).to eq({})
+      end
+
+      it "loads YAML file" do
+        YAML.should have_received(:load_file).with("#{Dir.home}/.ruby_resty.yml")
+      end
+    end
+
+    context "config file doesn't exist" do
+      it "raises ConfigFileError" do
+        File.stubs(:exist?).returns(false)
+        expect { Resty::Options.new(alias: "nyan") }.to raise_error(Resty::ConfigFileError)
+      end
+    end
+
+    context "alias doesn't exist" do
+      it "raises ConfigFileError" do
+        YAML.stubs(:load_file).returns({"ice_cream" => {} } )
+        File.stubs(:exist?).returns(true)
+        expect { Resty::Options.new(alias: "nyan") }.to raise_error(Resty::ConfigFileError)
+      end
+    end
+
+    context "host doesn't exist" do
+      it "raises error" do
+        YAML.stubs(:load_file).returns({"nyan" => {}})
+        File.stubs(:exist?).returns(true)
+        expect { Resty::Options.new(alias: "nyan") }.to raise_error(Resty::ConfigFileError)
+      end
+    end
+  end
+end

data/spec/lib/resty/pretty_printer_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'json'
+
+describe Resty::PrettyPrinter do
+  let(:request) { stub }
+
+  context "#generate" do
+    context "JSON response" do
+      let(:response) { JSON.dump({foo: "bar"}) }
+
+      before(:each) { response.stubs(:code).returns(200) }
+
+      context "non-verbose" do
+        let(:printer) { Resty::PrettyPrinter.new(stub(verbose?: false),
+                                                 Hashie::Mash.new(response: response, request: request)) }
+
+        it "returns output" do
+          output = <<-eos.unindent
+           > Response Code: 200
+           {
+             "foo": "bar"
+           }
+          eos
+
+          # multi-line text adds an extra \n, so let's ignore it
+          printer.generate.should eq(output[0..-2])
+        end
+      end
+
+      context "verbose" do
+        let(:printer) { Resty::PrettyPrinter.new(stub(verbose?: true),
+                                                 Hashie::Mash.new(response: response, request: request)) }
+
+        before(:each) do
+          request.stubs(:method).returns("get")
+          request.stubs(:url).returns("foo.com")
+          request.stubs(:processed_headers).returns(header: "value", header2: "value2")
+          response.stubs(:headers).returns(response_header: "value", response_header2: "value2")
+        end
+
+        it "returns verbose output" do
+          output = <<-eos.unindent
+           > GET foo.com
+           > header: value
+           > header2: value2
+
+           > Response Code: 200
+           > response_header: value
+           > response_header2: value2
+           {
+             "foo": "bar"
+           }
+          eos
+
+          # multi-line text adds an extra \n, so let's ignore it
+          printer.generate.should eq(output[0..-2])
+        end
+      end
+    end
+
+    context "non-json response" do
+      let(:response) { "Ender Wiggin" }
+
+      before(:each) { response.stubs(:code).returns(200) }
+
+      context "non-verbose" do
+        let(:printer) { Resty::PrettyPrinter.new(stub(verbose?: false),
+                                                 Hashie::Mash.new(response: response, request: request)) }
+
+        it "returns output" do
+          output = <<-eos.unindent
+           > Response Code: 200
+           Ender Wiggin
+          eos
+
+          # multi-line text adds an extra \n, so let's ignore it
+          printer.generate.should eq(output[0..-2])
+        end
+      end
+
+      context "verbose" do
+        let(:printer) { Resty::PrettyPrinter.new(stub(verbose?: true),
+                                                 Hashie::Mash.new(response: response, request: request)) }
+
+        before(:each) do
+          request.stubs(:method).returns("get")
+          request.stubs(:url).returns("foo.com")
+          request.stubs(:processed_headers).returns(header: "value", header2: "value2")
+          response.stubs(:headers).returns(response_header: "value", response_header2: "value2")
+        end
+
+        it "returns verbose output" do
+          output = <<-eos.unindent
+           > GET foo.com
+           > header: value
+           > header2: value2
+
+           > Response Code: 200
+           > response_header: value
+           > response_header2: value2
+           Ender Wiggin
+          eos
+
+          # multi-line text adds an extra \n, so let's ignore it
+          printer.generate.should eq(output[0..-2])
+        end
+      end
+    end
+  end
+end

data/spec/lib/resty/request_spec.rb

@@ -1,88 +1,112 @@
 require 'spec_helper'
 
 describe Resty::Request do
-  let(:cli_options) { stub(host: "foo.com", verbose?: false, headers: { header: "value" }) }
+  let(:options) { Resty::Options.new(host: "foo.com", headers: ["header:value"]) }
 
   context "#send_request" do
+    let(:request) { stub(:execute) }
+
     before(:each) do
-      RestClient.stubs(:send)
+      RestClient::Request.stubs(:new).returns(request)
     end
 
-    context "GET" do
+    context "HTTP method without body" do
       let(:params) { { method: "get", path: "/api/merchants" } }
 
       before(:each) do
-        Resty::Request.new(cli_options, params).send_request
+        Resty::Request.new(options, params).send_request
       end
 
-      it "sends request" do
-        RestClient.should have_received(:send).with("get", "foo.com/api/merchants",
-                                                    {header: "value"})
-      end
-    end
-
-    context "DELETE" do
-      let(:params) { { method: "delete", path: "/api/merchants" } }
-
-      before(:each) do
-        Resty::Request.new(cli_options, params).send_request
+      it "creates request" do
+        RestClient::Request.should have_received(:new).with(url: "foo.com/api/merchants",
+                                                            method: "get",
+                                                            headers: {header: "value"})
       end
 
       it "sends request" do
-        RestClient.should have_received(:send).with("delete", "foo.com/api/merchants",
-                                                    {header: "value"})
+        request.should have_received(:execute)
       end
     end
 
-    context "HEAD" do
-      let(:params) { { method: "head", path: "/api/merchants" } }
+    context "HTTP method with body" do
+      let(:params) { { method: "post", path: "/api/merchants", data: {"foo" => "bar"} } }
 
       before(:each) do
-        Resty::Request.new(cli_options, params).send_request
+        Resty::Request.new(options, params).send_request
+      end
+
+      it "creates resource" do
+        RestClient::Request.should have_received(:new).with(url: "foo.com/api/merchants",
+                                                            method: "post",
+                                                            payload: {"foo" => "bar"},
+                                                            headers: {header: "value"})
       end
 
       it "sends request" do
-        RestClient.should have_received(:send).with("head", "foo.com/api/merchants",
-                                                    {header: "value"})
+        request.should have_received(:execute)
       end
     end
 
-    context "OPTIONS" do
-      let(:params) { { method: "options", path: "/api/merchants" } }
+    context "with basic authentication" do
+      let(:options) { Resty::Options.new(host: "foo.com", headers: ["header:value"],
+                                         username: "leeroy", password: "jenkins") }
+      let(:params) { { method: "get", path: "/api/merchants" } }
 
       before(:each) do
-        Resty::Request.new(cli_options, params).send_request
+        Resty::Request.new(options, params).send_request(foo: "bar")
+      end
+
+      it "creates request" do
+        RestClient::Request.should have_received(:new).with(url: "foo.com/api/merchants",
+                                                            method: "get",
+                                                            user: "leeroy",
+                                                            password: "jenkins",
+                                                            headers: {header: "value"})
       end
 
       it "sends request" do
-        RestClient.should have_received(:send).with("options", "foo.com/api/merchants",
-                                                    {header: "value"})
+        request.should have_received(:execute)
       end
     end
 
-    context "PUT" do
-      let(:params) { { method: "put", path: "/api/merchants", data: {"foo" => "bar"} } }
-
-      before(:each) do
-        Resty::Request.new(cli_options, params).send_request
+    context "with request options" do
+      context "with global headers" do
+        let(:options) { Resty::Options.new(host: "foo.com", headers: ["header:value"]) }
+        let(:params) { { method: "get", path: "/api/merchants" } }
+
+        before(:each) do
+          Resty::Request.new(options, params).send_request(headers: { name: "cat", age: 42})
+        end
+
+        it "creates request" do
+          RestClient::Request.should have_received(:new).with(url: "foo.com/api/merchants",
+                                                              method: "get",
+                                                              headers: { header: "value",
+                                                                         name: "cat", age: 42})
+        end
+
+        it "sends request" do
+          request.should have_received(:execute)
+        end
       end
 
-      it "sends request" do
-        RestClient.should have_received(:send).with("put", "foo.com/api/merchants",
-                                                    {"foo" => "bar"}, {header: "value"})
-      end
-    end
+      context "without global headers" do
+        let(:options) { Resty::Options.new(host: "foo.com") }
+        let(:params) { { method: "get", path: "/api/merchants" } }
 
-    context "POST" do
-      let(:params) { { method: "post", path: "/api/merchants", data: {"foo" => "bar"} } }
+        before(:each) do
+          Resty::Request.new(options, params).send_request(headers: { name: "cat", age: 42})
+        end
 
-      before(:each) do
-        Resty::Request.new(cli_options, params).send_request
-      end
+        it "creates request" do
+          RestClient::Request.should have_received(:new).with(url: "foo.com/api/merchants",
+                                                              method: "get",
+                                                              headers: { name: "cat", age: 42 })
+        end
 
-      it "sends request" do
-        RestClient.should have_received(:send).with("post", "foo.com/api/merchants",
-                                                    {"foo" => "bar"}, {header: "value"})
+        it "sends request" do
+          request.should have_received(:execute)
+        end
       end
     end
   end

data/spec/requests/commands/method_command_request_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe "method_command", :vcr do
+  let(:options) { Resty::Options.new(host: "localhost:4567", username: "nyan", password: "cat",
+                                     headers: ["name:nyaaa", "color:green"]) }
+
+  context "GET" do
+    context "with per request headers" do
+      before(:each) do
+        @result = pry_eval(options, "get /api/nyan -H age:42 -H address:space")
+      end
+
+      it "sends headers" do
+        @result.request.headers.should eq(name: "nyaaa", color: "green", age: "42", address: "space")
+      end
+
+      it "returns 200" do
+        @result.response.code.should eq(200)
+      end
+
+      it "returns response" do
+        JSON.parse(@result.response).should eq("nyan" => "cat")
+      end
+    end
+
+    context "without per request headers" do
+      before(:each) do
+        @result = pry_eval(options, "get /api/nyan")
+      end
+
+      it "sends headers" do
+        @result.request.headers.should eq(name: "nyaaa", color: "green")
+      end
+
+      it "returns 200" do
+        @result.response.code.should eq(200)
+      end
+
+      it "returns response" do
+        JSON.parse(@result.response).should eq("nyan" => "cat")
+      end
+    end
+
+    context "non-json response" do
+      before(:each) do
+        @result = pry_eval(options, "get /api/nyan?format=xml")
+      end
+
+      it "sends headers" do
+        @result.request.headers.should eq(name: "nyaaa", color: "green")
+      end
+
+      it "returns 200" do
+        @result.response.code.should eq(200)
+      end
+
+      it "returns response" do
+        @result.response.should eq("<nyan>cat</nyan>")
+      end
+    end
+  end
+
+  context "DELETE" do
+    before(:each) do
+      @result = pry_eval(options, "delete /api/nyan")
+    end
+
+    it "sends headers" do
+      @result.request.headers.should eq(name: "nyaaa", color: "green")
+    end
+
+    it "returns 200" do
+      @result.response.code.should eq(200)
+    end
+  end
+
+  context "HEAD" do
+    before(:each) do
+      @result = pry_eval(options, "head /api/nyan")
+    end
+
+    it "sends headers" do
+      @result.request.headers.should eq(name: "nyaaa", color: "green")
+    end
+
+    it "returns 200" do
+      @result.response.code.should eq(200)
+    end
+  end
+
+  context "OPTIONS" do
+    before(:each) do
+      @result = pry_eval(options, "options /api/nyan")
+    end
+
+    it "sends headers" do
+      @result.request.headers.should eq(name: "nyaaa", color: "green")
+    end
+
+    it "returns 200" do
+      @result.response.code.should eq(200)
+    end
+  end
+
+  context "POST" do
+    before(:each) do
+      @result = pry_eval(options, "post /api/nyan {nyan: 'cat'}")
+    end
+
+    it "sends headers" do
+      @result.request.headers.should eq(name: "nyaaa", color: "green")
+    end
+
+    it "returns 200" do
+      @result.response.code.should eq(200)
+    end
+
+    it "returns created object" do
+      JSON.parse(@result.response.body).should eq("nyan" => "cat")
+    end
+  end
+
+  context "PUT" do
+    before(:each) do
+      @result = pry_eval(options, "put /api/nyan {nyan: 'cat'}")
+    end
+
+    it "sends headers" do
+      @result.request.headers.should eq(name: "nyaaa", color: "green")
+    end
+
+    it "returns 204" do
+      @result.response.code.should eq(204)
+    end
+  end
+
+  context "PATCH" do
+    before(:each) do
+      @result = pry_eval(options, "patch /api/nyan {nyan: 'cat'}")
+    end
+
+    it "sends headers" do
+      @result.request.headers.should eq(name: "nyaaa", color: "green")
+    end
+
+    it "returns 204" do
+      @result.response.code.should eq(200)
+    end
+  end
+end

data/spec/server.rb

@@ -0,0 +1,34 @@
+require 'sinatra'
+require 'json'
+
+use Rack::Auth::Basic do |username, password|
+  username == 'nyan' && password == 'cat'
+end
+
+get '/api/nyan' do
+  if params[:format] == "xml"
+    "<nyan>cat</nyan>"
+  else
+    JSON.dump({ nyan: "cat" })
+  end
+end
+
+delete '/api/nyan' do
+end
+
+head '/api/nyan' do
+end
+
+options '/api/nyan' do
+end
+
+put '/api/nyan' do
+  [204]
+end
+
+post '/api/nyan' do
+  JSON.dump(params)
+end
+
+patch '/api/nyan' do
+end

data/spec/spec_helper.rb

@@ -2,15 +2,63 @@ require_relative "../lib/resty"
 
 require 'mocha/api'
 require 'bourne'
+require 'vcr'
 
+require 'active_support/inflector'
 require 'pry/test/helper'
 
 RSpec.configure do |c|
   c.mock_with :mocha
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+
+  c.around(:each, :vcr) do |example|
+    name = example.metadata[:full_description].split(/\s+/, 2).join("/").underscore.gsub(/[^\w\/]+/, "_")
+    options = {}
+    options[:record] = example.metadata[:record] if example.metadata[:record]
+    VCR.use_cassette(name, options) { example.call }
+  end
 
   include PryTestHelpers
 end
 
+VCR.configure do |c|
+  c.cassette_library_dir        = 'spec/vcr'
+  c.hook_into                   :webmock
+
+  c.default_cassette_options    = {
+    :record                     => :once,
+    :decode_compressed_response => true,
+    # Because psych is binary encoding response headers marked with ASCII-8BIT
+    # https://groups.google.com/forum/?fromgroups#!topic/vcr-ruby/2sKrJa86ktU
+    # And syck's output is much easier to read
+    :serialize_with             => :syck,
+  }
+
+  # Pretty print your json so it's not all on one line
+  # From discussion here: https://github.com/myronmarston/vcr/pull/147
+  # https://gist.github.com/26edfe7669cc7b85e164
+  c.before_record do |i|
+    type = Array(i.response.headers['Content-Type']).join(',').split(';').first
+    code = i.response.status.code
+
+    if type =~ /[\/+]json$/ or 'text/javascript' == type
+      begin
+        data = JSON.parse i.response.body
+      rescue
+        if code != 404
+          puts
+          warn "VCR: JSON parse error for Content-type #{type}"
+          warn "Your unparseable json is: " + i.response.body.inspect
+          puts
+        end
+      else
+        i.response.body = JSON.pretty_generate data
+        i.response.update_content_length_header
+      end
+    end
+  end
+end
+
 class String
   def unindent
     gsub(/^#{scan(/^\s*/).min_by{|l|l.length}}/, "")