http2 0.0.29 → 0.0.34

data/spec/helpers.rb

@@ -0,0 +1,27 @@
+module Helpers
+  def with_webserver
+    require "hayabusa"
+    hayabusa = Hayabusa.new(
+      doc_root: "#{File.dirname(__FILE__)}/spec_root",
+      port: 3005
+    )
+    hayabusa.start
+
+    begin
+      yield(hayabusa)
+    ensure
+      hayabusa.stop
+    end
+  end
+
+  def with_http(args = {})
+    with_webserver do |hayabusa|
+      Http2.new({host: "localhost", port: hayabusa.port, encoding_gzip: false}.merge(args)) do |http|
+        yield http
+      end
+    rescue Http2::Errors::Internalserver => e
+      puts "Body of error-response: #{e.response.body}"
+      raise e
+    end
+  end
+end

data/spec/http2/cookies_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Http2 do
+  include Helpers
+
+  it "should parse cookies and let them be read" do
+    with_http do |http|
+      http.get("cookie_test.rhtml")
+      expect(http.cookies.length).to eq 2
+
+      cookie = http.cookie("TestCookie")
+      expect(cookie.name).to eq "TestCookie"
+      expect(cookie.value).to eq "TestValue"
+      expect(cookie.path).to eq "/"
+      expect(cookie.expires).to be > Time.now
+    end
+  end
+end

data/spec/http2/get_request_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Http2::GetRequest do
+  it "reads the headers from the request" do
+    with_http do |http|
+      res = http.get("content_type_test.rhtml")
+      headers = res.request.headers_string
+      expect(headers).to include "GET /content_type_test.rhtml"
+    end
+  end
+end

data/spec/http2/post_data_generator_spec.rb

@@ -19,6 +19,7 @@ describe Http2::PostDataGenerator do
         }
       }
     ).generate
-    raise "Expected 'test1%5Border%5D%5B%5B%3ABnet_profile%2C+%22profile_id%22%5D%5D=5' but got: '#{res}'." if res != "test1%5Border%5D%5B%5B%3ABnet_profile%2C+%22profile_id%22%5D%5D=5"
+
+    expect(res).to eq "test1%5Border%5D%5B%5B%3ABnet_profile%2C+%22profile_id%22%5D%5D=5"
   end
 end

data/spec/http2/post_multipart_request_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Http2::PostMultipartRequest do
+  it "reads the headers from the request" do
+    with_http do |http|
+      res = http.post_multipart(url: "json_test.rhtml", post: {"test1" => "test2"})
+      headers = res.request.headers_string
+      expect(headers).to include "POST /json_test.rhtml"
+    end
+  end
+end

data/spec/http2/post_request_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Http2::PostRequest do
+  it "reads the headers from the request" do
+    with_http do |http|
+      res = http.post(url: "json_test.rhtml", json: {testkey: "testvalue"})
+      headers = res.request.headers_string
+      expect(headers).to include "POST /json_test.rhtml"
+    end
+  end
+end

data/spec/http2/response_reader_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Http2::ResponseReader do
+  it "#url_and_args_from_location" do
+    with_http(ssl_skip_verify: true, follow_redirects: true) do |http|
+      response = http.get("redirect_test.rhtml?redirect_to=https://www.google.dk")
+      expect(response.host).to eq "www.google.dk"
+      expect(response.ssl?).to eq true
+      expect(response.port).to eq 443
+    end
+  end
+end

data/spec/http2/response_spec.rb

@@ -1,17 +1,93 @@
 require "spec_helper"
 
 describe Http2::Response do
-  it "should register content type" do
-    Http2.new(host: "http2test.kaspernj.org") do |http|
-      res = http.get("content_type_test.php")
-      res.content_type.should eq "text/html"
+  it "#content_type" do
+    with_http do |http|
+      res = http.get("content_type_test.rhtml")
+      expect(res.content_type).to eq "text/html"
     end
   end
 
