ethon 0.5.12 → 0.6.0

data/spec/ethon/easy/http/put_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Ethon::Easy::Http::Put do
+  let(:easy) { Ethon::Easy.new }
+  let(:url) { "http://localhost:3001/" }
+  let(:params) { nil }
+  let(:form) { nil }
+  let(:put) { described_class.new(url, {:params => params, :body => form}) }
+
+  describe "#setup" do
+    context "when nothing" do
+      it "sets url" do
+        put.setup(easy)
+        expect(easy.url).to eq(url)
+      end
+
+      it "sets upload" do
+        easy.should_receive(:upload=).with(true)
+        put.setup(easy)
+      end
+
+      it "sets infilesize" do
+        easy.should_receive(:infilesize=).with(0)
+        put.setup(easy)
+      end
+
+      context "when requesting" do
+        it "makes a put request" do
+          put.setup(easy)
+          easy.perform
+          expect(easy.response_body).to include('"REQUEST_METHOD":"PUT"')
+        end
+      end
+    end
+
+    context "when params" do
+      let(:params) { {:a => "1&"} }
+
+      it "attaches escaped to url" do
+        put.setup(easy)
+        expect(easy.url).to eq("#{url}?a=1%26")
+      end
+
+      it "sets upload" do
+        easy.should_receive(:upload=).with(true)
+        put.setup(easy)
+      end
+
+      it "sets infilesize" do
+        easy.should_receive(:infilesize=).with(0)
+        put.setup(easy)
+      end
+
+      context "when requesting" do
+        before do
+          put.setup(easy)
+          easy.perform
+        end
+
+        it "makes a put request" do
+          expect(easy.response_body).to include('"REQUEST_METHOD":"PUT"')
+        end
+      end
+    end
+
+    context "when body" do
+      let(:form) { {:a => "1&b=2"} }
+
+      it "sets infilesize" do
+        easy.should_receive(:infilesize=).with(11)
+        put.setup(easy)
+      end
+
+      it "sets readfunction" do
+        easy.should_receive(:readfunction)
+        put.setup(easy)
+      end
+
+      it "sets upload" do
+        easy.should_receive(:upload=).with(true)
+        put.setup(easy)
+      end
+
+      context "when requesting" do
+        context "sending string body" do
+          before do
+            easy.headers = { 'Expect' => '' }
+            put.setup(easy)
+            easy.perform
+          end
+
+          it "makes a put request" do
+            expect(easy.response_body).to include('"REQUEST_METHOD":"PUT"')
+          end
+
+          it "submits a body" do
+            expect(easy.response_body).to include('"body":"a=1%26b%3D2"')
+          end
+        end
+
+        context "when injecting a file as body" do
+          let(:file) { File.open(__FILE__) }
+          let(:easy) do
+            e = Ethon::Easy.new(:url => url, :upload => true)
+            e.set_read_callback(file)
+            e.infilesize = File.size(file.path)
+            e
+          end
+
+          before do
+            easy.headers = { 'Expect' => '' }
+            easy.perform
+          end
+
+          it "submits file" do
+            expect(easy.response_body).to include("injecting")
+          end
+        end
+      end
+    end
+
+    context "when params and body"
+  end
+end

data/spec/ethon/easy/http_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Ethon::Easy::Http do
+  let(:easy) { Ethon::Easy.new }
+
+  describe "#http_request" do
+    let(:url) { "http://localhost:3001/" }
+    let(:action_name) { :get }
+    let(:options) { {} }
+
+    let(:get) { double(:setup) }
+    let(:get_class) { Ethon::Easy::Http::Get }
+
+    it "instanciates action" do
+      get.should_receive(:setup)
+      get_class.should_receive(:new).and_return(get)
+      easy.http_request(url, action_name, options)
+    end
+
+    context "when requesting" do
+      [ :get, :post, :put, :delete, :head, :patch, :options ].map do |action|
+        it "returns ok" do
+          easy.http_request(url, action, options)
+          easy.perform
+          expect(easy.return_code).to be(:ok)
+        end
+
+        unless action == :head
+          it "makes a #{action.to_s.upcase} request" do
+            easy.http_request(url, action, options)
+            easy.perform
+            expect(easy.response_body).to include("\"REQUEST_METHOD\":\"#{action.to_s.upcase}\"")
+          end
+        end
+      end
+
+      it "makes requests with custom HTTP verbs" do
+        easy.http_request(url, :purge, options)
+        easy.perform
+        expect(easy.response_body).to include(%{"REQUEST_METHOD":"PURGE"})
+      end
+    end
+  end
+end

