hayabusa 0.0.24 → 0.0.29

data/spec/hayabusa_spec.rb

@@ -1,423 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Hayabusa" do
-  require "rubygems"
-  require "sqlite3" if RUBY_ENGINE != "jruby"
-  require "json"
-  require "RMagick"
-  
-  begin
-    require "#{File.realpath(File.dirname(__FILE__))}/../../knjrbfw/lib/knjrbfw.rb"
-  rescue LoadError
-    require "knjrbfw"
-  end
-  
-  require "#{File.realpath(File.dirname(__FILE__))}/../lib/hayabusa.rb"
-  
-  begin
-    require "#{File.realpath(File.dirname(__FILE__))}/../../http2/lib/http2.rb"
-    puts "Loaded custom version of Http2."
-  rescue LoadError
-    require "http2"
-    puts "Loaded normal gem version of Http2."
-  end
-  
-  db_path = "#{Knj::Os.tmpdir}/hayabusa_rspec.sqlite3"
-  File.unlink(db_path) if File.exists?(db_path)
-  
-  db = Knj::Db.new(
-    :type => "sqlite3",
-    :path => db_path,
-    :return_keys => "symbols"
-  )
-  
-  $appserver = Hayabusa.new(
-    :debug => false,
-    :title => "SpecTest",
-    :port => 1515,
-    :doc_root => "#{File.dirname(__FILE__)}/../pages",
-    :locales_gettext_funcs => true,
-    :locale_default => "da_DK",
-    :db => db,
-    :threadding => {
-      :priority => -3
-    }
-  )
-  
-  $appserver.config[:handlers] << {
-    :regex => /^\/Kasper$/,
-    :callback => proc{|data|
-      data[:httpsession].page_path = nil
-      
-      eruby = data[:httpsession].eruby
-      eruby.connect(:on_error) do |e|
-        _hb.handle_error(e)
-      end
-      
-      eruby.import("#{File.dirname(__FILE__)}/../pages/spec.rhtml")
-    }
-  }
-  
-  $appserver.vars[:test] = "kasper"
-  $appserver.define_magic_var(:_testvar1, "Kasper")
-  $appserver.define_magic_var(:_testvar2, "Johansen")
-  $appserver.start
-  
-  raise "Expected thread-pool-priority to be '-3' but it wasnt: '#{$appserver.threadpool.args[:priority]}'." if $appserver.threadpool.args[:priority] != -3
-  
-  http = Http2.new(:host => "localhost", :port => 80, :encoding_gzip => false, :debug => false) rescue nil
-  
-  $testmodes = [{
-    :name => :standalone,
-    :path_pre => "",
-    :http => Http2.new(:host => "localhost", :port => 1515, :debug => false)
-  }]
-  
-  if http
-    $testmodes += [{
-      :name => :cgi,
-      :path_pre => "hayabusa_cgi_test/",
-      :http => http
-    },{
-      :name => :fcgi,
-      :path_pre => "hayabusa_fcgi_test/",
-      :http => http
-    }]
-  end
-  
-  it "should be able to get multiple pictures" do
-    require "base64"
-    
-    # Symlink 'image.rhtml' first.
-    img_from_path = "#{Knj.knjrbfw_path}/webscripts/image.rhtml"
-    img_to_path = "#{File.realpath("#{File.dirname(__FILE__)}/../pages")}/image.rhtml"
-    
-    raise "Invalid from path: '#{img_from_path}'." unless File.exists?(img_from_path)
-    
-    File.unlink(img_to_path) if File.symlink?(img_to_path)
-    File.symlink(img_from_path, img_to_path)
-    
-    last_tdata = nil
-    
-    begin
-      $testmodes.each do |tdata|
-        last_tdata = tdata
-        
-        3.times do
-          path = "#{File.dirname(__FILE__)}/../pages/testpic.jpeg"
-          
-          res = tdata[:http].get("#{tdata[:path_pre]}testpic.jpeg")
-          res.body.bytesize.should eql(File.size(path))
-          
-          res.body.bytes.to_a.should eql(File.read(path).bytes.to_a)
-          
-          #puts "Getting forced image through #{tdata[:name]}"
-          res = tdata[:http].get("#{tdata[:path_pre]}image.rhtml?force=true&path64=#{Base64.encode64("testpic.jpeg").to_s.strip}")
-          
-          #puts "Getting normal image through #{tdata[:name]}"
-          res1 = tdata[:http].get("#{tdata[:path_pre]}image.rhtml?path64=#{Base64.encode64("image.png").to_s.strip}&rounded_corners=8&width=550")
-          res1.contenttype.should eql("image/png")
-          
-          #puts "Getting exit-script through #{tdata[:name]}"
-          res_exit = tdata[:http].get("#{tdata[:path_pre]}spec_exit.rhtml")
-          res_exit.body.should eql("ExitOutput\n")
-          res_exit.code.to_i.should eql(304)
-          
-          #puts "Getting normal image through #{tdata[:name]}"
-          res2 = tdata[:http].get("#{tdata[:path_pre]}image.rhtml?path64=#{Base64.encode64("image.png").to_s.strip}&rounded_corners=8&width=550")
-          res2.contenttype.should eql("image/png")
-          
-          res1.body.bytesize.should eql(res2.body.bytesize)
-        end
-      end
-    rescue => e
-      puts "Mode: #{last_tdata[:name]}" if last_tdata
-      STDERR.puts e.inspect
-      STDERR.puts e.backtrace
-      raise e
-    ensure
-      File.unlink(img_to_path) if File.exists?(img_to_path)
-    end
-  end
-  
-  #it "should be able to handle custom urls" do
-  #  $testmodes.each do |tdata|
-  #    res = tdata[:http].get("#{tdata[:path_pre]}Kasper")
-  #    raise "Expected data to be 'Test' in mode '#{tdata[:name]}' but it wasnt: '#{res.body}'." if res.body != "Test"
-  #  end
-  #end
-  
-  it "should be able to upload files" do
-    $testmodes.each do |tdata|
-      fpaths = {
-        "fpath1" => "#{File.realpath(File.dirname(__FILE__))}/../pages/spec_thread_joins.rhtml",
-        "fpath2" => "#{File.realpath(File.dirname(__FILE__))}/test_upload.xlsx"
-      }
-      
-      res = tdata[:http].post_multipart(:url => "#{tdata[:path_pre]}spec_vars_post_fileupload.rhtml", :post => {
-        "testfile1" => {
-          :filename => "spec_thread_joins.rhtml",
-          :fpath => fpaths["fpath1"]
-        },
-        "testfile2" => {
-          :filename => "test_upload.xlsx",
-          :fpath => fpaths["fpath2"]
-        }
-      })
-      
-      1.upto(2) do |count|
-        data = Marshal.load(res.body)
-        raise "No data returned?" unless data
-        
-        if count != 2
-          key = "testfile#{count}"
-          raise "Not defined in returned data: '#{key}' in '#{data}'." unless data.key?(key)
-          if data[key]["val"] != File.read(fpaths["fpath#{count}"])
-            File.open("/tmp/hayabusa_spec_testfile#{count}_1", "w") do |fp|
-              fp.puts("Class: #{data["testfile#{count}"].class.name}")
-              fp.write(data["testfile#{count}"])
-            end
-            
-            File.open("/tmp/hayabusa_spec_testfile#{count}_2", "w") do |fp|
-              fp.write(File.read(fpaths["fpath#{count}"]))
-            end
-            
-            raise "Expected uploaded data for mode '#{tdata[:name]}' to be the same but it wasnt:\n\"#{data["testfile#{count}"]}\"\n\n\"#{File.read(fpaths["fpath#{count}"])}\""
-          end
-        end
-        
-        raise "Expected 'testfile' class to be 'Hayabusa::Http_session::Post_multipart::File_upload' in mode '#{tdata[:name]}' but it wasnt: '#{data["testfile#{count}"]["class"]}'." if data["testfile#{count}"]["class"] != "Hayabusa::Http_session::Post_multipart::File_upload"
-      end
-    end
-  end
-  
-  it "should be able to handle a GET-request." do
-    $testmodes.each do |tdata|
-      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml")
-      raise "Unexpected HTML: '#{res.body}'." if res.body.to_s != "Test"
-      
-      #Check that URL-decoding are being done.
-      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml?choice=check_get_parse&value=#{Knj::Web.urlenc("gfx/nopic.png")}")
-      raise "Unexpected HTML: '#{res.body}'." if res.body.to_s != "gfx/nopic.png"
-    end
-  end
-  
-  it "should be able to handle a HEAD-request." do
-    #Http2 doesnt support head?
-    #res = $http.head("spec.rhtml")
-    #raise "HEAD-request returned content - it shouldnt?" if res.body.to_s.length > 0
-  end
-  
-  it "should be able to handle a POST-request." do
-    $testmodes.each do |tdata|
-      res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec.rhtml", :post => {
-        "postdata" => "Test post"
-      })
-      raise "POST-request did not return expected data: '#{res.body}' for '#{tdata[:name]}' data: '#{res.body}'." if res.body.to_s.strip != "Test post"
-      
-      res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec.rhtml?choice=dopostconvert", :post => {
-        "postdata" => "Test post",
-        "array" => ["a", "b", "d"]
-      })
-      data = JSON.parse(res.body)
-      raise "Expected posted data restored but it wasnt: '#{data}'." if data["array"]["0"] != "a" or data["array"]["1"] != "b" or data["array"]["2"] != "d"
-    end
-  end
-  
-  it "should be able to join the server so other tests can be made manually." do
-    begin
-      Timeout.timeout(1) do
-        $appserver.join
-        raise "Appserver didnt join."
-      end
-    rescue Timeout::Error
-      #ignore.
-    end
-  end
-  
-  it "should be able to use the header-methods." do
-    $testmodes.each do |tdata|
-      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml")
-      raise "Normal header data could not be detected." if res.header("testheader") != "NormalHeader"
-      raise "Raw header data could not be detected." if res.header("testraw") != "RawHeader"
-    end
-  end
-  
-  it "should be able to set and get multiple cookies at the same time." do
-    $testmodes.each do |tdata|
-      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml?choice=test_cookie")
-      raise res.body if res.body.to_s.length > 0
-      
-      res = tdata[:http].get("#{tdata[:path_pre]}spec.rhtml?choice=get_cookies")
-      parsed = JSON.parse(res.body)
-      
-      raise "Unexpected value for 'TestCookie': '#{parsed["TestCookie"]}'." if parsed["TestCookie"] != "TestValue"
-      raise "Unexpected value for 'TestCookie2': '#{parsed["TestCookie2"]}'." if parsed["TestCookie2"] != "TestValue2"
-      raise "Unexpected value for 'TestCookie3': '#{parsed["TestCookie3"]}'." if parsed["TestCookie3"] != "TestValue 3 "
-    end
-  end
-  
-  it "should be able to run the rspec_threadded_content test correctly." do
-    $testmodes.each do |tdata|
-      res = tdata[:http].get("#{tdata[:path_pre]}spec_threadded_content.rhtml")
-      raise "Expected body to be '12345678910' for mode '#{tdata[:name]}' but it wasnt: '#{res.body.to_s}'." if res.body.to_s != "12345678910"
-    end
-  end
-  
-  it "should be able to add a timeout." do
-    $break_timeout = false
-    timeout = $appserver.timeout(:time => 1) do
-      $break_timeout = true
-    end
-    
-    Timeout.timeout(2) do
-      loop do
-        break if $break_timeout
-        sleep 0.1
-      end
-    end
-  end
-  
-  it "should be able to stop a timeout." do
-    $timeout_runned = false
-    timeout = $appserver.timeout(:time => 1) do
-      $timeout_runned = true
-    end
-    
-    sleep 0.5
-    timeout.stop
-    
-    begin
-      Timeout.timeout(1.5) do
-        loop do
-          raise "The timeout ran even though stop was called?" if $timeout_runned
-          sleep 0.1
-        end
-      end
-    rescue Timeout::Error
-      #the timeout didnt run - and it shouldnt so dont do anything.
-    end
-  end
-  
-  it "should be able to join threads tarted from _hb.thread." do
-    $testmodes.each do |tdata|
-      res = tdata[:http].get("#{tdata[:path_pre]}spec_thread_joins.rhtml")
-      raise res.body if res.body.to_s != "12345"
-    end
-  end
-  
-  it "should be able to properly parse special characters in post-requests." do
-    $testmodes.each do |tdata|
-      res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec_vars_post.rhtml", :post => {
-        "test" => "123+456%789%20"
-      })
-      data = JSON.parse(res.body)
-      raise res.body if data["test"] != "123+456%789%20"
-    end
-  end
-  
-  it "should be able to do logging" do
-    class ::TestModels
-      class Person < Knj::Datarow
-        
-      end
-    end
-    
-    Knj::Db::Revision.new.init_db("db" => $appserver.db, "schema" => {
-      "tables" => {
-        "Person" => {
-          "columns" => [
-            {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
-            {"name" => "name", "type" => "varchar"}
-          ]
-        }
-      }
-    })
-    
-    ob = Knj::Objects.new(
-      :db => $appserver.db,
-      :datarow => true,
-      :require => false,
-      :module => ::TestModels
-    )
-    
-    person = ob.add(:Person, :name => "Kasper")
-    
-    $appserver.log("This is a test", person)
-    logs = $appserver.ob.list(:Log, "object_lookup" => person).to_a
-    raise "Expected count to be 1 but got: #{logs.length}" if logs.length != 1
-    
-    $appserver.logs_delete(person)
-    
-    logs = $appserver.ob.list(:Log, "object_lookup" => person).to_a
-    raise "Expected count to be 0 but got: #{logs.length}" if logs.length != 0
-  end
-  
-  it "should handle multi-threadding well" do
-    ts = []
-    es = []
-    
-    #Execute multiple threads to test FCGI-proxy and thread-safety.
-    1.upto(5) do
-      $testmodes.each do |tdata|
-        ts << Thread.new do
-          begin
-            res = tdata[:http].post(:url => "#{tdata[:path_pre]}spec_vars_post.rhtml", :post => {
-              "test_special_chars" => "1%23+-456",
-              "var" => {
-                0 => 1,
-                1 => 2,
-                3 => {
-                  "kasper" => 5,
-                  "arr" => ["a", "b", "c"]
-                }
-              }
-            })
-            
-            begin
-              data = JSON.parse(res.body)
-            rescue JSON::GeneratorError
-              raise "Could not parse JSON from result: '#{res.body}'."
-            end
-            
-            begin
-              raise "Expected hash to be a certain way: '#{data}'." if data["var"]["0"] != "1" or data["var"]["1"] != "2" or data["var"]["3"]["kasper"] != "5" or data["var"]["3"]["arr"]["0"] != "a" or data["var"]["3"]["arr"]["1"] != "b"
-            rescue => e
-              raise "Error when parsing result: '#{data}'."
-            end
-            
-            raise "Expected 'test_special_chars' to be '1%23+-456' but it wasnt: '#{data["test_special_chars"]}'." if data["test_special_chars"] != "1%23+-456"
-            
-            res = tdata[:http].get("#{tdata[:path_pre]}spec_threadded_content.rhtml")
-            raise "Expected body to be '12345678910' but it was: '#{res.body}'." if res.body != "12345678910"
-            
-            res = tdata[:http].get("#{tdata[:path_pre]}spec_vars_get.rhtml?var[]=1&var[]=2&var[]=3&var[3][kasper]=5")
-            data = JSON.parse(res.body)
-            raise "Expected hash to be a certain way: '#{data}'." if data["var"]["0"] != "1" or data["var"]["1"] != "2" or data["var"]["3"]["kasper"] != "5"
-            
-            
-            
-            res = tdata[:http].get("#{tdata[:path_pre]}spec_vars_header.rhtml")
-            raise "Expected header 'testheader' to be 'TestValue' but it wasnt: '#{res.header("testheader")}'." if res.header("testheader") != "TestValue"
-          rescue => e
-            es << e
-            puts e.inspect
-            puts e.backtrace
-          end
-        end
-      end
-      
-      ts.each do |t|
-        t.join
-      end
-      
-      es.each do |e|
-        raise e
-      end
-    end
-  end
-  
-  it "should be able to stop." do
-    $appserver.stop
-  end
-end

data/spec/spec_helper.rb

@@ -1,12 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rspec'
-require 'hayabusa'
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
-
-RSpec.configure do |config|
-  
-end