background_queue 0.2.0

data/spec/background_queue/command_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'background_queue'
+
+describe "Command" do
+
+  
+  context "serialization" do
+    it "can reload from serialized format" do
+      cmd = BackgroundQueue::ClientLib::Command.add_task_command(:worker, :owner_id, :job_id, :task_id, 1, {:a=>:b}, {:c=>:d} )
+      serialized = cmd.to_buf
+
+      cmd = BackgroundQueue::Command.from_buf(serialized)
+      
+      cmd.code.should eq(:add_task)
+      cmd.options[:c].should eq('d')
+      cmd.args[:worker].should eq('worker')
+      cmd.args[:owner_id].should eq('owner_id')
+      cmd.args[:job_id].should eq('job_id')
+      cmd.args[:task_id].should eq('task_id')
+      cmd.args[:params]['a'].should eq('b')
+      
+    end
+    
+    it "fails when loading from invalid json" do
+      expect { BackgroundQueue::Command.from_buf("{sdf, sdfsdf}")}.to raise_exception(BackgroundQueue::InvalidCommand)
+    end
+    
+    it "fails when loading from missing data in json" do
+      expect { BackgroundQueue::Command.from_buf('{"a": "b"}')}.to raise_exception(BackgroundQueue::InvalidCommand, "Error loading command from buffer: Missing 'c' (code)")
+    end
+    
+  end
+
+end

