timberline 0.3.1 → 0.4.0

data/spec/lib/timberline/queue_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Timberline::Queue do
+  describe "#initialize" do
+    it "raises an ArgumentError if no queue_name is provided" do
+      expect { Timberline::Queue.new(nil) }.to raise_error(ArgumentError)
+    end
+
+    it "loads a default read_timeout of 0" do
+      expect(Timberline::Queue.new("fritters").read_timeout).to eq(0)
+    end
+
+    it "allows you to override the default read_timeout" do
+      expect(Timberline::Queue.new("fritters", 50).read_timeout).to eq(50)
+    end
+
+    it "adds the queue's name to the Timberline queue listing" do
+      Timberline::Queue.new("fritters")
+      expect(Timberline.all_queues.map { |q| q.queue_name }).to include("fritters")
+    end
+  end
+
+  describe "#delete" do
+    subject { Timberline::Queue.new("fritters") }
+
+    before do
+      subject.delete 
+    end
+
+    it "removes the queue from redis" do
+      expect(Timberline.redis["fritters"]).to be_nil 
+    end
+
+    it "removes all of the queue's attributes from redis" do
+      expect(Timberline.redis["fritters:*"]).to be_nil
+    end
+
+    it "removes the queue from the Timberline queue listing" do
+      expect(Timberline.all_queues.map { |q| q.queue_name }).not_to include("fritters")
+    end
+  end
+
+  describe "#pop" do
+    subject { Timberline::Queue.new("fritters") }
+    before { subject.push("apple") }
+
+    it "will block if the queue is paused" do
+      expect(subject).to receive(:block_while_paused)
+      subject.pop
+    end
+
+    it "will return a Timberline::Envelope object" do
+      expect(subject.pop).to be_a Timberline::Envelope
+    end
+  end
+
+  describe "#push" do
+    subject { Timberline::Queue.new("fritters") }
+
+    it "returns the current size of the queue when you push" do
+      expect(subject.push("Test")).to be_a Numeric
+    end
+
+    it "puts an item on the queue when you push" do
+      subject.push("Test")
+      expect(subject.length).to eq(1)
+    end
+    
+    it "properly formats data so it can be popped successfully" do
+      subject.push("Test")
+      expect(subject.pop).to be_a Timberline::Envelope
+    end
+  end
+
+  describe "#pause" do
+    subject { Timberline::Queue.new("fritters") }
+
+    before do
+      subject.pause
+    end
+
+    it "puts the queue in paused mode" do
+      expect(subject).to be_paused
+    end
+  end
+
+  describe "#unpause" do
+    subject { Timberline::Queue.new("fritters") }
+
+    before do
+      subject.pause
+      subject.unpause
+    end
+
+    it "unpauses the queue" do
+      expect(subject).not_to be_paused
+    end
+
+  end
+end

data/spec/lib/timberline_spec.rb

