htty 1.4.1 → 1.5.0

data/spec/unit/htty/preferences_spec.rb

@@ -1,4 +1,4 @@
-require 'rspec'
+require 'spec_helper'
 require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/preferences")
 
 describe HTTY::Preferences do

data/spec/unit/htty/request_follow_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/request")
+require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/response")
+
+
+describe HTTY::Request do
+  let(:request_address) {'http://example.com/a?b=c#d'}
+  let(:request) {HTTY::Request.new request_address}
+
+  describe '#follow a response' do
+    let(:response) do
+      HTTY::Response.new({:headers => {'Location' => response_location}})
+    end
+
+    before :each do
+      request.send :response=, response
+    end
+
+    describe 'with an absolute URI in Location header' do
+      let(:response_location) {'http://followme.com/a/b/c'}
+
+      it 'should return another request' do
+        request.follow(response).should_not == request
+      end
+
+      it 'should return a request with the absolute URI as its HTTP URI' do
+        request.follow(response).uri.should == URI.parse(response_location)
+      end
+    end
+
+    describe 'with an absolute path in Location header' do
+      let(:response_location) {'/a/b/c'}
+
+      it 'should return a request with the same URI host ' +
+         'and with the URI path changed to the absolute path in Location' do
+        expected_uri = URI.parse(request_address)
+        expected_uri.path = response_location
+        expected_uri.query = nil
+        expected_uri.fragment = nil
+        request.follow(response).uri.should == expected_uri
+      end
+    end
+
+    describe 'with a relative path in Location header' do
+      let(:response_location) {'a/b/c'}
+
+      it 'should return a request with the same URI host ' +
+         'and with the URI path changed joining the ' +
+         'original URI path to the relative path in Location' do
+        expected_uri = URI.parse(request_address)
+        expected_uri.path = File.join(expected_uri.path, response_location)
+        expected_uri.query = nil
+        expected_uri.fragment = nil
+        request.follow(response).uri.should == expected_uri
+      end
+
+      context 'when invoked more than once' do
+        let(:after_follow) {request.follow(response)}
+
+        it 'should return always the same request' do
+          after_follow.uri.should == after_follow.follow(response).uri
+        end
+      end
+    end
+
+    describe 'with an URI with query string in Location header' do
+      let(:response_location) {'a/b/c?d=e&f=g'}
+
+      it 'should return a request with URI query string ' +
+         'equal to the Location query string' do
+        expected_query = URI.parse(response_location).query
+        request.follow(response).uri.query.should == expected_query
+      end
+
+      it 'should return a request without URI fragment' do
+        request.follow(response).uri.fragment.should be_nil
+      end
+    end
+
+    describe 'with an URI with fragment in Location header' do
+      let(:response_location) {'a/b/c#f'}
+
+      it 'should return a request with URI fragment ' +
+         'equal to the Location fragment' do
+        expected_fragment = URI.parse(response_location).fragment
+        request.follow(response).uri.fragment.should == expected_fragment
+      end
+
+      it 'should return a request without URI query string' do
+        request.follow(response).uri.query.should be_nil
+      end
+    end
+  end
+end

data/spec/unit/htty/request_spec.rb

@@ -1,81 +1,19 @@
-require 'rspec'
+require 'spec_helper'
 require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/request")
 require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/response")
 require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/version")
 
-shared_examples_for 'an empty request' do
-  it 'should have only the default headers' do
-    request.headers.should == [['User-Agent', "htty/#{HTTY::VERSION}"]]
-  end
-
-  it 'should have no body' do
-    request.body.should be_nil
-  end
-
-  it 'should have no response' do
-    request.response.should be_nil
-  end
-end
-
-shared_examples_for 'an empty, authenticated request' do
-  it 'should the expected Authorization header plus the default headers' do
-    request.headers.should == [['User-Agent',    "htty/#{HTTY::VERSION}"],
-                               ['Authorization', 'Basic bmpvbnNzb24=']]
-  end
-
-  it 'should have no body' do
-    request.body.should be_nil
-  end
-
-  it 'should have no response' do
-    request.response.should be_nil
-  end
-end
+require File.expand_path("#{File.dirname __FILE__}/shared_examples_for_requests")
 
 describe HTTY::Request do
+  let(:username) {'njonsson'}
+  let(:password) {nil}
+
   describe 'initializing with' do
     let :klass do
       HTTY::Request
     end
 
