spassky 0.1.0

data/spec/spassky/client/test_runner_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+require 'spassky/client/test_runner'
+
+module Spassky::Client
+  describe TestRunner do
+    before do
+      @test_pusher = mock(:test_pusher)
+      @writer = mock(:writer)
+      @writer.stub!(:write_passing)
+      @writer.stub!(:write_failing)
+      Kernel.stub!(:exit)
+      @directory_reader = mock(:directory_reader)
+      @directory_reader.stub!(:read_files).and_return({ "test.html" => "contents" })
+      @test_runner = TestRunner.new(@test_pusher, @writer, @directory_reader)
+    end
+
+    def new_in_progress_test_result
+      test_result = mock :in_progress_test_result
+      test_result.stub!(:status).and_return "in progress"
+      test_result.stub!(:summary).and_return "in progress summary"
+      test_result.stub!(:completed_since).and_return([])
+      test_result
+    end
+
+    def new_passed_test_result
+      test_result = mock :passed_test_result
+      test_result.stub!(:status).and_return "pass"
+      test_result.stub!(:summary).and_return "pass summary"
+      test_result.stub!(:completed_since).and_return([])
+      test_result
+    end
+
+    def new_failed_test_result
+      test_result = mock :failed_test_result
+      test_result.stub!(:status).and_return "fail"
+      test_result.stub!(:summary).and_return "fail summary"
+      test_result.stub!(:completed_since).and_return([])
+      test_result
+    end
+
+    def new_timeout_test_result
+      test_result = mock :timeout_test_result
+      test_result.stub!(:status).and_return "timed out"
+      test_result.stub!(:summary).and_return "timed out summary"
+      test_result.stub!(:completed_since).and_return([])
+      test_result
+    end
+
+    it "reads a test" do
+      @test_pusher.stub!(:push)
+      @directory_reader.should_receive(:read_files).and_return(:file_body)
+      @test_runner.run_tests("foo_test")
+    end
+
+    it "gets the test name from the base name of the pattern and pushes the test" do
+      @test_pusher.should_receive(:push).with({:name => 'foo_test', :contents => { "test.html" => "contents" }.to_json })
+      @test_runner.run_tests("path/to/foo_test")
+    end
+
+    context "timeout" do
+      it 'returns a exit status of 2' do
+        @test_pusher.stub!(:push).and_yield(new_timeout_test_result)
+        Kernel.should_receive(:exit).with(2)
+        @test_runner.run_tests("foo_test")
+      end
+    end
+
+    context "failing test" do
+      before do
+        @test_pusher.stub!(:push).and_yield(new_failed_test_result)
+      end
+
+      it "only writes once" do
+        @writer.should_receive(:write_failing).once
+        @test_runner.run_tests("foo_test")
+      end
+
+      it "writes out an error code" do
+        Kernel.should_receive(:exit).with(1)
+        @test_runner.run_tests("foo_test")
+      end
+    end
+
+    context "passing test" do
+      it "writes passing output" do
+        @test_pusher.stub!(:push).and_yield(new_passed_test_result)
+        @writer.should_receive(:write_passing).with("pass summary")
+        @test_runner.run_tests("foo_test")
+      end
+    end
+
+    context "in progress" do
+      it "writes nothing" do
+        @test_pusher.stub!(:push).and_yield(new_in_progress_test_result)
+        @writer = mock(:writer)
+        @writer.should_not_receive(:write_passing)
+        @writer.should_not_receive(:write_failing)
+        TestRunner.new(@test_pusher, @writer, @directory_reader).run_tests("foo_test")
+      end
+    end
+
+    context "in progress, then passed result yielded" do
+      it "only writes out the summary when the status is not 'in progress'" do
+        in_progress_test_result = new_in_progress_test_result
+        pass_test_result        = new_passed_test_result
+        @test_pusher.stub!(:push).and_yield(in_progress_test_result).and_yield(pass_test_result)
+        @writer.should_receive(:write_passing).with("pass summary").once
+        @test_runner.run_tests("foo_test")
+      end
+    end
+
+    context "in progress twice then passed result yielded" do
+      it "writes the difference between test results on each iteration" do
+        in_progress_one = new_in_progress_test_result
+        in_progress_two = new_in_progress_test_result
+        @test_pusher.stub!(:push).and_yield(in_progress_one).and_yield(in_progress_two)
+
+        in_progress_two.stub!(:completed_since).with(in_progress_one).and_return([
+          mock(:status_one, :status => "pass", :user_agent => "ipad", :test_name => "foo"),
+          mock(:status_one, :status => "fail", :user_agent => "iphone", :test_name => "bar")
+        ])
+
+        @writer.should_receive(:write_passing).with("PASS foo on ipad").once
+        @writer.should_receive(:write_failing).with("FAIL bar on iphone").once
+
+        @test_runner.run_tests("foo bar")
+      end
+    end
+  end
+end