data/spec/background_queue/config_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'background_queue'
+
+unless defined? Rails
+  module Rails; end
+end
+  
+describe "Config" do
+
+  context "loading" do
+    context "from file" do
+      it "gets an io from a file that exists" do
+        File.should_receive(:open).with(:path_that_exists) { :string }
+        File.should_receive(:exist?).with(:path_that_exists) { true }
+        BackgroundQueue::Config.__prv__get_string_from_file(:path_that_exists).should eq(:string)
+      end
+      
+      it "calls load using string if file exists" do
+        File.should_receive(:open).with(:path_that_exists) { :string }
+        File.should_receive(:exist?).with(:path_that_exists) { true }
+        BackgroundQueue::Config.should_receive(:load_string).with(:string, :path_that_exists) { true }
+        BackgroundQueue::Config.load_file(:path_that_exists).should eq(true)
+      end
+      
+      it "errors if the file is not found" do
+        File.should_receive(:exist?).with(:path_that_does_not_exist) { false }
+        File.should_receive(:expand_path).with(:path_that_does_not_exist) { :expanded_path }
+        expect { BackgroundQueue::Config.__prv__get_string_from_file(:path_that_does_not_exist) }.to raise_error(BackgroundQueue::LoadError, "Failed to open background_queue configuration file at 'expanded_path'")
+      end
+    end
+    
+    context "using string" do
+      it "executes ERB on the string" do
+        BackgroundQueue::Config.__prv__evaluate_erb("TEST <%=1+1%>", :path_that_exists).should eq("TEST 2")
+      end
+      
+      it "errors if invalid ERB" do
+        File.should_receive(:expand_path).with(:path_that_exists) { :expanded_path }
+        expect { BackgroundQueue::Config.__prv__evaluate_erb("TEST <%= aa %>", :path_that_exists)}.to raise_error(BackgroundQueue::LoadError, /Error executing ERB for background_queue configuration file at 'expanded_path':/)
+      end
+      
+      it "calls load yaml if erb evaluates" do
+        BackgroundQueue::Config.should_receive(:evaluate_erb).with(:string, :path_that_exists) { :loaded_string }
+        BackgroundQueue::Config.should_receive(:load_yaml).with(:loaded_string, :path_that_exists) { true }
+        BackgroundQueue::Config.load_string(:string, :path_that_exists).should eq(true)
+      end
+      
+      context "loading as YAML" do
+        it "gets a hash object if the string is valid YAML" do
+          File.stub(:expand_path) { :expanded_path }
+          BackgroundQueue::Config.__prv__convert_yaml_to_hash("a: b", :path_that_exists).should eq( {'a' => 'b'})
+        end
+         
+        it "errors if the YAML is not a hash" do
+          File.stub(:expand_path) { :expanded_path }
+          expect { BackgroundQueue::Config.__prv__convert_yaml_to_hash("a", :path_that_exists)}.to raise_error(BackgroundQueue::LoadError, "Error loading YAML for background_queue configuration file at 'expanded_path': Root of config should be a hash of environment configurations")
+        end
+      end
+      
+      context "extracting the environment entry" do
+        it "gets_the_current environment from env" do
+          ENV.should_receive(:has_key?).with("RAILS_ENV") { true }
+          ENV.should_receive(:[]).with("RAILS_ENV") { :the_env }
+          BackgroundQueue::Config.__prv__current_environment.should eq(:the_env)
+        end
+        
+        it "gets_the_current environment from Rails" do
+          ENV.should_receive(:has_key?).with("RAILS_ENV") { false }
+          Rails.should_receive(:env) { :the_env }
+          BackgroundQueue::Config.__prv__current_environment.should eq(:the_env)
+        end
+        
+        context "with development environment" do
+          before do
+            BackgroundQueue::Config.stub(:current_environment) { 'development' }
+          end
+          
+          it "extracts the correct environment entry from the hash" do
+            BackgroundQueue::Config.__prv__extract_enviroment_entry({:development=>:test}, :path_that_exists).should eq(:test)
+          end
+          
+          it "errors if the YAML does not define environment entry" do
+            File.stub(:expand_path) { :expanded_path }
+            expect { BackgroundQueue::Config.__prv__extract_enviroment_entry({:test=>:test}, :path_that_exists).should eq(:test)}.to raise_error(BackgroundQueue::LoadError, "Error loading YAML for background_queue configuration file at 'expanded_path': missing enviroment root entry: development")
+          end
+        end
+      end
+      
+      context "with extracted environment entry" do
+        before do
+          BackgroundQueue::Config.stub(:current_environment) { 'development' }
+        end
+        it "calls load using map" do
+          BackgroundQueue::Config.should_receive(:load_hash).with({'a'=>'b'}, :path_that_exists) { true }
+          BackgroundQueue::Config.load_yaml("development: { a: b }", :path_that_exists).should eq(true)
+        end
+        
+        context "loading memcache server" do
+          it "loads server from comma separated list" do
+            entries = BackgroundQueue::ClientLib::Config.__prv__build_memcache_array({ :memcache=> "127.0.0.1:4000 , 127.0.0.1:4001,127.0.0.1:4002"}, :path_that_exists)
+            entries.length.should eq(3)
+            entries[0].should eq('127.0.0.1:4000')
+            entries[1].should eq('127.0.0.1:4001')
+            entries[2].should eq('127.0.0.1:4002')
+          end
+        
+          it "errors if missing memcache entry" do
+            File.stub(:expand_path) { :expanded_path }
+            expect { 
+              entries = BackgroundQueue::ClientLib::Config.__prv__build_memcache_array({}, :path_that_exists)
+            }.to raise_error(
+              BackgroundQueue::LoadError, 
+              "Missing 'memcache' entry in configuration file expanded_path"
+            )
+          end
+          
+          it "errors if memcache entry not String" do
+            File.stub(:expand_path) { :expanded_path }
+            expect { 
+              entries = BackgroundQueue::ClientLib::Config.__prv__build_memcache_array({:memcache=>1}, :path_that_exists)
+            }.to raise_error(
+              BackgroundQueue::LoadError, 
+              "Error loading 'memcache' entry in configuration file expanded_path: invalid data type (Fixnum), expecting String (comma separated)"
+            )
+          end
+        end
+      end
+    end
+    
+    
+  end
+  
+  
+end