-  it "should register content length" do
-    Http2.new(host: "http2test.kaspernj.org") do |http|
-      res = http.get("content_type_test.php")
-      res.content_length.should > 50
+  it "#content_length" do
+    with_http do |http|
+      res = http.get("content_type_test.rhtml")
+      expect(res.content_length).to be > 50
+    end
+  end
+
+  describe "#json?" do
+    it "returns true for 'application/json'" do
+      with_http do |http|
+        res = http.get("json_test.rhtml")
+
+        expect(res).to receive(:content_type).and_return("application/json")
+        expect(res.json?).to eq true
+      end
+    end
+
+    it "returns true for 'application/json'" do
+      with_http do |http|
+        res = http.get("json_test.rhtml")
+        expect(res.json?).to eq true
+      end
+    end
+
+    it "returns true for 'application/json'" do
+      with_http do |http|
+        res = http.post(url: "json_test.rhtml", post: {test: "test2"})
+
+        expect(res).to receive(:content_type).and_return("application/json; charset=utf-8")
+        expect(res.json?).to eq true
+      end
+    end
+  end
+
+  it "#host" do
+    with_http do |http|
+      res = http.get("json_test.rhtml")
+      expect(res.host).to eq "localhost"
+    end
+  end
+
+  it "#port" do
+    with_http do |http|
+      res = http.get("json_test.rhtml")
+      expect(res.port).to eq http.port
+    end
+  end
+
+  it "#ssl?" do
+    with_http do |http|
+      res = http.get("json_test.rhtml")
+      expect(res.ssl?).to eq false
+    end
+  end
+
+  it "#path" do
+    with_http do |http|
+      res = http.get("json_test.rhtml")
+      expect(res.path).to eq "json_test.rhtml"
+    end
+  end
+
+  it "#header" do
+    with_http do |http|
+      res = http.get("json_test.rhtml")
+      expect(res.header("connection")).to eq "Keep-Alive"
+    end
+  end
+
+  it "#header?" do
+    with_http do |http|
+      res = http.get("json_test.rhtml")
+      expect(res.header?("connection")).to eq true
+    end
+  end
+
+  it "#json" do
+    with_http do |http|
+      res = http.post(url: "json_test.rhtml", post: {test: "test2"})
+      expect(res.json["_POST"]).to eq("test" => "test2")
     end
   end
 end

data/spec/http2/url_builder_spec.rb

@@ -11,7 +11,7 @@ describe Http2::UrlBuilder do
       ub.params["test"] = "true"
       ub.params["test2"] = "false"
 
-      ub.build.should eq "https://www.github.com:443/index.php?test=true&test2=false"
+      expect(ub.build).to eq "https://www.github.com:443/index.php?test=true&test2=false"
     end
   end
 end

data/spec/http2_spec.rb

@@ -3,154 +3,173 @@ require "json"
 
 describe "Http2" do
   it "should be able to do normal post-requests." do
-    #Test posting keep-alive and advanced post-data.
-    Http2.new(host: "www.partyworm.dk", debug: false) do |http|
+    # Test posting keep-alive and advanced post-data.
+    with_http do |http|
       0.upto(5) do
-        resp = http.get("multipart_test.php")
-
-        resp = http.post(url: "multipart_test.php?choice=post-test", post: {
-          "val1" => "test1",
-          "val2" => "test2",
-          "val3" => [
-            "test3"
-          ],
-          "val4" => {
-            "val5" => "test5"
-          },
-          "val6" => {
-            "val7" => [
-              {
-                "val8" => "test8"
-              }
-            ]
-          },
-          "val9" => ["a", "b", "d"]
-        })
+        http.get("multipart_test.rhtml")
+
+        resp = http.post(
+          url: "multipart_test.rhtml?choice=post-test",
+          post: {
+            "val1" => "test1",
+            "val2" => "test2",
+            "val3" => [
+              "test3"
+            ],
+            "val4" => {
+              "val5" => "test5"
+            },
+            "val6" => {
+              "val7" => [
+                {
+                  "val8" => "test8"
+                }
+              ]
+            },
+            "val9" => %w[a b d]
+          }
+        )
         res = JSON.parse(resp.body)
 
