octopusci 0.2.3 → 0.3.0

data/spec/lib/octopusci/job_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Octopusci::Job do
+
+  describe "self.run" do
+    it "when not overridden should raise Ocotpusci::PureVirtualMethod" do
+      class SomeJob < Octopusci::Job; end
+      expect { SomeJob.run(nil) }.to raise_error(Octopusci::PureVirtualMethod)
+    end
+  end
+
+  describe "self.failed!" do
+    it "should create an instance of Octopusci::JobRunFailed with the given message" do
+      excep_bef_mock = Octopusci::JobRunFailed.new("foo bar")
+      Octopusci::JobRunFailed.should_receive(:new).with("a test failure message").and_return(excep_bef_mock)
+      class SomeJob < Octopusci::Job; end
+      begin
+        SomeJob.failed!("a test failure message")
+      rescue Octopusci::JobRunFailed
+      end
+    end
+
+    it "should raise Octopusci::JobRunFailed" do
+      class SomeJob < Octopusci::Job; end
+      expect { SomeJob.failed!("a test failure message") }.to raise_error(Octopusci::JobRunFailed)
+    end
+  end
+
+  describe "self.context" do
+    it "should push context string onto the context stack" do
+      class SomeJob < Octopusci::Job; end
+      SomeJob.stub(:output)
+      SomeJob.stub(:get_recip_email)
+      Octopusci::Notifier.stub_chain(:job_complete, :deliver)
+      SomeJob.context_stack.should_receive(:push).with("commit")
+      SomeJob.context("commit") {}
+    end
+
+    it "should execute the given block" do
+      class SomeJob < Octopusci::Job; end
+      SomeJob.stub(:output)
+      SomeJob.stub(:get_recip_email)
+      Octopusci::Notifier.stub_chain(:job_complete, :deliver)
+      @a = mock('some_inst_var_in_block')
+      @a.should_receive(:foo)
+      SomeJob.context("commit") { @a.foo }
+    end
+
+    it "should pop context string off the context stack" do
+      class SomeJob < Octopusci::Job; end
+      SomeJob.stub(:output)
+      SomeJob.stub(:get_recip_email)
+      Octopusci::Notifier.stub_chain(:job_complete, :deliver)
+      SomeJob.context_stack.should_receive(:pop)
+      SomeJob.context("commit") {}
+    end
+
+    it "should pop context even if an exception is thrown inside the context" do
+      class SomeJob < Octopusci::Job; end
+      class FooExcep < RuntimeError; end
+      SomeJob.stub(:output)
+      SomeJob.stub(:get_recip_email)
+      Octopusci::Notifier.stub_chain(:job_complete, :deliver)
+      SomeJob.context_stack.should_receive(:pop)
+      begin
+        SomeJob.context("commit") { raise FooExcep.new('aoeuaoee') }
+      rescue FooExcep
+      end
+    end
+
+    it "should raise a Octopusci::JobHalted exception if the failed! method is called inside the context" do
+      job_rec = stub('job_record')
+      class SomeJob < Octopusci::Job
+        def self.run(job_rec)
+          context("commit") do
+            failed!("some reason")
+          end
+        end
+      end
+      SomeJob.stub(:write_exception)
+      SomeJob.stub(:output)
+      SomeJob.stub(:get_recip_email)
+      Octopusci::Notifier.stub_chain(:job_complete, :deliver)
+      expect { SomeJob.run(job_rec) }.to raise_error(Octopusci::JobHalted)
+    end
+
+    it "should stop execution from continuing after the failed!" do
+      job_rec = mock('job_record')
+      job_rec.should_receive(:foo)
+      job_rec.should_not_receive(:bar)
+      class SomeJob < Octopusci::Job
+        def self.run(job_rec)
+          context("commit") do
+            job_rec.foo
+            failed!("some failure")
+            job_rec.bar
+          end
+        end
+      end
+      SomeJob.stub(:write_exception)
+      SomeJob.stub(:output)
+      SomeJob.stub(:get_recip_email)
+      Octopusci::Notifier.stub_chain(:job_complete, :deliver)
+      begin
+        SomeJob.run(job_rec)
+      rescue Octopusci::JobHalted
+      end
+    end
+  end
+
+  describe "self.run_shell_cmd" do
+
+  end
+
+  describe "self.log" do
+
+  end
+
+  describe "self.perform" do
+
+  end
+end

