resque-bus 0.3.7 → 0.5.7

data/lib/resque_bus/compatibility/driver.rb

@@ -0,0 +1,10 @@
+module ResqueBus
+  class Driver
+    class << self
+      def perform(attributes={})
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Driver"
+        ::QueueBus::Driver.perform(attributes)
+      end
+    end
+  end
+end

data/lib/resque_bus/compatibility/heartbeat.rb

@@ -0,0 +1,10 @@
+module ResqueBus
+  class Heartbeat
+    class << self
+      def perform(attributes={})
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Heartbeat"
+        ::QueueBus::Heartbeat.perform(attributes)
+      end
+    end
+  end
+end

data/lib/resque_bus/compatibility/publisher.rb

@@ -0,0 +1,13 @@
+module ResqueBus
+  # publishes on a delay
+  class Publisher
+    class << self
+      def perform(event_type, attributes = {})
+        attributes["bus_event_type"] = event_type # now using one hash only
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Publisher"
+        ::QueueBus::Publisher.perform(attributes)
+      end
+    end
+
+  end
+end

data/lib/resque_bus/compatibility/rider.rb

@@ -0,0 +1,32 @@
+require 'resque-retry'
+
+module ResqueBus
+  class Rider
+    extend Resque::Plugins::ExponentialBackoff
+    
+    class << self
+      def perform(attributes = {})
+        ResqueBus.note_deprecation "[MIGRATION] Note: new events will be using QueueBus::Rider"
+        ::QueueBus::Rider.perform(attributes)
+      end
+      
+      # @failure_hooks_already_ran on https://github.com/defunkt/resque/tree/1-x-stable
+      # to prevent running twice
+      def queue
+        @my_queue
+      end
+      
+      def on_failure_aaa(exception, *args)
+        # note: sorted alphabetically
+        # queue needs to be set for rety to work (know what queue in Requeue.class_to_queue)
+        @my_queue = args[0]["bus_rider_queue"]
+      end
+      
+      def on_failure_zzz(exception, *args)
+        # note: sorted alphabetically
+        @my_queue = nil
+      end
+
+    end
+  end
+end

data/lib/resque_bus/compatibility/subscriber.rb

@@ -0,0 +1,8 @@
+module ResqueBus
+  module Subscriber
+    def self.included(base)
+      ResqueBus.note_deprecation "[DEPRECATION] ResqueBus::Subscriber is deprecated. Use QueueBus::Subscriber instead."
+      base.send(:include, ::QueueBus::Subscriber)
+    end
+  end
+end

data/lib/resque_bus/compatibility/task_manager.rb

@@ -0,0 +1,8 @@
+module ResqueBus
+  class TaskManager < ::QueueBus::TaskManager
+    def initialize(logging)
+      ResqueBus.note_deprecation "[DEPRECATION] ResqueBus::TaskManager is deprecated. Use QueueBus::TaskManager instead."
+      super(logging)
+    end
+  end
+end

data/lib/resque_bus/server/views/bus.erb

@@ -18,7 +18,7 @@ else
   event_hash = {}
   
   # collect each differently
-  ResqueBus::Application.all.each do |app|
+  ::QueueBus::Application.all.each do |app|
     app_key = app.app_key
     
     app_hash[app_key] ||= []
@@ -61,7 +61,7 @@ else
     else
       one, two, queue, filters = val
       out = "<td>#{h(one)}</td><td>#{h(two)}</td><td><a href='#{u("queues/#{queue}")}'>#{h(queue)}</a></td>"
