xenda-typhoeus 0.2.4

data/spec/typhoeus/filter_spec.rb

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,300 @@
+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,
+                                        :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,
+                                        :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,
+                                          :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 mock(options = {})
+        Typhoeus::HydraMock.new("http://localhost:3000", :get, options)
+      end
+
+      context 'when no :headers option is given' do
+        subject { mock }
+
+        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 { mock(: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 = mock(: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
+          mock(
+            :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
+          mock(
+            :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
+          mock(
+            :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 mock' do
+          mock(
+            :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 mock and request' do
+          mock(
+            :headers => { 'A' => 'B', 'c' => 'D' }
+          ).matches?(request(
+            :headers => { 'a' => 'B', 'C' => 'D' }
+          )).should be_true
+        end
+
+        it 'matches if the mocked values are regexes and match the request values' do
+          mock(
+            :headers => { 'A' => /foo/, }
+          ).matches?(request(
+            :headers => { 'A' => 'foo bar' }
+          )).should be_true
+        end
+
+        it 'does not match if the mocked values are regexes and do not match the request values' do
+          mock(
+            :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
+            mock(
+              :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 mock array has the same value' do
+            mock(
+              :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
+            mock(
+              :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
+            mock(
+              :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
+            mock(
+              :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
+            mock(
+              :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,
+                                        :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,
+                                        :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,
+                                        :user_agent => 'test')
+        mock = Typhoeus::HydraMock.new(/fdsa/, :get,
+                                       :headers => { 'user-agent' => 'test' })
+        mock.matches?(request).should be_true
+      end
+    end
+  end
+end
+