data/spec/spassky/client/writer_spec.rb

@@ -0,0 +1,31 @@
+require 'spassky/client/writer'
+
+module Spassky::Client
+  describe DefaultWriter do
+    it "writes failures in no colour" do
+      output = mock(:output)
+      output.should_receive(:puts).with("hello")
+      DefaultWriter.new(output).write_failing("hello")
+    end
+    
+    it "writes passes in no colour" do
+      output = mock(:output)
+      output.should_receive(:puts).with("hello")
+      DefaultWriter.new(output).write_passing("hello")
+    end
+  end
+  
+  describe ColouredWriter do
+    it "writes failures in red" do
+      output = mock(:output)
+      output.should_receive(:puts).with("\e[31mhello\e[0m")
+      ColouredWriter.new(output).write_failing("hello")
+    end
+    
+    it "writes passes in green" do
+      output = mock(:output)
+      output.should_receive(:puts).with("\e[32mhello\e[0m")
+      ColouredWriter.new(output).write_passing("hello")
+    end
+  end
+end

data/spec/spassky/server/app_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+require 'capybara'
+require 'capybara/dsl'
+require 'rack/test'
+require 'json'
+
+ENV["RACK_ENV"] = "test"
+require 'spassky/server/app'
+
+module Spassky::Server
+  describe App do
+    include Rack::Test::Methods
+
+    before do
+      RandomStringGenerator.stub!(:random_string).and_return("random-string")
+    end
+
+    def app
+      App.new(device_list)
+    end
+
+    let :device_list do
+      mock(:device_list, :update_last_connected => true, :recently_connected_devices => [])
+    end
+
+    describe "GET /device/connect" do
+      it "redirects to a unique URL" do
+        RandomStringGenerator.should_receive(:random_string).and_return("random-string")
+        get "/device/connect"
+        last_response.should be_redirect
+        last_response.location.should == "http://example.org/device/idle/random-string"
+      end
+    end
+
+    describe "GET /device/idle/123" do
+
+      it "tells the device list that the device connected" do
+        device_list.should_receive(:update_last_connected).with("some user agent")
+        header "User-Agent", "some user agent"
+        get "/device/idle/123"
+      end
+
+      context "when there are no tests to run on the connected device" do
+        it "serves HTML page with a meta-refresh tag" do
+          TestRun.stub!(:find_next_to_run_for_user_agent).and_return(nil)
+          RandomStringGenerator.should_receive(:random_string).and_return("next-iteration")
+          get "/device/idle/123"
+          last_response.body.should include("<meta http-equiv=\"refresh\" content=\"1; url='/device/idle/next-iteration'\">")
+        end
+      end
+
+      context "when there is a test to run on the connected device" do
+        it "redirects to /test_runs/:id/run/:random/test_name" do
+          RandomStringGenerator.stub!(:random_string).and_return("a-random-string")
+          test = mock(:test, :contents => "test contents")
+          test.stub!(:id).and_return("the-test-id")
+          test.stub!(:name).and_return("the-test-name")
+          TestRun.stub!(:find_next_to_run_for_user_agent).with("some user agent").and_return(test)
+          header "User-Agent", "some user agent"
+          get '/device/idle/123'
+          last_response.should be_redirect
+          last_response.location.should == 'http://example.org/test_runs/the-test-id/run/a-random-string/the-test-name'
+        end
+      end
+    end
+
+    describe "GET /test_runs/:id/run/:random/assert" do
+      it "saves the test result" do
+        test = mock(:test)
+        TestRun.stub!(:find).with('123').and_return(test)
+        header "User-Agent", "the user agent"
+        test.should_receive(:save_results_for_user_agent).with(:user_agent => "the user agent", :status => "pass")
+        get "/test_runs/123/run/random/assert?status=pass"
+      end
+    end
+
+    describe "GET /test_runs/:id/run/:random/filename" do
+      before do
+        @test_contents = {
+          "test_file.js"        => "some javascript",
+          "fake_test.html.file" => "don't choose this one",
+          "test_name.html"      => "actual test!"
+        }
+      end
+
+      context "file name is a file" do
+        it "returns the specified file" do
+          test = mock(:test, :name => "fake_test.html.file", :contents => @test_contents)
+          TestRun.stub!(:find).with('123').and_return(test)
+          header "User-Agent", "some user agent"
+          get "/test_runs/123/run/random/fake_test.html.file"
+          last_response.body.should include("don't choose this one")
+        end
+      end
+
+      context "file name is not a file" do
+        it "returns the first file that ends with .html" do
+          test = mock(:test, :name => "directory/test_name.html", :contents => @test_contents)
+          TestRun.stub!(:find).with('123').and_return(test)
+          header "User-Agent", "some user agent"
+          get "/test_runs/123/run/random/not_a_file"
+          last_response.body.should include("actual test!")
+        end
+      end
+
+      describe "when the test contents includes a </head> tag" do
+        before do
+          @test_contents["test_name.html"] = "</head>"
+          @test = mock(:test, :name => "test_name", :contents => @test_contents)
+          TestRun.stub!(:find).with('123').and_return(@test)
+        end
+
+        it "adds a meta-refresh tag to the test contents" do
+          RandomStringGenerator.stub!(:random_string).and_return("next-iteration")
+          get "/test_runs/123/run/random/test_name.html"
+          url = "/device/idle/next-iteration"
+          last_response.body.should include("<meta http-equiv=\"refresh\" content=\"1; url='#{url}'\"></head>")
+        end
+
+        it "adds the assert.js script to the head" do
+          File.stub!(:read).and_return("assert.js!")
+          get "/test_runs/123/run/random/test_name.html"
+          last_response.body.should include("<script type=\"text/javascript\">assert.js!</script>")
+        end
+      end
+    end
+
+    describe "POST /test_runs" do
+      before do
+        device_list.stub!(:recently_connected_devices).and_return(["foo", "bar"])
+        @test_run = mock(:test_run)
+        @test_run.stub!(:id).and_return(42)
+        TestRun.stub!(:create).and_return(@test_run)
+        RandomStringGenerator.stub!(:random_string).and_return("number")
+        @test_contents = {"file1" => "file1 contents", "file2" => "file2 contents"}
+      end
+
+      it "creates a test run" do
+        TestRun.should_receive(:create).with(:name => "first-test", :contents => @test_contents, :devices => ["foo", "bar"])
+        post "/test_runs", { :name => "first-test", :contents => @test_contents.to_json }
+      end
+
+      it "redirects to the status page" do
+        post "/test_runs", { :name => "first-test", :contents => @test_contents.to_json}
+        last_response.should be_redirect
+        last_response.location.should =~ /test_runs\/42$/
+      end
+    end
+
+    describe "GET /test_runs/123" do
+      it "returns the status of the test with the id '123'" do
+        test_run = mock(:test_run)
+        test_result = mock(:test_result)
+        test_result.stub!(:to_json).and_return("the test run as json")
+        test_run.stub!(:result).and_return(test_result)
+        test_run.stub!(:update_connected_devices)
+        TestRun.should_receive(:find).with('123').and_return test_run
+        get '/test_runs/123'
+        last_response.body.should == "the test run as json"
+      end
+
+      it "tells the test run which devices are still connected" do
+        test_run = mock(:test_run)
+        test_result = mock(:test_result)
+        test_result.stub!(:to_json).and_return("the test run as json")
+        test_run.stub!(:result).and_return(test_result)
+        TestRun.stub!(:find).with('123').and_return test_run
+        still_connected_devices = ["device1", "device2"]
+        device_list.stub!(:recently_connected_devices).and_return(still_connected_devices)
+        test_run.should_receive(:update_connected_devices).with(still_connected_devices)
+        get '/test_runs/123'
+      end
+    end
+
+  end
+end

