cukeq 0.0.1.dev

data/spec/cukeq/cukeq_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ do
+  it "identifies this CukeQ instance" do
+    Socket.stub!(:gethostname => "hostname")
+    Etc.stub!(:getlogin => "login")
+
+    CukeQ.identifier.should == "hostname-login"
+  end
+end

data/spec/cukeq/master_spec.rb

@@ -0,0 +1,153 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::Master do
+  def mock_master
+    CukeQ::Master.new(
+      mock("CukeQ::Broker").as_null_object,
+      mock("CukeQ::WebApp").as_null_object,
+      mock("CukeQ::Scm", :working_copy => ".").as_null_object,
+      mock("CukeQ::Reporter").as_null_object,
+      mock("CukeQ::Exploder").as_null_object
+    )
+  end
+
+  def running_master
+    master = mock_master
+    master.broker.stub!(:start).and_yield
+    master.start
+
+    master
+  end
+
+  describe ".configured_instance" do
+    it "sets up defaults if --broker is not given" do
+      master = CukeQ::Master.configured_instance(
+        %w[-s git://example.com -r http://cukereports.com]
+      )
+
+      master.broker.host.should  == 'localhost'
+      master.broker.port.should  == 5672
+      master.broker.user.should  == 'cukeq-master'
+      master.broker.pass.should  == 'cukeq123'
+      master.broker.vhost.should == '/cukeq'
+    end
+
+    it "adds defaults if the --broker argument is incomplete" do
+      master = CukeQ::Master.configured_instance(
+        %w[--broker amqp://otherhost:9000 -s git://example.com -r http://cukereports.com]
+      )
+
+      master.broker.host.should  == 'otherhost'
+      master.broker.port.should  == 9000
+      master.broker.user.should  == 'cukeq-master'
+      master.broker.pass.should  == 'cukeq123'
+      master.broker.vhost.should == '/cukeq'
+    end
+
+    it "sets up defaults if --webapp is not given" do
+      master = CukeQ::Master.configured_instance(
+        %w[-s git://example.com -r http://cukereports.com]
+      )
+
+      master.webapp.uri.host.should == '0.0.0.0'
+      master.webapp.uri.port.should == 9292
+    end
+
+    it "uses the given --webapp" do
+      master = CukeQ::Master.configured_instance(
+        %w[-s git://example.com -r http://cukereports.com -w http://example.com]
+      )
+
+      master.webapp.uri.host.should == 'example.com'
+      master.webapp.uri.port.should == 80
+    end
+  end
+
+  describe ".execute" do
+    it "starts the configured instance" do
+      args   = %w[some args]
+      master = mock_master
+
+      CukeQ::Master.should_receive(:configured_instance).with(args).and_return(master)
+      master.should_receive(:start)
+
+      CukeQ::Master.execute(args)
+    end
+  end
+
+  describe "#start" do
+    it "updates, subscribes to the results queue and runs the webapp" do
+      master = CukeQ::Master.new(mock("CukeQ::Broker"), mock("CukeQ::WebApp"), mock("CukeQ::Scm"), nil, nil)
+
+      master.scm.should_receive(:update).and_yield
+      master.broker.should_receive(:start).and_yield
+      master.should_receive(:subscribe)
+      master.webapp.should_receive(:run)
+
+      master.start
+    end
+  end
+
+  describe "#run" do
+    it "sends the payload to the exploder" do
+      data = { 'features' => ["some.feature:10", "another.feature:12"] }
+      master   = running_master
+
+      master.exploder.should_receive(:explode).with(data['features']).and_return([])
+      master.run(data)
+    end
+
+    it "publishes the exploded scenarios on the jobs queue" do
+      jobs   = %w[job1 job2 job3 job4]
+      master = running_master
+
+      master.exploder.stub!(:explode).and_yield(jobs)
+      master.broker.should_receive(:publish).exactly(4).times
+
+      master.run({})
+    end
+
+    it "adds a run_id and scm info to the job payload" do
+      jobs = ["job1"]
+      master = running_master
+
+      master.exploder.stub!(:explode).and_yield(jobs)
+      master.scm.stub!(:current_revision).and_return("abadbabe")
+      master.scm.stub!(:url).and_return("git://github.com/jarib/cukeq.git")
+
+      master.broker.should_receive(:publish).with do |queue, json|
+        payload = JSON.parse(json)
+
+        payload['scm']['revision'].should == "abadbabe"
+        payload['scm']['url'].should == "git://github.com/jarib/cukeq.git"
+        payload['run']['id'].should == 1
+        payload['run']['no_of_units'].should == 1
+      end
+
+      master.run({'run_id' => 1})
+    end
+  end
+
+  describe "#result" do
+    it "sends the result to the reporter" do
+      result = {:some => 'data'}
+      master = running_master
+      master.reporter.should_receive(:report).with(result)
+
+      master.result(result)
+    end
+  end
+
+  describe "#subscribe" do
+    it "should subscribe to the results queue and process the result" do
+      master = running_master
+      result = '{"some": "result"}'
+
+      master.broker.should_receive(:subscribe).with(:results).and_yield(result)
+      master.should_receive(:result).with("some" => "result")
+
+      master.subscribe
+    end
+  end
+
+end

data/spec/cukeq/reporter_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::Reporter do
+
+  def reporter
+    @reporter ||= CukeQ::Reporter.new(URI.parse("http://example.com/some/path"))
+  end
+
+  it "POSTs results to the given URL" do
+    expected_params = {
+      :host    => "example.com",
+      :port    => 80,
+      :verb    => 'POST',
+      :request => '/some/path',
+      :content => '{"some":"result"}'
+    }
+
+    EM::P::HttpClient.should_receive(:request).with(expected_params)
+    reporter.report("some" => "result")
+  end
+
+  it "catches and logs EM errors" do
+    reporter.should_receive(:log)
+    EM::P::HttpClient.stub!(:request).and_raise(RuntimeError)
+
+    reporter.report(nil)
+  end
+
+end

data/spec/cukeq/runner_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::Runner do
+  it "triggers a run with the files given" do
+    pending
+  end
+
+  it "prints the report URL and run ID" do
+    pending
+  end
+end

data/spec/cukeq/scenario_exploder_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::ScenarioExploder do
+
+  def exploder
+    CukeQ::ScenarioExploder.new
+  end
+
+  it "returns the parsed features" do
+    # our IO.popen call doesn't work well with rspec - probably a race condition since
+    # it only fails on RCR
+    pending
+
+    # units = exploder.explode("features/example1.feature")
+    # units.first.should == {"file" => "features/example1.feature"}
+  end
+end

data/spec/cukeq/scenario_runner_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::ScenarioRunner do
+
+  def runner
+    @runner ||= CukeQ::ScenarioRunner.new
+  end
+
+  it "returns an error if the job is incorrect" do
+    runner.run({}) do |result|
+      result[:success].should be_false
+      result[:error].should_not be_empty
+      result[:backtrace].should_not be_empty
+    end
+  end
+
+  it "creates a configured and updated Scm instance" do
+    job = {'scm' => {'url' => 'git://example.com/foo/bar', 'revision' => 'some-revision'}}
+
+    CukeQ::Scm.should_receive(:new).with(job['scm']['url']).and_return(mock_scm = mock("scm"))
+    mock_scm.should_receive(:current_revision).and_return 'another-revision'
+    mock_scm.should_receive(:update).and_yield
+
+    runner.scm_for(job).should == mock_scm
+  end
+
+  # important.
+  it "executes the given job" do
+    pending
+  end
+
+end

data/spec/cukeq/scm/git_bridge_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe CukeQ::Scm::GitBridge do
+  include FileUtils
+
+  GIT_URL = "git://example.com"
+  WORKING_COPY = "spec-scm-repo"
+
+  after(:each) do
+    rm_rf WORKING_COPY
+  end
+
+  def mock_repo
+    @mock_repo ||= mock("Git::Base").as_null_object
+  end
+
+  def bridge
+    @bridge ||= CukeQ::Scm::GitBridge.new(GIT_URL, WORKING_COPY)
+  end
+
+  it "clones the repo of it doesn't exist" do
+    Git.stub!(:open)
+    Git.should_receive(:clone).with(GIT_URL, WORKING_COPY)
+    bridge.repo
+  end
+
+  it "does not clone the repo if it already exists" do
+    Git.stub!(:open)
+    Git.should_receive(:clone).never
+
+    mkdir WORKING_COPY
+    bridge.repo
+  end
+
+  it "fetches the current revision" do
+    bridge.stub!(:repo).and_return(mock_repo)
+    mock_repo.should_receive(:revparse).with("HEAD").and_return("rev")
+
+    bridge.current_revision.should == "rev"
+  end
+
+  it "updates the working copy" do
+    bridge.stub!(:repo).and_return(mock_repo)
+
+    mock_repo.should_receive(:reset_hard)
+    mock_repo.should_receive(:pull)
+
+    bridge.update {}
+  end
+
+
+end

data/spec/cukeq/scm/svn_bridge_spec.rb

@@ -0,0 +1,5 @@
+# require File.expand_path("../../../spec_helper", __FILE__)
+#
+# describe CukeQ::Scm::SvnBridge do
+#
+# end

data/spec/cukeq/scm_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::Scm do
+
+  def scm(vcs, mock_bridge = false)
+    scm = case vcs
+          when :git
+            CukeQ::Scm.new("git://github.com/jarib/cukeq.git")
+          when :svn
+            CukeQ::Scm.new("svn://example.com/somerepo/trunk")
+          else
+            raise "unknown vcs: #{vcs.inspect}"
+          end
+
+    if mock_bridge
+      scm.instance_variable_set("@bridge", mock("scm-bridge"))
+    end
+
+    scm
+  end
+
+  it "replaces special characters in the working copy dir" do
+    scm(:git).working_copy.should_not =~ /[^A-z_\/.]/
+  end
+
+  it "creates the correct bridge" do
+    scm(:git).bridge.should be_kind_of(CukeQ::Scm::GitBridge)
+    scm(:svn).bridge.should be_kind_of(CukeQ::Scm::SvnBridge)
+  end
+
+  it "understands http urls" do
+    CukeQ::Scm.new("http://github.com/foo/bar.git").bridge.should be_kind_of(CukeQ::Scm::GitBridge)
+    CukeQ::Scm.new("https://svn.example.com/foo/bar").bridge.should be_kind_of(CukeQ::Scm::SvnBridge)
+  end
+
+  it "forwards update() to the bridge" do
+    scm = scm(:git, true)
+    scm.bridge.should_receive(:update).and_yield
+    scm.update {}
+  end
+
+  it "forwards current_revision() to the bridge" do
+    scm = scm(:git, true)
+    scm.bridge.should_receive(:current_revision)
+    scm.current_revision
+  end
+
+end

data/spec/cukeq/slave_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::Slave do
+
+  def mock_slave
+    CukeQ::Slave.new(
+      mock("CukeQ::Broker").as_null_object,
+      mock("CukeQ::ScenarioRunner").as_null_object
+    )
+  end
+
+  def running_slave
+    slave = mock_slave
+    slave.broker.stub!(:start).and_yield
+
+    slave
+  end
+
+  describe ".configured_instance" do
+    it "sets up defaults if --broker is not given" do
+      slave = CukeQ::Slave.configured_instance
+
+      slave.broker.host.should == 'localhost'
+      slave.broker.port.should == 5672
+      slave.broker.user.should == 'cukeq-slave'
+      slave.broker.pass.should == 'cukeq123'
+      slave.broker.vhost.should == '/cukeq'
+    end
+
+    it "adds defaults if the --broker argument is incomplete" do
+      slave = CukeQ::Slave.configured_instance(%w[--broker amqp://otherhost:9000])
+
+      slave.broker.host.should == 'otherhost'
+      slave.broker.port.should == 9000
+      slave.broker.user.should == 'cukeq-slave'
+      slave.broker.pass.should == 'cukeq123'
+      slave.broker.vhost.should == '/cukeq'
+    end
+  end
+
+  describe ".execute" do
+    it "starts the configured instance" do
+      args   = %w[some args]
+      slave = mock_slave
+
+      CukeQ::Slave.should_receive(:configured_instance).with(args).and_return(slave)
+      slave.should_receive(:start)
+
+      CukeQ::Slave.execute(args)
+    end
+  end
+
+  describe "#start" do
+    it "subscribes to the jobs queue" do
+      slave = mock_slave
+      slave.broker.should_receive(:start).and_yield
+      slave.should_receive(:poll)
+
+      slave.start
+    end
+  end
+
+  describe "#job" do
+    it "runs each job with the scenario runner and publishes each result on the results queue" do
+      slave = running_slave
+      job   = {:some => 'job'}
+      result = {:some => 'result'}
+
+      slave.scenario_runner.should_receive(:run).with(job).and_yield(result)
+      slave.should_receive(:publish).with(result)
+
+      slave.job(job)
+    end
+  end
+
+  describe "#publish" do
+    it "it publishes the message on the results queue" do
+      slave = running_slave
+      message = {:run => "some message"}
+
+      slave.broker.should_receive(:publish).with(:results, message.to_json)
+      slave.publish(message)
+    end
+  end
+
+end