howler 1.0.0

data/spec/models/runner_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+describe Howler::Runner do
+  before do
+    subject.stub(:require)
+    subject.stub(:sleep)
+  end
+
+  describe "#run" do
+    let!(:manager) { Howler::Manager.current }
+
+    before do
+      Howler::Manager.stub(:current).and_return(manager)
+      manager.stub(:run!)
+    end
+
+    it "should create a manager" do
+      Howler::Manager.should_receive(:current)
+
+      subject.run
+    end
+
+    it "should run the manager" do
+      manager.should_receive(:run!)
+
+      subject.run
+    end
+
+    it "should sleep forever" do
+      subject.should_receive(:sleep).with(no_args)
+
+      subject.run
+    end
+
+    it "should load the Rails 3 environment" do
+      subject.should_receive(:require).with("./config/environment.rb")
+
+      subject.run
+    end
+
+    describe "when the runner receives an Interrupt" do
+      before do
+        manager.stub(:run!).and_raise(Interrupt)
+        Howler::Manager.current.stub(:chewing).and_return([])
+      end
+
+      it "should trap the interrupt" do
+        expect {
+          subject.run
+        }.not_to raise_error
+      end
+
+      describe "logging" do
+        let!(:plain_log) { Howler::Logger.new }
+        let!(:log) { mock(Howler::Logger::Proxy, :info => nil, :debug => nil) }
+
+        before do
+          Howler::Logger.stub(:new).and_return(plain_log)
+          plain_log.stub(:log).and_yield(log)
+
+          Howler::Config[:shutdown_timeout] = 6
+        end
+
+        it "should log information" do
+          log.should_receive(:info).with("INT - Stopping all workers")
+          plain_log.should_receive(:info).with("INT - All workers have shut down - Exiting")
+
+          subject.run
+        end
+
+        it "should log debugging" do
+          log.should_receive(:debug).ordered.with("INT - 0 workers still working.")
+
+          subject.run
+        end
+
+        describe "when there are workers still working" do
+          before do
+            Howler::Config[:concurrency] = 4
+
+            @chewing = 1.times.collect { mock(Howler::Worker) }
+
+            Howler::Manager.current.stub(:chewing).and_return(@chewing)
+            Howler::Manager.current.stub(:shutdown).and_return(3)
+          end
+
+          it "should log the number of seconds it will wait" do
+            log.should_receive(:info).with("INT - Waiting 6 seconds for workers to complete.")
+
+            subject.run
+          end
+
+          it "should wait the specified number of seconds" do
+            subject.should_receive(:sleep).with(6)
+
+            subject.run
+          end
+
+          it "should notify the user about the number of worker still working" do
+            log.should_receive(:debug).with("INT - 3 workers were shutdown immediately.")
+            log.should_receive(:debug).with("INT - 1 workers still working.")
+
+            subject.run
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/support/config_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Howler::Config do
+  it "should have an attribute white-list" do
+    Howler::Config::WHITELIST.should == %w(concurrency shutdown_timeout)
+  end
+
+  describe ".[]" do
+    before do
+      Howler.redis.with {|redis| redis.hset("howler:config", "concurrency", "10") }
+    end
+
+    it "should configure options" do
+      Howler::Config[:concurrency].should == "10"
+    end
+  end
+
+  describe ".[]=" do
+    before do
+      Howler::Config[:message] = '{"key": 3}'
+    end
+
+    it "should configure options" do
+      Howler.redis.with {|redis| redis.hget("howler:config", "message") }.should == '{"key": 3}'
+    end
+
+    describe "when the value is nil" do
+      it "should remove the key" do
+        Howler.redis.with {|redis| redis.hexists("howler:config", "message") }.should == true
+
+        Howler::Config[:message] = nil
+
+        Howler.redis.with {|redis| redis.hexists("howler:config", "message") }.should == false
+      end
+    end
+  end
+
+  describe ".flush" do
+    before do
+      Howler::Config[:concurrency] = 10
+
+      [:message, :flag, :boolean].each do |key|
+        Howler::Config[key] = "unimportant value"
+      end
+    end
+    it "should clear all non-whitelisted config" do
+      Howler::Config.flush
+
+      [:message, :flag, :boolean].each do |key|
+        Howler.redis.with {|redis| redis.hget("howler:config", key.to_s) }.should be_nil
+      end
+
+      Howler::Config[:concurrency].to_i.should == 10
+    end
+  end
+end