data/spec/spassky/server/device_list_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'spassky/server/device_list'
+
+module Spassky::Server
+  describe DeviceList do
+    it "keeps track of when devices last connected" do
+      list = DeviceList.new
+      list.update_last_connected("foo")
+      list.update_last_connected("bar")
+      list.recently_connected_devices.should == ["foo", "bar"]
+    end
+    
+    it "clears all devices" do
+      list = DeviceList.new
+      list.update_last_connected("foo")
+      list.update_last_connected("bar")
+      list.clear
+      list.recently_connected_devices.size.should == 0
+    end
+    
+    it "ignores devices connected more than 3 seconds ago" do
+      list = DeviceList.new
+      now = Time.now
+      Time.stub!(:now).and_return(now - 3)
+      list.update_last_connected("a")
+      Time.stub!(:now).and_return(now - 2)
+      list.update_last_connected("b")
+      Time.stub!(:now).and_return(now)
+      list.recently_connected_devices.should == ["b"]
+    end
+  end
+end

data/spec/spassky/server/random_string_generator_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'spassky/server/random_string_generator'
+
+module Spassky::Server
+  describe RandomStringGenerator do
+    it "returns the current ticks" do
+      now = mock
+      now.stub!(:to_i).and_return(123)
+      Time.stub!(:now).and_return(now)
+      RandomStringGenerator.random_string.should == "123"
+    end
+  end
+end