-    describe 'an invalid IPv4 address having' do
-      describe 'consecutive dots' do
-        it 'should raise URI::InvalidURIError' do
-          expect { klass.new '1.2.3..4' }.to raise_error(URI::InvalidURIError)
-        end
-      end
-
-      describe 'no dots' do
-        it 'should raise URI::InvalidURIError' do
-          expect { klass.new '1234' }.to raise_error(URI::InvalidURIError)
-        end
-      end
-
-      describe 'too few dotted decimals' do
-        it 'should raise URI::InvalidURIError' do
-          expect { klass.new '1.2.3' }.to raise_error(URI::InvalidURIError)
-        end
-      end
-
-      describe 'too many dotted decimals' do
-        it 'should raise URI::InvalidURIError' do
-          expect { klass.new '1.2.3.4.5' }.to raise_error(URI::InvalidURIError)
-        end
-      end
-
-      describe 'a dotted decimal out of range' do
-        it 'should raise URI::InvalidURIError' do
-          expect { klass.new '1.2.3.1000' }.to raise_error(URI::InvalidURIError)
-        end
-      end
-    end
-
-    describe 'an invalid hostname having a leading hyphen' do
-      it 'should raise URI::InvalidURIError' do
-        expect { klass.new '-google.com' }.to raise_error(URI::InvalidURIError)
-      end
-    end
-
     describe 'a valid FTP address' do
       it 'should raise URI::InvalidURIError' do
         expect do
@@ -390,93 +328,6 @@ describe HTTY::Request do
           end
         end
 
-        describe '-- when sent #userinfo_set with' do
-          describe 'the same userinfo --' do
-            before :each do
-              request.userinfo_set 'njonsson'
-            end
-
-            it 'should have an unchanged URI' do
-              request.uri.should == URI.parse('https://njonsson@github.com' +
-                                              ':123'                        +
-                                              '/search/deep?q=http&lang=en' +
-                                              '#content')
-            end
-
-            it_should_behave_like 'an empty, authenticated request'
-          end
-
-          describe 'different userinfo' do
-            describe "that does not contain '@' --" do
-              before :each do
-                request.userinfo_set 'nils'
-              end
-
-              it 'should have the same URI, with the changed userinfo' do
-                request.uri.should == URI.parse('https://nils@github.com:123' +
-                                                '/search/deep?q=http&lang=en' +
-                                                '#content')
-              end
-
-              it 'should the expected Authorization header plus the default ' +
-                 'headers' do
-                request.headers.should == [['User-Agent',    'htty/' +
-                                                             HTTY::VERSION],
-                                           ['Authorization', 'Basic bmlscw==']]
-              end
-
-              it 'should have no body' do
-                request.body.should be_nil
-              end
-
-              it 'should have no response' do
-                request.response.should be_nil
-              end
-            end
-
-            describe "that contains an escaped '@' --" do
-              before :each do
-                request.userinfo_set 'n%45'
-              end
-
-              it 'should have the same URI, with the changed userinfo' do
-                request.uri.should == URI.parse('https://n%45@github.com:123' +
-                                                '/search/deep?q=http&lang=en' +
-                                                '#content')
-              end
-
-              it 'should the expected Authorization header plus the default ' +
-                 'headers' do
-                request.headers.should == [['User-Agent',    'htty/' +
-                                                             HTTY::VERSION],
-                                           ['Authorization', 'Basic bkU=']]
-              end
-
-              it 'should have no body' do
-                request.body.should be_nil
-              end
-
-              it 'should have no response' do
-                request.response.should be_nil
-              end
-            end
-          end
-        end
-
-        describe '-- when sent #userinfo_unset --' do
-          before :each do
-            request.userinfo_unset
-          end
-
-          it 'should have the same URI, without userinfo' do
-            request.uri.should == URI.parse('https://github.com:123'      +
-                                            '/search/deep?q=http&lang=en' +
-                                            '#content')
-          end
-
-          it_should_behave_like 'an empty request'
-        end
-
         describe '-- when sent #host_set with' do
           describe 'the same host --' do
             before :each do
@@ -1111,39 +962,6 @@ describe HTTY::Request do
           end
         end
 
-        describe '-- when sent #userinfo_set with different userinfo --' do
-          let :new_request do
-            request.userinfo_set 'nils'
-          end
-
-          it 'should return a request with the same URI having the changed ' +
-             'userinfo' do
-            new_request.uri.should == URI.parse('https://nils@github.com:123' +
-                                                '/search/deep?q=http&lang=en' +
-                                                '#content')
-          end
-
-          it 'should return a request without a response' do
-            new_request.response.should be_nil
-          end
-        end
-
-        describe '-- when sent #userinfo_unset --' do
-          let :new_request do
-            request.userinfo_unset
-          end
-
-          it 'should return a request with the same URI not having userinfo' do
-            new_request.uri.should == URI.parse('https://github.com:123'      +
-                                                '/search/deep?q=http&lang=en' +
-                                                '#content')
-          end
-
-          it 'should return a request without a response' do
-            new_request.response.should be_nil
-          end
-        end
-
         describe '-- when sent #host_set with a different host --' do
           let :new_request do
             request.host_set 'gist.github.com'

