RubyGems - webmachine - Versions diffs - 0.4.1 → 0.4.2 - Mend

webmachine 0.4.1 → 0.4.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (907) hide show

data/pkg/webmachine-0.4.0/spec/webmachine/adapters/rack_spec.rb DELETED Viewed

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'webmachine/adapters/rack'
-require 'rack'
-module Test
-  class Resource < Webmachine::Resource
-    def to_html
-      "<html><body>testing</body></html>"
-    end
-  end
-end
-describe Webmachine::Adapters::Rack do
-  let(:env) do
-    { "REQUEST_METHOD"    => "GET",
-      "SCRIPT_NAME"       => "",
-      "PATH_INFO"         => "/test",
-      "QUERY_STRING"      => "",
-      "SERVER_NAME"       => "test.server",
-      "SERVER_PORT"       => 8080,
-      "rack.version"      => Rack::VERSION,
-      "rack.url_scheme"   => "http",
-      "rack.input"        => StringIO.new,
-      "rack.errors"       => StringIO.new,
-      "rack.multithread"  => false,
-      "rack.multiprocess" => true,
-      "rack.run_once"     => false }
-  end
-  let(:configuration) { Webmachine::Configuration.new('0.0.0.0', 8080, :Rack, {}) }
-  let(:dispatcher)    { Webmachine::Dispatcher.new }
-  let(:adapter) do
-    described_class.new(configuration, dispatcher)
-  end
-  subject { adapter }
-  before do
-    dispatcher.add_route ['test'], Test::Resource
-  end
-  it "inherits from Webmachine::Adapter" do
-    adapter.should be_a_kind_of(Webmachine::Adapter)
-  end
-  describe "#run" do
-    before do
-      configuration.adapter_options[:debug] = true
-    end
-    it "starts a rack server with the correct options" do
-      Rack::Server.should_receive(:start).with(
-        :app => adapter,
-        :Port => configuration.port,
-        :Host => configuration.ip,
-        :debug => true
-      )
-      adapter.run
-    end
-  end
-  it "should proxy request to webmachine" do
-    code, headers, body = subject.call(env)
-    code.should == 200
-    headers["Content-Type"].should == "text/html"
-    body.should include "<html><body>testing</body></html>"
-  end
-  it "should set Server header" do
-    code, headers, body = subject.call(env)
-    headers.should have_key "Server"
-  end
-  it "should handle non-success correctly" do
-    env["PATH_INFO"] = "/missing"
-    code, headers, body = subject.call(env)
-    code.should == 404
-    headers["Content-Type"].should == "text/html"
-  end
-  it "should handle empty bodies correctly" do
-    env["HTTP_ACCEPT"] = "application/json"
-    code, headers, body = subject.call(env)
-    code.should == 406
-    headers.should_not have_key "Content-Type"
-    headers.should_not have_key "Content-Length"
-    body.should == []
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/adapters/webrick_spec.rb DELETED Viewed

@@ -1,18 +0,0 @@
-require "spec_helper"
-describe Webmachine::Adapters::WEBrick do
-  let(:configuration) { Webmachine::Configuration.default }
-  let(:dispatcher) { Webmachine::Dispatcher.new }
-  let(:adapter) do
-    described_class.new(configuration, dispatcher)
-  end
-  it "inherits from Webmachine::Adapter" do
-    adapter.should be_a_kind_of(Webmachine::Adapter)
-  end
-  it "implements #run" do
-    described_class.instance_methods(false).map {|m| m.to_sym }.should include :run
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/application_spec.rb DELETED Viewed

