rearview 1.0.0-jruby

data/spec/models/job_error_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+describe Rearview::JobError do
+
+  let(:dashboard) { create(:dashboard) }
+  let(:job) { create(:job,:dashboard => dashboard) }
+  let(:alert_handler) { mock }
+  let(:event_data) { {:monitor_results=>{:x=>:y}} }
+
+  describe 'factory' do
+    it 'should be valid' do
+      expect { FactoryGirl.create(:job_error) }.not_to raise_error
+      expect( FactoryGirl.create(:job_error).valid? ).to be_true
+    end
+  end
+
+  describe 'validations' do
+    it { should validate_presence_of(:job_id) }
+    it { should ensure_inclusion_of(:status).in_array(Rearview::JobError::Status.values) }
+  end
+
+  describe 'create_alert' do
+    it "should sends alerts through the alerts handler" do
+      Rearview::AlertsHandler.expects(:new).with(job,event_data[:monitor_results]).returns(alert_handler)
+      alert_handler.expects(:run).once
+      job_error = create(:job_error,:job=>job)
+      job_error.expects(:save!).once
+      job_error.expects(:last_alerted_at=).once
+      job_error.event_data = event_data
+      job_error.create_alert(nil)
+    end
+  end
+
+  describe 'update_alert' do
+    it "should sends alerts when last_alerted_at is empty" do
+      Rearview::AlertsHandler.expects(:new).with(job,event_data[:monitor_results]).returns(alert_handler)
+      alert_handler.expects(:run).once
+      job_error = create(:job_error,:job=>job)
+      job_error.expects(:save!).once
+      job_error.expects(:last_alerted_at=).once
+      job_error.event_data = event_data
+      job_error.update_alert(nil)
+    end
+    it "should sends alerts when the last_alerted_at is past the error timeout" do
+      Rearview::AlertsHandler.expects(:new).with(job,event_data[:monitor_results]).returns(alert_handler)
+      alert_handler.expects(:run).once
+      job_error = create(:job_error,:job=>job,:last_alerted_at=>1.day.ago)
+      job_error.expects(:save!).once
+      job_error.expects(:last_alerted_at=).once
+      job_error.event_data = event_data
+      job_error.update_alert(nil)
+    end
+    it "should not send alerts when the last_alerted_at is not past the error timeout" do
+      Rearview::AlertsHandler.expects(:new).with(job,event_data[:monitor_results]).never
+      alert_handler.expects(:run).never
+      job_error = create(:job_error,:job=>job,:last_alerted_at=>1.minutes.ago)
+      job_error.expects(:save!).never
+      job_error.expects(:last_alerted_at=).never
+      job_error.event_data = event_data
+      job_error.update_alert(nil)
+    end
+  end
+
+  describe 'last_error' do
+    it "should return the last error" do
+      job_error = create(:job_error,:job=>job,:created_at=>1.day.ago,:status=>Rearview::JobError::Status::FAILED)
+      last_error = Rearview::JobError.last_error(job.id)
+      expect(last_error).to eq(job_error)
+    end
+    it "shouldn't return non-errors" do
+      job_error = create(:job_error,:job=>job,:created_at=>1.day.ago,:status=>Rearview::JobError::Status::SUCCESS)
+      last_error = Rearview::JobError.last_error(job.id)
+      expect(last_error).to be_nil
+    end
+  end
+
+  describe 'latest_entry' do
+    it "should return the latest entry" do
+      je1 = create(:job_error,:job=>job,:created_at=>1.day.ago,:status=>Rearview::JobError::Status::FAILED)
+      je2 = create(:job_error,:job=>job,:created_at=>2.day.ago,:status=>Rearview::JobError::Status::FAILED)
+      expect(Rearview::JobError.latest_entry(job)).to eq(je1)
+    end
+  end
+
+  describe 'application_errors' do
+    before do
+      create(:job_error,:job=>job,:created_at=>1.day.ago,:status=>Rearview::JobError::Status::SUCCESS)
+      create(:job_error,:job=>job,:created_at=>1.day.ago,:status=>Rearview::JobError::Status::FAILED)
+      create(:job_error,:job=>job,:created_at=>1.day.ago,:status=>Rearview::JobError::Status::ERROR)
+      create(:job_error,:job=>job,:created_at=>1.day.ago,:status=>Rearview::JobError::Status::GRAPHITE_ERROR)
+    end
+    it "should include errors for the application" do
+      errors = Rearview::JobError.application_errors(dashboard.id)
+      expect(errors.size).to eq(4)
+    end
+  end
+
+  describe 'search' do
+    before do
+      Timecop.freeze(Time.now)
+      create(:job_error,:job=>job,:created_at=>1.day.ago)
+      create(:job_error,:job=>job,:created_at=>2.day.ago)
+      create(:job_error,:job=>job,:created_at=>3.day.ago)
+      create(:job_error,:job=>job,:created_at=>4.day.ago)
+      create(:job_error,:job=>job,:created_at=>5.day.ago)
+      create(:job_error,:job=>job,:created_at=>6.day.ago)
+      create(:job_error,:job=>job,:created_at=>7.day.ago)
+    end
+    after do
+      Timecop.return
+    end
+    it "should default order by created descending" do
+      job_errors = Rearview::JobError.search(:id=>job.id)
+      expect(job_errors.first.created_at.to_i).to eq(1.day.ago.to_i)
+    end
+    it "should filter by limit" do
+      job_errors = Rearview::JobError.search(:id=>job.id,:limit=>3)
+      expect(job_errors.size).to eq(3)
+    end
+    it "should filter by limit and offset" do
+      job_errors = Rearview::JobError.search(:id=>job.id,:limit=>3,:offset=>1)
+      expect(job_errors.size).to eq(3)
+      expect(job_errors.first.created_at.to_i).to eq(2.day.ago.to_i)
+    end
+    it "should filter by start_date of created" do
+      job_errors = Rearview::JobError.search(:id=>job.id,:start_date=>2.day.ago)
+      expect(job_errors.size).to eq(2)
+      expect(job_errors.first.created_at.to_i).to eq(2.day.ago.to_i)
+      expect(job_errors.last.created_at.to_i).to eq(1.day.ago.to_i)
+    end
+    it "should filter by end_date of created" do
+      job_errors = Rearview::JobError.search(:id=>job.id,:end_date=>6.day.ago)
+      expect(job_errors.size).to eq(2)
+      expect(job_errors.first.created_at.to_i).to eq(7.day.ago.to_i)
+      expect(job_errors.last.created_at.to_i).to eq(6.day.ago.to_i)
+    end
+    it "should filter by start_date and end_date of created" do
+      job_errors = Rearview::JobError.search(:id=>job.id,:start_date=>5.day.ago, :end_date=>1.day.ago)
+      expect(job_errors.size).to eq(5)
+      expect(job_errors.first.created_at.to_i).to eq(5.day.ago.to_i)
+      expect(job_errors.last.created_at.to_i).to eq(1.day.ago.to_i)
+    end
+  end
+
+  describe 'calculate_durations' do
+
+    before do
+      Timecop.freeze(Time.now)
+    end
+
+    after do
+      Timecop.return
+    end
+
+    context 'timeline' do
+      def create_timeline(*args)
+        offset = args.count
+        args.map do |status_sym|
+          status = case status_sym
+                   when :s
+                     Rearview::JobError::Status::SUCCESS
+                   when :e
+                     Rearview::JobError::Status::ERROR
+                   else
+                     nil
+                   end
+          job_error = create(:job_error,:job=>job,:status=>status,:created_at=>Time.now - offset.minute)
+          offset -= 1
+          job_error
+        end
+      end
+      it 'is empty' do
+        expect { Rearview::JobError.calculate_durations([]) }.not_to raise_error
+      end
+      it 'is {success}' do
+        timeline = create_timeline(:s)
+        Rearview::JobError.calculate_durations(timeline)
+        expect(timeline.first.end_date).to be_nil
+      end
+      it 'is {error}' do
+        timeline = create_timeline(:e)
+        Rearview::JobError.calculate_durations(timeline)
+        expect(timeline.first.end_date).to be_nil
+      end
+      it 'is {error,success}' do
+        timeline = create_timeline(:e,:s)
+        Rearview::JobError.calculate_durations(timeline)
+        expect(timeline.first.end_date).to eq(timeline.last.created_at.utc.to_i)
+        expect(timeline.last.end_date).to be_nil
+      end
+      it 'is {success,error}' do
+        timeline = create_timeline(:s,:e)
+        Rearview::JobError.calculate_durations(timeline)
+        expect(timeline.first.end_date).to be_nil
+        expect(timeline.last.end_date).to be_nil
+      end
+      it 'is {success,error,success}' do
+        timeline = create_timeline(:s,:e,:s)
+        Rearview::JobError.calculate_durations(timeline)
+        expect(timeline[0].end_date).to be_nil
+        expect(timeline[1].end_date).to eq(timeline.last.created_at.utc.to_i)
+        expect(timeline[2].end_date).to be_nil
+      end
+      it 'returns results with success entries filtered out' do
+        timeline = create_timeline(:s,:e,:e,:s)
+        results = Rearview::JobError.calculate_durations(timeline)
+        expect(results.size).to eq(2)
+        expect(results.map(&:status)).not_to include(Rearview::JobError::Status::SUCCESS)
+      end
+    end
+
+  end
+end
+