-      out << "<td>#{h(Resque.encode(filters).gsub(/\"bus_special_value_(\w+)\"/){ "(#{$1})" }).gsub(" ", "&nbsp;").gsub('&quot;,&quot;', '&quot;, &quot;')}</td>"
+      out << "<td>#{h(::QueueBus::Util.encode(filters).gsub(/\"bus_special_value_(\w+)\"/){ "(#{$1})" }).gsub(" ", "&nbsp;").gsub('&quot;,&quot;', '&quot;, &quot;')}</td>"
     end
     
     if first

data/lib/resque_bus/server.rb

@@ -2,7 +2,8 @@ require 'resque-bus'
 require 'resque/server'
 require 'erb'
 
-# Extend Resque::Server to add tabs.
+# MIGRATE TODO: move to resque gem
+# Extend ::Resque::Server to add tabs.
 module ResqueBus
   module Server
 
@@ -24,7 +25,7 @@ module ResqueBus
   end
 end
 
-Resque::Server.tabs << 'Bus'
-Resque::Server.class_eval do
-  include ResqueBus::Server
+::Resque::Server.tabs << 'Bus'
+::Resque::Server.class_eval do
+  include ::ResqueBus::Server
 end

data/lib/resque_bus/tasks.rb

@@ -1,15 +1,35 @@
-# require 'resquebus/tasks'
-# will give you the resquebus tasks
-
+# require 'resque_bus/tasks'
+# will give you these tasks
 
+require "queue_bus/tasks"
 require "resque/tasks"
+
 namespace :resquebus do
+  # deprecated
+  task :setup => ["queuebus:setup"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:setup is deprecated. Use rake queuebus:setup instead."
+  end
+
+  task :driver => ["queuebus:driver"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:driver is deprecated. Use rake queuebus:driver instead."
+  end
+
+  task :subscribe => ["queuebus:subscribe"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:subscribe is deprecated. Use rake queuebus:subscribe instead."
+  end
+
+  task :unsubsribe => ["queuebus:unsubsribe"] do
+    ResqueBus.note_deprecation "[DEPRECATION] rake resquebus:driver is deprecated. Use rake queuebus:unsubsribe instead."
+  end
+end
+
+namespace :queuebus do
 
   desc "Setup will configure a resque task to run before resque:work"
   task :setup => [ :preload ] do
-    
+
     if ENV['QUEUES'].nil?
-      manager = ::ResqueBus::TaskManager.new(true)
+      manager = ::QueueBus::TaskManager.new(true)
       queues = manager.queue_names
       ENV['QUEUES'] = queues.join(",")
     else
@@ -23,24 +43,9 @@ namespace :resquebus do
     end
   end
 
-  desc "Subscribes this application to ResqueBus events"
-  task :subscribe => [ :preload ] do
-    manager = ::ResqueBus::TaskManager.new(true)
-    count = manager.subscribe!
-    raise "No subscriptions created" if count == 0
-  end
-  
-  desc "Unsubscribes this application from ResqueBus events"
-  task :unsubscribe => [ :preload ] do
-    require 'resque-bus'
-    manager = ::ResqueBus::TaskManager.new(true)
-    count = manager.unsubscribe!
-    puts "No subscriptions unsubscribed" if count == 0
-  end
-  
-  desc "Sets the queue to work the driver  Use: `rake resquebus:driver resque:work`"
+  desc "Sets the queue to work the driver  Use: `rake queuebus:driver resque:work`"
   task :driver => [ :preload ] do
-    ENV['QUEUES'] = "resquebus_incoming"
+    ENV['QUEUES'] = ::QueueBus.incoming_queue
   end
 
   # Preload app files if this is Rails
@@ -50,32 +55,27 @@ namespace :resquebus do
     require "resque/failure/redis"
     require "resque/failure/multiple_with_retry_suppression"
 
-    # change the namespace to be the ones used by ResqueBus
-    # save the old one for handling later
-    ResqueBus.original_redis = Resque.redis
-    Resque.redis = ResqueBus.redis
-    
     Resque::Failure::MultipleWithRetrySuppression.classes = [Resque::Failure::Redis]
     Resque::Failure.backend = Resque::Failure::MultipleWithRetrySuppression
-    
+
     Rake::Task["resque:setup"].invoke # loads the environment and such if defined
   end
-  
-  
+
+
   # examples to test out the system
   namespace :example do
     desc "Publishes events to example applications"
-    task :publish => [ "resquebus:preload", "resquebus:setup" ] do
+    task :publish => [ "queuebus:preload", "queuebus:setup" ] do
       which = ["one", "two", "three", "other"][rand(4)]
-      ResqueBus.publish("event_#{which}", { "rand" => rand(99999)})
-      ResqueBus.publish("event_all", { "rand" => rand(99999)})
-      ResqueBus.publish("none_subscribed", { "rand" => rand(99999)})
+      QueueBus.publish("event_#{which}", { "rand" => rand(99999)})
+      QueueBus.publish("event_all", { "rand" => rand(99999)})
+      QueueBus.publish("none_subscribed", { "rand" => rand(99999)})
       puts "published event_#{which}, event_all, none_subscribed"
     end
-    
+
     desc "Sets up an example config"
-    task :register => [ "resquebus:preload"] do      
-      ResqueBus.dispatch("example") do
+    task :register => [ "queuebus:preload"] do
+      QueueBus.dispatch("example") do
         subscribe "event_one" do
           puts "event1 happened"
         end
@@ -93,14 +93,14 @@ namespace :resquebus do
         end
       end
     end
-    
-    desc "Subscribes this application to ResqueBus example events"
-    task :subscribe => [ :register, "resquebus:subscribe" ]
-    
-    desc "Start a ResqueBus example worker"
-    task :work => [ :register, "resquebus:setup", "resque:work" ]
-    
-    desc "Start a ResqueBus example worker"
-    task :driver => [ :register, "resquebus:driver", "resque:work" ]
+
+    desc "Subscribes this application to QueueBus example events"
+    task :subscribe => [ :register, "queuebus:subscribe" ]
+
+    desc "Start a QueueBus example worker"
+    task :work => [ :register, "queuebus:setup", "resque:work" ]
+
+    desc "Start a QueueBus example worker"
+    task :driver => [ :register, "queuebus:driver", "resque:work" ]
   end
 end

data/lib/resque_bus/version.rb

@@ -1,5 +1,3 @@
-module Resque
-  module Bus
-    VERSION = "0.3.7"
-  end
+module ResqueBus
+  VERSION = "0.5.7"
 end

data/resque-bus.gemspec

@@ -4,13 +4,12 @@ require "resque_bus/version"
 
 Gem::Specification.new do |s|
   s.name        = "resque-bus"
-  s.version     = Resque::Bus::VERSION
+  s.version     = ResqueBus::VERSION
   s.authors     = ["Brian Leonard"]
   s.email       = ["brian@bleonard.com"]
-  s.homepage    = ""
+  s.homepage    = "https://github.com/queue-bus/resque-bus"
   s.summary     = %q{A simple event bus on top of Resque}
-  s.description = %q{A simple event bus on top of Resque.
-    Publish and subscribe to events as they occur through a queue.}
+  s.description = %q{A simple event bus on top of Resque. Publish and subscribe to events as they occur through a queue.}
 
   s.rubyforge_project = "resque-bus"
 
@@ -19,15 +18,11 @@ 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_dependency('queue-bus', '0.5.5')
   s.add_dependency('resque', ['>= 1.10.0', '< 2.0'])
   s.add_dependency('resque-scheduler', '>= 2.0.1')
   s.add_dependency('resque-retry')
-  s.add_dependency("redis-namespace")
-  s.add_dependency("redis")
-  
+
   s.add_development_dependency("rspec")
   s.add_development_dependency("timecop")
   s.add_development_dependency("json_pure")

data/spec/adapter/compatibility_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe "Compatibility with old resque-bus" do
+  before(:each) do
+    ResqueBus.show_deprecations = false # expected
+
+    QueueBus.dispatch("r1") do
+      subscribe "event_name" do |attributes|
+        QueueBus::Runner1.run(attributes)
+      end
+    end
+
+    QueueBus::TaskManager.new(false).subscribe!
+
+    @incoming = Resque::Worker.new(:resquebus_incoming)
+    @incoming.register_worker
+
+    @new_incoming = Resque::Worker.new(:bus_incoming)
+    @new_incoming.register_worker
+
+    @rider = Resque::Worker.new(:r1_default)
+    @rider.register_worker
+  end
+
+  describe "Publisher" do
+    it "should still publish as expected" do
+      val = QueueBus.redis { |redis| redis.lpop("queue:resquebus_incoming") }
+      val.should == nil
+      
+      args = [ "event_name", {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12} ]
+      item = {:class => "ResqueBus::Publisher", :args => args}
+
+      QueueBus.redis { |redis| redis.sadd(:queues, "resquebus_incoming") }
+      QueueBus.redis { |redis| redis.rpush "queue:resquebus_incoming", Resque.encode(item) }
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @incoming # publish
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @new_incoming # drive
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider # ride
+
+      QueueBus::Runner1.value.should == 1
+
+    end
+  end
+
+  describe "Rider" do
+    it "should still ride as expected" do
+      val = QueueBus.redis { |redis| redis.lpop("queue:r1_default") }
+      val.should == nil
+
+      args = [ {"bus_rider_app_key"=>"r1", "x" => "y", "bus_event_type" => "event_name", 
+                "bus_rider_sub_key"=>"event_name", "bus_rider_queue" => "default", 
+                "bus_rider_class_name"=>"::ResqueBus::Rider"}]
+      item = {:class => "ResqueBus::Rider", :args => args}
+
+      QueueBus.redis { |redis| redis.sadd(:queues, "r1_default") }
+      QueueBus.redis { |redis| redis.rpush "queue:r1_default", Resque.encode(item) }
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider
+
+      QueueBus::Runner1.value.should == 1
+    end
+  end
+
+  describe "Driver" do
+    it "should still drive as expected" do
+      val = QueueBus.redis { |redis| redis.lpop("queue:resquebus_incoming") }
+      val.should == nil
+      
+      args = [ {"bus_event_type" => "event_name", "two"=>"here", "one"=>1, "id" => 12} ]
+      item = {:class => "ResqueBus::Driver", :args => args}
+
+      QueueBus.redis { |redis| redis.sadd(:queues, "resquebus_incoming") }
+      QueueBus.redis { |redis| redis.rpush "queue:resquebus_incoming", Resque.encode(item) }
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @incoming
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider
+
+      QueueBus::Runner1.value.should == 1
+
+    end
+  end
+end

data/spec/adapter/integration_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe "Resque Integration" do
+  describe "Happy Path" do
+    before(:each) do
+      QueueBus.dispatch("r1") do
+        subscribe "event_name" do |attributes|
+          QueueBus::Runner1.run(attributes)
+        end
+      end
+
+      QueueBus::TaskManager.new(false).subscribe!
+
+      @incoming = Resque::Worker.new(:bus_incoming)
+      @incoming.register_worker
+
+      @rider = Resque::Worker.new(:r1_default)
+      @rider.register_worker
+    end
+
+    it "should publish and receive" do
+      QueueBus::Runner1.value.should == 0
+
+      QueueBus.publish("event_name", "ok" => true)
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @incoming
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider
+
+      QueueBus::Runner1.value.should == 1
+    end
+  end
+
+  describe "Delayed Publishing" do
+    before(:each) do
+      Timecop.freeze(now)
+      QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+    end
+    after(:each) do
+      Timecop.return
+    end
+    let(:delayed_attrs) { {"bus_delayed_until" => future.to_i,
+                       "bus_id" => "#{now.to_i}-idfhlkj",
+                       "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+
+    let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
+    let(:now)    { Time.parse("01/01/2013 5:00")}
+    let(:future) { Time.at(now.to_i + 60) }
+    let(:worktime) {Time.at(future.to_i + 1)}
+
+    it "should add it to Redis" do
+      hash = {:one => 1, "two" => "here", "id" => 12 }
+      event_name = "event_name"
+      QueueBus.publish_at(future, event_name, hash)
+
+      schedule = QueueBus.redis { |redis| redis.zrange("delayed_queue_schedule", 0, 1) }
+      schedule.should == [future.to_i.to_s]
+
+      val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
+      hash = JSON.parse(val)
+
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+      hash["queue"].should == "bus_incoming"
+    end
+
+    it "should move it to the real queue when processing" do
+      hash = {:one => 1, "two" => "here", "id" => 12 }
+      event_name = "event_name"
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil
+
+      QueueBus.publish_at(future, event_name, hash)
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil # nothing really added
+
+      # process sceduler now
+      Resque::Scheduler.handle_delayed_items
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil # nothing added yet
+
+      # process scheduler in future
+      Timecop.freeze(worktime) do
+        Resque::Scheduler.handle_delayed_items
+
+        # added
+        val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+        hash = JSON.parse(val)
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+
+       QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
+
+       val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+       hash = JSON.parse(val)
+       hash["class"].should == "QueueBus::Worker"
+       hash["args"].size.should == 1
+       JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
+      end
+    end
+
+  end
+end

data/spec/adapter/publish_at_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "Publishing an event in the future" do
+
+  before(:each) do
+    Timecop.freeze(now)
+    QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+  end
+  after(:each) do
+    Timecop.return
+  end
+  let(:delayed_attrs) { {"bus_delayed_until" => future.to_i,
+                     "bus_id" => "#{now.to_i}-idfhlkj",
+                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+
+  let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
+  let(:now)    { Time.parse("01/01/2013 5:00")}
+  let(:future) { Time.at(now.to_i + 60) }
+  let(:worktime) {Time.at(future.to_i + 1)}
+
+  it "should add it to Redis then to the real queue" do
+    hash = {:one => 1, "two" => "here", "id" => 12 }
+    event_name = "event_name"
+    QueueBus.publish_at(future, event_name, hash)
+
+    schedule = QueueBus.redis { |redis| redis.zrange("delayed_queue_schedule", 0, 1) }
+    schedule.should == [future.to_i.to_s]
+
+    val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
+    hash = JSON.parse(val)
+
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+    hash["queue"].should == "bus_incoming"
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val.should == nil # nothing really added
+
+    Timecop.freeze(worktime)
+    QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    hash = JSON.parse(val)
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
+  end
+
+end

data/spec/adapter/retry_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Retry" do
+  class RetryTest1
+    include QueueBus::Subscriber
+    application :my_thing
+    subscribe :event_sub
+    def event_sub(attributes)
+      QueueBus::Runner1.run(attributes)
+    end
+  end
+
+  it "should have the methods" do
+    ::QueueBus::Worker.methods.should include(:on_failure_aaa)
+    ::QueueBus::Worker.methods.should include(:on_failure_zzz)
+  end
+
+  # it "should retry failed riders"
+
+  describe "Failed Jobs" do
+    before(:each) do
+      QueueBus.enqueue_to("testing", "QueueBus::Worker", { "bus_class_proxy" => "QueueBus::Rider", "bus_rider_app_key" => "r2", "bus_rider_sub_key" => "event_name", "bus_event_type" => "event_name", "ok" => true, "bus_rider_queue" => "testing" })
+
+      @worker = Resque::Worker.new(:testing)
+      @worker.register_worker
+    end
+
+    it "should put it in the failed jobs" do
+
+      QueueBus.dispatch("r2") do
+        subscribe "event_name" do |attributes|
+          raise "boo!"
+        end
+      end
+
+      perform_next_job @worker
+      Resque.info[:processed].should == 1
+      Resque.info[:failed].should == 1
+      Resque.info[:pending].should == 1 # requeued
+
+      perform_next_job @worker
+      Resque.info[:processed].should == 2
+      Resque.info[:failed].should == 2
+      Resque.info[:pending].should == 0
+    end
+  end
+end

data/spec/adapter/support.rb

@@ -0,0 +1,23 @@
+require 'resque-bus'
+require 'resque'
+require 'resque/scheduler'
+
+def reset_test_adapter
+  QueueBus.send(:reset)
+  QueueBus.adapter = QueueBus::Adapters::Resque.new
+end
+
+def adapter_under_test_class
+  QueueBus::Adapters::Resque
+end
+
+def adapter_under_test_symbol
+  :resque
+end
+
+def perform_next_job(worker, &block)
+  return unless job = worker.reserve
+  worker.perform(job, &block)
+  worker.done_working
+end
+

data/spec/adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "adapter is set" do
+  it "should call it's enabled! method on init" do
+    QueueBus.send(:reset)
+    adapter_under_test_class.any_instance.should_receive(:enabled!)
+    instance = adapter_under_test_class.new
+    QueueBus.send(:reset)
+  end
+
+  it "should be defaulting to Data from spec_helper" do
+    QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+  end
+end