path: root/spec/models/build_spec.rb

# == Schema Information
#
# Table name: builds
#
#  id          :integer          not null, primary key
#  status      :string(255)
#  finished_at :datetime
#  trace       :text
#  created_at  :datetime
#  updated_at  :datetime
#  started_at  :datetime
#  tmp_file    :string(255)
#  runner_id   :integer
#  commit_id   :integer
#

require 'spec_helper'

describe Build do
  let(:project) { FactoryGirl.create :project }
  let(:commit) { FactoryGirl.create :commit, project: project }
  let(:build) { FactoryGirl.create :build, commit: commit }

  it { should belong_to(:commit) }
  it { should validate_presence_of :status }

  it { should respond_to :success? }
  it { should respond_to :failed? }
  it { should respond_to :running? }
  it { should respond_to :pending? }
  it { should respond_to :trace_html }

  it { should allow_mass_assignment_of(:commit_id) }
  it { should allow_mass_assignment_of(:status) }
  it { should allow_mass_assignment_of(:started_at) }
  it { should allow_mass_assignment_of(:finished_at) }
  it { should allow_mass_assignment_of(:trace) }
  it { should allow_mass_assignment_of(:runner_id) }

  describe :first_pending do
    let(:first) { FactoryGirl.create :build, commit: commit, status: 'pending', created_at: Date.yesterday }
    let(:second) { FactoryGirl.create :build, commit: commit, status: 'pending' }
    before { first; second }
    subject { Build.first_pending }

    it { should be_a(Build) }
    it('returns with the first pending build') { should eq(first) }
  end

  describe :create_from do
    before do
      build.status = 'success'
      build.save
    end
    let(:create_from_build) { Build.create_from build }

    it ('there should be a pending task') do
      Build.pending.count.should eq(0)
      create_from_build
      Build.pending.count.should > 0
    end
  end

  describe :started? do
    subject { build.started? }

    context 'without started_at' do
      before { build.started_at = nil }

      it { should be_false }
    end

    %w(running success failed).each do |status|
      context "if build status is #{status}" do
        before { build.status = status }

        it { should be_true }
      end
    end

    %w(pending canceled).each do |status|
      context "if build status is #{status}" do
        before { build.status = status }

        it { should be_false }
      end
    end
  end

  describe :active? do
    subject { build.active? }

    %w(pending running).each do |state|
      context "if build.status is #{state}" do
        before { build.status = state }

        it { should be_true }
      end
    end

    %w(success failed canceled).each do |state|
      context "if build.status is #{state}" do
        before { build.status = state }

        it { should be_false }
      end
    end
  end

  describe :complete? do
    subject { build.complete? }

    %w(success failed canceled).each do |state|
      context "if build.status is #{state}" do
        before { build.status = state }

        it { should be_true }
      end
    end

    %w(pending running).each do |state|
      context "if build.status is #{state}" do
        before { build.status = state }

        it { should be_false }
      end
    end
  end

  describe :trace do
    subject { build.trace_html }

    it { should be_empty }

    context 'if build.trace contains text' do
      let(:text) { 'example output' }
      before { build.trace = text }

      it { should include(text) }
      it { should have_at_least(text.length).items }
    end
  end

  describe :commands do
    subject { build.commands }

    it { should eq(commit.project.scripts) }
  end

  describe :timeout do
    subject { build.timeout }

    it { should eq(commit.project.timeout) }
  end

  describe :duration do
    subject { build.duration }

    it { should eq(120.0) }

    context 'if the building process has not started yet' do
      before do
        build.started_at = nil
        build.finished_at = nil
      end

      it { should be_nil }
    end

    context 'if the building process has started' do
      before do
        build.started_at = Time.now - 1.minute
        build.finished_at = nil
      end

      it { should be_a(Float) }
      it { should > 0.0 }
    end
  end

  describe :ref do
    subject { build.ref }

    it { should eq(commit.ref) }
  end

  describe :sha do
    subject { build.sha }

    it { should eq(commit.sha) }
  end

  describe :short_sha do
    subject { build.short_sha }

    it { should eq(commit.short_sha) }
  end

  describe :before_sha do
    subject { build.before_sha }

    it { should eq(commit.before_sha) }
  end

  describe :allow_git_fetch do
    subject { build.allow_git_fetch }

    it { should eq(commit.allow_git_fetch) }
  end

  describe :project do
    subject { build.project }

    it { should eq(commit.project) }
  end

  describe :project_id do
    subject { build.project_id }

    it { should eq(commit.project_id) }
  end

  describe :project_name do
    subject { build.project_name }

    it { should eq(commit.project_name) }
  end

  describe :repo_url do
    subject { build.repo_url }

    it { should eq(commit.repo_url) }
  end
end