webroar 0.6.1 → 0.7.0

data/src/admin_panel/vendor/plugins/prototype_legacy_helper/test/test_prototype_helper.rb

@@ -0,0 +1,297 @@
+if Rails.root
+  environment = File.expand_path('vendor/gems/environment', Rails.root.to_s)
+  require environment if File.exist?("#{environment}.rb")
+end
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'test/unit'
+require 'action_view'
+require 'action_controller'
+require 'active_model'
+require 'prototype_helper'
+
+class Bunny < Struct.new(:Bunny, :id)
+end
+
+class Author
+  extend ActiveModel::Naming
+
+  attr_reader :id
+  def save; @id = 1 end
+  def new_record?; @id.nil? end
+  def name
+    @id.nil? ? 'new author' : "author ##{@id}"
+  end
+end
+
+class Article
+  extend ActiveModel::Naming
+
+  attr_reader :id
+  attr_reader :author_id
+  def save; @id = 1; @author_id = 1 end
+  def new_record?; @id.nil? end
+  def name
+    @id.nil? ? 'new article' : "article ##{@id}"
+  end
+end
+
+class Author::Nested < Author; end
+
+class PrototypeHelperTest < ActionView::TestCase
+  attr_accessor :formats, :output_buffer, :template_format
+
+  def _evaluate_assigns_and_ivars() end
+
+  def reset_formats(format)
+    @format = format
+  end
+
+  def setup
+    @record = @author = Author.new
+    @article = Article.new
+    super
+    @template = self
+    @controller = Class.new do
+      def url_for(options)
+        if options.is_a?(String)
+          options
+        else
+          url =  "http://www.example.com/"
+          url << options[:action].to_s if options and options[:action]
+          url << "?a=#{options[:a]}" if options && options[:a]
+          url << "&b=#{options[:b]}" if options && options[:a] && options[:b]
+          url
+        end
+      end
+    end.new
+  end
+
+
+  def test_observe_form
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Observer('cart', 2, function(element, value) {new Ajax.Request('http://www.example.com/cart_changed', {asynchronous:true, evalScripts:true, parameters:value})})\n//]]>\n</script>),
+      observe_form("cart", :frequency => 2, :url => { :action => "cart_changed" })
+  end
+
+  def test_observe_form_using_function_for_callback
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Observer('cart', 2, function(element, value) {alert('Form changed')})\n//]]>\n</script>),
+      observe_form("cart", :frequency => 2, :function => "alert('Form changed')")
+  end
+
+  def test_observe_field
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/reorder_if_empty', {asynchronous:true, evalScripts:true, parameters:value})})\n//]]>\n</script>),
+      observe_field("glass", :frequency => 5.minutes, :url => { :action => "reorder_if_empty" })
+  end
+
+  def test_observe_field_using_with_option
+    expected = %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/check_value', {asynchronous:true, evalScripts:true, parameters:'id=' + encodeURIComponent(value)})})\n//]]>\n</script>)
+    assert_dom_equal expected, observe_field("glass", :frequency => 5.minutes, :url => { :action => "check_value" }, :with => 'id')
+    assert_dom_equal expected, observe_field("glass", :frequency => 5.minutes, :url => { :action => "check_value" }, :with => "'id=' + encodeURIComponent(value)")
+  end
+
+  def test_observe_field_using_json_in_with_option
+    expected = %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {new Ajax.Request('http://www.example.com/check_value', {asynchronous:true, evalScripts:true, parameters:{'id':value}})})\n//]]>\n</script>)
+    assert_dom_equal expected, observe_field("glass", :frequency => 5.minutes, :url => { :action => "check_value" }, :with => "{'id':value}")
+  end
+
+  def test_observe_field_using_function_for_callback
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.Observer('glass', 300, function(element, value) {alert('Element changed')})\n//]]>\n</script>),
+      observe_field("glass", :frequency => 5.minutes, :function => "alert('Element changed')")
+  end
+
+  def test_observe_field_without_frequency
+    assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Form.Element.EventObserver('glass', function(element, value) {new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:value})})\n//]]>\n</script>),
+      observe_field("glass")
+  end
+
+
+  def test_periodically_call_remote
+    assert_dom_equal %(<script type="text/javascript">\n//<![CDATA[\nnew PeriodicalExecuter(function() {new Ajax.Updater('schremser_bier', 'http://www.example.com/mehr_bier', {asynchronous:true, evalScripts:true})}, 10)\n//]]>\n</script>),
+      periodically_call_remote(:update => "schremser_bier", :url => { :action => "mehr_bier" })
+  end
+
+  def test_periodically_call_remote_with_frequency
+    assert_dom_equal(
+      "<script type=\"text/javascript\">\n//<![CDATA[\nnew PeriodicalExecuter(function() {new Ajax.Request('http://www.example.com/', {asynchronous:true, evalScripts:true})}, 2)\n//]]>\n</script>",
+      periodically_call_remote(:frequency => 2)
+    )
+  end
+
+
+  def test_form_remote_tag
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  })
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => { :success => "glass_of_beer" }, :url => { :action => :fast  })
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => { :failure => "glass_of_water" }, :url => { :action => :fast  })
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer',failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => { :success => 'glass_of_beer', :failure => "glass_of_water" }, :url => { :action => :fast  })
+  end
+
+  def test_form_remote_tag_with_method
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\"><div style='margin:0;padding:0;display:inline'><input name='_method' type='hidden' value='put' /></div>),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, :html => { :method => :put })
+  end
+
+  def test_form_remote_tag_with_block_in_erb
+    __in_erb_template = ''
+    form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }) { concat "Hello world!" }
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;\">Hello world!</form>), output_buffer
+  end
+
+  def test_on_callbacks
+    callbacks = [:uninitialized, :loading, :loaded, :interactive, :complete, :success, :failure]
+    callbacks.each do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :success => "glass_of_beer" }, :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({failure:'glass_of_beer'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :failure => "glass_of_beer" }, :url => { :action => :fast  }, callback=>"monkeys();")
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater({success:'glass_of_beer',failure:'glass_of_water'}, 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => { :success => "glass_of_beer", :failure => "glass_of_water" }, :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+
+    #HTTP status codes 200 up to 599 have callbacks
+    #these should work
+    100.upto(599) do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on#{callback.to_s.capitalize}:function(request){monkeys();}, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+
+    #test 200 and 404
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on200:function(request){monkeys();}, on404:function(request){bananas();}, parameters:Form.serialize(this)}); return false;">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, 200=>"monkeys();", 404=>"bananas();")
+
+    #these shouldn't
+    1.upto(99) do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+    600.upto(999) do |callback|
+      assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;">),
+        form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, callback=>"monkeys();")
+    end
+
+    #test ultimate combo
+    assert_dom_equal %(<form action=\"http://www.example.com/fast\" method=\"post\" onsubmit=\"new Ajax.Updater('glass_of_beer', 'http://www.example.com/fast', {asynchronous:true, evalScripts:true, on200:function(request){monkeys();}, on404:function(request){bananas();}, onComplete:function(request){c();}, onFailure:function(request){f();}, onLoading:function(request){c1()}, onSuccess:function(request){s()}, parameters:Form.serialize(this)}); return false;\">),
+      form_remote_tag(:update => "glass_of_beer", :url => { :action => :fast  }, :loading => "c1()", :success => "s()", :failure => "f();", :complete => "c();", 200=>"monkeys();", 404=>"bananas();")
+  end
+
+  def test_remote_form_for_with_record_identification_with_new_record
+    remote_form_for(@record, {:html => { :id => 'create-author' }}) {}
+
+    expected = %(<form action='#{authors_path}' onsubmit="new Ajax.Request('#{authors_path}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='new_author' id='create-author' method='post'></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_record_identification_without_html_options
+    remote_form_for(@record) {}
+
+    expected = %(<form action='#{authors_path}' onsubmit="new Ajax.Request('#{authors_path}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='new_author' method='post' id='new_author'></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_record_identification_with_existing_record
+    @record.save
+    remote_form_for(@record) {}
+
+    expected = %(<form action='#{author_path(@record)}' id='edit_author_1' method='post' onsubmit="new Ajax.Request('#{author_path(@record)}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='edit_author'><div style='margin:0;padding:0;display:inline'><input name='_method' type='hidden' value='put' /></div></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_new_object_in_list
+    remote_form_for([@author, @article]) {}
+
+    expected = %(<form action='#{author_articles_path(@author)}' onsubmit="new Ajax.Request('#{author_articles_path(@author)}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='new_article' method='post' id='new_article'></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+  def test_remote_form_for_with_existing_object_in_list
+    @author.save
+    @article.save
+    remote_form_for([@author, @article]) {}
+
+    expected = %(<form action='#{author_article_path(@author, @article)}' id='edit_article_1' method='post' onsubmit="new Ajax.Request('#{author_article_path(@author, @article)}', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this)}); return false;" class='edit_article'><div style='margin:0;padding:0;display:inline'><input name='_method' type='hidden' value='put' /></div></form>)
+    assert_dom_equal expected, output_buffer
+  end
+
+
+  def test_button_to_remote
+    assert_dom_equal %(<input class=\"fine\" type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true});\" />),
+      button_to_remote("Remote outpost", { :url => { :action => "whatnot"  }}, { :class => "fine"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onComplete:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :complete => "alert(request.reponseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onSuccess:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :success => "alert(request.reponseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :failure => "alert(request.reponseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<input type=\"button\" value=\"Remote outpost\" onclick=\"new Ajax.Request('http://www.example.com/whatnot?a=10&amp;b=20', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.reponseText)}});\" />),
+      button_to_remote("Remote outpost", :failure => "alert(request.reponseText)", :url => { :action => "whatnot", :a => '10', :b => '20' })
+  end
+
+  def test_submit_to_remote
+    assert_dom_equal %(<input name=\"More beer!\" onclick=\"new Ajax.Updater('empty_bottle', 'http://www.example.com/', {asynchronous:true, evalScripts:true, parameters:Form.serialize(this.form)});\" type=\"button\" value=\"1000000\" />),
+      submit_to_remote("More beer!", 1_000_000, :update => "empty_bottle")
+  end
+
+
+  def test_link_to_remote
+    assert_dom_equal %(<a class=\"fine\" href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", { :url => { :action => "whatnot"  }}, { :class => "fine"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onComplete:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :complete => "alert(request.responseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onSuccess:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :success => "alert(request.responseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :failure => "alert(request.responseText)", :url => { :action => "whatnot"  })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot?a=10&amp;b=20', {asynchronous:true, evalScripts:true, onFailure:function(request){alert(request.responseText)}}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :failure => "alert(request.responseText)", :url => { :action => "whatnot", :a => '10', :b => '20' })
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:false, evalScripts:true}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :url => { :action => "whatnot" }, :type => :synchronous)
+    assert_dom_equal %(<a href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true, insertion:'bottom'}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", :url => { :action => "whatnot" }, :position => :bottom)
+  end
+
+  def test_link_to_remote_html_options
+    assert_dom_equal %(<a class=\"fine\" href=\"#\" onclick=\"new Ajax.Request('http://www.example.com/whatnot', {asynchronous:true, evalScripts:true}); return false;\">Remote outauthor</a>),
+      link_to_remote("Remote outauthor", { :url => { :action => "whatnot"  }, :html => { :class => "fine" } })
+  end
+
+  def test_link_to_remote_url_quote_escaping
+    assert_dom_equal %(<a href="#" onclick="new Ajax.Request('http://www.example.com/whatnot\\\'s', {asynchronous:true, evalScripts:true}); return false;">Remote</a>),
+      link_to_remote("Remote", { :url => { :action => "whatnot's" } })
+  end
+
+  protected
+    def request_forgery_protection_token
+      nil
+    end
+
+    def protect_against_forgery?
+      false
+    end
+
+    def create_generator
+      block = Proc.new { |*args| yield *args if block_given? }
+      JavaScriptGenerator.new self, &block
+    end
+
+    def author_path(record)
+      "/authors/#{record.id}"
+    end
+
+    def authors_path
+      "/authors"
+    end
+
+    def author_articles_path(author)
+      "/authors/#{author.id}/articles"
+    end
+
+    def author_article_path(author, article)
+      "/authors/#{author.id}/articles/#{article.id}"
+    end
+end

data/src/helper/wr_config.c

@@ -25,7 +25,7 @@
 #include <sys/socket.h>
 
 #define SERVER_NAME       "WebROaR"
-#define SERVER_VERSION    "0.6.1"
+#define SERVER_VERSION    "0.7.0"
  
 #define FILE_PATH         "FILE_PATH"
 #define CONN_ID           "CONNECTION_ID"

data/src/ruby_lib/analyzer/message_analyzer.rb

@@ -207,6 +207,7 @@ module Webroar
         exception_details_hash = Hash.new
         ExceptionDetail.columns.each { |column|  exception_details_hash[column.name] = nil }
         exception_details_hash.delete("id")
+        exception_details_hash.delete("app_exception_id")
         exception_details_hash.each_key do |key|
           exception_details_hash[key] = exception_hash[key.to_sym]
         end

data/src/ruby_lib/analyzer/webroar_analyzer.rb

@@ -29,7 +29,7 @@ module Webroar
       # Reading configuration file. Opening log file and PID file on given path.
       def initialize
         @@instance = self
-        @configuration = YAML.load(File.open(File.join(WEBROAR_ROOT,'conf','server_internal_config.yml')))
+        @configuration = YAML.load_file(File.join(WEBROAR_ROOT,'conf','server_internal_config.yml'))
         @process = ProcessHelper.new(@configuration["webroar_analyzer_script"]["log_file"], @configuration["webroar_analyzer_script"]["pid_file"])
         WLogger.set_log_file(@configuration["webroar_analyzer_script"]["log_file"])
 
@@ -45,7 +45,7 @@ module Webroar
 
       def get_starling_pid
         # read starling process id
-        pid_file = YAML.load(File.open(File.join(WEBROAR_ROOT, 'conf', 'starling_server_config.yml')))["starling"]["pid_file"]
+        pid_file = YAML.load_file(File.join(WEBROAR_ROOT, 'conf', 'starling_server_config.yml'))["starling"]["pid_file"]
         pid = File.read(pid_file).chomp.to_i rescue nil
       end
 

data/src/ruby_lib/profiler/message_dispatcher.rb

@@ -31,7 +31,7 @@ module Webroar
         @app_name = $g_options["app_name"].freeze
         @app_env = $g_options["environment"].freeze
         filename = File.join($g_options["webroar_root"],'conf','server_internal_config.yml')
-        configuration = YAML.load(File.open(filename))["starling"]
+        configuration = YAML.load_file(filename)["starling"]
         host = configuration["host"]
         port = configuration["port"]        
         @server = %Q{#{host}:#{port}}.freeze

data/src/ruby_lib/ruby_interface/version.rb

@@ -20,8 +20,8 @@ module Webroar
   
   module VERSION #:nodoc:
     MAJOR    = "0"
-    MINOR    = "6"
-    TINY     = "1"
+    MINOR    = "7"
+    TINY     = "0"
 
     STRING   = [MAJOR, MINOR, TINY].join('.')
   end

data/src/ruby_lib/webroar_app_loader.rb

@@ -21,7 +21,7 @@ begin
   require 'yaml'
   $g_options['analytics'] = true
 
-  server_conf = YAML.load(File.open(File.join($g_options["webroar_root"], "conf", "server_internal_config.yml")))
+  server_conf = YAML.load_file(File.join($g_options["webroar_root"], "conf", "server_internal_config.yml"))
   if(server_conf and server_conf["webroar"] and !server_conf["webroar"]["analyzer"].nil?)
     $g_options['analytics'] = server_conf["webroar"]["analyzer"]
   end

data/tasks/gem.rake

@@ -21,7 +21,7 @@
 ###############################################################################
 require 'rubygems'
 #Gem::manage_gems
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
 
 TESTFILE = "/etc/profile"
 MESSAGE_DEPLOYMENT = "This command needs to be run as root. Please try again using 'sudo'.".freeze
@@ -40,18 +40,16 @@ spec = Gem::Specification.new do |s|
   s.email                 = ["hokam.chauhan@webroar.in", "nikunj.limbaseeya@webroar.in"]
   s.homepage              = "http://webroar.in"
   s.rubyforge_project     = "webroar"
-  s.has_rdoc              = false
   s.executables           = ['webroar','webroar-analyzer']
   
   s.required_ruby_version = '>= 1.8.5'
 
-  s.add_dependency 'rails', '2.3.9'
-  s.add_dependency 'calendar_date_select', '>= 1.15'  
+  s.add_dependency 'rails', '3.0.9'
   s.add_dependency 'rake', '>= 0.8.1'  
   s.add_dependency 'rspec', '~>1.3.1'
   s.add_dependency 'sqlite3', '>=1.2.3'
   s.add_dependency 'starling', '>=0.10.0'
-  s.add_dependency 'will_paginate', '~>2.3.12'
+  s.add_dependency 'will_paginate', '~>2.3.16'
   
   s.files = FileList['Rakefile',
     'README',
@@ -69,6 +67,7 @@ spec = Gem::Specification.new do |s|
     File.join('src', 'admin_panel', 'tmp', 'pids','*'),
     File.join('src', 'admin_panel', 'tmp', 'sessions','*'),
     File.join('src', 'admin_panel', 'tmp', 'sockets','*')].exclude(
+                                                                    File.join('src', 'admin_panel', 'Gemfile.lock'),
                                                                     File.join('src', 'admin_panel', 'db', '*.*'),
                                                                     File.join('src', 'admin_panel', 'log', '*.*'),
                                                                     File.join('src', 'admin_panel', 'config', 'user.yml'),
@@ -81,7 +80,6 @@ spec = Gem::Specification.new do |s|
     s.test_files = FileList[File.join('test', '**', '*.{c,h,yml,rb,js,css,html,txt}'),
     File.join('test', 'spec','test_app','app','**','*'),
     File.join('test', 'spec','test_app','script','**','*'),
-    File.join('test', 'spec', 'test_app', 'vendor', '.placeholder'),
     File.join('test', 'spec','test_app','public','**','*'),
     File.join('test', 'spec', 'test_app', 'README'),
     File.join('test', 'spec', 'test_app', 'Rakefile')].exclude(
@@ -92,7 +90,7 @@ spec = Gem::Specification.new do |s|
   s.bindir                = "bin"
 end
 
-Rake::GemPackageTask.new(spec) do |p|
+Gem::PackageTask.new(spec) do |p|
   p.gem_spec = spec
   p.need_tar = true
 end

data/tasks/test.rake

@@ -274,6 +274,7 @@ task :load_test => [:create_test_dirs] do
   next unless test_flag == 1
 
   puts "Executing load tests ..."
+  test_setup
   begin
     create_config({},{'baseuri' => '/test_app', 'max_worker' => 6})
     move_config

data/test/spec/analytics_spec.rb

@@ -21,7 +21,7 @@ require 'uri'
 require 'time'
 
 describe "Analytics" do
-  
+
   before(:all) do
     create_config({},{'baseuri' => '/test_app','analytics' => 'enabled', 'run_as_user' => 'root'}).should be_true
     Webroar::DBConnect.db_up('test')
@@ -30,26 +30,26 @@ describe "Analytics" do
     move_config.should be_true
     move_messaging_config.should be_true
     start_server.should be_true
-    
+
     sleep(45) # PID processor thread poll PID queue at every 30 seconds
     @t1 = Time.now - 30 #in seconds
     # To fill application profiling data
     action = 'create'
     uri = "http://#{HOST}:#{PORT}/test_app/users/"
-    15.times do
-      Net::HTTP.post_form(URI.parse(uri + action),{'user[name]'=>'created'})
+    15.times do |i|
+      Net::HTTP.post_form(URI.parse(uri + action),{"user[name]"=>"created#{i}"})
     end
     action = 'update'
-    10.times do
-      Net::HTTP.post_form(URI.parse(uri + action),{'user[name]'=>'updated'})
+    10.times do |i|
+      Net::HTTP.post_form(URI.parse(uri + action),{"id" => i + 1,"user[name]"=>"updated#{i}"})
     end
     action = 'destroy'
-    10.times do
-      Net::HTTP.post_form(URI.parse(uri + action),{})
+    10.times do |i|
+      Net::HTTP.post_form(URI.parse(uri + action),{"id" => i+1})
     end
-    
+
     # To check exception logging
-    action='does/not/exists'
+	action = 'edit/0'
     res = Net::HTTP.post_form(URI.parse(uri + action),{})
     res = Net::HTTP.get(URI.parse(uri+action))
     
@@ -57,7 +57,7 @@ describe "Analytics" do
     sleep(120)
     @t2 = Time.now
   end
-  
+
   it "there should be entry in resource usage for every component" do
     result_set = ResourceUsage.find(:all, :select => "app_id, sum(cpu_usage) as tot_cpu, sum(memory_usage) as tot_memory", :conditions => ["wall_time >= ? and wall_time <= ?",@t1,@t2], :group => 'app_id')
     app_ids = result_set.collect { |a| a['app_id']}
@@ -73,38 +73,39 @@ describe "Analytics" do
     result_set.each do |result|
       result["total_time_in_request"].should >= (result["db_time"] + result["rendering_time"])
     end
-    
+
     result_set = UrlTimeSample.find(:all, :conditions => ["wall_time >= ? and wall_time <= ?",@t1,@t2])
     result_set.should_not be_empty
     result_set.each do |result|
       result["total_time"].should >= (result["db_time"] + result["rendering_time"])
     end
-    
+
     result_set = UrlBreakupTimeSample.find(:all, :conditions => ["wall_time >= ? and wall_time <= ?",@t1,@t2])
     result_set.should_not be_empty      
   end
-  
+
   it "there should be exceptions captured" do
     result_set = ExceptionDetail.find(:all, :conditions => ["wall_time >= ? and wall_time <= ?",@t1,@t2])
     result_set.should_not be_empty
+
     post_req = result_set.select { |a| a['request_method'] == 'POST'}
     post_req.should_not be_empty
     post_req = post_req.first
     post_req['app_env'].should == 'test'
-    post_req.app_exception['controller'].should == 'application'
-    post_req.app_exception['method'].should == 'index'
-    post_req.app_exception['exception_message'].should == 'No route matches "/users/does/not/exists" with {:method=>:post}'
-    post_req.app_exception['exception_class'].should == 'ActionController::RoutingError'
+    post_req.app_exception['controller'].should == 'users'
+    post_req.app_exception['method'].should == 'edit'
+    post_req.app_exception['exception_message'].should == 'Couldn\'t find User with ID=0'
+    post_req.app_exception['exception_class'].should == 'ActiveRecord::RecordNotFound'
     get_req = result_set.select { |a| a['request_method'] == 'GET'}
     get_req.should_not be_empty
     get_req = get_req.first
     get_req['app_env'].should == 'test'
-    get_req.app_exception['controller'].should == 'application'
-    get_req.app_exception['method'].should == 'index'
-    get_req.app_exception['exception_message'].should == 'No route matches "/users/does/not/exists" with {:method=>:get}'
-    get_req.app_exception['exception_class'].should == 'ActionController::RoutingError'
+    get_req.app_exception['controller'].should == 'users'
+    get_req.app_exception['method'].should == 'edit'
+    get_req.app_exception['exception_message'].should == 'Couldn\'t find User with ID=0'
+    get_req.app_exception['exception_class'].should == 'ActiveRecord::RecordNotFound'
   end
-  
+
   after(:all) do
     stop_server
     remove_config.should be_true
@@ -112,4 +113,4 @@ describe "Analytics" do
     remove_messaging_config.should be_true
   end
 
-end
+end