rufus-verbs 0.1

data/test/auth_test.rb

@@ -0,0 +1,46 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Sun Jan 13 12:33:03 JST 2008
+#
+
+require 'test/unit'
+require 'testbase'
+
+require 'rufus/verbs'
+
+
+class AuthTest < Test::Unit::TestCase
+    include TestBaseMixin
+
+    include Rufus::Verbs
+
+    #
+    # Using an items server with the authentication on.
+    #
+    def setup
+
+        @server = ItemServer.new :auth => true
+        @server.start
+    end
+
+
+    def test_0
+
+        #res = get :uri => "http://localhost:7777/items"
+        #assert_equal 200, res.code.to_i
+        #assert_equal "{}", res.body.strip
+        expect 401, nil, get(:uri => "http://localhost:7777/items")
+
+        expect 401, nil, get(
+            :uri => "http://localhost:7777/items", 
+            :http_basic_authentication => [ "toto", "wrong" ])
+
+        expect 200, {}, get(
+            :uri => "http://localhost:7777/items?a", 
+            :http_basic_authentication => [ "toto", "toto" ])
+    end
+end

data/test/block_test.rb

@@ -0,0 +1,49 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Sun Jan 13 20:02:25 JST 2008
+#
+
+require 'test/unit'
+require 'testbase'
+
+require 'rufus/verbs'
+
+
+class BlockTest < Test::Unit::TestCase
+    include TestBaseMixin
+
+    include Rufus::Verbs
+
+
+    def test_0
+
+        res = post :uri => "http://localhost:7777/items/0" do
+            "Fedor" +
+            "Fedorovitch"
+        end
+        assert_equal 201, res.code.to_i
+        assert_equal "http://localhost:7777/items/0", res['Location']
+
+
+        expect(
+            200, 
+            { 0 => "FedorFedorovitch" }, 
+            get(:uri => "http://localhost:7777/things"))
+
+        res = post :uri => "http://localhost:7777/items/1" do |req|
+            # do whatever with the request [headers]
+            "John"
+        end
+        assert_equal 201, res.code.to_i
+        assert_equal "http://localhost:7777/items/1", res['Location']
+
+        expect(
+            200, 
+            { 0 => "FedorFedorovitch", 1 => "John" }, 
+            get(:uri => "http://localhost:7777/things"))
+    end
+end

data/test/conditional_test.rb

@@ -0,0 +1,49 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Wed Jan 16 13:54:36 JST 2008
+#
+
+require 'test/unit'
+require 'testbase'
+
+require 'rufus/verbs'
+
+
+class ConditionalTest < Test::Unit::TestCase
+    include TestBaseMixin
+
+    include Rufus::Verbs
+
+
+    def test_1
+
+        ep = ConditionalEndPoint.new(:host => "localhost", :port => 7777)
+        expect 200, {}, ep.get(:resource => "items")
+
+        res = ep.put :resource => "items", :id => 0 do
+            "blockdata"
+        end
+        assert_equal 404, res.code.to_i
+
+        res = ep.post :resource => "items", :id => 0 do
+            "blockdata"
+        end
+        assert_equal 201, res.code.to_i
+        assert_equal "http://localhost:7777/items/0", res['Location']
+
+        res = expect 200, { 0 => "blockdata" }, ep.get(:res => "items")
+        assert_kind_of Net::HTTPResponse, res
+        assert_respond_to res, :lastmod
+        i = res.object_id
+        #p res.to_hash
+
+        res = expect 200, { 0 => "blockdata" }, ep.get(:res => "items")
+        assert_equal i, res.object_id
+
+        assert_equal 1, ep.cache_current_size
+    end
+end

data/test/dryrun_test.rb

@@ -0,0 +1,42 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Tue Jan 15 09:26:45 JST 2008
+#
+
+require 'test/unit'
+
+require 'rufus/verbs'
+
+
+class DryRunTest < Test::Unit::TestCase
+
+    include Rufus::Verbs
+
+
+    def test_0
+
+        req = put(
+            :dry_run => true, 
+            :uri => "http://localhost:7777/items/1", 
+            :params => { "a" => "A", :b => :B })
+
+        assert "/items/1?a=A&b=B", req.path
+
+        req = put(
+            :dry_run => true, 
+            :uri => "http://localhost:7777/items/1", 
+            :query => { "a" => "A", :b => :B })
+
+        assert "/items/1?a=A&b=B", req.path
+
+        req = put(
+            "http://localhost:7777/items/1?a=A", :d => "toto", :dry_run => true)
+
+        assert "/items/1?a=A", req.path
+        assert "toto", req.body
+    end
+end