data/spec/background_queue/server_lib/balanced_queue_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'background_queue_server'
+
+
+describe BackgroundQueue::ServerLib::BalancedQueue do
+
+  it_behaves_like "a queue registry" do
+    let(:server) {
+     SimpleServer.new( :thread_manager=>:thread_manager)
+    }
+    let(:new_instance) { BackgroundQueue::ServerLib::BalancedQueue.new(server) }
+  end
+  
+  let(:thread_manager) {
+    tm = double("thread_manager")
+    tm.stub(:protect_access).and_yield
+    tm.stub(:control_access).and_yield
+    tm
+  }
+  let(:server) {
+   SimpleServer.new( :thread_manager=>thread_manager)
+  }
+  subject {  BackgroundQueue::ServerLib::BalancedQueue.new(server) }
+  
+  context "callbacks" do
+    it "gets the owner_id from tasks" do
+      subject.__prv__get_queue_id_from_item(SimpleTask.new(:owner_id, :job_id, :task_id, 3)).should eq(:owner_id)
+    end
+    
+    it "calls add_item to add items to owner" do
+      BackgroundQueue::ServerLib::Owner.any_instance.should_receive(:add_item).with(:item)
+      subject.__prv__add_item_to_queue(BackgroundQueue::ServerLib::Owner.new(1, :parent), :item)
+    end
+    
+    it "specifies the owner class as its queue class" do
+      subject.class.queue_class.should eq(BackgroundQueue::ServerLib::Owner)
+    end
+  end
+  
+  context "adding tasks" do
+    context "with no existing task running" do
+      before do
+        thread_manager.should_receive(:signal_access)
+        subject.should_receive(:add_item).with(anything) { :does_not_matter }
+      end
+      
+      it "adds a new task" do
+        BackgroundQueue::ServerLib::TaskRegistry.any_instance.should_receive(:register).with(anything).and_return([:new, nil])
+        subject.add_task(SimpleTask.new(:owner_id, :job_id, :task_id, 3))
+      end
+      
+      it "adds a task with existing id thats not running" do
+        BackgroundQueue::ServerLib::TaskRegistry.any_instance.should_receive(:register).with(anything).and_return([:existing, :existing_task])
+        subject.should_receive(:remove_item).with(:existing_task)
+        subject.add_task(SimpleTask.new(:owner_id, :job_id, :task_id, 3))
+      end
+    end
+    
+    it "adds a task with existing id thats running" do
+      BackgroundQueue::ServerLib::TaskRegistry.any_instance.should_receive(:register).with(anything).and_return([:waiting, nil])
+      subject.should_not_receive(:add_item).with(anything)
+      subject.add_task(SimpleTask.new(:owner_id, :job_id, :task_id, 3))
+    end
+   
+  end
+  
+  context "removing tasks" do
+    it "delegates call to queue_registry" do
+      subject.should_receive(:remove_item).with(anything) { :does_not_matter }
+      subject.remove_task(:task_id)
+    end
+  end
+  
+  context "getting tasks" do
+    
+    it "will wait on condition if queue is empty" do
+      thread_manager.should_receive(:wait_on_access)
+      bg = BackgroundQueue::ServerLib::BalancedQueue.new(server)
+      bg.next_task.should eq(nil)
+    end
+    
+  end
+  
+  context "#save_to_file" do
+    it "will write the tasks as json to file" do
+      subject.stub(:register_job)
+      thread_manager.stub(:signal_access)
+
+      t1 = BackgroundQueue::ServerLib::Task.new(:owner_id, :job_id, :task_id, 1, :worker, {:a=>'b'}, {:c=>'d'})
+      t2 = BackgroundQueue::ServerLib::Task.new(:owner2_id, :job2_id, :task2_id, 2, :worker, {}, {})
+      t3 = BackgroundQueue::ServerLib::Task.new(:owner3_id, :job3_id, :task3_id, 3, :worker, {}, {})
+      subject.add_task(t1)
+      subject.add_task(t2)
+      subject.add_task(t3)
+      sio = StringIO.new
+      subject.save_to_file(sio)
+
+      sio.string.should eq([t1.to_json_object(true),t2.to_json_object(true),t3.to_json_object(true)].to_json)
+    end
+  end
+  
+  context "#load_from_file" do
+    it "will load the tasks as json from file" do
+      subject.stub(:register_job)
+      thread_manager.stub(:signal_access)
+
+      t1 = BackgroundQueue::ServerLib::Task.new(:owner_id, :job_id, :task_id, 1, :worker, {:a=>'b'}, {:c=>'d'})
+      t2 = BackgroundQueue::ServerLib::Task.new(:owner2_id, :job2_id, :task2_id, 2, :worker, {}, {})
+      t3 = BackgroundQueue::ServerLib::Task.new(:owner3_id, :job3_id, :task3_id, 3, :worker, {}, {})
+      
+      sio = StringIO.new([t1.to_json_object(true),t2.to_json_object(true),t3.to_json_object(true)].to_json)
+      subject.load_from_file(sio)
+
+      sio = StringIO.new
+      subject.save_to_file(sio)
+
+      sio.string.should eq([t1.to_json_object(true),t2.to_json_object(true),t3.to_json_object(true)].to_json)
+    end
+  end
+  
+
+end