data/spec/ethon/easy/informations_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Ethon::Easy::Informations do
+  let(:easy) { Ethon::Easy.new }
+
+  before do
+    easy.url = "http://localhost:3001"
+    easy.perform
+  end
+
+  describe "#httpauth_avail" do
+    it "returns" do
+      expect(easy.httpauth_avail).to be
+    end
+  end
+
+  describe "#total_time" do
+    it "returns float" do
+      expect(easy.total_time).to be_a(Float)
+    end
+  end
+
+  describe "#starttransfer_time" do
+    it "returns float" do
+      expect(easy.starttransfer_time).to be_a(Float)
+    end
+  end
+
+  describe "#appconnect_time" do
+    it "returns float" do
+      expect(easy.appconnect_time).to be_a(Float)
+    end
+  end
+
+  describe "#pretransfer_time" do
+    it "returns float" do
+      expect(easy.pretransfer_time).to be_a(Float)
+    end
+  end
+
+  describe "#connect_time" do
+    it "returns float" do
+      expect(easy.connect_time).to be_a(Float)
+    end
+  end
+
+  describe "#namelookup_time" do
+    it "returns float" do
+      expect(easy.namelookup_time).to be_a(Float)
+    end
+  end
+
+  describe "#effective_url" do
+    it "returns url" do
+      expect(easy.effective_url).to match(/^http:\/\/localhost:3001\/?/)
+    end
+  end
+
+  describe "#primary_ip" do
+    it "returns localhost" do
+      expect(easy.primary_ip).to match(/::1|127\.0\.0\.1/)
+    end
+  end
+
+  describe "#response_code" do
+    it "returns 200" do
+      expect(easy.response_code).to eq(200)
+    end
+  end
+
+  describe "#redirect_count" do
+    it "returns 0" do
+      expect(easy.redirect_count).to eq(0)
+    end
+  end
+
+  describe "#supports_zlib?" do
+    it "returns true" do
+      expect(easy.supports_zlib?).to be_true
+    end
+  end
+end

data/spec/ethon/easy/mirror_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Ethon::Easy::Mirror do
+  let(:options) { nil }
+  let(:mirror) { described_class.new(options) }
+
+  describe ".informations_to_mirror" do
+    [
+      :return_code, :response_code, :response_body, :response_headers,
+      :total_time, :starttransfer_time, :appconnect_time,
+      :pretransfer_time, :connect_time, :namelookup_time,
+      :effective_url, :primary_ip, :redirect_count, :debug_info
+    ].each do |name|
+      it "contains #{name}" do
+        expect(described_class.informations_to_mirror).to include(name)
+      end
+    end
+  end
+
+  describe "#to_hash" do
+    let(:options) { {:return_code => 1} }
+
+    it "returns mirror as hash" do
+      expect(mirror.to_hash).to eq(options)
+    end
+  end
+
+  describe "#log_informations" do
+    let(:options) { {:return_code => 1} }
+
+    it "returns hash" do
+      expect(mirror.log_informations).to be_a(Hash)
+    end
+
+    it "includes return code" do
+      expect(mirror.log_informations).to include(options)
+    end
+  end
+end

