webmachine 0.4.2 → 1.0.0

data/lib/webmachine/trace/trace_resource.rb

@@ -0,0 +1,129 @@
+require 'erb'
+require 'multi_json'
+
+module Webmachine
+  module Trace
+    # Implements the user-interface of the visual debugger. This
+    # includes serving the static files (the PNG flow diagram, CSS and
+    # JS for the UI) and the HTML for the individual traces.
+    class TraceResource < Resource
+
+      MAP_EXTERNAL = %w{static map.png}
+      MAP_FILE = File.expand_path("../static/http-headers-status-v3.png", __FILE__)
+      SCRIPT_EXTERNAL = %w{static wmtrace.js}
+      SCRIPT_FILE = File.expand_path("../#{SCRIPT_EXTERNAL.join '/'}", __FILE__)
+      STYLE_EXTERNAL = %w{static wmtrace.css}
+      STYLE_FILE = File.expand_path("../#{STYLE_EXTERNAL.join '/'}", __FILE__)
+      TRACELIST_ERB = File.expand_path("../static/tracelist.erb", __FILE__)
+      TRACE_ERB = File.expand_path("../static/trace.erb", __FILE__)
+
+      # The ERB template for the trace list
+      def self.tracelist
+        @@tracelist ||= ERB.new(File.read(TRACELIST_ERB))
+      end
+
+      # The ERB template for a single trace
+      def self.trace
+        @@trace ||= ERB.new(File.read(TRACE_ERB))
+      end
+
+      def content_types_provided
+        case request.path_tokens
+        when []
+          [["text/html", :produce_list]]
+        when MAP_EXTERNAL
+          [["image/png", :produce_file]]
+        when SCRIPT_EXTERNAL
+          [["text/javascript", :produce_file]]
+        when STYLE_EXTERNAL
+          [["text/css", :produce_file]]
+        else
+          [["text/html", :produce_trace]]
+        end
+      end
+
+      def resource_exists?
+        case request.path_tokens
+        when []
+          true
+        when MAP_EXTERNAL
+          @file = MAP_FILE
+          File.exist?(MAP_FILE)
+        when SCRIPT_EXTERNAL
+          @file = SCRIPT_FILE
+          File.exist?(SCRIPT_FILE)
+        when STYLE_EXTERNAL
+          @file = STYLE_FILE
+          File.exist?(STYLE_FILE)
+        else
+          @trace = request.path_tokens.first
+          Trace.traces.include? @trace
+        end
+      end
+
+      def last_modified
+        File.mtime(@file) if @file
+      end
+
+      def expires
+        (Time.now + 30 * 86400).utc if @file
+      end
+
+      def produce_file
+        # TODO: Add support for IO objects as response bodies,
+        # allowing server optimizations like sendfile or chunked
+        # downloads
+        File.read(@file)
+      end
+
+      def produce_list
+        traces = Trace.traces
+        self.class.tracelist.result(binding)
+      end
+
+      def produce_trace
+        data = Trace.fetch(@trace)
+        treq, tres, trace = encode_trace(data)
+        name = @trace
+        self.class.trace.result(binding)
+      end
+
+      def encode_trace(data)
+        data = data.dup
+        # Request is first, response is last
+        treq = data.shift.dup
+        tres = data.pop.dup
+        treq.delete :type
+        tres.delete :type
+        [ MultiJson.dump(treq), MultiJson.dump(tres), MultiJson.dump(encode_decisions(data)) ]
+      end
+
+      def encode_decisions(decisions)
+        decisions.inject([]) do |list, event|
+          case event[:type]
+          when :decision
+            # Don't produce new decisions for sub-steps in the graph
+            unless event[:decision].to_s =~ /[a-z]$/
+              list << {'d' => event[:decision], 'calls' => []}
+            end
+          when :attempt
+            list.last['calls'] << {
+              "call" => event[:name],
+              "source" => event[:source],
+              "input" => event[:args] && event[:args].inspect
+            }
+          when :result
+            list.last['calls'].last['output'] = event[:value].inspect
+          when :exception
+            list.last['calls'].last['exception'] = {
+              'class' => event[:class],
+              'backtrace' => event[:backtrace].join("\n"),
+              'message' => event[:message]
+            }
+          end
+          list
+        end
+      end
+    end
+  end
+end

data/lib/webmachine/version.rb

@@ -1,6 +1,6 @@
 module Webmachine
   # Library version
-  VERSION = "0.4.2"
+  VERSION = "1.0.0"
 
   # String for use in "Server" HTTP response header, which includes
   # the {VERSION}.

data/spec/spec_helper.rb

@@ -16,3 +16,22 @@ RSpec.configure do |config|
     config.order = :random
   end
 end
+
+# For use in specs that need a fully initialized resource
+shared_context "default resource" do
+  let(:method) { 'GET' }
+  let(:uri) { URI.parse("http://localhost/") }
+  let(:headers) { Webmachine::Headers.new }
+  let(:body) { "" }
+  let(:request) { Webmachine::Request.new(method, uri, headers, body) }
+  let(:response) { Webmachine::Response.new }
+
+  let(:resource_class) do
+    Class.new(Webmachine::Resource) do
+      def to_html
+        "<html><body>Hello, world!</body></html>"
+      end
+    end
+  end
+  let(:resource) { resource_class.new(request, response) }
+end

data/spec/webmachine/adapters/rack_spec.rb

@@ -1,19 +1,42 @@
 require 'spec_helper'
 require 'webmachine/adapters/rack'
 require 'rack'
+require 'rack/test'
 
 module Test
   class Resource < Webmachine::Resource
     def allowed_methods