data/spec/spassky/server/test_run_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'spassky/server/test_run'
+
+module Spassky::Server
+  describe TestRun do
+    before do
+      TestRun.delete_all
+    end
+        
+    it "can be created and retrieved" do
+      created = TestRun.create(:name => "a test", :contents => "the contents")
+      retrieved = TestRun.find(created.id)
+      created.should == retrieved
+    end
+    
+    it "assigns each test run a unique id" do
+      test_run1 = TestRun.create(:name => "test run 1", :contents => "the contents")
+      test_run2 =TestRun.create(:name => "test run 2", :contents => "the contents")
+      test_run1.id.should_not == test_run2.id
+    end
+
+    it "finds a test run by it's id" do
+      first = TestRun.create(:name => "test run 1", :contents => "the contents")
+      second = TestRun.create(:name => "test run 2", :contents => "the contents")
+      TestRun.find(first.id.to_s).should == first
+      TestRun.find(second.id).should == second
+    end
+
+    it "returns the next test to run for each device" do
+      created = TestRun.create(:name => "test", :contents => "contents", :devices => ["x", "y"])
+      TestRun.find_next_to_run_for_user_agent("x").should == created
+      TestRun.find_next_to_run_for_user_agent("y").should == created 
+    end
+    
+    it "only returns a test run per user agent until results are saved" do
+      created = TestRun.create(:name => "another test", :contents => "the contents of the test", :devices => ["user agent 1"])
+      TestRun.find_next_to_run_for_user_agent("user agent 1").should == created
+      TestRun.find_next_to_run_for_user_agent("user agent 1").should == created
+      created.save_results_for_user_agent(:user_agent => "user agent 1", :status => "pass")
+      TestRun.find_next_to_run_for_user_agent("user agent 1").should be_nil
+    end
+    
+    it "returns 'in progress' status per user agent until the results are saved" do
+      created = TestRun.create(:name => "another test", :contents => "the contents of the test")
+      created.result.status.should == 'in progress'
+      created.save_results_for_user_agent(:user_agent => "some user agent", :status => "pass")
+      created.result.status.should == 'pass'
+    end
+    
+    it "returns failed if the saved tests results failed" do
+      created = TestRun.create(:name => "another test", :contents => "the contents of the test")
+      created.save_results_for_user_agent(:user_agent => "another user agent", :status => "fail")
+      created.result.status.should == 'fail'
+    end
+    
+    it "rejects nonsense status" do
+      run = TestRun.create(:name => "another test", :contents => "the contents of the test")
+      lambda {
+        run.save_results_for_user_agent(:user_agent => "another user agent", :status => "wtf?")
+      }.should raise_error("wtf? is not a valid status")
+    end
+    
+    it "creates an in progress test result from the device list" do
+      run = TestRun.create(
+        :name => "another test",
+        :contents => "the contents of the test",
+        :devices => ["device1", "device2"]
+      )
+      run.result.device_statuses.size.should == 2
+      run.result.device_statuses.first.status.should == "in progress"
+      run.result.device_statuses.last.status.should == "in progress"
+    end
+
+    it "updates the status of disconnected devices to 'timed out'" do
+      run = TestRun.create(
+        :name => "another test",
+        :contents => "the contents of the test",
+        :devices => ["device1", "device2"]
+      )
+      run.update_connected_devices(["device1"])
+      run.result.device_statuses.first.status.should == "in progress"
+      run.result.device_statuses.last.status.should == "timed out"
+    end
+    
+    it "does not update the status of disconnected devices that have already passed or failed" do
+      run = TestRun.create(
+        :name => "another test",
+        :contents => "the contents of the test",
+        :devices => ["device1", "device2"]
+      )
+      run.save_results_for_user_agent(:user_agent => "device1", :status => "pass")
+      run.save_results_for_user_agent(:user_agent => "device2", :status => "fail")
+      run.update_connected_devices([])
+      run.result.device_statuses.first.status.should == "pass"
+      run.result.device_statuses.last.status.should == "fail"
+    end
+  end
+end