data/spec/lib/octopusci/job_store_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Octopusci::JobStore do
+
+  describe "#prepend" do
+    it "should increment the job count" do
+      r = mock('redis').as_null_object
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.should_receive(:incr).with('octopusci:job_count')
+      Octopusci::JobStore.prepend({ "stub_job" => "foo", 'ref' => 'refs/heads/master' })
+    end
+
+    it "should store the job record" do
+      r = mock('redis').as_null_object
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.stub(:incr).and_return(1)
+      Octopusci::JobStore.should_receive(:set).with(1, { "stub_job" => "foo", 'ref' => 'refs/heads/master', 'id' => 1 })
+      Octopusci::JobStore.prepend({ "stub_job" => "foo", 'ref' => 'refs/heads/master' })
+    end
+
+    it "should prepend the job id to the job ids list" do
+      r = mock('redis').as_null_object
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.stub(:incr).and_return(10)
+      r.should_receive(:lpush).with("octopusci:jobs", 10)
+      Octopusci::JobStore.prepend({ "stub_job" => "foo", 'ref' => 'refs/heads/master' })
+    end
+
+    it "should prepend the job id to the project, branch, job ids list" do
+      r = mock('redis').as_null_object
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.stub(:incr).and_return(10)
+      r.should_receive(:lpush).with("octopusci:foo:bar:jobs", 10)
+      Octopusci::JobStore.prepend({ 'repo_name' => 'foo', 'ref' => 'refs/heads/bar' })      
+    end
+
+    it "should return the prepended jobs id" do
+      r = mock('redis').as_null_object
+      r.stub(:incr).and_return(1)
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      Octopusci::JobStore.prepend({ "stub_job" => "foo", 'ref' => 'refs/heads/foo' }).should == 1
+    end
+  end
+
+  describe "#set" do
+    it "should store the passed job record serialized at the proper key" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.should_receive(:set).with("octopusci:jobs:1", YAML.dump({ "stub_job" => "foo"}))
+      Octopusci::JobStore.set(1, { "stub_job" => "foo"})
+    end
+  end
+
+  describe "#get" do
+    it "should get the job record using the proper key" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.should_receive(:get).with("octopusci:jobs:1")
+      Octopusci::JobStore.get(1)
+    end
+  end
+
+  describe "#size" do
+    it "should get the number of jobs in the jobs list" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.should_receive(:llen).with("octopusci:jobs").and_return(8)
+      Octopusci::JobStore.size
+    end
+
+    it "should return the number of jobs in the jobs list" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.stub(:llen).and_return(8)
+      Octopusci::JobStore.size.should == 8
+    end
+  end
+
+  describe "#repo_branch_size" do
+    it "should get the number of jobs in the list for the branch name of the given repository" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.should_receive(:llen).with("octopusci:foo:bar:jobs").and_return(8)
+      Octopusci::JobStore.repo_branch_size("foo", "bar")
+    end
+
+    it "should return the number of jbos in the list for the branch name of the given repository" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      r.should_receive(:llen).with("octopusci:foo:bar:jobs").and_return(8)
+      Octopusci::JobStore.repo_branch_size("foo", "bar").should == 8
+    end
+  end
+
+  describe "#list_job_ids" do
+    it "should return a list of count job ids from the first index given" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      Octopusci::JobStore.stub(:size).and_return(2)
+      r.should_receive(:lrange).with("octopusci:jobs", 0, 1)
+      Octopusci::JobStore.list_job_ids(0, 2)
+    end
+
+    it "should return a list of all job ids from the first index given if count is larger than the start index to the end of the list" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      Octopusci::JobStore.stub(:size).and_return(2)
+      r.should_receive(:lrange).with("octopusci:jobs", 0, 1)
+      Octopusci::JobStore.list_job_ids(0, 3423)
+    end
+  end
+
+  describe "#list_repo_branch_job_ids" do
+    it "should return a list of count job ids from the first index given for the provided repo and branch" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      Octopusci::JobStore.stub(:repo_branch_size).and_return(2)
+      r.should_receive(:lrange).with("octopusci:foo:bar:jobs", 0, 1)
+      Octopusci::JobStore.list_repo_branch_job_ids('foo', 'bar', 0, 2)
+    end
+
+    it "should return a list of all job ids from the first index given if count is larger than the start index to the end of the repositories branch job list" do
+      r = mock('redis')
+      Octopusci::JobStore.stub(:redis).and_return(r)
+      Octopusci::JobStore.stub(:repo_branch_size).and_return(2)
+      r.should_receive(:lrange).with("octopusci:foo:bar:jobs", 0, 1)
+      Octopusci::JobStore.list_repo_branch_job_ids('foo', 'bar', 0, 4232)
+    end
+  end
+
+  describe "#list" do
+    it "should get a list of all the job ids given starting index and a count" do
+      Octopusci::JobStore.stub(:list_job_ids).and_return([1, 2, 3, 4, 5])
+      Octopusci::JobStore.stub(:get).with(1).and_return("foo1")
+      Octopusci::JobStore.stub(:get).with(2).and_return("foo2")
+      Octopusci::JobStore.stub(:get).with(3).and_return("foo3")
+      Octopusci::JobStore.stub(:get).with(4).and_return("foo4")
+      Octopusci::JobStore.stub(:get).with(5).and_return("foo5")
+      Octopusci::JobStore.list(0, 5).should == ["foo1", "foo2", "foo3", "foo4", "foo5"]
+    end
+  end
+
+  describe "#list_repo_branch" do
+    it "should get a list of all the job ids given starting index and a count" do
+      Octopusci::JobStore.stub(:list_repo_branch_job_ids).and_return([1, 2, 3, 4, 5])
+      Octopusci::JobStore.stub(:get).with(1).and_return("foo1")
+      Octopusci::JobStore.stub(:get).with(2).and_return("foo2")
+      Octopusci::JobStore.stub(:get).with(3).and_return("foo3")
+      Octopusci::JobStore.stub(:get).with(4).and_return("foo4")
+      Octopusci::JobStore.stub(:get).with(5).and_return("foo5")
+      Octopusci::JobStore.list_repo_branch("foo", "bar", 0, 5).should == ["foo1", "foo2", "foo3", "foo4", "foo5"]
+    end
+  end
+
+end

