webbed 0.1.1 → 0.2.0

data/lib/webbed/version.rb

@@ -1,3 +1,3 @@
 module Webbed
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/test/support/assertions.rb

@@ -0,0 +1,17 @@
+module WebbedTest
+  module Assertions
+    def assert_comparable(smaller, larger)
+      assert_operator smaller, :<, larger
+      assert_operator smaller, :<=, larger
+      
+      refute_operator larger, :<, smaller
+      refute_operator larger, :<=, smaller
+      
+      assert_operator larger, :>, smaller
+      assert_operator larger, :>=, smaller
+      
+      refute_operator smaller, :>, larger
+      refute_operator smaller, :>=, larger
+    end
+  end
+end

data/test/support/runner.rb

@@ -0,0 +1,326 @@
+require 'minitest/unit'
+require 'ansi'
+require 'progressbar'
+
+# Code has been borrowed and modified from MiniTest, written by Ryan Davis of
+# Seattle.rb. MiniTest is licensed under the MIT License, and can be found on
+# GitHub at https://github.com/seattlerb/minitest.
+# 
+# This code is also heavily based upon these gists as well:
+# * https://gist.github.com/356945
+# * https://gist.github.com/960669
+# 
+# TODO: Add documentation to everything.
+
+module Perfection
+  class Reporter
+    def runner
+      Perfection::Runner.runner
+    end
+    
+    def print(*args)
+      runner.output.print(*args)
+    end
+    
+    def puts(*args)
+      runner.output.puts(*args)
+    end
+    
+    def before_suites(suites); end
+    def after_suites(suites); end
+    def before_suite(suite); end
+    def after_suite(suite); end
+    def before_test(suite, test); end
+    def pass(suite, test); end
+    def skip(suite, test, e); end
+    def failure(suite, test, e); end
+    def error(suite, test, e); end
+  end
+  
+  # Takes a signficant amount of code from Jef Kreefmeijer's Fuubar. Fuubar is
+  # licensed under the MIT License and can be found at:
+  # https://github.com/jeffkreeftmeijer/fuubar.
+  class ProgressReporter < Reporter
+    include ANSI::Code
+    
+    INFO_PADDING = 2
+    
+    def before_suites(suites)
+      puts 'Started'
+      puts
+      
+      @color = GREEN
+      @finished_count = 0
+      @progress = ProgressBar.new("0/#{runner.test_count}", runner.test_count, runner.output)
+      @progress.bar_mark = '='
+    end
+    
+    def increment
+      with_color do
+        @finished_count += 1
+        @progress.instance_variable_set('@title', "#{@finished_count}/#{runner.test_count}")
+        @progress.inc
+      end
+    end
+    
+    def pass(suite, test)
+      increment
+    end
+    
+    def skip(suite, test, e)
+      @color = YELLOW unless @color == RED
+      print(yellow { 'SKIP' })
+      print_test_with_time(suite, test)
+      puts
+      puts
+      increment
+    end
+    
+    def failure(suite, test, e)
+      @color = RED
+      print(red { 'FAIL' })
+      print_test_with_time(suite, test)
+      puts
+      print_info(e)
+      puts
+      increment
+    end
+    
+    def error(suite, test, e)
+      @color = RED
+      print(red { 'ERROR' })
+      print_test_with_time(suite, test)
+      puts
+      print_info(e)
+      puts
+      increment
+    end
+    
+    def after_suites(suites)
+      with_color { @progress.finish }
+      
+      total_time = Time.now - runner.start_time
+      
+      puts
+      puts('Finished in %.5fs' % total_time)
+      print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
+      print(red { '%d failures, %d errors, ' } % [runner.failures, runner.errors])
+      print(yellow { '%d skips' } % runner.skips)
+      puts
+    end
+    
+    private
+    
+    def print_test_with_time(suite, test)
+      total_time = Time.now - runner.test_start_time
+      print(" #{suite}##{test} (%.2fs)#{clr}" % total_time)
+    end
+    
+    def print_info(e)
+      e.message.each_line { |line| puts pad(line) }
+      
+      trace = MiniTest.filter_backtrace(e.backtrace)
+      trace.each { |line| puts pad(line) }
+    end
+    
+    def pad(str)
+      ' ' * INFO_PADDING + str
+    end
+    
+    def with_color
+      print @color
+      yield
+      print CLEAR
+    end
+  end
+  
+  class SpecReporter < Reporter
+    include ANSI::Code
+    
+    TEST_PADDING = 2
+    INFO_PADDING = 8
+    MARK_SIZE    = 5
+    
+    def before_suites(suites)
+      puts 'Started'
+      puts
+    end
+    
+    def after_suites(suites)
+      total_time = Time.now - runner.start_time
+      
+      puts('Finished in %.5fs' % total_time)
+      print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
+      print(red { '%d failures, %d errors, ' } % [runner.failures, runner.errors])
+      print(yellow { '%d skips' } % runner.skips)
+      puts
+    end
+    
+    def before_suite(suite)
+      puts suite
+    end
+    
+    def after_suite(suite)
+      puts
+    end
+    
+    def pass(suite, test)
+      print(green { pad_mark('PASS') })
+      print_test_with_time(test)
+      puts
+    end
+    
+    def skip(suite, test, e)
+      print(yellow { pad_mark('SKIP') })
+      print_test_with_time(test)
+      puts
+    end
+    
+    def failure(suite, test, e)
+      print(red { pad_mark('FAIL') })
+      print_test_with_time(test)
+      puts
+      print_info(e)
+      puts
+    end
+    
+    def error(suite, test, e)
+      print(red { pad_mark('ERROR') })
+      print_test_with_time(test)
+      puts
+      print_info(e)
+      puts
+    end
+    
+    private
+    
+    def print_test_with_time(test)
+      total_time = Time.now - runner.test_start_time
+      print(" #{test} (%.2fs)" % total_time)
+    end
+    
+    def print_info(e)
+      e.message.each_line { |line| puts pad(line, INFO_PADDING) }
+      
+      trace = MiniTest.filter_backtrace(e.backtrace)
+      trace.each { |line| puts pad(line, INFO_PADDING) }
+    end
+    
+    def pad(str, size)
+      ' ' * size + str
+    end
+    
+    def pad_mark(str)
+      pad("%#{MARK_SIZE}s" % str, TEST_PADDING)
+    end
+  end
+  
+  class Runner < MiniTest::Unit
+    class << self
+      attr_writer :reporter
+      
+      def reporter
+        @reporter ||= ProgressReporter.new
+      end
+    end
+    
+    attr_accessor :suite_start_time, :test_start_time
+    
+    def reporter
+      self.class.reporter
+    end
+    
+    def puke(suite, method, e)
+      case e
+      when MiniTest::Skip then
+        @skips += 1
+        [:skip, e]
+      when MiniTest::Assertion then
+        @failures += 1
+        [:failure, e]
+      else
+        @errors += 1
+        [:error, e]
+      end
+    end
+    
+    def _run_anything(type)
+      suites = TestCase.send("#{type}_suites")
+      return if suites.empty?
+      
+      @test_count = suites.inject(0) { |acc, suite| acc + suite.send("#{type}_methods").length }
+      @assertion_count = 0
+      
+      @start_time = Time.now
+      reporter.before_suites(suites)
+      fix_sync { _run_suites(suites, type) }
+      reporter.after_suites(suites)
+    end
+    
+    def _run_suites(suites, type)
+      suites.each { |suite| _run_suite(suite, type) }
+    end
+    
+    def _run_suite(suite, type)
+      run_suite_header(suite, type)
+      
+      filter = options[:filter] || '/./'
+      filter = Regexp.new($1) if filter =~ /\/(.*)\//
+      
+      tests = suite.send("#{type}_methods").grep(filter)
+      
+      unless tests.empty?
+        @suite_start_time = Time.now
+        reporter.before_suite(suite)
+        _run_tests(suite, tests)
+        reporter.after_suite(suite)
+      end
+    end
+    
+    private
+    
+    def run_suite_header(suite, type)
+      header_method = "#{type}_suite_header"
+      send(header_method, suite) if respond_to?(header_method)
+    end
+    
+    def _run_tests(suite, tests)
+      suite.startup if suite.respond_to?(:startup)
+      tests.each { |test| _run_test(suite, test) }
+    ensure
+      suite.shutdown if suite.respond_to?(:shutdown)
+    end
+    
+    def _run_test(suite, test)
+      @test_start_time = Time.now
+      reporter.before_test(suite, test)
+      
+      suite_instance = suite.new(test)
+      suite_instance._assertions = 0
+      
+      result = fix_result(suite_instance.run(self))
+      @assertion_count += suite_instance._assertions
+      
+      case result[0]
+      when :pass then reporter.pass(suite, test)
+      when :skip then reporter.skip(suite, test, result[1])
+      when :failure then reporter.failure(suite, test, result[1])
+      else reporter.error(suite, test, result[1])
+      end
+    end
+    
+    def fix_result(result)
+      result == '.' ? [:pass, nil] : result
+    end
+    
+    def fix_sync
+      sync = output.respond_to?(:'sync=') # stupid emacs
+      old_sync, output.sync = output.sync, true if sync
+      yield
+      output.sync = old_sync if sync
+    end
+  end
+end
+
+Perfection::Runner.runner = Perfection::Runner.new
+Perfection::Runner.reporter = Perfection::ProgressReporter.new

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'mocha'
+require 'test_declarative'
+require 'webbed'
+
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |f| require f }
+
+module WebbedTest
+  class TestCase < MiniTest::Unit::TestCase
+    include Assertions
+  end
+end

