typhoeus 0.3.3 → 0.4.0

data/spec/typhoeus/filter_spec.rb

@@ -1,35 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Typhoeus::Filter do
-  it "should take a method name and optionally take options" do
-    filter = Typhoeus::Filter.new(:bar, :only => :foo)
-    filter = Typhoeus::Filter.new(:bar)
-  end
-  
-  describe "#apply_filter?" do
-    it "should return true for any method when :only and :except aren't specified" do
-      filter = Typhoeus::Filter.new(:bar)
-      filter.apply_filter?(:asdf).should be_true
-    end
-    
-    it "should return true if a method is in only" do
-      filter = Typhoeus::Filter.new(:bar, :only => :foo)
-      filter.apply_filter?(:foo).should be_true
-    end
-    
-    it "should return false if a method isn't in only" do
-      filter = Typhoeus::Filter.new(:bar, :only => :foo)
-      filter.apply_filter?(:bar).should be_false
-    end
-    
-    it "should return true if a method isn't in except" do
-      filter = Typhoeus::Filter.new(:bar, :except => :foo)
-      filter.apply_filter?(:bar).should be_true
-    end
-    
-    it "should return false if a method is in except" do
-      filter = Typhoeus::Filter.new(:bar, :except => :foo)
-      filter.apply_filter?(:foo).should be_false
-    end
-  end
-end

data/spec/typhoeus/form_spec.rb

@@ -1,117 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Typhoeus::Form do
-  describe "#process!" do
-    it "should generate a valid form object" do
-      form = Typhoeus::Form.new({
-        :name => "John Smith",
-        :age => "29"
-      })
-      form.should_receive(:formadd_param).with("name", "John Smith")
-      form.should_receive(:formadd_param).with("age", "29")
-      form.process!
-    end
-
-    it "should handle params that are a hash" do
-      form = Typhoeus::Form.new({
-        :attributes => {
-          :eyes => "brown",
-          :hair => "green",
-          :teeth => "white"
-        },
-        :name => "John Smith",
-        :age => "29"
-      })
-      form.should_receive(:formadd_param).with("attributes[eyes]", "brown")
-      form.should_receive(:formadd_param).with("attributes[hair]", "green")
-      form.should_receive(:formadd_param).with("attributes[teeth]", "white")
-      form.should_receive(:formadd_param).with("name", "John Smith")
-      form.should_receive(:formadd_param).with("age", "29")
-      form.process!
-    end
-
-    it "should params that have mutliple values" do
-      form = Typhoeus::Form.new({
-        :colors => ["brown", "green", "white"],
-        :name => "John Smith",
-        :age => "29"
-      })
-      form.should_receive(:formadd_param).with("colors", "brown")
-      form.should_receive(:formadd_param).with("colors", "green")
-      form.should_receive(:formadd_param).with("colors", "white")
-      form.should_receive(:formadd_param).with("name", "John Smith")
-      form.should_receive(:formadd_param).with("age", "29")
-      form.process!
-    end
-
-    context "when a File object is a param" do
-      it "should handle one file" do
-        form = Typhoeus::Form.new(
-          :file => File.open(File.expand_path(File.dirname(__FILE__) + "/../fixtures/placeholder.txt"), "r")
-        )
-        form.should_receive(:formadd_file).with("file", "placeholder.txt", "text/plain", anything)
-        form.process!
-      end
-
-      it "should handle more than one file" do
-        form = Typhoeus::Form.new(
-          :text_file => File.open(File.expand_path(File.dirname(__FILE__) + "/../fixtures/placeholder.txt"), "r"),
-          :gif_file => File.open(File.expand_path(File.dirname(__FILE__) + "/../fixtures/placeholder.gif"), "r")
-        )
-        form.should_receive(:formadd_file).with("gif_file", "placeholder.gif", "image/gif", anything)
-        form.should_receive(:formadd_file).with("text_file", "placeholder.txt", "text/plain", anything)
-        form.process!
-      end
-
-      it "should handle tempfiles (file subclasses)" do
-        tempfile = Tempfile.new('placeholder_temp')
-        form = Typhoeus::Form.new(
-          :file => tempfile
-        )
-        form.should_receive(:formadd_file).with("file", File.basename(tempfile.path), "application/octet-stream", anything)
-        form.process!
-      end
-
-      it "should default to 'application/octet-stream' if no content type can be determined" do
-        pending
-        form = Typhoeus::Form.new(
-          :file => File.open(File.expand_path(File.dirname(__FILE__) + "/../fixtures/placeholder.txt"), "r")
-        )
-        form.should_receive(:formadd_file).with("file", "placeholder.ukn", "application/octet-stream", anything)
-        form.process!
-      end
-    end
-  end
-
-  describe "#to_s" do
-    it "should generate a valid query string" do
-      form = Typhoeus::Form.new({
-        :name => "John Smith",
-        :age => "29"
-      })
-      form.to_s.should == "age=29&name=John Smith"
-    end
-
-    it "should handle params that are a hash" do
-      form = Typhoeus::Form.new({
-        :attributes => {
-          :eyes => "brown",
-          :hair => "green",
-          :teeth => "white"
-        },
-        :name => "John Smith",
-        :age => "29"
-      })
-      form.to_s.should == "age=29&attributes[eyes]=brown&attributes[hair]=green&attributes[teeth]=white&name=John Smith"
-    end
-
-    it "should params that have multiple values" do
-      form = Typhoeus::Form.new({
-        :colors => ["brown", "green", "white"],
-        :name => "John Smith",
-        :age => "29"
-      })
-      form.to_s.should == "age=29&colors=brown&colors=green&colors=white&name=John Smith"
-    end
-  end
-end