data/spec/unit/htty/request_userinfo_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/request")
+require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/response")
+require File.expand_path("#{File.dirname __FILE__}/../../../lib/htty/version")
+
+require File.expand_path("#{File.dirname __FILE__}/shared_examples_for_requests")
+
+
+shared_examples_for 'a request with basic authentication' do
+  it 'should have userinfo in the URI' do
+    expected_uri = URI.parse(uri)
+    expected_uri.userinfo = [username, password].compact.join(':')
+    subject.uri.should == expected_uri
+  end
+
+  it 'should have the Authorization header' do
+    subject.headers.should == [
+      user_agent_header,
+      HTTY::Headers.basic_authentication_for(
+        username, password
+      )
+    ]
+  end
+end
+
+shared_examples_for 'a request without basic authentication' do
+  it 'should not have userinfo in the URI' do
+    expected_uri = URI.parse(uri)
+    expected_uri.userinfo = nil
+    subject.uri.should == expected_uri
+  end
+
+  it 'should not have the Authorization header' do
+    subject.headers.should == [user_agent_header]
+  end
+end
+
+
+describe HTTY::Request do
+  let(:request) {HTTY::Request.new uri}
+  let(:user_agent_header) {['User-Agent', 'htty/' + HTTY::VERSION]}
+
+  subject {request}
+
+  describe 'without basic authentication' do
+    let(:uri) do
+      "https://github.com:80/search/deep?q=http#content"
+    end
+
+    it_should_behave_like 'an empty request'
+    it_should_behave_like 'a request without basic authentication'
+
+    describe '#userinfo_unset' do
+      before :each do
+        subject.userinfo_unset
+      end
+
+      it_should_behave_like 'a request without basic authentication'
+    end
+
+    describe '#userinfo_set' do
+      let(:username) {'njonsson'}
+      let(:password) {'123'}
+
+      before :each do
+        subject.userinfo_set username, password
+      end
+
+      it_should_behave_like 'a request with basic authentication'
+
+      context 'with empty password' do
+        let(:password) {nil}
+
+        it_should_behave_like 'a request with basic authentication'
+      end
+    end
+
+    describe '#headers_set Authorization' do
+      let(:username) {'njonsson'}
+      let(:password) {'123'}
+
+      before :each do
+        subject.header_set 'Authorization',
+          HTTY::Headers.basic_authentication_for(username, password).last
+      end
+
+      it_should_behave_like 'a request with basic authentication'
+    end
+  end
+
+  describe 'with basic authentication' do
+    let(:username) {'njonsson'}
+    let(:password) {'123'}
+    let(:uri) do
+      "https://#{username}:#{password}@github.com:80/search/deep?q=http#content"
+    end
+
+    let(:basic_authentication) do
+      HTTY::Headers.basic_authentication_for(username, password)
+    end
+
+    it_should_behave_like 'an empty, authenticated request'
+    it_should_behave_like 'a request with basic authentication'
+
+    describe '#userinfo_unset' do
+      before :each do
+        subject.userinfo_unset
+      end
+
+      it 'should have the same URI, without userinfo' do
+        expected_uri = URI.parse(uri)
+        expected_uri.user = nil
+        subject.uri.should == expected_uri
+      end
+    end
+
+    describe '#userinfo_set' do
+      context 'with the same credentials' do
+        before :each do
+          subject.userinfo_set username, password
+        end
+
+        it 'should have the same URI' do
+          subject.uri.should == URI.parse(uri)
+        end
+
+        it 'should have the same Authorization header' do
+          subject.headers.should == [user_agent_header, basic_authentication]
+        end
+      end
+
+      context 'with different credentials' do
+        let(:different_username) {'gabrielelana'}
+        let(:different_password) {'456'}
+
+        before :each do
+          subject.userinfo_set different_username, different_password
+        end
+
+        it 'should have the same URI, with the changed userinfo part' do
+          expected_uri = URI.parse(uri)
+          expected_uri.userinfo = [different_username, different_password].join(':')
+          subject.uri.should == expected_uri
+        end
+
+        it 'should have changed the Authorization header' do
+          subject.headers.should == [
+            user_agent_header,
+            HTTY::Headers.basic_authentication_for(
+              different_username, different_password
+            )
+          ]
+        end
+      end
+
+      context 'with credentials that contains an escaped character' do
+        let(:username) {'n%40'}
+
+        it 'should be escaped in the URI' do
+          subject.uri.userinfo.should start_with(username)
+        end
+
+        it 'should not be escaped in the Authorization header' do
+          subject.headers.should == [
+            user_agent_header,
+            HTTY::Headers.basic_authentication_for(
+              URI.unescape(username), password
+            )
+          ]
+        end
+      end
+
+      context 'with a response' do
+        before :each do
+          subject.send :response=, HTTY::Response.new
+        end
+
+        it 'should return a request without a response' do
+          subject.userinfo_set(username, password).response.should be_nil
+        end
+      end
+    end
+
+    describe '#headers_unset Authorization' do
+      before :each do
+        subject.header_unset 'Authorization'
+      end
+
+      it 'should have the same URI, without userinfo' do
+        expected_uri = URI.parse(uri)
+        expected_uri.user = nil
+        subject.uri.should == expected_uri
+      end
+    end
+
+    describe '#headers_unset_all' do
+      before :each do
+        subject.headers_unset_all
+      end
+
+      it 'should have the same URI, without userinfo' do
+        expected_uri = URI.parse(uri)
+        expected_uri.user = nil
+        subject.uri.should == expected_uri
+      end
+    end
+  end
+end