-      ["GET", "PUT"]
+      ["GET", "PUT", "POST"]
     end
 
     def content_types_accepted
       [["application/json", :from_json]]
     end
 
+    def content_types_provided
+      [
+        ["text/html", :to_html],
+        ["application/vnd.webmachine.streaming+enum", :to_enum_stream],
+        ["application/vnd.webmachine.streaming+proc", :to_proc_stream]
+      ]
+    end
+
+    def process_post
+      true
+    end
+
     def to_html
-      "<html><body>testing</body></html>"
+      response.set_cookie('cookie', 'monster')
+      response.set_cookie('rodeo', 'clown')
+      "<html><body>#{request.cookies['string'] || 'testing'}</body></html>"
+    end
+
+    def to_enum_stream
+      %w{Hello, World!}
+    end
+
+    def to_proc_stream
+      Proc.new { "Stream" }
     end
 
     def from_json; end
@@ -21,29 +44,14 @@ module Test
 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("Hello, World!"),
-      "rack.errors"       => StringIO.new,
-      "rack.multithread"  => false,
-      "rack.multiprocess" => true,
-      "rack.run_once"     => false }
-  end
+  include Rack::Test::Methods
 
   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 }
+  let(:app) { adapter }
 
   before do
     dispatcher.add_route ['test'], Test::Resource
@@ -71,17 +79,17 @@ describe Webmachine::Adapters::Rack do
   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>"
+    get "/test"
+    last_response.status.should == 200
+    last_response.headers["Content-Type"].should == "text/html"
+    last_response.body.should == "<html><body>testing</body></html>"
   end
 
   it "should build a string-like request body" do
     dispatcher.should_receive(:dispatch) do |request, response|
       request.body.to_s.should eq("Hello, World!")
     end
-    subject.call(env)
+    request "/test", :method => "GET", :input => "Hello, World!"
   end
 
   it "should build an enumerable request body" do
@@ -89,35 +97,63 @@ describe Webmachine::Adapters::Rack do
     dispatcher.should_receive(:dispatch) do |request, response|
       request.body.each { |chunk| chunks << chunk }
     end
-    subject.call(env)
+    request "/test", :method => "GET", :input => "Hello, World!"
     chunks.join.should eq("Hello, World!")
   end
 
   it "should understand the Content-Type header correctly" do
-    env["REQUEST_METHOD"] = "PUT"
-    env["CONTENT_TYPE"] = "application/json"
-    code, headers, body = subject.call(env)
-    code.should == 204
+    header "CONTENT_TYPE", "application/json"
+    put "/test"
+    last_response.status.should == 204
   end
 
   it "should set Server header" do
-    code, headers, body = subject.call(env)
-    headers.should have_key "Server"
+    get "/test"
+    last_response.headers.should have_key("Server")
+  end
+
+  it "should set Set-Cookie header" do
+    get "/test"
+    # Yes, Rack expects multiple values for a given cookie to be
+    # \n separated.
+    last_response.headers["Set-Cookie"].should == "cookie=monster\nrodeo=clown"
   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"
+    get "/missing"
+    last_response.status.should == 404
+    last_response.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 == []
+    header "CONTENT_TYPE", "application/json"
+    post "/test"
+    last_response.status.should == 204
+    last_response.headers.should_not have_key("Content-Type")
+    last_response.headers.should_not have_key("Content-Length")
+    last_response.body.should == ""
+  end
+
+  it "should handle cookies correctly" do
+    header "COOKIE", "string=123"
+    get "/test"
+    last_response.status.should == 200
+    last_response.body.should == "<html><body>123</body></html>"
+  end
+
+  it "should handle streaming enumerable response bodies" do
+    header "ACCEPT", "application/vnd.webmachine.streaming+enum"
+    get "/test"
+    last_response.status.should == 200
+    last_response.headers["Transfer-Encoding"].should == "chunked"
+    last_response.body.split("\r\n").should == %W{6 Hello, 6 World! 0}
+  end
+
+  it "should handle streaming callable response bodies" do
+    header "ACCEPT", "application/vnd.webmachine.streaming+proc"
+    get "/test"
+    last_response.status.should == 200
+    last_response.headers["Transfer-Encoding"].should == "chunked"
+    last_response.body.split("\r\n").should == %W{6 Stream 0}
   end
 end

data/spec/webmachine/configuration_spec.rb

@@ -2,7 +2,7 @@ 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}=") }

data/spec/webmachine/cookie_spec.rb

@@ -0,0 +1,99 @@
+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
+        str.should include "Secure"
+        str.should include "HttpOnly"
+        str.should include "Comment=comment+with+spaces"
+        str.should include "Domain=www.server.com"
+        str.should include "Path=/"
+        str.should include "Version=1"
+        str.should include "MaxAge=60"
+        str.should 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") { subject.should == { "cookie" => "monster" } }
+
+    describe "parsing multiple cookie parameters" do
+      let(:str) { "cookie=monster; monster=mash" }
+
+      it("should have both cookies") { subject.should == { "cookie" => "monster", "monster" => "mash" } }
+    end
+
+    describe "parsing an encoded cookie" do
+      let(:str) { "cookie=yum+yum" }
+
+      it("should decode the cookie") { subject.should == { "cookie" => "yum yum" } }
+    end
+
+    describe "parsing nil" do
+      let(:str) { nil }
+
+      it("should return empty hash") { subject.should == {} }
+    end
+
+    describe "parsing duplicate cookies" do
+      let(:str) { "cookie=monster; cookie=yum+yum" }
+
+      it("should return the first instance of the cookie") { subject.should == { "cookie" => "monster" } }
+    end
+  end
+end