webmachine 1.6.0 → 2.0.0.beta

data/spec/webmachine/dispatcher_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Dispatcher do
-  let(:dispatcher) { Webmachine.application.dispatcher }
-  let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
-  let(:request2) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/hello/bob.html"), Webmachine::Headers["accept" => "*/*"], "") }
-  let(:response) { Webmachine::Response.new }
-  let(:resource) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "hello world!"; end
-    end
-  end
-  let(:resource2) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "goodbye, cruel world"; end
-    end
-  end
-  let(:resource3) do
-    Class.new(Webmachine::Resource) do
-      def to_html
-        name, format = request.path_info[:captures]
-        "Hello #{name} with #{format}"
-      end
-    end
-  end
-  let(:fsm){ double }
-
-  before { dispatcher.reset }
-
-  it "should add routes from a block" do
-    _resource = resource
-    expect(Webmachine.routes do
-      add [:*], _resource
-    end).to eq(Webmachine)
-    expect(dispatcher.routes.size).to eq(1)
-  end
-
-  it "should add routes" do
-    expect {
-      dispatcher.add_route [:*], resource
-    }.to_not raise_error
-  end
-
-  it "should have add_route return the newly created route" do
-    route = dispatcher.add_route [:*], resource
-    expect(route).to be_instance_of Webmachine::Dispatcher::Route
-  end
-
-  it "should route to the proper resource" do
-    dispatcher.add_route ["goodbye"], resource2
-    dispatcher.add_route [:*], resource
-    expect(Webmachine::Decision::FSM).to receive(:new).with(instance_of(resource), request, response).and_return(fsm)
-    expect(fsm).to receive(:run)
-    dispatcher.dispatch(request, response)
-  end
-  it "should handle regex path segments in route definition" do
-    dispatcher.add_route ["hello", /(.*)\.(.*)/], resource3
-    expect(Webmachine::Decision::FSM).to receive(:new).with(instance_of(resource3), request2, response).and_return(fsm)
-    expect(fsm).to receive(:run)
-    dispatcher.dispatch(request2, response)
-  end
-
-  it "should apply route to request before creating the resource" do
-    route   = dispatcher.add_route [:*], resource
-    applied = false
-
-    expect(route).to receive(:apply) { applied = true }
-    expect(resource).to(receive(:new) do
-      expect(applied).to be(true)
-      resource2.new(request, response)
-    end)
-
-    dispatcher.dispatch(request, response)
-  end
-
-  it "should add routes with guards" do
-    dispatcher.add [], lambda {|req| req.method == "POST" }, resource
-    dispatcher.add [:*], resource2 do |req|
-      !req.query.empty?
-    end
-    request.uri.query = "?foo=bar"
-    expect(dispatcher.routes.size).to eq(2)
-    expect(Webmachine::Decision::FSM).to receive(:new).with(instance_of(resource2), request, response).and_return(fsm)
-    expect(fsm).to receive(:run)
-    dispatcher.dispatch(request, response)
-  end
-
-  it "should respond with a valid resource for a 404" do
-    dispatcher.dispatch(request, response)
-    expect(response.code).to     eq(404)
-    expect(response.body).to_not be_empty
-    expect(response.headers).to  have_key('Content-Length')
-    expect(response.headers).to  have_key('Date')
-  end
-
-  it "should respond with a valid resource for a 404 with a custom Accept header" do
-    request.headers['Accept'] = "application/json"
-    dispatcher.dispatch(request, response)
-    expect(response.code).to     eq(404)
-    expect(response.body).to_not be_empty
-    expect(response.headers).to  have_key('Content-Length')
-    expect(response.headers).to  have_key('Date')
-  end
-end

data/spec/webmachine/errors_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "Webmachine errors" do
-  describe ".render_error" do
-    it "sets the given response code on the response object" do
-      req = double('request', :method => 'GET').as_null_object
-      res = Webmachine::Response.new
-
-      Webmachine.render_error(404, req, res)
-      expect(res.code).to eq(404)
-    end
-  end
-end

data/spec/webmachine/etags_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::ETag do
-  let(:etag_str){ '"deadbeef12345678"' }
-  let(:etag) { described_class.new etag_str }
-
-  subject { etag }
-
-  it { is_expected.to eq(etag_str) }
-  it { is_expected.to be_kind_of(described_class) }
-  its(:to_s) { should == '"deadbeef12345678"' }
-  its(:etag) { should == '"deadbeef12345678"' }
-  it { is_expected.to eq(described_class.new(etag_str.dup)) }
-
-  context "when the original etag is unquoted" do
-    let(:etag_str) { 'deadbeef12345678' }
-
-    it { is_expected.to eq(etag_str) }
-    its(:to_s) { should == '"deadbeef12345678"' }
-    its(:etag) { should == '"deadbeef12345678"' }
-    it { is_expected.to eq(described_class.new(etag_str.dup)) }
-  end
-
-  context "when the original etag contains unbalanced quotes" do
-    let(:etag_str) { 'deadbeef"12345678' }
-
-    it { is_expected.to eq(etag_str) }
-    its(:to_s) { should == '"deadbeef\\"12345678"' }
-    its(:etag) { should == '"deadbeef\\"12345678"' }
-    it { is_expected.to eq(described_class.new(etag_str.dup)) }
-  end
-end
-
-describe Webmachine::WeakETag do
-  let(:strong_etag){ '"deadbeef12345678"' }
-  let(:weak_etag) { described_class.new strong_etag }
-
-  subject { weak_etag }
-
-  it { is_expected.to eq(strong_etag) }
-  it { is_expected.to be_kind_of(described_class) }
-  its(:to_s) { should == 'W/"deadbeef12345678"' }
-  its(:etag) { should == '"deadbeef12345678"' }
-  it { is_expected.to eq(described_class.new(strong_etag.dup)) }
-
-  context "when the original etag is unquoted" do
-    let(:strong_etag) { 'deadbeef12345678' }
-
-    it { is_expected.to eq(strong_etag) }
-    it { is_expected.to be_kind_of(described_class) }
-    its(:to_s) { should == 'W/"deadbeef12345678"' }
-    its(:etag) { should == '"deadbeef12345678"' }
-    it { is_expected.to eq(described_class.new(strong_etag.dup)) }
-  end
-
-  context "when the original etag contains unbalanced quotes" do
-    let(:strong_etag) { 'deadbeef"12345678' }
-
-    it { is_expected.to eq(strong_etag) }
-    it { is_expected.to be_kind_of(described_class) }
-    its(:to_s) { should == 'W/"deadbeef\\"12345678"' }
-    its(:etag) { should == '"deadbeef\\"12345678"' }
-    it { is_expected.to eq(described_class.new(strong_etag.dup)) }
-  end
-
-  context "when the original etag is already a weak tag" do
-    let(:strong_etag) { 'W/"deadbeef12345678"' }
-
-    it { is_expected.to eq(strong_etag) }
-    it { is_expected.to be_kind_of(described_class) }
-    its(:to_s) { should == 'W/"deadbeef12345678"' }
-    its(:etag) { should == '"deadbeef12345678"' }
-    it { is_expected.to eq(described_class.new(strong_etag.dup)) }
-  end
-end

data/spec/webmachine/events_spec.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Events do
-  describe ".backend" do
-    it "defaults to AS::Notifications" do
-      expect(described_class.backend).to be(AS::Notifications)
-    end
-  end
-
-  describe ".publish" do
-    it "calls the backend" do
-      expect(described_class.backend).to receive(:publish).with('test.event', 1, 'two')
-      described_class.publish('test.event', 1, 'two')
-    end
-  end
-
-  describe ".instrument" do
-    it "calls the backend" do
-      expect(described_class.backend).to receive(:instrument).with(
-        'test.event', {}
-      ).and_yield
-
-      described_class.instrument('test.event') { }
-    end
-  end
-
-  describe ".subscribe" do
-    it "calls the backend" do
-      expect(described_class.backend).to receive(:subscribe).with(
-        'test.event'
-      ).and_yield
-
-      described_class.subscribe('test.event') { }
-    end
-  end
-
-  describe ".subscribed" do
-    it "calls the backend" do
-      callback = Proc.new { }
-
-      expect(described_class.backend).to receive(:subscribed).with(
-        callback, 'test.event'
-      ).and_yield
-
-      described_class.subscribed(callback, 'test.event') { }
-    end
-  end
-
-  describe ".unsubscribe" do
-    it "calls the backend" do
-      subscriber = described_class.subscribe('test.event') { }
-
-      expect(described_class.backend).to receive(:unsubscribe).with(subscriber)
-
-      described_class.unsubscribe(subscriber)
-    end
-  end
-end

data/spec/webmachine/headers_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::Headers do
-  it "should set and access values insensitive to case" do
-    subject['Content-TYPE'] = "text/plain"
-    expect(subject['CONTENT-TYPE']).to eq('text/plain')
-    expect(subject.delete('CoNtEnT-tYpE')).to eq('text/plain')
-  end
-
-  describe "#from_cgi" do
-    it "should understand the Content-Length header" do
-      headers = described_class.from_cgi("CONTENT_LENGTH" => 14)
-      expect(headers["content-length"]).to eq(14)
-    end
-  end
-
-  describe ".[]" do
-    context "Webmachine::Headers['Content-Type', 'application/json']" do
-      it "creates a hash with lowercase keys" do
-        headers = described_class[
-          'Content-Type', 'application/json',
-          'Accept', 'application/json'
-        ]
-
-        expect(headers.to_hash).to eq({
-          'content-type' => 'application/json',
-          'accept' => 'application/json'
-        })
-      end
-    end
-
-    context "Webmachine::Headers[[['Content-Type', 'application/json']]]" do
-      it "creates a hash with lowercase keys" do
-        headers = described_class[
-          [
-            ['Content-Type', 'application/json'],
-            ['Accept', 'application/json']
-          ]
-        ]
-
-        expect(headers.to_hash).to eq({
-          'content-type' => 'application/json',
-          'accept' => 'application/json'
-        })
-      end
-    end
-
-    context "Webmachine::Headers['Content-Type' => 'application/json']" do
-      it "creates a hash with lowercase keys" do
-        headers = described_class[
-          'Content-Type' => 'application/json',
-          'Accept' => 'application/json'
-        ]
-
-        expect(headers.to_hash).to eq({
-          'content-type' => 'application/json',
-          'accept' => 'application/json'
-        })
-      end
-    end
-  end
-
-  describe "#fetch" do
-    subject { described_class['Content-Type' => 'application/json'] }
-
-    it "returns the value for the given key" do
-      expect(subject.fetch('conTent-tYpe')).to eq('application/json')
-    end
-
-    context "acessing a missing key" do
-      it "raises an IndexError" do
-        expect { subject.fetch('accept') }.to raise_error(IndexError)
-      end
-
-      context "and a default value given" do
-        it "returns the default value if the key does not exist" do
-          expect(subject.fetch('accept', 'text/html')).to eq('text/html')
-        end
-      end
-
-      context "and a block given" do
-        it "passes the value to the block and returns the block's result" do
-          expect(subject.fetch('access') {|k| "#{k} not found"}).to eq('access not found')
-        end
-      end
-    end
-  end
-
-  context "filtering with #grep" do
-    subject { described_class["content-type" => "text/plain", "etag" => '"abcdef1234567890"'] }
-    it "should filter keys by the given pattern" do
-      expect(subject.grep(/content/i)).to include("content-type")
-    end
-
-    it "should return a Headers instance" do
-      expect(subject.grep(/etag/i)).to be_instance_of(described_class)
-    end
-  end
-end

data/spec/webmachine/media_type_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe Webmachine::MediaType do
-  let(:raw_type){ "application/xml;charset=UTF-8" }
-  subject { described_class.new("application/xml", {"charset" => "UTF-8"}) }
-
-  context "equivalence" do
-    it { is_expected.to eq(raw_type) }
-    it { is_expected.to eq(described_class.parse(raw_type)) }
-  end
-
-  context "when it is the wildcard type" do
-    subject { described_class.new("*/*") }
-    it { is_expected.to be_matches_all }
-  end
-
-  context "parsing a type" do
-    it "should return MediaTypes untouched" do
-      expect(described_class.parse(subject)).to equal(subject)
-    end
-
-    it "should parse a String" do
-      type = described_class.parse(raw_type)
-      expect(type).to be_kind_of(described_class)
-      expect(type.type).to eq("application/xml")
-      expect(type.params).to eq({"charset" => "UTF-8"})
-    end
-
-    it "should parse a type/params pair" do
-      type = described_class.parse(["application/xml", {"charset" => "UTF-8"}])
-      expect(type).to be_kind_of(described_class)
-      expect(type.type).to eq("application/xml")
-      expect(type.params).to eq({"charset" => "UTF-8"})
-    end
-
-    it "should parse a type/params pair where the type has some params in the string" do
-      type = described_class.parse(["application/xml;version=1",  {"charset" => "UTF-8"}])
-      expect(type).to be_kind_of(described_class)
-      expect(type.type).to eq("application/xml")
-      expect(type.params).to eq({"charset" => "UTF-8", "version" => "1"})
-    end
-
-    it "should parse a type/params pair with params and whitespace in the string" do
-      type = described_class.parse(["multipart/form-data; boundary=----------------------------2c46a7bec2b9", {"charset" => "UTF-8"}])
-      expect(type).to be_kind_of(described_class)
-      expect(type.type).to eq("multipart/form-data")
-      expect(type.params).to eq({"boundary" => "----------------------------2c46a7bec2b9", "charset" => "UTF-8"})
-    end
-
-    it "should parse a type/params pair where type has single-token params" do
-      type = described_class.parse(["text/html;q=1;rdfa", {"charset" => "UTF-8"}])
-      expect(type).to be_kind_of(described_class)
-      expect(type.type).to eq("text/html")
-      expect(type.params).to eq({"q" => "1", "rdfa" => "", "charset" => "UTF-8"})
-    end
-
-    it "should raise an error when given an invalid type/params pair" do
-      expect {
-        described_class.parse([false, "blah"])
-      }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "matching a requested type" do
-    it { is_expected.to     be_exact_match("application/xml;charset=UTF-8") }
-    it { is_expected.to     be_exact_match("application/*;charset=UTF-8") }
-    it { is_expected.to     be_exact_match("*/*;charset=UTF-8") }
-    it { is_expected.to     be_exact_match("*;charset=UTF-8") }
-    it { is_expected.not_to be_exact_match("text/xml") }
-    it { is_expected.not_to be_exact_match("application/xml") }
-    it { is_expected.not_to be_exact_match("application/xml;version=1") }
-
-    it { is_expected.to     be_type_matches("application/xml") }
-    it { is_expected.to     be_type_matches("application/*") }
-    it { is_expected.to     be_type_matches("*/*") }
-    it { is_expected.to     be_type_matches("*") }
-    it { is_expected.not_to be_type_matches("text/xml") }
-    it { is_expected.not_to be_type_matches("text/*") }
-
-    it { is_expected.to     be_params_match({}) }
-    it { is_expected.to     be_params_match({"charset" => "UTF-8"}) }
-    it { is_expected.not_to be_params_match({"charset" => "Windows-1252"}) }
-    it { is_expected.not_to be_params_match({"version" => "3"}) }
-  end
-end