data/spec/models/support/logger_spec.rb

@@ -0,0 +1,147 @@
+require "spec_helper"
+
+describe Howler::Logger do
+  let!(:logger) { mock(Logger, :info => nil, :formatter= => nil) }
+
+  before do
+    Logger.stub(:new).and_return(logger)
+  end
+
+  describe ".new" do
+    it "should log to stdout" do
+      Logger.should_receive(:new).with(STDOUT)
+
+      Howler::Logger.new
+    end
+
+    it "should use a custom formatter" do
+      logger.should_receive(:formatter=).with(Howler::Logger::DefaultFormatter)
+
+      Howler::Logger.new
+    end
+
+    describe "when there is log output" do
+      let!(:logger) { Logger.new(STDOUT) }
+
+      before do
+        Logger.stub(:new).and_return(logger)
+      end
+    end
+  end
+
+  describe "#info" do
+    describe "when called with a message" do
+      it "should log to info" do
+        logger.should_receive(:info).with("A pertinent piece of information.")
+
+        subject.info("A pertinent piece of information.")
+      end
+    end
+  end
+
+  describe "#debug" do
+    describe "when called with a message" do
+      it "should log to debug" do
+        logger.should_receive(:debug).with("A pertinent piece of debug information.")
+
+        subject.debug("A pertinent piece of debug information.")
+      end
+    end
+  end
+
+  describe "#log" do
+    let(:worker) { "#<Worker id: 1>" }
+
+    describe "when given a block" do
+      describe "when on the main process" do
+        it "should log to the main process" do
+          logger.should_receive(:info).with("#<Worker id: 0 name: 'supervisor'>\n   INFO: A supervisor level information bite.")
+
+          subject.log do |log|
+            log.info("A supervisor level information bite.")
+          end
+        end
+      end
+
+      it "should log information" do
+        logger.should_receive(:info).with("#<Worker id: 1>\n   INFO: A pertinent piece of information.")
+
+        subject.log(worker) do |log|
+          log.info("A pertinent piece of information.")
+        end
+      end
+
+      describe "debugging" do
+        before do
+          Howler::Config[:log] = 'debug'
+        end
+
+        it "should be true" do
+          subject.log(worker) do |log|
+            log.debug("anything").should == true
+          end
+        end
+
+        it "should log debugging information" do
+          logger.should_receive(:info).with("#<Worker id: 1>\n   DBUG: A pertinent piece of debug information.")
+
+          subject.log(worker) do |log|
+            log.debug("A pertinent piece of debug information.")
+          end
+        end
+
+        it "should log information and debugging information" do
+          logger.should_receive(:info).with("#<Worker id: 1>\n   INFO: A pertinent piece of information.\n   DBUG: A pertinent piece of debug information.")
+
+          subject.log(worker) do |log|
+            log.info("A pertinent piece of information.")
+            log.debug("A pertinent piece of debug information.")
+          end
+        end
+      end
+
+      describe "information" do
+        before do
+          Howler::Config[:log] = 'info'
+        end
+
+        it "should only log information" do
+          logger.should_not_receive(:info)
+
+          subject.log(worker) do |log|
+            log.debug("It's a debug thing.")
+          end
+        end
+
+        describe "when there is debugging" do
+          it "should return false" do
+            subject.log(worker) do |log|
+              log.debug("It's a debug thing.").should == false
+            end
+          end
+
+          it "should not store the debug string" do
+            subject.log(worker) do |log|
+              log.info("something")
+              log.debug("It's a debug thing.")
+
+              log.flush.should_not match(/It's a debug thing\./)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Howler::Logger::DefaultFormatter do
+  describe ".call" do
+    it "should have a compact format" do
+      Timecop.freeze(DateTime.now) do
+        format = Howler::Logger::DefaultFormatter.call(nil, Time.now, nil, "A Message")
+        format.should =~ /\[#{Time.now.strftime('%Y-%m-%d %H:%I:%M:%9N')}\]/
+        format.should =~ /A Message\n/
+      end
+    end
+  end
+end

data/spec/models/support/util_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Howler::Util do
+  describe ".constantize" do
+    it "should convert a string into a constant" do
+      Howler::Util.constantize("Array").should == Array
+      Howler::Util.constantize("Howler").should == Howler
+      Howler::Util.constantize("::Howler").should == Howler
+      Howler::Util.constantize("Howler::Util").should == Howler::Util
+    end
+
+    it "should raise a NameError" do
+      expect {
+        Howler::Util.constantize("a")
+      }.to raise_error(NameError)
+    end
+
+    it "should raise a NoMethodError" do
+      expect {
+        Howler::Util.constantize(nil)
+      }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe ".now"  do
+    it "should be properly formatted" do
+      Timecop.freeze(2012, 3, 24, 14, 30, 55) do
+        Howler::Util.now.should == "Mar 24 2012 14:30:55"
+      end
+    end
+  end
+
+  describe ".at"  do
+    it "should be properly formatted" do
+      Timecop.freeze(2012, 3, 24, 14, 30, 55) do
+        Howler::Util.at(Time.now.to_f).should == "Mar 24 2012 14:30:55"
+      end
+    end
+
+    it "should handle a nil time" do
+      Howler::Util.at(nil).should == ""
+    end
+  end
+end

data/spec/models/worker_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Howler::Worker do
+  describe "#perform" do
+    let!(:queue) { Howler::Queue.new }
+
+    def build_message
+      Howler::Message.new(
+        "class" => "Howler",
+        "method" => "length",
+        "args" => [1234]
+      )
+    end
+
+    before do
+      Howler::Manager.current.wrapped_object.stub(:done_chewing)
+      Howler::Queue.stub(:new).and_return(queue)
+      @message = build_message
+    end
+
+    it "should setup a Queue with the given queue name" do
+      Howler::Queue.should_receive(:new).with("a_queue")
+
+      subject.perform(@message, "a_queue")
+    end
+
+    it "should log statistics" do
+      queue.should_receive(:statistics).with(Howler, :length, [1234])
+
+      subject.perform(@message, "a_queue")
+    end
+
+    it "should execute the given message" do
+      array = mock(Howler)
+      Howler.should_receive(:new).and_return(array)
+
+      array.should_receive(:length).with(1234)
+
+      subject.perform(@message, "a_queue")
+    end
+
+    it "should use the specified queue" do
+      Howler::Queue.should_not_receive(:new)
+
+      subject.perform(@message, queue)
+    end
+
+    it "should register with the manager when done" do
+      Howler::Manager.current.wrapped_object.should_receive(:done_chewing).with(subject)
+
+      subject.perform(@message, "a_queue")
+    end
+  end
+end

data/spec/requests/web_spec.rb

@@ -0,0 +1,220 @@
+require "spec_helper"
+
+describe "web" do
+  include Capybara::DSL
+  let!(:queue) { Howler::Queue.new }
+  let(:message) do
+    Howler::Message.new(
+      'class' => 'Array',
+      'method' => :length,
+      'args' => [2345]
+    )
+  end
+
+  describe "#root" do
+    it "when viewing the navigation bar" do
+      visit "/"
+
+      within "#navigation" do
+        page.should have_content("Howler")
+        page.should have_content("Queues")
+        page.should have_content("Notifications")
+        page.should have_content("Statistics")
+        page.should have_content("Settings")
+      end
+    end
+
+    it "when navigating to Queues#index" do
+      visit "/"
+      click_link "Queues"
+
+      current_path.should == "/queues"
+    end
+
+    it "when navigating to Notifications#index" do
+      visit "/"
+      click_link "Notifications"
+
+      current_path.should == "/notifications"
+    end
+
+    it "when navigating to Statistics#index" do
+      visit "/"
+      click_link "Statistics"
+
+      current_path.should == "/statistics"
+    end
+
+    it "when navigating to Settings#index" do
+      visit "/"
+      click_link "Settings"
+
+      current_path.should == "/settings"
+    end
+  end
+
+  describe "Queues#index" do
+    it "when navigating to Queues#show" do
+      visit "/queues"
+
+      within "#queue_#{queue.id}" do
+        click_link "More..."
+      end
+
+      current_path.should == "/queues/#{queue.id}"
+
+      within "##{queue.id}" do
+        page.should have_content(queue.id)
+      end
+    end
+
+    it "when viewing queue statistics" do
+      6.times { queue.statistics { lambda {}}}
+      4.times { queue.statistics { raise "failed" }}
+
+      visit "/queues"
+
+      within "#queue_#{queue.id}" do
+        page.should have_content(queue.id)
+        page.should have_content(queue.created_at.to_s)
+        page.should have_content("6")
+
+        within ".error" do
+          page.should have_content("4")
+        end
+      end
+    end
+  end
+
+  describe "Queues#show" do
+    before do
+      Timecop.travel(DateTime.now)
+      @time = Time.now.to_f
+
+      queue.statistics(Fiber, :yield, [4567], @time) { raise Howler::Message::Retry }
+
+      Benchmark.stub(:measure).and_return("1.1 1.3 1.5 ( 1.7)", "2.1 2.3 2.5 ( 2.7)")
+
+      [[Hash, :keys, [1234]], [Array, :length, [2345]]].each do |(klass, method, args)|
+        queue.statistics(klass, method, args, @time) { lambda {}}
+      end
+
+      Howler::Manager.current.push(Logger, :info, [3456])
+    end
+
+    it "when viewing processed messages" do
+      visit "/queues/#{queue.id}"
+
+      within "#processed_messages" do
+        within ".table_title" do
+          page.should have_content("Processed Messages")
+        end
+
+        within ".table tr" do
+          ["Message", "Created At", "System Runtime", "Real Runtime", "Status"].each do |value|
+            page.should have_content(value)
+          end
+        end
+
+        within ".table tbody" do
+          page.should have_content(Howler::Util.at(@time))
+
+          %w(Hash.keys(1234) 1.5 1.7 success).each do |value|
+            page.should have_content(value)
+          end
+
+          %w(Array.length(2345) 2.5 2.7 success).each do |value|
+            page.should have_content(value)
+          end
+        end
+      end
+    end
+
+    it "when viewing pending messages" do
+      visit "/queues/#{queue.id}"
+
+      within "#pending_messages" do
+        within ".table_title" do
+          page.should have_content("Pending Messages")
+        end
+
+        within ".table tr" do
+          ["Message", "Created At", "Status"].each do |value|
+            page.should have_content(value)
+          end
+        end
+
+        within ".table tbody" do
+          page.should have_content(Howler::Util.at(@time))
+
+          %w(Logger.info(3456) pending).each do |value|
+            page.should have_content(value)
+          end
+
+          %w(Fiber.yield(4567) retrying).each do |value|
+            page.should have_content(value)
+          end
+        end
+      end
+    end
+
+    it "when viewing failed messages" do
+      Benchmark.unstub(:measure)
+      queue.statistics(Array, :length, [2345], @time) { raise Howler::Message::Failed }
+
+      visit "/queues/#{queue.id}"
+
+      within "#failed_messages" do
+        within ".table_title" do
+          page.should have_content("Failed Messages")
+        end
+
+        within ".table tr" do
+          ["Message", "Created At", "Failed At", "Cause", "Status"].each do |value|
+            page.should have_content(value)
+          end
+        end
+
+        within ".table tbody" do
+          within ".failed_at" do
+            page.should have_content(Howler::Util.at(@time))
+          end
+
+          %w(Array.length(2345) Howler::Message::Failed failed).each do |value|
+            page.should have_content(value)
+          end
+        end
+      end
+    end
+  end
+
+  describe "Notifications#index" do
+    describe "when there are notifications" do
+      before do
+        [:length, :collect, :max].each_with_index do |method, i|
+          queue.statistics(Array, method, [i*10]) { raise Howler::Message::Notify.new(generate_exception, :type => method)}
+        end
+
+        visit "/notifications"
+      end
+
+      it "when viewing the notifications table" do
+        within "#notifications" do
+          within ".table tr" do
+            %w(Message Notification Occurred).each do |value|
+              page.should have_content(value)
+            end
+          end
+
+          within ".table tbody" do
+            page.should have_content(Howler::Util.at(@time))
+
+            %w(Array.length(0) Array.collect(10) Array.max(20) notified).each do |value|
+              page.should have_content(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end