data/spec/models/job_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Rearview::Job do
+
+  describe 'factory' do
+    it 'should be valid' do
+      expect { FactoryGirl.create(:job) }.not_to raise_error
+      expect( FactoryGirl.create(:job).valid? ).to be_true
+    end
+  end
+
+  describe 'validations' do
+    it { should validate_presence_of(:cron_expr) }
+    it { should validate_presence_of(:name) }
+    it { should validate_presence_of(:metrics) }
+    it { should validate_presence_of(:app_id) }
+    it { should_not allow_value('abc').for(:cron_expr) }
+    it { should allow_value('0 * * * * ?').for(:cron_expr) }
+    it { should ensure_inclusion_of(:status).in_array(Rearview::Job::Status.values) }
+    describe 'alert_keys' do
+      let(:job) { create(:job) }
+      it "should require a valid URI" do
+        keys = ["htptptptpt://not_a_uri"]
+        job.alert_keys=keys
+        expect(job.valid?).to be_false
+        expect(job.errors[:alert_keys]).to include("invalid URI")
+      end
+      it "should require it to be one of the supported schemes" do
+        keys = ["http://www.google.com"]
+        job.alert_keys=keys
+        expect(job.valid?).to be_false
+        expect(job.errors[:alert_keys]).to include("unsupported scheme")
+      end
+      it "should validate the scheme against the corresponding alert" do
+        keys = ["pagerduty:10101010101010101010101010101010","mailto:first.last@hungrymachine.com","campfire://first.last@hungrymachine.com?token=123&room=text"]
+        job.alert_keys=keys
+        expect(job.valid?).to be_true
+      end
+      it "should detect an invalid pagerduty URI" do
+        keys = ["pagerduty:abcdefg"]
+        job.alert_keys=keys
+        expect(job.valid?).to be_false
+        expect(job.errors[:alert_keys]).to include("pagerduty URI is invalid")
+      end
+      it "should detect an invalid mail URI" do
+        keys = ["mailto:abcdefg"]
+        job.alert_keys=keys
+        expect(job.valid?).to be_false
+        expect(job.errors[:alert_keys]).to include("mailto URI is invalid")
+      end
+      it "should detect an invalid campfire URI" do
+        keys = ["campfire://first.last@hungrymachine.com"]
+        job.alert_keys=keys
+        expect(job.valid?).to be_false
+        expect(job.errors[:alert_keys]).to include("campfire URI is invalid")
+      end
+    end
+  end
+  describe 'reset' do
+    it "should reset the job" do
+      job = create(:job,:status=>Rearview::Job::Status::SUCCESS)
+      job_data = create(:job_data,:job=>job)
+      create(:job_error,:job=>job)
+      create(:job_error,:job=>job,:status=>Rearview::JobError::Status::SUCCESS)
+      job.expects(:schedule)
+      job.expects(:unschedule)
+      job.reset
+      expect(job.status).to be_nil
+      expect(job.job_data).to be_nil
+      expect(job.job_errors.size).to eq(0)
+    end
+    it "should not reschedule the job if it is not active" do
+      job = create(:job,:status=>Rearview::Job::Status::SUCCESS,:active=>0)
+      job_data = create(:job_data,:job=>job)
+      create(:job_error,:job=>job)
+      create(:job_error,:job=>job,:status=>Rearview::JobError::Status::SUCCESS)
+      job.expects(:schedule).never
+      job.expects(:unschedule).never
+      job.reset
+      expect(job.status).to be_nil
+      expect(job.job_data).to be_nil
+      expect(job.job_errors.size).to eq(0)
+    end
+  end
+  describe 'destroy' do
+    it "should unschedule the job" do
+      job = create(:job)
+      monitor_service = mock
+      Rearview.stubs(:monitor_service).returns(monitor_service)
+      monitor_service.expects(:unschedule).with(job)
+      job.destroy
+    end
+  end
+  describe 'schedulable' do
+    it "should only return jobs eligible for scheduling" do
+      j1 = create(:job,:active=>false)
+      j2 = create(:job,:active=>true)
+      schedulable = Rearview::Job.schedulable
+      expect(schedulable.count).to eq(1)
+      expect(schedulable.first).to eq(j2)
+    end
+  end
+  describe 'schedule' do
+    let(:monitor_service) { mock }
+    let(:job) { create(:job) }
+    it "should invoke the monitoring service to schedule the job" do
+      Rearview.stubs(:monitor_service).returns(monitor_service)
+      monitor_service.expects(:schedule).with(job)
+      job.schedule
+    end
+  end
+  describe 'unschedule' do
+    let(:monitor_service) { mock }
+    let(:job) { create(:job) }
+    it "should invoke the monitoring service to unschedule the job" do
+      Rearview.stubs(:monitor_service).returns(monitor_service)
+      monitor_service.expects(:unschedule).with(job)
+      job.unschedule
+    end
+  end
+  describe 'sync_monitor_service' do
+    let(:monitor_service) { mock }
+    it "should schedule an active job" do
+      Rearview.stubs(:monitor_service).returns(monitor_service)
+      active_job = create(:job,:active=>true)
+      monitor_service.expects(:schedule).with(active_job)
+      active_job.sync_monitor_service
+    end
+    it "should unschedule an inactive job" do
+      Rearview.stubs(:monitor_service).returns(monitor_service)
+      inactive_job = create(:job,:active=>false)
+      monitor_service.expects(:unschedule).with(inactive_job)
+      inactive_job.sync_monitor_service
+    end
+  end
+  context 'event' do
+    def mock_creation_event(job,event)
+      event_data = {:job_error=>{:message=>"foo"},:monitor_results=>{:x=>:y}}
+      job_errors = mock
+      job_error = mock
+      job_error.expects(:fire_event).with(event,event_data)
+      job_errors.expects(:create).with(any_parameters).returns(job_error)
+      job.expects(:job_errors).returns(job_errors)
+      { :job_error=>job_error, :job_errors=>job_errors, :event_data=>event_data }
+    end
+    def mock_update_event(job,event)
+      event_data = {:job_error=>{:message=>"foo"},:monitor_results=>{:x=>:y}}
+      job_error = mock
+      job_error.expects(:fire_event).with(event,event_data)
+      Rearview::JobError.expects(:latest_entry).with(job).returns(job_error)
+      { :job_error=>job_error, :event_data=>event_data }
+    end
+    context 'error' do
+      it "from nil to error creates associated event" do
+        job = create(:job,:status=>nil)
+        objects = mock_creation_event(job,:error)
+        job.fire_event(:error,objects[:event_data])
+      end
+      it "from success to error creates associated event" do
+        job = create(:job,:status=>"success")
+        objects = mock_creation_event(job,:error)
+        job.fire_event(:error,objects[:event_data])
+      end
+      it "from error to error updates associated event" do
+        job = create(:job,:status=>"error")
+        objects = mock_update_event(job,:error)
+        job.fire_event(:error,objects[:event_data])
+      end
+    end
+    context 'success' do
+      it "from nil to success creates associated event" do
+        job = create(:job,:status=>nil)
+        objects = mock_creation_event(job,:success)
+        job.fire_event(:success,objects[:event_data])
+      end
+      it "from error to success creates associated event" do
+        job = create(:job,:status=>"error")
+        objects = mock_creation_event(job,:success)
+        job.fire_event(:success,objects[:event_data])
+      end
+      it "from success to success updates associated event" do
+        job = create(:job,:status=>"success")
+        objects = mock_update_event(job,:success)
+        job.fire_event(:success,objects[:event_data])
+      end
+    end
+  end
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Rearview::User do
+  describe 'factory' do
+    it 'should be valid' do
+      expect { FactoryGirl.create(:user) }.not_to raise_error
+      expect( FactoryGirl.create(:user).valid? ).to be_true
+    end
+  end
+  describe 'validations' do
+    # let!(:first_user) { FactoryGirl.build(:user) }
+    # pending { should validate_presence_of(:email) }
+    # pending { should validate_uniqueness_of(:email) }
+    # pending { should_not allow_value("this is not an email address").for(:email) }
+    # pending("requires a hungrymachine.com email address") { should_not allow_value("user@example.com").for(:email) }
+    # pending { should allow_value("example@hungrymachine.com").for(:email) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path("../dummy/config/environment.rb", __FILE__)
+require 'rspec/rails'
+require 'rspec/autorun'
+require 'mocha/setup'
+require 'factory_girl_rails'
+require 'shoulda'
+require 'timecop'
+
+Rails.backtrace_cleaner.remove_silencers!
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+Rearview.configure do |config|
+  config.logger = Rails.logger
+  config.sandbox_dir = Rails.root + "sandbox"
+  config.sandbox_exec = ["rvm-exec","ruby-1.9.3-p448@rearview-sandbox","ruby"]
+  config.sandbox_timeout = 10
+  config.preload_jobs = false
+  config.enable_monitor = false
+end
+
+Rearview.boot!
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+  config.order = "random"
+  config.include FactoryGirl::Syntax::Methods
+end
+

