ruby-requests 0.0.1.a1

data/spec/functional/proxies/squid_conf/squid.conf

@@ -0,0 +1,11 @@
+auth_param basic program /usr/lib/squid3/basic_ncsa_auth /etc/squid3/passwords
+auth_param basic realm proxy
+acl authenticated proxy_auth REQUIRED
+http_access allow authenticated
+
+http_port 3128
+
+cache_dir ufs /var/spool/squid3 100 16 256
+coredump_dir /var/spool/squid3
+
+access_log stdio:/var/log/squid3/access.log squid

data/spec/functional/requests_spec.rb

@@ -0,0 +1,326 @@
+
+require 'rspec'
+require 'base64'
+require 'openssl'
+require_relative '../spec_helper'
+
+
+RSpec.describe Requests do
+    reset_log
+    display_verbose_log
+
+    shared_examples "bad SSL certificates" do |method|
+        it "raises exception on self-signed cert" do
+            url = BADSSL_URLS['self-signed']
+            expect {
+                Requests.send(method, url)
+            }.to raise_error(OpenSSL::SSL::SSLError)
+        end
+
+        it "doesn't raise exception when verify: false" do
+            url = BADSSL_URLS['self-signed']
+            expect {
+                Requests.send(method, url, verify: false)
+            }.not_to raise_error
+        end
+    end
+
+    shared_examples "redirects" do |method, protocol, httpbin|
+        it "#{protocol} follows redirect with allow_redirects: true" do
+            skip "Not implemented yet"
+            url = httpbin + '/redirect-to'
+            payload = {'url' => 'http://example.com'}
+            resp = Requests.send(method, url, params: payload,
+                                 allow_redirects: true)
+            expect(resp.status_code).to eq(200)
+            expect(resp.url).to eq('http://example.com')
+        end
+
+        it "#{protocol} doesn't follow redirect with allow_redirects: false" do
+            url = httpbin + '/redirect-to'
+            payload = {'url' => 'http://example.com'}
+            resp = Requests.send(method, url, params: payload,
+                                 allow_redirects: false)
+            expect(resp.status_code).to eq(302)
+            full_url = url + '?' + URI.encode_www_form(payload)
+            expect(resp.url).to eq(full_url)
+        end
+    end
+
+    shared_examples "all methods" do |method, protocol, httpbin|
+        it "#{protocol} sets url attribute on the response" do
+            url = httpbin + '/anything'
+            resp = Requests.send(method, url)
+            expect(resp.url).to eq(url)
+        end
+
+        it "uses timeout" do
+            url = httpbin + '/anything'
+            expect {
+                Requests.send(method, url, timeout: [0.00001, 2])
+            }.to raise_error(Requests::ConnectionTimeout)
+        end
+    end
+
+    shared_examples "methods with response body" do |method, protocol, httpbin|
+        let(:url) { httpbin + '/anything' }
+
+        it "#{protocol} makes request" do
+            resp = Requests.send(method, url)
+            received_headers = Requests::Utils::InsensitiveDict
+                               .new(resp.json['headers'])
+            expect(resp.json['args']).to eq({})
+            user_agent = received_headers['User-Agent']
+            expect(user_agent).to eq(Requests::Utils.default_user_agent)
+        end
+
+        it "#{protocol} sends query string params" do
+            payload = {
+                'example_key' => 'example_value',
+                'other_key' => 'other_value',
+                'another_key' => ['this', 'is', 'an', 'array'],
+            }
+            resp = Requests.send(method, url, params: payload)
+            expect(resp.json['args']).to eq(payload)
+        end
+
+        it "#{protocol} sends headers" do
+            headers = {
+                'Header-Name' => 'header value',
+                'Other-Header' => 'other value',
+                'lowercase-header' => 'should still match',
+                'User-Agent' => 'Mozilla whatever',
+            }
+            resp = Requests.send(method, url, headers: headers)
+            sent_headers = Requests::Utils::InsensitiveDict
+                           .new(resp.json['headers'])
+            headers.each do |k, v|
+                expect(sent_headers[k]).to eq(v)
+            end
+        end
+
+        it "#{protocol} sends cookies" do
+            cookies = {
+                'chocolate' => 'chip',
+                'oatmeal' => 'raisin hell',
+            }
+            resp = Requests.send(method, url, cookies: cookies)
+            sent_cookies = resp.json['headers']['Cookie']
+            expect(sent_cookies).to include('chocolate=chip')
+            expect(sent_cookies).to include('oatmeal="raisin hell"')
+        end
+    end
+
+    shared_examples "GET method" do |protocol, httpbin|
+        it "#{protocol} sends basic auth" do
+            url = httpbin + '/basic-auth/testuser/testpassword'
+            resp = Requests.get(url, auth: ['testuser', 'testpassword'])
+            expect(resp.status_code).to eq(200)
+        end
+
+        it "uses timeout" do
+            url = httpbin + '/delay/60'
+            expect {
+                Requests.get(url, timeout: 2)
+            }.to raise_error(Requests::TimeoutError)
+        end
+
+        it "#{protocol} decodes gzip" do
+            url = httpbin + '/gzip'
+            resp = Requests.get(url, headers: {'Test-Header' => 'value'})
+            expect(resp.json['headers']['Test-Header']).to eq('value')
+        end
+
+        it "#{protocol} decodes deflate" do
+            url = httpbin + '/deflate'
+            resp = Requests.get(url, headers: {'Test-Header' => 'value'})
+            expect(resp.json['headers']['Test-Header']).to eq('value')
+        end
+
+        it "#{protocol} sets response cookies from Set-Cookie header" do
+            url = httpbin + '/cookies/set'
+            set_cookies = {
+                'macadamia' => 'nut',
+                'peanut' => 'butter',
+            }
+            resp = Requests.get(url, params: set_cookies,
+                                allow_redirects: false)
+            expect(resp.cookies_hash).to eq(set_cookies)
+        end
+
+        it "#{protocol} handles unicode" do
+            url = httpbin + '/encoding/utf8'
+            unicode_str = "Зарегистрируйтесь сейчас на"
+            r = Requests.get(url)
+            expect(r.text).to include(unicode_str)
+        end
+    end
+
+    shared_examples "methods with request body" do |method, protocol, httpbin|
+        let(:url) { httpbin + '/anything' }
+
+        it "#{protocol} sends json object as body" do
+            json_payload = {
+                'some' => 'thing',
+                'that' => ['can', 'be', 'encoded'],
+                'as' => {'json' => true},
+            }
+            resp = Requests.send(method, url, json: json_payload)
+            expect(resp.json['json']).to eq(json_payload)
+        end
+
+        it "#{protocol} sends json array as body" do
+            json_payload = ['some', 'list', 'of', 7, {'items' => [1, 42]}]
+            resp = Requests.send(method, url, json: json_payload)
+            expect(resp.json['json']).to eq(json_payload)
+        end
+
+        it "#{protocol} sends data string as body" do
+            data = "Some sample data\nthat isn't JSON\n"
+            resp = Requests.send(method, url, data: data)
+            expect(resp.json['data']).to eq(data)
+        end
+
+        it "#{protocol} sends data hash as form-urlencoded" do
+            data = {
+                "key a" => "value a",
+                "key b" => "value b",
+            }
+            resp = Requests.send(method, url, data: data)
+            expect(resp.json['form']).to eq(data)
+        end
+
+        it "#{protocol} sends data array as form-urlencoded" do
+            data = [["key a", "value a"],
+                    ["key b", "value b"]]
+            expected = {
+                "key a" => "value a",
+                "key b" => "value b",
+            }
+            resp = Requests.send(method, url, data: data)
+            expect(resp.json['form']).to eq(expected)
+        end
+
+        it "#{protocol} sends files" do
+        end
+
+        it "#{protocol} sends basic auth" do
+            url = httpbin + '/basic-auth/testuser/testpassword'
+            resp = Requests.send(method, url, auth: ['testuser',
+                                                     'testpassword'])
+
+            # Can't check response status code here because httpbin.org
+            # only allows GET requests on /basic-auth:
+            auth_token = Base64.strict_encode64('testuser:testpassword')
+            encoded_auth = "Basic #{auth_token}"
+            auth_header = resp.request.headers['Authorization']
+            expect(auth_header).to eq(encoded_auth)
+        end
+    end
+
+    shared_examples "HEAD method" do |protocol, httpbin|
+        let(:url) { httpbin + '/anything' }
+
+        it "#{protocol} makes request" do
+            resp = Requests.head(url)
+            expect(resp.status_code).to eq(200)
+        end
+
+        it "#{protocol} body is empty" do
+            resp = Requests.head(url)
+            expect(resp.text).to eq('')
+        end
+    end
+
+    shared_examples "OPTIONS method" do |protocol, httpbin|
+        let(:all_methods) {
+            ['PUT', 'POST', 'OPTIONS', 'DELETE',
+             'HEAD', 'GET', 'TRACE', 'PATCH']
+        }
+
+        it "#{protocol} gets allow header in response /anything" do
+            url = httpbin + "/anything"
+            resp = Requests.options(url)
+            allowed = resp.headers['allow'].split(', ')
+            diff = (allowed - all_methods) + (all_methods - allowed)
+            expect(diff).to eq([])
+        end
+
+        it "#{protocol} gets allow header in response /delete" do
+            url = httpbin + "/delete"
+            resp = Requests.options(url)
+            allowed = resp.headers['allow'].split(', ')
+            methods = ['OPTIONS', 'DELETE']
+            diff = (allowed - methods) + (methods - allowed)
+            expect(diff).to eq([])
+        end
+    end
+
+    describe "GET" do
+        HTTPBIN_URLS.each do |protocol, httpbin|
+            include_examples("all methods", "get", protocol, httpbin)
+            include_examples("redirects", "get", protocol, httpbin)
+            include_examples("methods with response body", "get", protocol,
+                             httpbin)
+            include_examples("GET method", protocol, httpbin)
+        end
+        include_examples("bad SSL certificates", 'get')
+    end
+
+    describe "POST" do
+        HTTPBIN_URLS.each do |protocol, httpbin|
+            include_examples("all methods", "post", protocol, httpbin)
+            include_examples("redirects", "post", protocol, httpbin)
+            include_examples("methods with response body", "post", protocol,
+                             httpbin)
+            include_examples("methods with request body", "post", protocol,
+                             httpbin)
+        end
+        include_examples("bad SSL certificates", 'post')
+    end
+
+    describe "PUT" do
+        HTTPBIN_URLS.each do |protocol, httpbin|
+            include_examples("all methods", "put", protocol, httpbin)
+            include_examples("redirects", "put", protocol, httpbin)
+            include_examples("methods with response body", "put", protocol,
+                             httpbin)
+            include_examples("methods with request body", "put", protocol,
+                             httpbin)
+        end
+    end
+
+    describe "PATCH" do
+        HTTPBIN_URLS.each do |protocol, httpbin|
+            include_examples("all methods", "patch", protocol, httpbin)
+            include_examples("redirects", "patch", protocol, httpbin)
+            include_examples("methods with response body", "patch", protocol,
+                             httpbin)
+            include_examples("methods with request body", "patch", protocol,
+                             httpbin)
+        end
+    end
+
+    describe "HEAD" do
+        HTTPBIN_URLS.each do |protocol, httpbin|
+            include_examples("all methods", "head", protocol, httpbin)
+            include_examples("redirects", "head", protocol, httpbin)
+            include_examples("HEAD method", protocol, httpbin)
+        end
+    end
+
+    describe "DELETE" do
+        HTTPBIN_URLS.each do |protocol, httpbin|
+            include_examples("all methods", "delete", protocol, httpbin)
+            include_examples("redirects", "delete", protocol, httpbin)
+            # include_examples("DELETE method", protocol, httpbin)
+        end
+    end
+
+    describe "OPTIONS" do
+        HTTPBIN_URLS.each do |protocol, httpbin|
+            include_examples("all methods", "options", protocol, httpbin)
+            include_examples("OPTIONS method", protocol, httpbin)
+        end
+    end
+end