data/spec/spassky/test_result_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'spassky/test_result'
+
+module Spassky
+  describe TestResult do
+    context "when no devices are connected" do
+      it "is in progress" do
+        TestResult.new([]).status.should == "in progress"
+      end
+    end
+    
+    context "when one device passes" do
+      it "outputs a summary" do
+        test_result = TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'pass', 'test')
+        ])
+        test_result.summary.should == "1 test passed on 1 device"
+      end
+    end
+
+    context "when all devices pass" do
+      it "is a pass" do
+        TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'pass', 'test'),
+          Spassky::DeviceTestStatus.new('agent2', 'pass', 'test')
+        ]).status.should == "pass"
+      end
+      
+      it "outputs a pluralised summary" do
+        test_result = TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'pass', 'test'),
+          Spassky::DeviceTestStatus.new('agent2', 'pass', 'test')
+        ])
+        test_result.summary.should == "1 test passed on 2 devices"
+      end
+    end
+    
+    context "when any device fails" do
+      it "is a fail" do
+        TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'pass', 'test'),
+          Spassky::DeviceTestStatus.new('agent2', 'fail', 'test')
+        ]).status.should == "fail"
+      end
+      
+      it "outputs a summary" do
+        test_result = TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'fail', 'test')
+        ])
+        test_result.summary.should == "1 test failed on 1 device"
+      end
+    end
+    
+    context "when any test is still in progress" do
+      it "is a fail" do
+        TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'pass', 'test'),
+          Spassky::DeviceTestStatus.new('agent2', 'fail', 'test'),
+          Spassky::DeviceTestStatus.new('agent3', 'in progress', 'test')
+        ]).status.should == "in progress"
+      end
+    end
+    
+    context "when 1 test times out" do
+      it "outputs the correct summary" do
+        test_result = TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'timed out', 'test')
+        ])
+        test_result.summary.should == "1 test timed out on 1 device"
+      end
+      
+      it "has the status 'timed out'" do
+        test_result = TestResult.new([
+          Spassky::DeviceTestStatus.new('agent1', 'timed out', 'test'),
+          Spassky::DeviceTestStatus.new('agent2', 'pass', 'test')
+        ])
+        test_result.status.should == "timed out"
+      end
+    end
+    
+    it "can be serialized and deserialized" do
+      test_result = TestResult.new([Spassky::DeviceTestStatus.new('agent', 'pass', 'test')])
+      json = test_result.to_json
+      deserialized = TestResult.from_json(json)
+      deserialized.device_statuses.size.should == 1
+      deserialized.device_statuses.first.user_agent.should == 'agent'
+      deserialized.device_statuses.first.status.should == 'pass'      
+    end
+    
+    describe "#completed_since(nil)" do
+      it "returns all device test results that are not in progress" do
+        status_1 = Spassky::DeviceTestStatus.new('agent', 'pass', 'test1')
+        status_2 = Spassky::DeviceTestStatus.new('agent', 'in progress', 'test2')
+        status_3 = Spassky::DeviceTestStatus.new('agent', 'fail', 'test3')
+        test_result = TestResult.new([status_1, status_2, status_3])
+        test_result.completed_since(nil).should == [status_1, status_3]
+      end
+    end
+    
+    describe "#completed_since(other_test_result)" do
+      it "returns all device test results that are no longer in progress" do
+        status_a1 = Spassky::DeviceTestStatus.new('agent', 'pass', 'test1')
+        status_a2 = Spassky::DeviceTestStatus.new('agent', 'in progress', 'test2')
+        status_a3 = Spassky::DeviceTestStatus.new('agent', 'in progress', 'test3')
+        status_b1 = Spassky::DeviceTestStatus.new('agent', 'pass', 'test1')
+        status_b2 = Spassky::DeviceTestStatus.new('agent', 'fail', 'test2')
+        status_b3 = Spassky::DeviceTestStatus.new('agent', 'timed out', 'test3')
+        
+        test_result_before = TestResult.new([status_a1, status_a2, status_a3])
+        test_result_after  = TestResult.new([status_b1, status_b2, status_b3])
+        
+        test_result_after.completed_since(test_result_before).should == [status_b2, status_b3]
+      end
+    end    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.dirname(__FILE__))
+require 'spassky'