data/spec/typhoeus/hydra_mock_spec.rb

@@ -1,300 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
-
-describe Typhoeus::HydraMock do
-  it "should mark all responses as mocks" do
-    response = Typhoeus::Response.new(:mock => false)
-    response.should_not be_mock
-
-    mock = Typhoeus::HydraMock.new("http://localhost", :get)
-    mock.and_return(response)
-
-    mock.response.should be_mock
-    response.should be_mock
-  end
-
-  describe "stubbing response values" do
-    before(:each) do
-      @stub = Typhoeus::HydraMock.new('http://localhost:3000', :get)
-    end
-
-    describe "with a single response" do
-      it "should always return that response" do
-        response = Typhoeus::Response.new
-        @stub.and_return(response)
-
-        5.times do
-          @stub.response.should == response
-        end
-      end
-    end
-
-    describe "with multiple responses" do
-      it "should return consecutive responses in the array, then keep returning the last one" do
-        responses = []
-        3.times do |i|
-          responses << Typhoeus::Response.new(:body => "response #{i}")
-        end
-
-        # Stub 3 consecutive responses.
-        @stub.and_return(responses)
-
-        0.upto(2) do |i|
-          @stub.response.should == responses[i]
-        end
-
-        5.times do
-          @stub.response.should == responses.last
-        end
-      end
-    end
-  end
-
-  describe "#matches?" do
-    describe "basic matching" do
-      it "should not match if the HTTP verbs are different" do
-        request = Typhoeus::Request.new("http://localhost:3000",
-                                        :method => :get)
-        mock = Typhoeus::HydraMock.new("http://localhost:3000", :post)
-        mock.matches?(request).should be_false
-      end
-    end
-
-    describe "matching on ports" do
-      it "should handle default port 80 sanely" do
-        mock = Typhoeus::HydraMock.new('http://www.example.com:80/', :get,
-                                       :headers => { 'user-agent' => 'test' })
-        request = Typhoeus::Request.new('http://www.example.com/',
-                                        :method => :get,
-                                        :headers => { 'user-agent' => 'test' })
-        mock.matches?(request).should be_true
-      end
-
-      it "should handle default port 443 sanely" do
-        mock = Typhoeus::HydraMock.new('https://www.example.com:443/', :get,
-                                       :headers => { 'user-agent' => 'test' })
-        request = Typhoeus::Request.new('https://www.example.com/',
-                                        :method => :get,
-                                        :headers => { 'user-agent' => 'test' })
-        mock.matches?(request).should be_true
-      end
-    end
-
-
-    describe "any HTTP verb" do
-      it "should match any verb" do
-        mock = Typhoeus::HydraMock.new("http://localhost:3000", :any,
-                                       :headers => { 'user-agent' => 'test' })
-        [:get, :post, :delete, :put].each do |verb|
-          request = Typhoeus::Request.new("http://localhost:3000",
-                                          :method => verb,
-                                          :headers => { 'user-agent' => 'test' })
-          mock.matches?(request).should be_true
-        end
-      end
-    end
-
-    describe "header matching" do
-      def request(options = {})
-        Typhoeus::Request.new("http://localhost:3000", options.merge(:method => :get))
-      end
-
-      def hydra(options = {})
-        Typhoeus::HydraMock.new("http://localhost:3000", :get, options)
-      end
-
-      context 'when no :headers option is given' do
-        subject { hydra }
-
-        it "matches regardless of whether or not the request has headers" do
-          subject.matches?(request(:headers => nil)).should be_true
-          subject.matches?(request(:headers => {})).should be_true
-          subject.matches?(request(:headers => { 'a' => 'b' })).should be_true
-        end
-      end
-
-      [nil, {}].each do |value|
-        context "for :headers => #{value.inspect}" do
-          subject { hydra(:headers => value) }
-
-          it "matches when the request has no headers" do
-            subject.matches?(request(:headers => nil)).should be_true
-            subject.matches?(request(:headers => {})).should be_true
-          end
-
-          it "does not match when the request has headers" do
-            subject.matches?(request(:headers => { 'a' => 'b' })).should be_false
-          end
-        end
-      end
-
-      context 'for :headers => [a hash]' do
-        it 'does not match if the request has no headers' do
-          m = hydra(:headers => { 'A' => 'B', 'C' => 'D' })
-
-          m.matches?(request).should be_false
-          m.matches?(request(:headers => nil)).should be_false
-          m.matches?(request(:headers => {})).should be_false
-        end
-
-        it 'does not match if the request lacks any of the given headers' do
-          hydra(
-            :headers => { 'A' => 'B', 'C' => 'D' }
-          ).matches?(request(
-            :headers => { 'A' => 'B' }
-          )).should be_false
-        end
-
-        it 'does not match if any of the specified values are different from the request value' do
-          hydra(
-            :headers => { 'A' => 'B', 'C' => 'D' }
-          ).matches?(request(
-            :headers => { 'A' => 'B', 'C' => 'E' }
-          )).should be_false
-        end
-
-        it 'matches if the given hash is exactly equal to the request headers' do
-          hydra(
-            :headers => { 'A' => 'B', 'C' => 'D' }
-          ).matches?(request(
-            :headers => { 'A' => 'B', 'C' => 'D' }
-          )).should be_true
-        end
-
-        it 'matches even if the request has additional headers not specified in the hydra' do
-          hydra(
-            :headers => { 'A' => 'B', 'C' => 'D' }
-          ).matches?(request(
-            :headers => { 'A' => 'B', 'C' => 'D', 'E' => 'F' }
-          )).should be_true
-        end
-
-        it 'matches even if the casing of the header keys is different between the hydra and request' do
-          hydra(
-            :headers => { 'A' => 'B', 'c' => 'D' }
-          ).matches?(request(
-            :headers => { 'a' => 'B', 'C' => 'D' }
-          )).should be_true
-        end
-
-        it 'matches if the hydraed values are regexes and match the request values' do
-          hydra(
-            :headers => { 'A' => /foo/, }
-          ).matches?(request(
-            :headers => { 'A' => 'foo bar' }
-          )).should be_true
-        end
-
-        it 'does not match if the hydraed values are regexes and do not match the request values' do
-          hydra(
-            :headers => { 'A' => /foo/, }
-          ).matches?(request(
-            :headers => { 'A' => 'bar' }
-          )).should be_false
-        end
-
-        context 'when a header is specified as an array' do
-          it 'matches when the request header has the same array' do
-            hydra(
-              :headers => { 'Accept' => ['text/html', 'text/plain'] }
-            ).matches?(request(
-              :headers => { 'Accept' => ['text/html', 'text/plain'] }
-            )).should be_true
-          end
-
-          it 'matches when the request header is a single value and the hydra array has the same value' do
-            hydra(
-              :headers => { 'Accept' => ['text/html'] }
-            ).matches?(request(
-              :headers => { 'Accept' => 'text/html' }
-            )).should be_true
-          end
-
-          it 'matches even when the request header array is ordered differently' do
-            hydra(
-              :headers => { 'Accept' => ['text/html', 'text/plain'] }
-            ).matches?(request(
-              :headers => { 'Accept' => ['text/plain', 'text/html'] }
-            )).should be_true
-          end
-
-          it 'does not match when the request header array lacks a value' do
-            hydra(
-              :headers => { 'Accept' => ['text/html', 'text/plain'] }
-            ).matches?(request(
-              :headers => { 'Accept' => ['text/plain'] }
-            )).should be_false
-          end
-
-          it 'does not match when the request header array has an extra value' do
-            hydra(
-              :headers => { 'Accept' => ['text/html', 'text/plain'] }
-            ).matches?(request(
-              :headers => { 'Accept' => ['text/html', 'text/plain', 'application/xml'] }
-            )).should be_false
-          end
-
-          it 'does not match when the request header is not an array' do
-            hydra(
-              :headers => { 'Accept' => ['text/html', 'text/plain'] }
-            ).matches?(request(
-              :headers => { 'Accept' => 'text/html' }
-            )).should be_false
-          end
-        end
-      end
-    end
-
-    describe "post body matching" do
-      it "should not bother matching on body if we don't turn the option on" do
-        request = Typhoeus::Request.new("http://localhost:3000",
-                                        :method => :get,
-                                        :headers => { 'user-agent' => 'test' },
-                                        :body => "fdsafdsa")
-        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
-                                       :headers => { 'user-agent' => 'test' })
-        mock.matches?(request).should be_true
-      end
-
-      it "should match nil correctly" do
-        request = Typhoeus::Request.new("http://localhost:3000",
-                                        :method => :get,
-                                        :body => "fdsafdsa")
-        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
-                                       :body => nil)
-        mock.matches?(request).should be_false
-      end
-
-      it "should not match if the bodies do not match" do
-        request = Typhoeus::Request.new("http://localhost:3000",
-                                        :method => :get,
-                                        :body => "ffdsadsafdsa")
-        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
-                                       :body => 'fdsafdsa')
-        mock.matches?(request).should be_false
-      end
-
-      it "should match on optional body parameter" do
-        request = Typhoeus::Request.new("http://localhost:3000",
-                                        :method => :get,
-                                        :headers => { 'user-agent' => 'test' },
-                                        :body => "fdsafdsa")
-        mock = Typhoeus::HydraMock.new("http://localhost:3000", :get,
-                                       :body => 'fdsafdsa',
-                                       :headers => {
-                                         'User-Agent' => 'test'
-                                       })
-        mock.matches?(request).should be_true
-      end
-
-      it "should regex match" do
-        request = Typhoeus::Request.new("http://localhost:3000/whatever/fdsa",
-                                        :method => :get,
-                                        :headers => { 'user-agent' => 'test' })
-        mock = Typhoeus::HydraMock.new(/fdsa/, :get,
-                                       :headers => { 'user-agent' => 'test' })
-        mock.matches?(request).should be_true
-      end
-    end
-  end
-end
-