@@ -0,0 +1,375 @@
+require 'spec_helper'
+
+describe Timberline do
+  describe ".redis=" do
+    context "if Timberline hasn't been configured yet" do
+      before { Timberline.redis = nil }
+
+      it "initializes a new configuration object" do
+        expect(Timberline.config).not_to be_nil  
+      end
+    end
+
+    context "if the argument is a Redis instance" do
+      before { Timberline.redis = Redis.new }
+
+      it "wraps the server in a namespace" do
+        expect(Timberline.redis).to be_a Redis::Namespace
+      end
+    end
+
+    context "if the argument is a Redis::Namespace instance" do
+      let(:namespace) { Redis::Namespace.new("fritters", redis: Redis.new) }
+      before { Timberline.redis = namespace }
+
+      it "accepts the namespace as-is" do
+        expect(Timberline.redis).to eq(namespace)
+      end
+    end
+
+    context "if the argument is nil" do
+      before do
+        Timberline.redis = Redis.new
+        Timberline.redis = nil
+      end
+      
+      it "clears out the existing redis server" do
+        expect(Timberline.instance_variable_get("@redis")).to be_nil
+      end
+    end
+
+    context "if the argument is not an instance of nil, Redis, or Redis::Namespace" do
+      it "raises an exception" do
+        expect { Timberline.redis = "this isn't redis" }.to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe ".redis" do
+    context "if Timberline hasn't been configured yet" do
+      before { Timberline.redis }
+
+      it "initializes a new configuration object" do
+        expect(Timberline.config).not_to be_nil  
+      end
+
+      it "initializes a default redis server" do
+        expect(Timberline.redis).not_to be_nil
+      end
+    end
+
+    context "if Timberline has already had a redis server provided" do
+      let(:namespace) { Redis::Namespace.new("fritters", redis: Redis.new) }
+      before { Timberline.redis = namespace }
+
+      it "returns that server" do
+        expect(Timberline.redis).to eq(namespace)
+      end
+    end
+  end
+
+  describe ".all_queues" do
+    context "when there are no queues" do
+      before { allow(Timberline.redis).to receive(:smembers) { [] } }
+
+      it "returns an empty list" do
+        expect(Timberline.all_queues).to eq([])
+      end
+    end
+
+    context "when there are some queues" do
+      before { allow(Timberline.redis).to receive(:smembers) { %w(my_queue your_queue) } }
+
+      it "returns a list of appropriate size" do
+        expect(Timberline.all_queues.size).to eq(2)
+      end
+
+      it "returns a list of Queue objects" do
+        expect(Timberline.all_queues.first).to be_a Timberline::Queue
+        expect(Timberline.all_queues.last).to be_a Timberline::Queue
+      end
+    end
+  end
+
+  describe ".error_queue" do
+    it "returns a Timberline::Queue" do
+      expect(Timberline.error_queue).to be_a Timberline::Queue
+    end
+
+    it "returns the timberline_errors queue" do
+      expect(Timberline.error_queue.queue_name).to eq("timberline_errors")
+    end
+  end
+
+  describe ".queue" do
+    it "returns a Timberline::Queue" do
+      expect(Timberline.queue("fritters")).to be_a Timberline::Queue
+    end
+
+    it "returns a queue with the appropriate name" do
+      expect(Timberline.queue("fritters").queue_name).to eq("fritters")
+    end
+  end
+
+  describe ".push" do
+    let(:data) { "some data" }
+    let(:metadata) { { meta: :data } }
+
+    it "uses the #push method on the specified queue" do
+      expect_any_instance_of(Timberline::Queue).to receive(:push).with(data, metadata)
+      Timberline.push("fritters", data, metadata)
+    end
+  end
+
+  describe ".retry_item" do
+    let(:queue) { Timberline.queue("test_queue") }
+    let(:item) { Timberline.push(queue.queue_name, "Howdy kids."); queue.pop }
+
+    context "when the item has not yet been retried" do
+      before { Timberline.retry_item(item) }
+
+      it "puts the item back on the queue" do
+        expect(queue.length).to eq(1)
+      end
+
+      it "updates the retry count on the item" do
+        expect(item.retries).to eq(1)
+      end
+    end
+
+    context "when the item has been retried less than the maximum number of times" do
+      before do
+        Timberline.configure do |c|
+          c.max_retries = 5
+        end
+
+        item.retries = 3
+
+        Timberline.retry_item(item)
+      end
+
+      it "puts the item back on the queue" do
+        expect(queue.length).to eq(1)
+      end
+
+      it "updates the retry count on the item" do
+        expect(item.retries).to eq(4)
+      end
+    end
+
+    context "when the item has been retried the maximum number of times" do
+      before do
+        Timberline.configure do |c|
+          c.max_retries = 5
+        end
+
+        item.retries = 5
+      end
+
+      it "passes the item on to the error handling" do
+        expect(Timberline).to receive(:error_item).with(item)
+        Timberline.retry_item(item)
+      end
+    end
+  end
+
+  describe ".error_item" do
+    let(:queue) { Timberline.queue("test_queue") }
+    let(:error_queue) { Timberline.error_queue }
+    let(:item) { Timberline.push(queue.queue_name, "Howdy kids."); queue.pop }
+
+    before { Timberline.error_item(item) }
+
+    it "puts the item on the error_queue" do
+      expect(error_queue.length).to eq(1) 
+    end
+
+    it "updates the fatal_error_at property on the item" do
+      expect(item.fatal_error_at).not_to be_nil
+    end
+  end
+
+  describe ".pause" do
+    context "when a Queue is not paused" do
+      subject { Timberline.queue("pause_test_queue") }
+
+      before do
+        Timberline.pause(subject.queue_name)
+      end
+
+      it "pauses the queue" do
+        expect(subject.paused?).to be true
+      end
+    end
+
+    context "when a Queue is already paused" do
+      subject { Timberline.queue("pause_test_queue") }
+
+      before do
+        subject.pause
+        Timberline.pause(subject.queue_name)
+      end
+
+      it "keeps the queue paused" do
+        expect(subject.paused?).to be true
+      end
+    end
+  end
+
+  describe ".unpause" do
+    context "when a Queue is paused" do
+      subject { Timberline.queue("pause_test_queue") }
+
+      before do
+        subject.pause
+        Timberline.unpause(subject.queue_name)
+      end
+
+      it "unpauses the queue" do
+        expect(subject.paused?).to be false
+      end
+    end
+
+    context "when a Queue is already unpaused" do
+      subject { Timberline.queue("pause_test_queue") }
+
+      before do
+        Timberline.unpause(subject.queue_name)
+      end
+
+      it "keeps the queue unpaused" do
+        expect(subject.paused?).to be false
+      end
+    end
+  end
+
+  describe ".configure" do
+    context "if Timberline hasn't been configured yet" do
+      it "initializes a new configuration object" do
+        Timberline.configure {}
+        expect(Timberline.config).not_to be_nil  
+      end
+
+      it "yields the new config object to the block" do
+        expect { |b| Timberline.configure &b }.to yield_with_args(Timberline.config)
+      end
+    end
+
+    context "if Timberline has been configured" do
+      before do
+        Timberline.configure {}
+      end
+
+      it "yields the Timberlin config object to the block" do
+        expect { |b| Timberline.configure &b }.to yield_with_args(Timberline.config)
+      end
+    end
+  end
+
+  describe ".max_retries" do
+    context "if Timberline hasn't been configured yet" do
+      before { Timberline.max_retries }
+
+      it "initializes a new configuration object" do
+        expect(Timberline.config).not_to be_nil  
+      end
+    end
+
+    context "if Timberline has been configured" do
+      before do
+        Timberline.configure do |c|
+          c.max_retries = 10
+        end
+      end
+
+      it "returns the configured number of maximum retries" do
+        expect(Timberline.max_retries).to eq(10)
+      end
+    end
+  end
+
+  describe ".stat_timeout" do
+    context "if Timberline hasn't been configured yet" do
+      before { Timberline.stat_timeout }
+
+      it "initializes a new configuration object" do
+        expect(Timberline.config).not_to be_nil  
+      end
+    end
+
+    context "if Timberline has been configured" do
+      before do
+        Timberline.configure do |c|
+          c.stat_timeout = 10
+        end
+      end
+
+      it "returns the configured number of minutes for stat timeout" do
+        expect(Timberline.stat_timeout).to eq(10)
+      end
+    end
+  end
+
+  describe ".stat_timeout_seconds" do
+    context "if Timberline hasn't been configured yet" do
+      before { Timberline.stat_timeout_seconds }
+
+      it "initializes a new configuration object" do
+        expect(Timberline.config).not_to be_nil  
+      end
+    end
+
+    context "if Timberline has been configured" do
+      before do
+        Timberline.configure do |c|
+          c.stat_timeout = 10
+        end
+      end
+
+      it "returns the configured number of seconds for stat timeout" do
+        expect(Timberline.stat_timeout_seconds).to eq(600)
+      end
+    end
+  end
+
+  describe ".watch" do
+    let(:queue) { Timberline.queue("test_queue") }
+    let(:queue_name) { queue.queue_name }
+    let(:success_item) { Timberline::Envelope.from_json(Timberline.redis.xmembers(queue.attr("success_stats")).first) }
+    let(:retried_item) { Timberline::Envelope.from_json(Timberline.redis.xmembers(queue.attr("retry_stats")).first) }
+    let(:errored_item) { Timberline::Envelope.from_json(Timberline.redis.xmembers(queue.attr("error_stats")).first) }
+
+    before do
+      # Make sure that the watch doesn't run forever.
+      Timberline.watch_proc = lambda { queue.length > 0 }
+      Timberline.push(queue_name, "Hey There!")
+    end
+
+    context "If the item can be processed successfully" do
+      it "logs the success of the item" do
+        expect_any_instance_of(Timberline::Queue).to receive(:add_success_stat)
+        Timberline.watch(queue_name) do |item|
+          # don't do anything
+        end
+      end
+    end
+
+    context "If the item is retried" do
+      it "logs that the item was retried" do
+        expect_any_instance_of(Timberline::Queue).to receive(:add_retry_stat)
+        Timberline.watch(queue_name) do |item|
+          raise Timberline::ItemRetried
+        end
+      end
+    end
+
+    context "If the item can be processed successfully" do
+      it "logs that the item was retried" do
+        expect_any_instance_of(Timberline::Queue).to receive(:add_error_stat)
+        Timberline.watch(queue_name) do |item|
+          raise Timberline::ItemErrored
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+require 'pry'
+
+require File.expand_path("../../lib/timberline", __FILE__)
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.expect_with :rspec do |c|
+    c.syntax = [:expect]
+  end
+
+  config.order = "random"
+
+  config.after(:each) do
+    SpecSupport::TimberlineReset.clear_config
+  end
+end