data/spec/support/authentication_helper.rb

@@ -0,0 +1,14 @@
+module AuthenticationHelper
+
+  def sign_in_as(user)
+    controller.stubs(:user_signed_in?).returns(true)
+    controller.stubs(:current_user).returns(user)
+    controller.stubs(:authenticate_user!).returns(true)
+    session[:user_id] = user.id
+  end
+
+end
+
+RSpec.configure do |config|
+  config.include AuthenticationHelper, :type => :controller
+end

data/spec/support/json_factory.rb

@@ -0,0 +1,73 @@
+
+module JsonFactory
+
+  module Utils
+    class << self
+      def apply_attributes(json,ar,*attribs)
+        attribs.inject(json) { |a,v| a[v.to_s.camelize(:lower)] = ar.attributes[v.to_s] ; a }
+        self
+      end
+      def apply_defaults(json,ar=nil)
+        json["format"] = :json
+        self
+      end
+    end
+  end
+
+  module User
+    class << self
+      def update(job)
+        json = {}.tap do |json|
+          JsonFactory::Utils.apply_defaults(json)
+          json["preferences"] = { "pref1" => "val1", "pref2" => "val2" }
+        end
+        yield json if block_given?
+        json
+      end
+    end
+  end
+
+  module Monitor
+    class << self
+      def create
+        {}.tap do |json|
+          json["metrics"] = "blah.blah.blah"
+          json["format"] = :json
+          json["monitorExpr"] = "abc"
+          json["minutes"] = 1
+          json["toDate"] = "now"
+        end
+      end
+    end
+  end
+
+  module Job
+    class << self
+      def create(job)
+        {}.tap do |json|
+          JsonFactory::Utils.apply_attributes(json,job,:user_id,:name,:active,:alert_keys,:cron_expr,:error_timeout,:minutes,:metrics,:monitor_expr,:to_date,:description).apply_defaults(json,job)
+          json["dashboard_id"] = job.app_id
+          yield json if block_given?
+        end
+      end
+      def update(job)
+        json = self.create(job)
+        json["id"] = job.id
+        yield json if block_given?
+        json
+      end
+    end
+  end
+
+  module Dashboard
+    class << self
+      def create(dashboard)
+        {}.tap do |json|
+          JsonFactory::Utils.apply_attributes(json,dashboard,:user_id,:name).apply_defaults(json,dashboard)
+          yield json if block_given?
+        end
+      end
+    end
+  end
+
+end

