webmachine 1.6.0 → 2.0.0.beta

data/spec/webmachine/cookie_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Cookie do
-  describe "creating a cookie" do
-    let(:name) { "monster" }
-    let(:value) { "mash" }
-    let(:attributes) { {} }
-
-    let(:cookie) { Webmachine::Cookie.new(name, value, attributes) }
-
-    subject { cookie }
-
-    its(:name) { should == name }
-    its(:value) { should == value }
-
-    its(:to_s) { should == "monster=mash" }
-
-    describe "a cookie with whitespace in name and value" do
-      let(:name) { "cookie name" }
-      let(:value) { "cookie value" }
-
-      its(:to_s) { should == "cookie+name=cookie+value" }
-    end
-
-    describe "a cookie with attributes set" do
-      let(:domain) { "www.server.com" }
-      let(:path) { "/" }
-      let(:comment) { "comment with spaces" }
-      let(:version) { 1 }
-      let(:maxage) { 60 }
-      let(:expires) { Time.gm(2010,3,14, 3, 14, 0) }
-      let(:attributes) {
-        {
-          :comment => comment,
-          :domain => domain,
-          :path => path,
-          :secure => true,
-          :httponly => true,
-          :version => version,
-          :maxage => maxage,
-          :expires => expires
-        }
-      }
-
-      its(:secure?) { should be true }
-      its(:http_only?) { should be true }
-      its(:comment) { should == comment }
-      its(:domain) { should == domain }
-      its(:path) { should == path }
-      its(:version) { should == version }
-      its(:maxage) { should == maxage }
-      its(:expires) { should == expires }
-
-      it "should include the attributes in its string version" do
-        str = subject.to_s
-        expect(str).to include "Secure"
-        expect(str).to include "HttpOnly"
-        expect(str).to include "Comment=comment+with+spaces"
-        expect(str).to include "Domain=www.server.com"
-        expect(str).to include "Path=/"
-        expect(str).to include "Version=1"
-        expect(str).to include "Max-Age=60"
-        expect(str).to include "Expires=Sun, 14-Mar-2010 03:14:00 GMT"
-      end
-    end
-  end
-
-  describe "parsing a cookie parameter" do
-    let(:str) { "cookie = monster" }
-
-    subject { Webmachine::Cookie.parse(str) }
-
-    it("should have the cookie") { expect(subject).to eq({ "cookie" => "monster" }) }
-
-    describe "parsing multiple cookie parameters" do
-      let(:str) { "cookie=monster; monster=mash" }
-
-      it("should have both cookies") { expect(subject).to eq({ "cookie" => "monster", "monster" => "mash" }) }
-    end
-
-    describe "parsing an encoded cookie" do
-      let(:str) { "cookie=yum+yum" }
-
-      it("should decode the cookie") { expect(subject).to eq({ "cookie" => "yum yum" }) }
-    end
-
-    describe "parsing nil" do
-      let(:str) { nil }
-
-      it("should return empty hash") { expect(subject).to eq({}) }
-    end
-
-    describe "parsing duplicate cookies" do
-      let(:str) { "cookie=monster; cookie=yum+yum" }
-
-      it("should return the first instance of the cookie") { expect(subject).to eq({ "cookie" => "monster" }) }
-    end
-  end
-end

data/spec/webmachine/decision/conneg_spec.rb