data/test/webbed/generic_message_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module WebbedTest
+  class GenericMessageTest < TestCase
+    def setup
+      @klass = Class.new
+      @klass.instance_eval { include Webbed::GenericMessage }
+      @message = @klass.new
+    end
+    
+    test '#initialize' do
+      assert_nil @message.http_version
+      assert_nil @message.headers
+      assert_nil @message.entity_body
+    end
+    
+    test '#http_version' do
+      @message.http_version = 'HTTP/1.0'
+      
+      assert_instance_of Webbed::HTTPVersion, @message.http_version
+      assert_equal 1.0, @message.http_version
+    end
+    
+    test '#headers' do
+      @message.headers = { 'Host' => 'foo.com' }
+      
+      assert_instance_of Webbed::Headers, @message.headers
+      assert_equal 'foo.com', @message.headers['Host']
+    end
+    
+    test '#entity_body' do
+      @message.entity_body = 'foo'
+      assert_equal 'foo', @message.entity_body
+    end
+    
+    test '#to_s' do
+      @message.expects(:start_line).returns("Start Line\r\n")
+      @message.expects(:headers).returns("Headers\r\n")
+      @message.expects(:entity_body).returns('Entity Body')
+      
+      assert_equal "Start Line\r\nHeaders\r\n\r\nEntity Body", @message.to_s
+    end
+  end
+end