-        res.is_a?(Hash).should eq true
-        res["val1"].should eq "test1"
-        res["val2"].should eq "test2"
-        res["val3"][0].should eq "test3"
-        res["val4"]["val5"].should eq "test5"
-        res["val6"]["val7"][0]["val8"].should eq "test8"
-        res["val9"][0].should eq "a"
-        res["val9"][1].should eq "b"
-        res["val9"][2].should eq "d"
+        expect(res.is_a?(Hash)).to eq true
+        expect(res["val1"]).to eq "test1"
+        expect(res["val2"]).to eq "test2"
+        expect(res["val3"]["0"]).to eq "test3"
+        expect(res["val4"]["val5"]).to eq "test5"
+        expect(res["val6"]["val7"]["0"]["val8"]).to eq "test8"
+        expect(res["val9"]["0"]).to eq "a"
+        expect(res["val9"]["1"]).to eq "b"
+        expect(res["val9"]["2"]).to eq "d"
       end
     end
   end
 
   it "#reconnect" do
-    Http2.new(host: "www.partyworm.dk", follow_redirects: false, encoding_gzip: false, debug: false) do |http|
-      resp1 = http.get("multipart_test.php")
+    with_http(follow_redirects: false, encoding_gzip: false) do |http|
+      resp1 = http.get("multipart_test.rhtml")
       http.reconnect
-      resp2 = http.get("multipart_test.php")
+      resp2 = http.get("multipart_test.rhtml")
 
-      resp1.body.should eq resp2.body
+      expect(resp1.body).to eq resp2.body
     end
   end
 
   it "should be able to do multipart-requests and keep-alive when using multipart." do
-    Http2.new(host: "www.partyworm.dk", follow_redirects: false, encoding_gzip: false, debug: false) do |http|
+    with_http(follow_redirects: false) do |http|
       0.upto(5) do
         fpath = File.realpath(__FILE__)
         fpath2 = "#{File.realpath(File.dirname(__FILE__))}/../lib/http2.rb"
 