data/spec/views/dashboards/index.json.jbuilder_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "rearview/dashboards/index" do
+  let(:dashboards) {
+    [ create(:dashboard), create(:dashboard) ]
+  }
+  it "renders dashboards json" do
+    assign(:dashboards,dashboards)
+    render :template => "rearview/dashboards/index", :formats => :json, :handler => :jbuilder
+    json = JSON.parse(rendered)
+    expect(json).to be_a_kind_of(Array)
+    expect(json.size).to eq(2)
+  end
+  context "renders json with the correct enclosing type when there is no data" do
+    it "when nil" do
+      assign(:dashboards,nil)
+      render :template => "rearview/dashboards/index", :formats => :json, :handler => :jbuilder
+      json = JSON.parse(rendered)
+      expect(json).to be_a_kind_of(Array)
+      expect(json).to be_empty
+    end
+    it "when empty" do
+      assign(:dashboards,[])
+      render :template => "rearview/dashboards/index", :formats => :json, :handler => :jbuilder
+      json = JSON.parse(rendered)
+      expect(json).to be_a_kind_of(Array)
+      expect(json).to be_empty
+    end
+  end
+end
+

data/spec/views/dashboards/show.json.jbuilder_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "rearview/dashboards/show" do
+  let(:dashboard) {
+    create(:dashboard)
+  }
+  let(:dashboard_keys) {
+    ["id",
+     "userId",
+     "name",
+     "createdAt",
+     "modifiedAt",
+     "description",
+     "children"]
+  }
+  it "renders dashboard json" do
+    assign(:dashboard,dashboard)
+    render :template => "rearview/dashboards/show", :formats => :json, :handler => :jbuilder
+    json = JSON.parse(rendered)
+    expect(json).to be_a_kind_of(Hash)
+    dashboard_keys.each { |k| expect(json).to include(k) }
+    expect(json.keys.size).to eq(dashboard_keys.size)
+  end
+end
+