data/spec/lib/octopusci/notifier_spec.rb

@@ -8,20 +8,5 @@ describe Octopusci::Notifier do
   end
   
   describe "#job_complete" do
-    it "should send a multi-part email with the text version containing job status" do
-      pending
-      mail = Octopusci::Notifier.job_complete('joe@example.com', 'my output', 'my status').deliver()
-      
-      Octopusci::Notifier.deliveries.size.should == 1
-      mail.parts[0].body.should =~ /my output/
-    end
-    
-    it "should send a multi-part email with the html version containing job status" do
-      pending
-      mail = Octopusci::Notifier.job_complete('joe@example.com', 'my output', 'my status').deliver()
-      
-      Octopusci::Notifier.deliveries.size.should == 1
-      mail.parts[1].body.should =~ /my output/      
-    end
   end
 end

data/spec/lib/octopusci/queue_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe "Octopusci::Queueu" do
+  describe "#enqueue" do
+    it "should prepend the job to the job store if a matching job doesn't already exist" do
+      proj_info = { :some => 'proj_info' }
+      github_payload = { :some => 'github_payload' }
+      @mock_redis.stub(:set)
+      Resque.stub(:push)
+      Octopusci::Helpers.stub(:gh_payload_to_job_attrs).and_return({})
+      Octopusci::Queue.stub(:lismember).and_return(false)
+      Octopusci::JobStore.should_receive(:prepend)
+      Octopusci::Queue.enqueue('SomeTestJobKlass', 'repo-name', 'branch-name', github_payload, proj_info)
+    end
+
+    it "should store the github payload for the job if a matching job doesn't already exist" do
+      r = mock('redis')
+      proj_info = { :some => 'proj_info' }
+      github_payload = { :some => 'github_payload' }
+      Resque.stub(:push)
+      Octopusci::JobStore.stub(:prepend)
+      Octopusci::Queue.stub(:redis).and_return(r)
+      Octopusci::Helpers.stub(:gh_payload_to_job_attrs).and_return({})
+      Octopusci::Queue.stub(:lismember).and_return(false)
+      r.should_receive(:set)
+      Octopusci::Queue.enqueue('SomeTestJobKlass', 'repo-name', 'branch-name', github_payload, proj_info)
+    end
+
+    it "should enque the job in the octopusci Resque queue if a matching job doesn't already exist" do
+      proj_info = { :some => 'proj_info' }
+      github_payload = { :some => 'github_payload' }
+      Octopusci::JobStore.stub(:prepend)
+      @mock_redis.stub(:set)
+      Octopusci::Helpers.stub(:gh_payload_to_job_attrs).and_return({})
+      Octopusci::Queue.stub(:lismember).and_return(false)
+      Resque.should_receive(:push)
+      Octopusci::Queue.enqueue('SomeTestJobKlass', 'repo-name', 'branch-name', github_payload, proj_info)
+    end
+
+    it "should store the github payload if a matching job already exists" do
+      proj_info = { :some => 'proj_info' }
+      github_payload = { :some => 'github_payload' }
+      r = mock('redis')
+      Octopusci::JobStore.stub(:list_repo_branch).and_return([])
+      Octopusci::Queue.stub(:lismember).and_return(true)
+      Octopusci::Queue.stub(:redis).and_return(r)
+      r.should_receive(:set).with(Octopusci::Queue.github_payload_key('repo-name', 'branch-name'), Resque::encode(github_payload))
+      Octopusci::Queue.enqueue('SomeTestJobKlass', 'repo-name', 'branch-name', github_payload, proj_info)
+    end
+
+    it "should get the most recent job for the provided repo and branch combo if a matching job already exists" do
+      proj_info = { :some => 'proj_info' }
+      github_payload = { :some => 'github_payload' }
+      @mock_redis.stub(:set)
+      Octopusci::Queue.stub(:lismember).and_return(true)
+      Octopusci::JobStore.should_receive(:list_repo_branch).with('repo-name', 'branch-name', 0, 1).and_return([])
+      Octopusci::Queue.enqueue('SomeTestJobKlass', 'repo-name', 'branch-name', github_payload, proj_info)      
+    end
+
+    it "should update the job record with the new data from the github payload if a matching job already exists" do
+      proj_info = { :some => 'proj_info' }
+      github_payload = { :some => 'github_payload' }
+      @mock_redis.stub(:set)
+      Octopusci::Queue.stub(:lismember).and_return(true)
+      Octopusci::Helpers.stub(:gh_payload_to_job_attrs).and_return(github_payload)
+      Octopusci::JobStore.stub(:list_repo_branch).and_return([ { 'id' => 23 }.merge(github_payload) ])
+      Octopusci::JobStore.should_receive(:set).with(23, { 'id' => 23 }.merge(github_payload))
+      Octopusci::Queue.enqueue('SomeTestJobKlass', 'repo-name', 'branch-name', github_payload, proj_info)
+    end
+
+  end
+
+  describe "#lismember" do
+    it "should get the size of the provided queue" do
+      @mock_redis.stub(:lrange)
+      Resque.should_receive(:size).with("test:queue").and_return(0)
+      Octopusci::Queue.lismember("test:queue", { :test => 'foo' })
+    end
+
+    it "should get the entire list of queued jobs" do
+      Resque.stub(:size).and_return(2)
+      Resque.should_receive(:peek).with("test:queue", 0, 2)
+      Octopusci::Queue.lismember("test:queue", { :test => 'foo' })
+    end
+
+    it "should return true if the provided item exists in the queue identified by the provided queue name" do
+      Resque.stub(:size).and_return(2)
+      Resque.stub(:peek).and_return([ { :test => 'foo' }, { :hoopty => 'bar' } ])
+      Octopusci::Queue.lismember("test:queue", { :hoopty => 'bar' }).should == true
+    end
+
+    it "should return false if the provided item does NOT exist in the queue identified by the given queue name" do
+      Resque.stub(:size).and_return(2)
+      Resque.stub(:peek).and_return([ { :test => 'foo' }, { :hoopty => 'bar' } ])
+      Octopusci::Queue.lismember("test:queue", { :jack => 'crack' }).should == false
+    end
+  end
+
+  describe "#github_payload" do
+    it "should get the currently stored github_payload for a given repository and branch" do
+      r = mock('redis')
+      r.should_receive(:get).with(Octopusci::Queue.github_payload_key('my-repo', 'my-branch')).and_return({ :my => 'git', :hub => 'payload' })
+      Resque.should_receive(:decode).with({ :my => 'git', :hub => 'payload' })
+      Octopusci::Queue.stub(:redis).and_return(r)
+      Octopusci::Queue.github_payload('my-repo', 'my-branch')
+    end
+
+    it "should return nil if there is no github_payload for a given repository and branch" do
+      r = mock('redis')
+      r.should_receive(:get).with(Octopusci::Queue.github_payload_key('my-repo', 'my-branch')).and_return(nil)
+      Octopusci::Queue.stub(:redis).and_return(r)
+      Octopusci::Queue.github_payload('my-repo', 'my-branch').should be_nil
+    end
+  end
+
+  describe "#github_payload_key" do
+    it "should return the key of where the github payload would be stored for a given repository and branch" do
+      Octopusci::Queue.github_payload_key("jackie-repo", "brown-branch").should == "octopusci:github_payload:jackie-repo:brown-branch"
+    end
+  end
+
+end