-        resp = http.post_multipart(url: "multipart_test.php", post: {
-          "test_var" => "true",
-          "test_file1" => {
-            fpath: fpath,
-            filename: "specfile"
-          },
-          "test_file2" => {
-            fpath: fpath2,
-            filename: "http2.rb"
+        resp = http.post_multipart(
+          url: "multipart_test.rhtml",
+          post: {
+            "test_var" => "true",
+            "test_file1" => {
+              fpath: fpath,
+              filename: "specfile"
+            },
+            "test_file2" => {
+              fpath: fpath2,
+              filename: "http2.rb"
+            }
           }
-        })
+        )
 
         data = JSON.parse(resp.body)
 
-        data["post"]["test_var"].should eq "true"
-        data["files_data"]["test_file1"].should eq File.read(fpath)
-        data["files_data"]["test_file2"].should eq File.read(fpath2)
+        expect(data["post"]["test_var"]).to eq "true"
+        expect(data["files_data"]["test_file1"]).to eq File.read(fpath)
+        expect(data["files_data"]["test_file2"]).to eq File.read(fpath2)
       end
     end
   end
 
   it "it should be able to handle keep-alive correctly" do
     urls = [
-      "?show=users_search",
-      "?show=users_online",
-      "?show=drinksdb",
-      "?show=forum&fid=9&tid=1917&page=0"
+      "content_type_test.rhtml",
+      "json_test.rhtml"
     ]
-    urls = ["robots.txt"]
 
-    Http2.new(host: "www.partyworm.dk", debug: false) do |http|
-      0.upto(105) do |count|
+    with_http do |http|
+      0.upto(105) do |_count|
         url = urls[rand(urls.size)]
-        #print "Doing request #{count} of 200 (#{url}).\n"
+        # puts "Doing request #{count} of 200 (#{url})."
         res = http.get(url)
-        res.body.to_s.length.should > 0
+        expect(res.body.to_s.length).to be > 0
       end
     end
   end
 
-  it "should be able to convert URL's to 'is.gd'-short-urls" do
-    isgd = Http2.isgdlink("https://github.com/kaspernj/http2")
-    raise "Expected isgd-var to be valid but it wasnt: '#{isgd}'." if !isgd.match(/^http:\/\/is\.gd\/([A-z\d]+)$/)
-  end
-
   it "should raise exception when something is not found" do
-    expect{
-      Http2.new(host: "www.partyworm.dk") do |http|
-        http.get("something_that_does_not_exist.php")
-      end
-    }.to raise_error(::Http2::Errors::Notfound)
+    with_http do |http|
+      expect { http.get("something_that_does_not_exist.rhtml") }.to raise_error(::Http2::Errors::Notfound)
+    end
   end
 
   it "should be able to post json" do
-    Http2.new(host: "http2test.kaspernj.org") do |http|
+    with_http do |http|
       res = http.post(
-        url: "/jsontest.php",
+        url: "json_test.rhtml",
         json: {testkey: "testvalue"}
       )
 
       data = JSON.parse(res.body)
-      data["_SERVER"]["CONTENT_TYPE"].should eql("application/json")
-      data["PHP_JSON_INPUT"]["testkey"].should eql("testvalue")
+      expect(data["_SERVER"]["HTTP_CONTENT_TYPE"]).to eq "application/json"
+
+      # Hack JSON data from Hayabusa.
+      json_data = JSON.parse(data["_POST"].keys.first)
+      expect(json_data["testkey"]).to eq "testvalue"
+
+      expect(res.content_type).to eq "application/json"
+      expect(res.json?).to eq true
+      expect(res.json["_SERVER"]["REQUEST_METHOD"]).to eq "POST"
     end
   end
 
   it "should be able to post custom content types" do
-    require "json"
-
-    Http2.new(host: "http2test.kaspernj.org") do |http|
+    with_http do |http|
       res = http.post(
-        url: "content_type_test.php",
+        url: "content_type_test.rhtml",
         content_type: "plain/text",
         post: "test1_test2_test3"
       )
 
       data = JSON.parse(res.body)
-      data["_SERVER"]["CONTENT_TYPE"].should eql("plain/text")
-      data["PHP_INPUT"].should eql("test1_test2_test3")
+      expect(data["_SERVER"]["HTTP_CONTENT_TYPE"]).to eq "plain/text"
+
+      raw_data = data["_POST"].keys.first
+      expect(raw_data).to eq "test1_test2_test3"
     end
   end
 
   it "should set various timeouts" do
-    Http2.new(host: "http2test.kaspernj.org") do |http|
-      res = http.get("content_type_test.php")
-      http.keepalive_timeout.should eq 5
-      http.keepalive_max.should eq 100
+    with_http do |http|
+      http.get("content_type_test.rhtml")
+      expect(http.keepalive_timeout).to eq 15
+      expect(http.keepalive_max).to eq 30
     end
   end
 
   it "should follow redirects" do
-    Http2.new(host: "http2test.kaspernj.org", follow_redirects: true) do |http|
-      resp = http.get("redirect_test.php")
-      resp.code.should eq "200"
+    with_http(follow_redirects: true) do |http|
+      resp = http.get("redirect_test.rhtml")
+      expect(resp.code).to eq "200"
+    end
+  end
+
+  it "throws errors on unauhtorized" do
+    with_http do |http|
+      expect do
+        http.get("unauthorized.rhtml")
+      end.to raise_error(Http2::Errors::Unauthorized)
+    end
+  end
+
+  it "throws errors on unsupported media type" do
+    with_http do |http|
+      expect do
+        http.get("unsupported_media_type.rhtml")
+      end.to raise_error(Http2::Errors::UnsupportedMediaType)
     end
   end
 end