data/spec/background_queue/server_lib/config_spec.rb

@@ -0,0 +1,443 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'background_queue_server'
+
+unless defined? Rails
+  module Rails; end
+end
+  
+describe "Server Config" do
+
+  context "using map" do
+    context "loading worker entry" do
+      it "creates a worker entry if all required string fields exist" do
+        entry = BackgroundQueue::ServerLib::Config::Worker.new('http://127.0.0.1:801/background_queue')
+        entry.url.should eq('http://127.0.0.1:801/background_queue')
+        entry.uri.port.should eq(801)
+      end
+
+      it "errors if invalid type" do
+        expect { 
+          BackgroundQueue::ServerLib::Config::Worker.new([])
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Invalid data type (Array), expecting String (as a url)"
+        )
+      end
+      
+      it "errors if missing or nil" do
+        expect { 
+          BackgroundQueue::ServerLib::Config::Worker.new(nil)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Missing worker url"
+        )
+      end
+      
+      it "errors if invalid url" do
+        expect { 
+          BackgroundQueue::ServerLib::Config::Worker.new("something:/\\asdf dsafdsfdsaf")
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Invalid worker url (something:/\\asdf dsafdsfdsaf)"
+        )
+      end
+    end
+    
+    context "loading worker entries" do
+      it "creates an array of workers" do
+        entries = BackgroundQueue::ServerLib::Config.__prv__build_worker_entries({:workers=>['http://127.0.0.1:801/background_queue', 'http://127.0.0.1:802/background_queue', 'http://127.0.0.1:803/background_queue']}, :path_that_exists)
+        entries.length.should eq(3)
+        entries.first.uri.port.should eq(801)
+        entries.last.uri.port.should eq(803)
+      end
+      
+      it "errors if failover entry is invalid" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__build_worker_entries({ 'workers'=> ['http://127.0.0.1:801/background_queue','']}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'worker' entry (2) from background queue server configuration file expanded_path: Missing worker url"
+        )
+      end
+    end
+    
+    context "loading secret entry" do
+      it "creates an array of workers" do
+        secret = BackgroundQueue::ServerLib::Config.__prv__get_secret_entry({:secret=>'1234567890123456789012345678901234567890'}, :path_that_exists)
+        secret.should eq('1234567890123456789012345678901234567890')
+      end
+      
+      it "errors if secret is missing" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_secret_entry({}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Missing 'secret' entry in background queue server configuration file expanded_path"
+        )
+      end
+      
+      it "errors if secret is too short" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_secret_entry({:secret=>'1234567890123456789'}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'secret' entry in background queue server configuration file expanded_path: length too short (must be at least 20 characters long)"
+        )
+      end
+    end
+    
+    context "loading listen entry" do
+      it "defaults to 0.0.0.0:#{BackgroundQueue::Config::DEFAULT_PORT} if missing" do
+        entry = BackgroundQueue::ServerLib::Config::Address.new(nil)
+        entry.host.should eq("0.0.0.0")
+        entry.port.should eq(BackgroundQueue::Config::DEFAULT_PORT)
+      end
+      
+      it "defaults to 0.0.0.0 if host missing" do
+        entry = BackgroundQueue::ServerLib::Config::Address.new({:port=>3001})
+        entry.host.should eq("0.0.0.0")
+        entry.port.should eq(3001)
+      end
+      
+      it "defaults to port #{BackgroundQueue::Config::DEFAULT_PORT}" do
+        entry = BackgroundQueue::ServerLib::Config::Address.new({:host=>"127.0.0.1"})
+        entry.host.should eq("127.0.0.1")
+        entry.port.should eq(BackgroundQueue::Config::DEFAULT_PORT)
+      end
+      
+      it "errors if the host is invalid ap address" do
+        expect { BackgroundQueue::ServerLib::Config::Address.new({:host=>"x.y.z"}) }.to raise_exception("Invalid host: x.y.z")
+      end
+      
+      it "errors if the port is an invalid number" do
+        expect { BackgroundQueue::ServerLib::Config::Address.new({:port=>"dsfg"}) }.to raise_exception("Invalid port: dsfg")
+      end
+      
+      it "wraps the configuration file path in errors" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_address_entry({:address=>{:host=>"x.y.z"}}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'address' entry in background queue server configuration file expanded_path: Invalid host: x.y.z"
+        )
+      end
+      
+    end
+    
+    context "#get_connections_per_worker_entry" do
+      it "gets the entry" do
+        entry = BackgroundQueue::ServerLib::Config.__prv__get_connections_per_worker_entry({:connections_per_worker=>10}, :path_that_exists)
+        entry.should eq(10)
+      end
+      
+      it "errors if entry is missing" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_connections_per_worker_entry({}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Missing 'connections_per_worker' entry in background queue server configuration file expanded_path"
+        )
+      end
+      
+      it "errors if entry is not an Integer" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_connections_per_worker_entry({:connections_per_worker=>"abc"}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'connections_per_worker' entry in background queue server configuration file expanded_path: invalid data type (String), expecting Integer"
+        )
+      end
+    end
+    
+    context "#get_system_task_options_entry" do
+      it "gets a hash of options" do
+        opts = BackgroundQueue::ServerLib::Config.__prv__get_system_task_options_entry({:system_task_options=>{:a=>:b}}, :path_that_exists)
+        opts.should eq({:a=>:b})
+      end
+      
+      it "allows no options" do
+        opts = BackgroundQueue::ServerLib::Config.__prv__get_system_task_options_entry({}, :path_that_exists)
+        opts.should eq({})
+      end
+      
+      it "errors if the jobs entry is not a hash" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_system_task_options_entry({:system_task_options=>"abc"}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'system_task_options' entry in background queue server configuration file expanded_path: invalid data type (String), expecting Hash (of options)"
+        )
+      end
+      
+    end
+    
+    
+    context "#get_jobs_entry" do
+      it "gets an array of entries" do
+        BackgroundQueue::ServerLib::Config::Job.should_receive(:new).twice.and_return(:job)
+        jobs = BackgroundQueue::ServerLib::Config.__prv__get_jobs_entry({:jobs=>[:one, :two]}, :path_that_exists)
+        jobs.should eq([:job, :job])
+      end
+      
+      it "allows no jobs" do
+        jobs = BackgroundQueue::ServerLib::Config.__prv__get_jobs_entry({}, :path_that_exists)
+        jobs.should eq([])
+      end
+      
+      it "errors if the jobs entry is not an array" do
+        File.stub(:expand_path) { :expanded_path }
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_jobs_entry({:jobs=>"abc"}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'jobs' entry in background queue server configuration file expanded_path: invalid data type (String), expecting Array (of jobs)"
+        )
+      end
+      
+      it "passes job loading errors on" do
+        File.stub(:expand_path) { :expanded_path }
+        BackgroundQueue::ServerLib::Config::Job.should_receive(:new).and_raise("blah")
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_jobs_entry({:jobs=>[:a]}, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'jobs' entry in background queue server configuration file expanded_path: blah"
+        )
+      end
+    end
+    
+    context "#Job.initialize" do
+      it "will load at" do
+        job = BackgroundQueue::ServerLib::Config::Job.new(:at=>"something", :worker=>:abc)
+        job.type.should eq(:at)
+        job.at.should eq("something")
+      end
+      
+      it "will load in" do
+        job = BackgroundQueue::ServerLib::Config::Job.new(:in=>"something", :worker=>:abc)
+        job.type.should eq(:in)
+        job.in.should eq("something")
+      end
+      
+      it "will load cron" do
+        job = BackgroundQueue::ServerLib::Config::Job.new(:cron=>"something", :worker=>:abc)
+        job.type.should eq(:cron)
+        job.cron.should eq("something")
+      end
+      
+      it "will load the arguments" do
+        job = BackgroundQueue::ServerLib::Config::Job.new(:cron=>"something", :worker=>:abc, :args=>{:a=>:b})
+        job.args.should eq({:a=>:b})
+      end
+      
+      it "will error if timer not designated" do
+        expect { 
+          BackgroundQueue::ServerLib::Config::Job.new(:worker=>:abc)
+        }.to raise_error(
+          "Job is missing timer designation (at, in or cron)"
+        )
+      end
+      
+      it "will error if worker not designated" do
+        expect { 
+          BackgroundQueue::ServerLib::Config::Job.new(:at=>"abc")
+        }.to raise_error(
+          "Job is missing worker entry"
+        )
+      end
+      
+      it "will error if the arguments are not a map" do
+        expect { 
+          BackgroundQueue::ServerLib::Config::Job.new(:at=>"abc", :worker=>:abc, :args=>[])
+        }.to raise_error(
+          "Invalid 'args' entry in job: expecting Hash of arguments, got Array"
+        )
+      end
+      
+    end
+    
+    context "#Job.schedule" do
+      subject {
+        job = BackgroundQueue::ServerLib::Config::Job.new(:at=>"something", :worker=>:abc)
+        job.type = nil
+        job.at = nil
+        job
+      }
+      before do
+        subject.should_receive(:run).with(:server)
+      end
+      
+      let(:scheduler) { double("scheduler") }
+      
+      it "schedules at a time" do
+        subject.type = :at
+        subject.at = :time
+        scheduler.should_receive(:at).with(:time).and_yield
+        subject.schedule(scheduler, :server)
+      end
+      
+      it "schedules in a time" do
+        subject.type = :in
+        subject.in = :time
+        scheduler.should_receive(:in).with(:time).and_yield
+        subject.schedule(scheduler, :server)
+      end
+      
+      it "schedules by a cron time" do
+        subject.type = :cron
+        subject.cron = :time
+        scheduler.should_receive(:cron).with(:time).and_yield
+        subject.schedule(scheduler, :server)
+      end
+      
+      it "schedules every time" do
+        subject.type = :every
+        subject.every = :time
+        scheduler.should_receive(:every).with(:time).and_yield
+        subject.schedule(scheduler, :server)
+      end
+    end
+    
+    context "#Job.run" do
+      it "adds a task to the queue" do
+        job = BackgroundQueue::ServerLib::Config::Job.new(:at=>"something", :worker=>:abc, :args=>{:a=>:b})
+        server = SimpleServer.new(:config=>double("config", :system_task_options=>{}), :task_queue=>double("task_queue"))
+        server.task_queue.should_receive(:add_task)
+        job.run(server)
+      end
+      
+    end
+    
+    context "#get_task_file_entry" do
+      before do
+        File.stub(:expand_path) { :expanded_path }
+      end
+      
+      it "creates a task_file entry if the file exists" do
+        File.should_receive(:exist?).with('path').and_return(true)
+        entry = BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({:task_file=>'path'}, :path)
+        entry.should eq('path')
+      end
+      
+      it "creates a task_file entry if the directory is writable" do
+        File.should_receive(:exist?).with('path').and_return(false)
+        File.should_receive(:dirname).with('path').and_return('dir')
+        File.should_receive(:exist?).with('dir').and_return(true)
+        FileUtils.should_receive(:touch).with('path')
+        FileUtils.should_receive(:rm).with('path')
+        entry = BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({:task_file=>'path'}, :path)
+        entry.should eq('path')
+      end
+      
+      it "creates a task_file entry if the directory can be created" do
+        File.should_receive(:exist?).with('path').and_return(false)
+        File.should_receive(:dirname).with('path').and_return('dir')
+        File.should_receive(:exist?).with('dir').and_return(false)
+        FileUtils.should_receive(:mkdir_p).with('dir')
+        entry = BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({:task_file=>'path'}, :path)
+        entry.should eq('path')
+      end
+      
+      it "errors if the directory can not be created" do
+        File.should_receive(:exist?).with('path').and_return(false)
+        File.should_receive(:dirname).with('path').and_return('dir')
+        File.should_receive(:exist?).with('dir').and_return(false)
+        FileUtils.should_receive(:mkdir_p).with('dir').and_raise("Permission Denied")
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({:task_file=>'path'}, :path)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'task_file' entry in background queue server configuration file expanded_path: unable to create directory dir (Permission Denied)"
+        )
+      end
+      
+      it "errors if the directory can not be written to" do
+        File.should_receive(:exist?).with('path').and_return(false)
+        File.should_receive(:dirname).with('path').and_return('dir')
+        File.should_receive(:exist?).with('dir').and_return(true)
+        FileUtils.should_receive(:touch).with('path').and_raise("Permission Denied")
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({:task_file=>'path'}, :path)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'task_file' entry in background queue server configuration file expanded_path: unable to write to file path (Permission Denied)"
+        )
+      end
+
+      it "errors if invalid type" do
+        expect { 
+          BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({:task_file=>123}, :path)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Error loading 'task_file' entry in background queue server configuration file expanded_path: Invalid data type (Fixnum), expecting String"
+        )
+      end
+      
+      it "allows if missing or nil" do
+        
+        BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({:task_file=>nil}, :path).should eq(nil)
+        BackgroundQueue::ServerLib::Config.__prv__get_task_file_entry({}, :path).should eq(nil)
+        
+      end
+      
+    end
+    
+
+    context "creating Config entry" do
+      before do
+        File.stub(:expand_path) { :expanded_path }
+      end
+      
+      it "should create Config instance" do
+        config = BackgroundQueue::ServerLib::Config.load_hash({
+            :workers=>['http://127.0.0.1:801/background_queue', 'http://127.0.0.1:802/background_queue'],
+            :secret=>'1234567890123456789012345678901234567890',
+            :connections_per_worker=>10,
+            :jobs=>[{:at=>"some time", :worker=>:something}]
+        }, :path_that_exists)
+        config.workers.length.should eq(2)
+        config.workers.first.uri.port.should eq(801)
+        config.workers.last.uri.port.should eq(802)
+        config.jobs.length.should eq(1)
+        config.jobs.first.at.should eq('some time')
+        config.secret.should eq('1234567890123456789012345678901234567890')
+      end
+      
+      it "should fail when missing workers" do
+        expect { 
+          config = BackgroundQueue::ServerLib::Config.load_hash({ }, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Missing 'workers' in background queue server configuration file expanded_path"
+        )
+      end
+      
+      it "should fail when missing secret" do
+        expect { 
+          config = BackgroundQueue::ServerLib::Config.load_hash({ :workers=>['http://127.0.0.1:802/background_queue'] }, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Missing 'secret' entry in background queue server configuration file expanded_path"
+        )
+      end
+      
+      it "should fail when missing connections_per_worker" do
+        expect { 
+          config = BackgroundQueue::ServerLib::Config.load_hash({ :workers=>['http://127.0.0.1:802/background_queue'], :secret=>'1234567890123456789012345678901234567890' }, :path_that_exists)
+        }.to raise_error(
+          BackgroundQueue::LoadError, 
+          "Missing 'connections_per_worker' entry in background queue server configuration file expanded_path"
+        )
+      end
+     
+    end
+  end
+
+end