data/test/https_test.rb

@@ -0,0 +1,42 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Mon Jan 14 00:07:38 JST 2008
+#
+
+require 'test/unit'
+require 'testbase'
+
+require 'rufus/verbs'
+
+
+class HttpsTest < Test::Unit::TestCase
+    include TestBaseMixin
+
+    include Rufus::Verbs
+
+    def setup
+        # no need for an items server
+    end
+
+    def teardown
+    end
+
+    def test_0
+
+        res = expect(
+            200, 
+            nil, 
+            get(:uri => "http://jmettraux.wordpress.com/2006/03/31/cvs-down/"))
+
+        #res.each_header do |h|
+        #    p h
+        #end
+
+        #puts res.body
+        assert res.body.match "^<!DOCTYPE html PUBLIC"
+    end
+end

data/test/iconditional_test.rb

@@ -0,0 +1,68 @@
+
+#
+# Testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Sun Jan 13 12:33:03 JST 2008
+#
+
+require 'test/unit'
+require 'testbase'
+
+require 'rufus/verbs'
+
+
+class ItemConditionalTest < Test::Unit::TestCase
+    include TestBaseMixin
+
+    include Rufus::Verbs
+
+
+    def test_0
+
+        require 'open-uri'
+        f = open "http://localhost:7777/items"
+        d = f.read
+        f.close
+
+        assert_equal "{}", d.strip
+    end
+
+    def test_1
+
+        res = get :uri => "http://localhost:7777/items"
+
+        assert_equal 200, res.code.to_i
+        assert_equal "{}", res.body.strip
+
+        p res['Etag']
+        #p res['Last-Modified']
+        assert res['Etag'].length > 0
+        assert res['Last-Modified'].length > 0
+    end
+
+    def test_2
+
+        res = get "http://localhost:7777/items"
+        assert_equal 200, res.code.to_i
+
+        lm = res['Last-Modified']
+        etag = res['Etag']
+
+        res = get(
+            "http://localhost:7777/items", 
+            :headers => { 'If-Modified-Since' => lm })
+        assert_equal 304, res.code.to_i
+
+        res = get(
+            "http://localhost:7777/items", :h => { 'If-None-Match' => etag })
+        assert_equal 304, res.code.to_i
+
+        res = get(
+            "http://localhost:7777/items", 
+            :h => { 'If-Modified-Since' => lm, 'If-None-Match' => etag })
+        assert_equal 304, res.code.to_i
+    end
+end
+

data/test/items.rb