data/spec/lib/octopusci/server_spec.rb

@@ -10,6 +10,7 @@ describe "Octopusci::Server" do
     it "should parse the github payload using JSON" do
       parsed_github_payload = Octopusci::Helpers.decode(@github_test_payload)
       Octopusci::Helpers.should_receive(:decode).with(@github_test_payload).and_return(parsed_github_payload)
+      Octopusci::Queue.stub(:enqueue) # stub this out so test doesn't actually enqueue a job
       post '/github-build', :payload => @github_test_payload
     end
     
@@ -22,9 +23,99 @@ describe "Octopusci::Server" do
     it "should enqueue a job if the request is for a managed project" do
       test_proj_info = { 'name' => 'temp_pusc_test', 'owner' => 'cyphactor', 'job_klass' => 'MyTestJob' }
       Octopusci::Helpers.stub(:get_project_info).and_return(test_proj_info)
-      Octopusci::Queue.should_receive(:enqueue).with(test_proj_info['job_klass'], "temp_pusci_test", "master", Octopusci::Helpers.decode(@github_test_payload))
+      Octopusci::Queue.should_receive(:enqueue).with(test_proj_info['job_klass'], "temp_pusci_test", "master", Octopusci::Helpers.decode(@github_test_payload), test_proj_info)
       post '/github-build', :payload => @github_test_payload
       last_response.status.should == 200
     end
   end