data/test/webbed/headers_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+# TODO: Add more tests to this. Since it was stolen from Rack, I'm pretty darn
+# sure that it works correctly. Still, as a matter of principle, it should have
+# all the necessary tests to make sure it works correctly when it changes. But
+# yeah, very low priority at the moment.
+module WebbedTest
+  class HeadersTest < TestCase
+    test '#initialize without headers' do
+      assert Webbed::Headers.new.empty?
+    end
+    
+    test '#initialize with headers' do
+      headers = Webbed::Headers.new({ 'Host' => 'foo.com' })
+      
+      refute headers.empty?
+      assert_equal 'foo.com', headers['Host']
+      assert_equal 'foo.com', headers['host']
+      assert_equal 'foo.com', headers['HOST']
+    end
+    
+    test '#to_s' do
+      headers = Webbed::Headers.new({
+        'Content-Type' => 'application/json',
+        'Host' => 'foo.com'
+      })
+      
+      assert_equal "Content-Type: application/json\r\nHost: foo.com\r\n", headers.to_s
+    end
+  end
+end

data/test/webbed/helpers/entity_headers_helper_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module WebbedTest
+  module HelperTest
+    class EntityHeadersHelperTest < TestCase
+      def setup
+        @request = Webbed::Request.new('GET', '*', {}, '')
+        @response = Webbed::Response.new(200, {}, '')
+      end
+      
+      test '#content_length' do
+        [@request, @response].each do |message|
+          assert_nil message.content_length
+          
+          message.headers['Content-Length'] = 9876
+          assert_equal 9876, message.content_length
+          
+          message.content_length = 123
+          assert_equal 123, message.content_length
+          assert_equal '123', message.headers['Content-Length']
+        end
+      end
+      
+      test '#content_location' do
+        [@request, @response].each do |message|
+          assert_nil message.content_location
+          
+          message.headers['Content-Location'] = 'http://google.com'
+          assert_instance_of Addressable::URI, message.content_location
+          assert_equal 'http://google.com', message.content_location.to_s
+          
+          message.content_location = 'http://example.com/testing'
+          assert_instance_of Addressable::URI, message.content_location
+          assert_equal 'http://example.com/testing', message.content_location.to_s
+          assert_equal 'http://example.com/testing', message.headers['Content-Location']
+        end
+      end
+      
+      test '#content_md5' do
+        [@request, @response].each do |message|
+          assert_nil message.content_md5
+          
+          message.headers['Content-MD5'] = 'asdfasdf'
+          assert_equal 'asdfasdf', message.content_md5
+          
+          message.content_md5 = ';lkj;lkj'
+          assert_equal ';lkj;lkj', message.content_md5
+          assert_equal ';lkj;lkj', message.headers['Content-MD5']
+        end
+      end
+      
+      test '#content_type' do
+        [@request, @response].each do |message|
+          assert_nil message.content_type
+          
+          message.headers['Content-Type'] = 'text/html'
+          assert_instance_of Webbed::MediaType, message.content_type
+          assert_equal 'text/html', message.content_type.to_s
+          
+          message.content_type = 'application/json'
+          assert_instance_of Webbed::MediaType, message.content_type
+          assert_equal 'application/json', message.content_type.to_s
+          assert_equal 'application/json', message.headers['Content-Type']
+        end
+      end
+    end
+  end
+end