@@ -0,0 +1,262 @@
+
+#
+# an in-memory resource set for testing rufus-verbs
+#
+# jmettraux@gmail.com
+#
+# Fri Jan 11 12:36:45 JST 2008
+#
+
+require 'date'
+require 'webrick'
+
+
+class LastModifiedHash
+
+    def initialize
+
+        @hash = {}
+        touch
+    end
+
+    def touch (key=nil)
+
+        now = Time.now.httpdate
+        @hash[key] = now if key
+        @hash['__self'] = now
+    end
+
+    def delete (key)
+
+        @hash.delete key
+        @hash['__self'] = Time.now.httpdate
+    end
+
+    def last_modified (key)
+
+        key = key || '__self'
+        @hash[key]
+    end
+
+    def clear
+
+        @hash.clear
+        @hash['__self'] = Time.now.httpdate
+    end
+end
+
+
+#
+# This servlet provides a RESTful in-memory resource "/items".
+#
+class ItemServlet < WEBrick::HTTPServlet::AbstractServlet
+
+    @@items = {}
+    @@lastmod = LastModifiedHash.new
+
+
+    def initialize (server, *options)
+
+        super
+        @auth = server.auth
+    end
+
+    #
+    # Overriding the service() method to perform a potential auth check
+    #
+    def service (req, res)
+
+        WEBrick::HTTPAuth.basic_auth(req, res, "items") do |u, p|
+            (u != nil and u == p)
+        end if @auth
+
+        super
+    end
+
+    def do_GET (req, res)
+
+        i = item_id req
+
+        return reply(res, 404, "no item '#{i}'") \
+            if i and not items[i]
+
+        representation, et, lm = fetch_representation i
+
+        since = req['If-Modified-Since']
+        since = DateTime.parse(since) if since
+        match = req['If-None-Match']
+
+        if ((not since and not match) or
+            (since and (since > DateTime.parse(lm))) or
+            (match and (match != et)))
+
+            res['Etag'] = et
+            res['Last-Modified'] = lm
+            res.body = representation.inspect + "\n"
+
+        else
+
+            reply(res, 304, "Not Modified")
+        end
+    end
+
+    def do_POST (req, res)
+
+        query = WEBrick::HTTPUtils::parse_query(req.query_string)
+        m = query['_method']
+        m = m.downcase if m
+        return do_PUT(req, res) if m == 'put'
+        return do_DELETE(req, res) if m == 'delete'
+
+        i = item_id req
+        items[i] = req.body
+        lastmod.touch i
+
+        res['Location'] = "#{@host}/items/#{i}"
+        reply res, 201, "item created"
+    end
+
+    def do_PUT (req, res)
+
+        i = item_id req
+
+        return reply(res, 404, "no item '#{i}'") unless items[i] 
+
+        items[i] = req.body
+        lastmod.touch i
+
+        reply res, 200, "item updated"
+    end
+
+    def do_DELETE (req, res)
+
+        i = item_id req
+
+        return reply(res, 404, "no item '#{i}'") unless items[i] 
+
+        items.delete i
+        lastmod.delete i
+
+        reply res, 200, "item deleted"
+    end
+
+    #
+    # clears the items
+    #
+    def self.flush
+
+        @@items.clear
+        @@lastmod.clear
+    end
+
+    protected
+
+        def items
+            @@items
+        end
+        
+        def lastmod
+            @@lastmod
+        end
+
+        def is_modified (req, key)
+
+            since = req['If-Modified-Since']
+            match = req['If-None-Match']
+
+            return true unless since or match
+
+            puts
+            p [ since, match ]
+            puts
+
+            (since or match)
+        end
+
+        #
+        # Returns representation, etag, last_modified
+        #
+        def fetch_representation (key=nil)
+
+            representation = if key
+                items[key]
+            else
+                items
+            end
+
+            [ representation, 
+              representation.inspect.hash.to_s,
+              lastmod.last_modified(key) ]
+        end
+
+        def reply (res, code, message)
+
+            res.status = code
+            res.body = message + "\n"
+            res['Content-type'] = "text/plain"
+        end
+
+        def item_id (req)
+
+            p = req.path_info[1..-1]
+            return nil if not p or p == ''
+            p.to_i
+        end
+end
+
+#
+# just redirecting to the ItemServlet...
+#
+class ThingServlet < WEBrick::HTTPServlet::AbstractServlet
+
+    def do_GET (req, res)
+
+        res.set_redirect(
+            WEBrick::HTTPStatus[303], 
+            "http://localhost:7777/items")
+    end
+end
+
+#
+# Serving items, a dummy resource...
+# Also serving things, which just redirect to items...
+#
+class ItemServer
+
+    def initialize (args={})
+
+        port = args[:port] || 7777
+
+        #al = [ 
+        #    [ "", WEBrick::AccessLog::COMMON_LOG_FORMAT ],
+        #    [ "", WEBrick::AccessLog::REFERER_LOG_FORMAT ]]
+
+        @server = WEBrick::HTTPServer.new :Port => port, :AccessLog => nil
+
+        class << @server
+            attr_accessor :auth
+        end
+
+        @server.auth = args[:auth]
+
+        @server.mount "/items", ItemServlet
+        @server.mount "/things", ThingServlet
+
+        [ 'INT', 'TERM' ].each do |signal|
+            trap(signal) { shutdown } 
+        end
+    end
+
+    def start
+
+        Thread.new { @server.start }
+            # else the server and the test lock each other
+    end
+
+    def shutdown
+
+        ItemServlet.flush
+        @server.shutdown
+    end
+end
+