data/spec/support/fake_rails.rb

@@ -0,0 +1,17 @@
+module SpecSupport
+  module FakeRails
+    def self.create_fake_env
+      fake_rails = OpenStruct.new(:root => File.join(File.dirname(File.path(__FILE__)), "..", "fake_rails"), :env => "development") 
+      Object.send(:const_set, :Rails, fake_rails)
+    end
+
+    def self.create_fake_env_without_config
+      fake_rails = OpenStruct.new(:root => File.join(File.dirname(File.path(__FILE__)), "..", "gibberish"), :env => "development") 
+      Object.send(:const_set, :Rails, fake_rails)
+    end
+
+    def self.destroy_fake_env
+      Object.send(:remove_const, :Rails)
+    end
+  end
+end

data/spec/support/timberline_reset.rb

@@ -0,0 +1,20 @@
+module SpecSupport
+  module TimberlineReset
+    def self.clear_config
+      Timberline.redis = nil
+      Timberline.instance_variable_set("@config", nil)
+      clear_test_db
+      Timberline.redis = nil
+    end
+
+    # Use database 15 for testing, so we don't risk overwriting any data that's
+    # actually useful
+    def self.clear_test_db
+      Timberline.config do |c|
+        c.database = 15
+      end
+      Timberline.redis.flushdb
+    end
+
+  end
+end