@@ -1,73 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Application do
-  let(:application) { described_class.new }
-  let(:test_resource) { Class.new(Webmachine::Resource) }
-  it "accepts a Configuration when initialized" do
-    config = Webmachine::Configuration.new('1.1.1.1', 9999, :Mongrel, {})
-    described_class.new(config).configuration.should be(config)
-  end
-  it "is yielded into a block provided during initialization" do
-    yielded_app = nil
-    described_class.new do |app|
-      app.should be_kind_of(Webmachine::Application)
-      yielded_app = app
-    end.should be(yielded_app)
-  end
-  it "is initialized with the default Configration if none is given" do
-    application.configuration.should eq(Webmachine::Configuration.default)
-  end
-  it "returns the receiver from the configure call so you can chain it" do
-    application.configure { |c| }.should equal(application)
-  end
-  it "is configurable" do
-    application.configure do |config|
-      config.should be_kind_of(Webmachine::Configuration)
-    end
-  end
-  it "is initialized with an empty Dispatcher" do
-    application.dispatcher.routes.should be_empty
-  end
-  it "can have routes added" do
-    route = nil
-    resource = test_resource # overcome instance_eval :/
-    application.routes.should be_empty
-    application.routes do
-      route = add ['*'], resource
-    end
-    route.should be_kind_of(Webmachine::Dispatcher::Route)
-    application.routes.should eq([route])
-  end
-  describe "#adapter" do
-    let(:adapter_class) { application.adapter_class }
-    it "returns an instance of it's adapter class" do
-      application.adapter.should be_an_instance_of(adapter_class)
-    end
-    it "is memoized" do
-      application.adapter.should eql application.adapter
-    end
-  end
-  it "can be run" do
-    application.adapter.should_receive(:run)
-    application.run
-  end
-  it "can be queried about its configured adapter" do
-    expected = Webmachine::Adapters.const_get(application.configuration.adapter)
-    application.adapter_class.should equal(expected)
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/chunked_body_spec.rb DELETED Viewed

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'webmachine/chunked_body'
-describe Webmachine::ChunkedBody do
-  it "builds a proper body" do
-    body = ''
-    Webmachine::ChunkedBody.new(['foo', 'bar', '', 'j', 'webmachine']).each do |chunk|
-      body << chunk
-    end
-    body.should == "3\r\nfoo\r\n3\r\nbar\r\n1\r\nj\r\na\r\nwebmachine\r\n0\r\n\r\n"
-  end
-  context "with an empty body" do
-    it "builds a proper body" do
-      body = ''
-      Webmachine::ChunkedBody.new([]).each do |chunk|
-        body << chunk
-      end
-      body.should == "0\r\n\r\n"
-    end
-  end
-  describe "#each" do
-    context "without a block given" do
-      it "returns an Enumerator" do
-        Webmachine::ChunkedBody.new([]).each.should respond_to(:next)
-      end
-    end
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/configuration_spec.rb DELETED Viewed

@@ -1,27 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Configuration do
-  before { Webmachine.configuration = nil }
-  %w{ip port adapter adapter_options}.each do |field|
-    it { should respond_to(field) }
-    it { should respond_to("#{field}=") }
-  end
-  it "should yield configuration to the block" do
-    Webmachine.configure do |config|
-      config.should be_kind_of(described_class)
-    end
-  end
-  it "should set the global configuration from the yielded instance" do
-    Webmachine.configure do |config|
-      @config = config
-    end
-    @config.should == Webmachine.configuration
-  end
-  it "should return the module from the configure call so you can chain it" do
-    Webmachine.configure {|c|}.should == Webmachine
-  end
-end

data/pkg/webmachine-0.4.0/spec/webmachine/decision/conneg_spec.rb DELETED Viewed