+
+  describe "GET /" do
+    it "should get the 20 most recently queued jobs" do
+      Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+      Octopusci::JobStore.should_receive(:list).with(0, 20).and_return([])
+      get '/'
+      last_response.status.should == 200
+    end
+  end
+
+  describe "GET /:repo_name/:branch_name/jobs" do
+    it "should get the 20 most recently queue jobs for the provided repo_name, branch_name combo" do
+      Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+      Octopusci::JobStore.should_receive(:list_repo_branch).with('foo-repo', 'bar-branch', 0, 20).and_return([])
+      get '/foo-repo/bar-branch/jobs'
+      last_response.status.should == 200
+    end
+  end
+
+  describe "job specific" do
+
+    before(:each) do
+      @job_id = "234"
+      @job = { 'id' => @job_id, 'status' => 'pending',
+          'payload' => { 'repository' => { 'url' => 'http://somewhere.com' }, 'pusher' => { 'email' => 'bob@example.com' } },
+          'repo_name' => 'bar', 'branch_name' => 'foo', 'created_at' => Time.now, 'started_at' => Time.now,
+          'ended_at' => Time.now + 1000, 'compare' => 'http://compareurl.com', 'stage' => 'test_a', 'ref' => 'refs/heads/foo' }
+    end
+
+    describe "GET /jobs/:job_id" do
+      it "should get the job specified by :job_id" do
+        Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+        Octopusci::JobStore.should_receive(:get).with(@job_id).and_return(@job)
+        get "/jobs/#{@job_id}"
+        last_response.status.should == 200
+      end
+    end
+
+    describe "GET /jobs/:job_id/output" do
+      it "should get the job specified by :job_id" do
+        Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+        Octopusci::JobStore.should_receive(:get).with(@job_id).and_return(@job)
+        get "/jobs/#{@job_id}/output"
+        last_response.status.should == 200
+      end
+    end
+
+    describe "GET /jobs/:job_id/silent_output" do
+      it "should get the job specified by :job_id" do
+        Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+        Octopusci::JobStore.should_receive(:get).with(@job_id).and_return(@job)
+        get "/jobs/#{@job_id}/silent_output"
+        last_response.status.should == 200
+      end
+
+      it "should return the log output for the job identified by :job_id" do
+        Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+        Octopusci::JobStore.stub(:get).with(@job_id).and_return(@job)
+        Octopusci::IO.any_instance.stub(:read_all_log).and_return("log output")
+        get "/jobs/#{@job_id}/silent_output"
+        last_response.body.should == "log output"
+      end
+    end
+
+    describe "GET /jobs/:job_id/status" do
+      it "should get the job specified by :job_id" do
+        Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+        Octopusci::JobStore.should_receive(:get).with(@job_id).and_return(@job)
+        get "/jobs/#{@job_id}/status"
+        last_response.status.should == 200
+      end
+
+      it "should return the status of the current status of the job identified by :job_id" do
+        Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+        Octopusci::JobStore.stub(:get).with(@job_id).and_return(@job)
+        get "/jobs/#{@job_id}/status"
+        last_response.body.should == "pending"
+      end
+    end
+
+    describe "GET /jobs/:job_id/ajax_summary" do
+      it "should get the job specified by :job_id" do
+        Octopusci::Server.any_instance.stub(:authorized?).and_return(true)
+        Octopusci::JobStore.should_receive(:get).with(@job_id).and_return(@job)
+        get "/jobs/#{@job_id}/ajax_summary"
+        last_response.status.should == 200
+      end
+    end
+    
+  end
 end