data/spec/support/timberline_yaml.rb

@@ -0,0 +1,17 @@
+module SpecSupport
+  module TimberlineYaml
+    def self.load_constant
+      config_file = File.join(File.dirname(File.path(__FILE__)), "..", "config", "test_config.yaml") 
+      Object.send(:const_set, :TIMBERLINE_YAML, config_file)
+    end
+
+    def self.load_constant_for_missing_file
+      config_file = File.join(File.dirname(File.path(__FILE__)), "..", "config", "party_config.yaml") 
+      Object.send(:const_set, :TIMBERLINE_YAML, config_file)
+    end
+
+    def self.destroy_constant
+      Object.send(:remove_const, :TIMBERLINE_YAML)
+    end
+  end
+end

data/timberline.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = Timberline::VERSION
   s.authors     = ["Tommy Morgan"]
   s.email       = ["tommy.morgan@gmail.com"]
-  s.homepage    = "http://github.com/duwanis/timberline"
+  s.homepage    = "http://github.com/treehouse/timberline"
   s.summary     = %q{Timberline is a simple and extensible queuing system built in Ruby and backed by Redis.}
   s.description = %q{Timberline is a simple and extensible queuing system built in Ruby and backed by Redis. It makes as few assumptions as possible about how you want to interact with your queues while also allowing for some functionality that should be universally useful, like allowing for automatic retries of jobs and queue statistics.}
 
@@ -18,14 +18,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
   s.add_runtime_dependency "redis"
   s.add_runtime_dependency "redis-namespace"
   s.add_runtime_dependency "redis-expiring-set"
   s.add_runtime_dependency "trollop"
   s.add_runtime_dependency "daemons"
 
-  s.add_development_dependency "nutrasuite"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", '~> 3.0.0.rc1'
+  s.add_development_dependency "pry"
 end