@@ -1,159 +0,0 @@
-require 'spec_helper'
-describe Webmachine::Decision::Conneg do
-  let(:request) { Webmachine::Request.new("GET", URI.parse("http://localhost:8080/"), Webmachine::Headers["accept" => "*/*"], "") }
-  let(:response) { Webmachine::Response.new }
-  let(:resource) do
-    Class.new(Webmachine::Resource) do
-      def to_html; "hello world!"; end
-    end
-  end
-  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
-      subject.choose_media_type([], "*/*").should be_nil
-    end
-    it "should not choose a type when none are acceptable" do
-      subject.choose_media_type(["text/html"], "application/json").should be_nil
-    end
-    it "should choose the first acceptable type" do
-      subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml, text/html, */*").should == "application/xml"
-    end
-    it "should choose the type that matches closest when matching subparams" do
-      subject.choose_media_type(["text/html",
-                                 ["text/html", {"charset" => "iso8859-1"}]],
-                                "text/html;charset=iso8859-1, application/xml").
-        should == "text/html;charset=iso8859-1"
-    end
-    it "should choose a type more specific than requested when an exact match is not present" do
-      subject.choose_media_type(["application/json;v=3;foo=bar", "application/json;v=2"],
-                                "text/html, application/json").
-        should == "application/json;v=3;foo=bar"
-    end
-    it "should choose the preferred type over less-preferred types" do
-      subject.choose_media_type(["text/html", "application/xml"],
-                                "application/xml;q=0.7, text/html, */*").should == "text/html"
-    end
-    it "should raise an exception when a media-type is improperly formatted" do
-      expect {
-        subject.choose_media_type(["text/html", "application/xml"],
-                                  "bah;")
-      }.to raise_error(Webmachine::MalformedRequest)
-    end
-  end
-  context "choosing an encoding" do
-    it "should not set the encoding when none are provided" do
-      subject.choose_encoding({}, "identity, gzip")
-      subject.metadata['Content-Encoding'].should be_nil
-      subject.response.headers['Content-Encoding'].should 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")
-      subject.metadata['Content-Encoding'].should == 'identity'
-      response.headers['Content-Encoding'].should be_nil
-    end
-    it "should choose the first acceptable encoding" do
-      subject.choose_encoding({"gzip" => :encode_gzip}, "identity, gzip")
-      subject.metadata['Content-Encoding'].should == 'gzip'
-      response.headers['Content-Encoding'].should == '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")
-      subject.metadata['Content-Encoding'].should == 'gzip'
-      response.headers['Content-Encoding'].should == 'gzip'
-    end
-    it "should not set the encoding if none are acceptable" do
-      subject.choose_encoding({"gzip" => :encode_gzip}, "identity")
-      subject.metadata['Content-Encoding'].should be_nil
-      response.headers['Content-Encoding'].should 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")
-      subject.metadata['Charset'].should 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")
-      subject.metadata['Charset'].should == "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")
-      subject.metadata['Charset'].should == "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")
-      subject.metadata['Charset'].should 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")
-      subject.metadata['Charset'].should == "utf-8"
-    end
-  end
-  context "choosing a language" do
-    it "should not set the language when none are provided" do
-      subject.choose_language([], "en")
-      subject.metadata['Language'].should be_nil
-    end
-    it "should choose the first acceptable language" do
-      subject.choose_language(['en', 'en-US', 'es'], "en-US, es")
-      subject.metadata['Language'].should == "en-US"
-      response.headers['Content-Language'].should == "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")
-      subject.metadata['Language'].should == "es"
-      response.headers['Content-Language'].should == "es"
-    end
-    it "should select the first language if all are acceptable" do
-      subject.choose_language(['en', 'fr', 'es'], "*")
-      subject.metadata['Language'].should == "en"
-      response.headers['Content-Language'].should == "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")
-      subject.metadata['Language'].should == 'en-US'
-      response.headers['Content-Language'].should == 'en-US'
-    end
-    it "should not set the language if none are acceptable" do
-      subject.choose_language(['en'], 'es')
-      subject.metadata['Language'].should be_nil
-      response.headers.should_not include('Content-Language')
-    end
-    it "should choose a language case-insensitively" do
-      subject.choose_language(['en-US', 'ZH'], 'zh-ch, EN')
-      subject.metadata['Language'].should == 'en-US'
-      response.headers['Content-Language'].should == 'en-US'
-    end
-  end
-end