data/spec/ethon/easy/operations_spec.rb

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+describe Ethon::Easy::Operations do
+  let(:easy) { Ethon::Easy.new }
+
+  describe "#handle" do
+    it "returns a pointer" do
+      expect(easy.handle).to be_a(FFI::Pointer)
+    end
+  end
+
+
+  describe "#perform" do
+    let(:url) { nil }
+    let(:timeout) { nil }
+    let(:connect_timeout) { nil }
+    let(:follow_location) { nil }
+    let(:max_redirs) { nil }
+    let(:user_pwd) { nil }
+    let(:http_auth) { nil }
+    let(:headers) { nil }
+    let(:protocols) { nil }
+    let(:redir_protocols) { nil }
+    let(:username) { nil }
+    let(:password) { nil }
+
+    before do
+      easy.url = url
+      easy.timeout = timeout
+      easy.connecttimeout = connect_timeout
+      easy.followlocation = follow_location
+      easy.maxredirs = max_redirs
+      easy.httpauth = http_auth
+      easy.headers = headers
+      easy.protocols = protocols
+      easy.redir_protocols = redir_protocols
+
+      if user_pwd
+        easy.userpwd = user_pwd
+      else
+        easy.username = username
+        easy.password = password
+      end
+
+      easy.perform
+    end
+
+    it "calls Curl.easy_perform" do
+      Ethon::Curl.should_receive(:easy_perform)
+      easy.perform
+    end
+
+    context "when url" do
+      let(:url) { "http://localhost:3001/" }
+
+      it "returns ok" do
+        expect(easy.return_code).to eq(:ok)
+      end
+
+      it "sets response body" do
+        expect(easy.response_body).to be
+      end
+
+      it "sets response headers" do
+        expect(easy.response_headers).to be
+      end
+
+      context "when request timed out" do
+        let(:url) { "http://localhost:3001/?delay=1" }
+        let(:timeout) { 1 }
+
+        it "returns operation_timedout" do
+          expect(easy.return_code).to eq(:operation_timedout)
+        end
+      end
+
+      context "when connection timed out" do
+        let(:url) { "http://localhost:3009" }
+        let(:connect_timeout) { 1 }
+
+        it "returns couldnt_connect" do
+          expect(easy.return_code).to eq(:couldnt_connect)
+        end
+      end
+
+      context "when no follow location" do
+        let(:url) { "http://localhost:3001/redirect" }
+        let(:follow_location) { false }
+
+        it "doesn't follow" do
+          expect(easy.response_code).to eq(302)
+        end
+      end
+
+      context "when follow location" do
+        let(:url) { "http://localhost:3001/redirect" }
+        let(:follow_location) { true }
+
+        it "follows" do
+          expect(easy.response_code).to eq(200)
+        end
+
+        context "when infinite redirect loop" do
+          let(:url) { "http://localhost:3001/bad_redirect" }
+          let(:max_redirs) { 5 }
+
+          context "when max redirect set" do
+            it "follows only x times" do
+              expect(easy.response_code).to eq(302)
+            end
+          end
+        end
+      end
+
+      context "when user agent" do
+        let(:headers) { { 'User-Agent' => 'Ethon' } }
+
+        it "sets" do
+          expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon"')
+        end
+      end
+    end
+
+    context "when auth url" do
+      before { easy.url = url }
+
+      context "when basic auth" do
+        let(:url) { "http://localhost:3001/auth_basic/username/password" }
+
+        context "when no user_pwd" do
+          it "returns 401" do
+            expect(easy.response_code).to eq(401)
+          end
+        end
+
+        context "when invalid user_pwd" do
+          let(:user_pwd) { "invalid:invalid" }
+
+          it "returns 401" do
+            expect(easy.response_code).to eq(401)
+          end
+        end
+
+        context "when valid user_pwd" do
+          let(:user_pwd) { "username:password" }
+
+          it "returns 200" do
+            expect(easy.response_code).to eq(200)
+          end
+        end
+
+        context "when user and password" do
+          let(:username) { "username" }
+          let(:password) { "password" }
+
+          it "returns 200" do
+            expect(easy.response_code).to eq(200)
+          end
+        end
+      end
+
+      context "when ntlm" do
+        let(:url) { "http://localhost:3001/auth_ntlm" }
+        let(:http_auth) { :ntlm }
+
+        context "when no user_pwd" do
+          it "returns 401" do
+            expect(easy.response_code).to eq(401)
+          end
+        end
+
+        context "when user_pwd" do
+          let(:user_pwd) { "username:password" }
+
+          it "returns 200" do
+            expect(easy.response_code).to eq(200)
+          end
+        end
+      end
+    end
+
+    context "when protocols" do
+      context "when asking for a allowed url" do
+        let(:url) { "http://localhost:3001" }
+        let(:protocols) { :http }
+
+        it "returns ok" do
+          expect(easy.return_code).to be(:ok)
+        end
+      end
+
+      context "when asking for a not allowed url" do
+        let(:url) { "http://localhost:3001" }
+        let(:protocols) { :https }
+
+        it "returns unsupported_protocol" do
+          expect(easy.return_code).to be(:unsupported_protocol)
+        end
+      end
+    end
+
+    context "when multiple protocols" do
+      context "when asking for a allowed url" do
+        let(:protocols) { [:http, :https] }
+
+        context "when http" do
+          let(:url) { "http://localhost:3001" }
+
+          it "returns ok for http" do
+            expect(easy.return_code).to be(:ok)
+          end
+        end
+
+        context "when https" do
+          let(:url) { "https://localhost:3001" }
+
+          it "returns ssl_connect_error for https" do
+            expect(easy.return_code).to be(:ssl_connect_error)
+          end
+        end
+      end
+
+      context "when asking for a not allowed url" do
+        let(:url) { "ssh://localhost" }
+        let(:protocols) { [:https, :http] }
+
+        it "returns unsupported_protocol" do
+          expect(easy.return_code).to be(:unsupported_protocol)
+        end
+      end
+    end
+
+    context "when redir_protocols" do
+      context "when redirecting to a not allowed url" do
+        let(:url) { "http://localhost:3001/redirect" }
+        let(:follow_location) { true }
+        let(:redir_protocols) { :https }
+
+        it "returns unsupported_protocol" do
+          expect(easy.return_code).to be(:unsupported_protocol)
+        end
+      end
+    end
+
+    context "when no url" do
+      it "returns url_malformat" do
+        expect(easy.perform).to eq(:url_malformat)
+      end
+    end
+  end
+end