data/spec/functional/session_spec.rb

@@ -0,0 +1,111 @@
+require 'rspec'
+require_relative '../spec_helper'
+
+
+RSpec.describe Requests::Session do
+    let(:httpbin) {
+        HTTPBIN_URLS['HTTPS']
+    }
+
+    let(:anything_url) {
+        httpbin + '/anything'
+    }
+
+    before(:each) do
+        @session = Requests::Session.new
+    end
+
+    describe "headers" do
+        before(:each) do
+            @session_hdrs = {
+                'Test-Header' => 'test value',
+                'Other-Header' => 'other value',
+            }
+            @session.headers = @session_hdrs
+        end
+
+        it "sends session headers with each request" do
+            r = @session.get(anything_url)
+            expect(r.json['headers']['Test-Header']).to(
+                eq(@session_hdrs['Test-Header'])
+            )
+            expect(r.json['headers']['Other-Header']).to(
+                eq(@session_hdrs['Other-Header'])
+            )
+        end
+
+        it "request headers take precedence over session headers" do
+            req_hdrs = {'Test-Header' => 'request-specific'}
+            r = @session.get(anything_url, headers: req_hdrs)
+            expect(r.json['headers']['Test-Header']).to(
+                eq(req_hdrs['Test-Header'])
+            )
+            expect(r.json['headers']['Other-Header']).to(
+                eq(@session_hdrs['Other-Header'])
+            )
+        end
+
+        it "session headers can be updated" do
+            @session.headers['New-Header'] = 'new value'
+            r = @session.put(anything_url)
+            expect(r.json['headers']['New-Header']).to eq('new value')
+        end
+    end
+
+    describe "cookies" do
+        let(:cookie_url) { httpbin + '/cookies' }
+
+        before(:each) do
+            @cookies = Requests::CookieJar.new
+            @cookies.add(
+                Requests::Cookie.new('chocolate', 'chip', domain: 'httpbin.org',
+                                     for_domain: true, path: '/')
+            )
+            @cookies.add(
+                Requests::Cookie.new('or', 'eo', domain: 'httpbin.org',
+                                     for_domain: true, path: '/')
+            )
+            @session.cookies = @cookies
+        end
+
+        it "sends session cookies with each request" do
+            r = @session.get(cookie_url)
+            expect(r.json['cookies']).to(
+                eq({'chocolate' => 'chip', 'or' => 'eo'})
+            )
+        end
+
+        it "request cookies take precedence over session cookies" do
+            r = @session.get(cookie_url, cookies: {'or' => 'something else'})
+            expect(r.json['cookies']).to(
+                eq({'chocolate' => 'chip',
+                    'or' => 'something else'})
+            )
+        end
+
+        it "only sends cookies belonging to request uri" do
+            # this will set some cookies for github.com:
+            r = @session.get("https://github.com")
+            github_cookies = r.cookies.to_hash
+
+            r = @session.get(cookie_url)
+            github_cookies.each_key do |key|
+                expect(r.json['cookies']).not_to include(key)
+            end
+        end
+
+        it "persists cookies set by requests" do
+            req_cookies = {'new-cookie' => 'new value',
+                                      'other-cookie' => 'other value'}
+            @session.get(cookie_url + '/set', params: req_cookies)
+            r = @session.get(cookie_url)
+            expect(r.json['cookies']).to(
+                eq({'chocolate' => 'chip',
+                    'or' => 'eo'}.merge(req_cookies))
+            )
+        end
+    end
+
+    # TODO: Write tests for proxies in a Session after figuring out
+    #       a good automated way to test proxies
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'simplecov'
+
+SimpleCov.start { add_filter 'spec/' } unless ENV['COVERAGE'] == 'false'
+
+require_relative '../lib/requests'
+
+REQUESTS_VERBOSE = (ENV['REQUESTS_VERBOSE'] == 'true')
+ENV['REQUESTS_HTTP_DEBUG'] = 'true' if REQUESTS_VERBOSE
+
+HTTPBIN_URLS = {
+    'HTTP' => 'http://httpbin.org',
+    'HTTPS' => 'https://httpbin.org',
+}
+
+BADSSL_URLS = {
+    'self-signed' => 'https://self-signed.badssl.com/',
+}
+
+$log = StringIO.new
+$logger = Requests::Logger.new($log, level: 'debug', enabled: true)
+Requests.logger = $logger
+
+
+def reset_log
+    before(:each) do
+        $log.seek(0)
+    end
+end
+
+def display_verbose_log
+    after(:each) do
+        if REQUESTS_VERBOSE
+            $log.seek(0)
+            puts "\nCAPTURED LOG:"
+            puts "=" * 16
+            puts $log.read
+            puts "=" * 16 + "\n"
+        end
+    end
+end
+
+def running_in_docker
+    ENV['RUNNING_IN_DOCKER'] == 'true'
+end