@@ -1,166 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Decision::Conneg do
-  include_context "default resource"
-
-  subject do
-    Webmachine::Decision::FSM.new(resource, request, response)
-  end
-
-  context "choosing a media type" do
-    it "should not choose a type when none are provided" do
-      expect(subject.choose_media_type([], "*/*")).to be_nil
-    end
-
-    it "should not choose a type when none are acceptable" do
-      expect(subject.choose_media_type(["text/html"], "application/json")).to be_nil
-    end
-
-    it "should choose the first acceptable type" do
-      expect(subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml, text/html, */*")).to eq("application/xml")
-    end
-
-    it "should choose the type that matches closest when matching subparams" do
-      expect(subject.choose_media_type(["text/html",
-                                 ["text/html", {"charset" => "iso8859-1"}]],
-                                "text/html;charset=iso8859-1, application/xml")).
-        to eq("text/html;charset=iso8859-1")
-    end
-
-    it "should choose a type more specific than requested when an exact match is not present" do
-      expect(subject.choose_media_type(["application/json;v=3;foo=bar", "application/json;v=2"],
-                                "text/html, application/json")).
-        to eq("application/json;v=3;foo=bar")
-    end
-
-
-    it "should choose the preferred type over less-preferred types" do
-      expect(subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml;q=0.7, text/html, */*")).to eq("text/html")
-
-    end
-
-    it "should raise an error when a media-type is improperly formatted" do
-      expect {
-        subject.choose_media_type(["text/html", "application/xml"],
-                                  "bah;")
-      }.to raise_error(Webmachine::MalformedRequest)
-    end
-
-    it "should choose a type when more than one accept header is present" do
-      expect(subject.choose_media_type(["text/html"],
-                                ["text/html", "text/plain"])).to eq("text/html")
-
-    end
-  end
-
-  context "choosing an encoding" do
-    it "should not set the encoding when none are provided" do
-      subject.choose_encoding({}, "identity, gzip")
-      expect(subject.metadata['Content-Encoding']).to be_nil
-      expect(subject.response.headers['Content-Encoding']).to be_nil
-    end
-
-    it "should not set the Content-Encoding header when it is identity" do
-      subject.choose_encoding({"gzip"=> :encode_gzip, "identity" => :encode_identity}, "identity")
-      expect(subject.metadata['Content-Encoding']).to eq('identity')
-      expect(response.headers['Content-Encoding']).to be_nil
-    end
-
-    it "should choose the first acceptable encoding" do
-      subject.choose_encoding({"gzip" => :encode_gzip}, "identity, gzip")
-      expect(subject.metadata['Content-Encoding']).to eq('gzip')
-      expect(response.headers['Content-Encoding']).to eq('gzip')
-    end
-
-    it "should choose the first acceptable encoding" \
-    ", even when no white space after comma" do
-      subject.choose_encoding({"gzip" => :encode_gzip}, "identity,gzip")
-      expect(subject.metadata['Content-Encoding']).to eq('gzip')
-      expect(response.headers['Content-Encoding']).to eq('gzip')
-    end
-
-    it "should choose the preferred encoding over less-preferred encodings" do
-      subject.choose_encoding({"gzip" => :encode_gzip, "identity" => :encode_identity}, "gzip, identity;q=0.7")
-      expect(subject.metadata['Content-Encoding']).to eq('gzip')
-      expect(response.headers['Content-Encoding']).to eq('gzip')
-    end
-
-    it "should not set the encoding if none are acceptable" do
-      subject.choose_encoding({"gzip" => :encode_gzip}, "identity")
-      expect(subject.metadata['Content-Encoding']).to be_nil
-      expect(response.headers['Content-Encoding']).to be_nil
-    end
-  end
-
-  context "choosing a charset" do
-    it "should not set the charset when none are provided" do
-      subject.choose_charset([], "ISO-8859-1")
-      expect(subject.metadata['Charset']).to be_nil
-    end
-
-    it "should choose the first acceptable charset" do
-      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII, UTF-8")
-      expect(subject.metadata['Charset']).to eq("US-ASCII")
-    end
-
-    it "should choose the preferred charset over less-preferred charsets" do
-      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "US-ASCII;q=0.7, UTF-8")
-      expect(subject.metadata['Charset']).to eq("UTF-8")
-    end
-
-    it "should not set the charset if none are acceptable" do
-      subject.choose_charset([["UTF-8", :to_utf8],["US-ASCII", :to_ascii]], "ISO-8859-1")
-      expect(subject.metadata['Charset']).to be_nil
-    end
-
-    it "should choose a charset case-insensitively" do
-      subject.choose_charset([["UtF-8", :to_utf8],["US-ASCII", :to_ascii]], "iso-8859-1, utf-8")
-      expect(subject.metadata['Charset']).to eq("utf-8")
-    end
-  end
-
-  context "choosing a language" do
-    it "should not set the language when none are provided" do
-      subject.choose_language([], "en")
-      expect(subject.metadata['Language']).to be_nil
-    end
-
-    it "should choose the first acceptable language" do
-      subject.choose_language(['en', 'en-US', 'es'], "en-US, es")
-      expect(subject.metadata['Language']).to eq("en-US")
-      expect(response.headers['Content-Language']).to eq("en-US")
-    end
-
-    it "should choose the preferred language over less-preferred languages" do
-      subject.choose_language(['en', 'en-US', 'es'], "en-US;q=0.6, es")
-      expect(subject.metadata['Language']).to eq("es")
-      expect(response.headers['Content-Language']).to eq("es")
-    end
-
-    it "should select the first language if all are acceptable" do
-      subject.choose_language(['en', 'fr', 'es'], "*")
-      expect(subject.metadata['Language']).to eq("en")
-      expect(response.headers['Content-Language']).to eq("en")
-    end
-
-    it "should select the closest acceptable language when an exact match is not available" do
-      subject.choose_language(['en-US', 'es'], "en, fr")
-      expect(subject.metadata['Language']).to eq('en-US')
-      expect(response.headers['Content-Language']).to eq('en-US')
-    end
-
-    it "should not set the language if none are acceptable" do
-      subject.choose_language(['en'], 'es')
-      expect(subject.metadata['Language']).to be_nil
-      expect(response.headers).not_to include('Content-Language')
-    end
-
-    it "should choose a language case-insensitively" do
-      subject.choose_language(['en-US', 'ZH'], 'zh-ch, EN')
-      expect(subject.metadata['Language']).to eq('en-US')
-      expect(response.headers['Content-Language']).to eq('en-US')
-    end
-  end
-end

data/spec/webmachine/decision/falsey_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Decision::Falsey do
-  specify { expect(described_class.=== false).to be(true) }
-  specify { expect(described_class.=== nil).to be(true) }
-  specify { expect(described_class.=== true).to be(false) }
-  specify { expect(described_class.=== []).to be(false) }
-end