data/spec/views/jobs/data.json.jbuilder_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "rearview/jobs/data" do
+  let(:job_data) { create(:job_data) }
+  let(:job_data_keys) {
+    ["status",
+     "output",
+     "graph_data"]
+  }
+  it "render json" do
+    assign(:job_data,create(:job_data))
+    render :template => "rearview/jobs/data", :formats => :json, :handler => :jbuilder
+    json = JSON.parse(rendered)
+    expect(json).to be_a_kind_of(Hash)
+    job_data_keys.each { |k| expect(json).to include(k) }
+    expect(json.keys.size).to eq(job_data_keys.size)
+    expect(json["graph_data"]).to be_a_kind_of(Hash)
+  end
+  it "render json with the correct enclosing type when there is no data" do
+    assign(:job_data,nil)
+    render :template => "rearview/jobs/data", :formats => :json, :handler => :jbuilder
+    json = JSON.parse(rendered)
+    expect(json).to be_a_kind_of(Hash)
+    expect(json).to be_empty
+  end
+end
+

data/spec/views/jobs/errors.json.jbuilder_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "rearview/jobs/errors" do
+  let(:job_errors) {
+    [ create(:job_error), create(:job_error) ]
+  }
+  let(:job_errors_keys) {
+    ["id",
+     "jobId",
+     "status",
+     "message",
+     "endDate",
+     "date"]
+  }
+  it "renders jobs errors json" do
+    assign(:job_errors,job_errors)
+    render :template => "rearview/jobs/errors", :formats => :json, :handler => :jbuilder
+    json = JSON.parse(rendered)
+    expect(json).to be_a_kind_of(Array)
+    expect(json.size).to eq(2)
+    job_errors_keys.each { |k| expect(json[0]).to include(k) }
+    expect(json[0].keys.size).to eq(job_errors_keys.size)
+  end
+  context "renders json with the correct enclosing type when there is no data" do
+    it "when nil" do
+      assign(:job_errors,nil)
+      render :template => "rearview/jobs/errors", :formats => :json, :handler => :jbuilder
+      json = JSON.parse(rendered)
+      expect(json).to be_a_kind_of(Array)
+      expect(json).to be_empty
+    end
+    it "when empty" do
+      assign(:job_errors,[])
+      render :template => "rearview/jobs/errors", :formats => :json, :handler => :jbuilder
+      json = JSON.parse(rendered)
+      expect(json).to be_a_kind_of(Array)
+      expect(json).to be_empty
+    end
+  end
+end
+