Battle specs

battle_spec.rb

require 'spec_helper'

describe Battle do

  context "new" do

    let!(:battle) { Battle.new }
    let!(:events) { [:can_open?, :can_close_no_opponent?, :can_start?, :can_close_no_video?, :can_close_no_videos?, :can_close_no_votes?, :can_close_ex_equo?, :can_close_more_votes?, :can_close?] }

    it "should have default :pending status" do
      battle.current_state.name.should == :pending
    end

    it "should have proper states flow" do
      battle.send(events[0]).should be_true
      battle.send(events[1]).should be_true
      battle.send(events[2]).should be_false
      battle.send(events[3]).should be_false
      battle.send(events[4]).should be_false
      battle.send(events[5]).should be_false
      battle.send(events[6]).should be_false
      battle.send(events[7]).should be_false
      battle.send(events[8]).should be_false

      battle.open!
      battle.send(events[0]).should be_false
      battle.send(events[1]).should be_false
      battle.send(events[2]).should be_true
      battle.send(events[3]).should be_true
      battle.send(events[4]).should be_true
      battle.send(events[5]).should be_false
      battle.send(events[6]).should be_false
      battle.send(events[7]).should be_false
      battle.send(events[8]).should be_false

      battle.start!
      battle.send(events[0]).should be_false
      battle.send(events[1]).should be_false
      battle.send(events[2]).should be_false
      battle.send(events[3]).should be_false
      battle.send(events[4]).should be_false
      battle.send(events[5]).should be_true
      battle.send(events[6]).should be_true
      battle.send(events[7]).should be_true
      battle.send(events[8]).should be_true

    end

  end

  context "validations" do

    let!(:battle) { Battle.new }

    it "should validate the presence of :rule_id, :type_id and :lasts_for" do
      battle.valid?.should be_false

      [:rule_id, :type_id, :lasts_for].each do |attr|
        battle.should have_at_least(1).error_on(attr)
      end
    end

    it "should validate numericality of :lasts_for; Value must be between 1 and 4" do
      battle.should have(2).errors_on(:lasts_for)

      battle.lasts_for = "text"
      battle.should have(1).error_on(:lasts_for)

      battle.lasts_for = 0
      battle.should have(1).error_on(:lasts_for)

      battle.lasts_for = 5
      battle.should have(1).error_on(:lasts_for)

      battle.lasts_for = 1.123313
      battle.lasts_for.should eql 1
      battle.should have(0).errors_on(:lasts_for)

      [1,2,3,4].each do |valid_value|
        battle.lasts_for = valid_value
        battle.should have(0).errors_on(:lasts_for)
      end

    end

  end

  context "scopes" do

    let!(:common) { {:type_id => 1, :rule_id => 1, :lasts_for => 3, :finish_date => 2.days.ago} }
    let!(:states) { ["awaiting_votes", "closed_no_votes", "closed_ex_equo", "closed_more_votes", "closed", "closed_no_video", "closed_no_videos"] }

    pending "#awaiting_videos"

    pending "#awaiting_votes"

    it "#finished should return only battles finished by: no votes / ex equo / more votes / WIN or KO or TKO" do
      Battle.create(common.merge :state => states[0])
      Battle.create(common.merge :state => states[1])
      Battle.create(common.merge :state => states[2])
      Battle.create(common.merge :state => states[3])
      Battle.create(common.merge :state => states[4])
      Battle.create(common.merge :state => states[5])
      Battle.create(common.merge :state => states[6])

      Battle.finished.should have(4).elements
    end

    pending "#pending"

    pending "#closed_dq should return only battles finished by not providing videos (DQ)"

    pending "#closed_no_opponent"

    it "#created_before_2_weeks" do
      @battle1  = Battle.create(common.merge :created_at => 13.days.ago)
      @battle2  = Battle.create(common.merge :created_at => 14.days.ago)
      @battle3  = Battle.create(common.merge :created_at => 15.days.ago)
      Battle.created_before_2_weeks.should have(1).element
      Battle.created_before_2_weeks.should == [@battle3]
    end

    pending "#awaiting_videos_dq"

    pending "#awaiting_votes_to_close"

  end


  context  "custom methods" do

    let!(:today)     { Time.now.utc.to_date }
    let!(:common)    { {:type_id => 1, :rule_id => 1, :lasts_for => 3} }
    let!(:battle)    { Battle.new }


    describe "#formatted_finish_date" do

      it "should return 'not specified' if is nil" do
        battle.formatted_finish_date.should == "not specified"
      end

      it "should return 'today' if battle is starting/finishing today" do
        battle.finish_date = today
        battle.formatted_finish_date.should == "today"
      end

      it "should return dd.mm.yyyy formatted date if battle is not starting/finishing today" do
        battle.finish_date = today.tomorrow
        battle.formatted_finish_date.should =~  /\d{2}.\d{2}.\d{4}/
      end

    end

    it "#hidden_rival? should return true if battle type is hidden rival (type_id == 2)" do
      battle.type_id = 1
      battle.hidden_rival?.should be_false

      battle.type_id = 2
      battle.hidden_rival?.should be_true
    end


    it "#finished? should return bool (if battle is finished by: no votes / ex equo / more votes / WIN or KO or TKO)l" do
      battle.state = "awaiting_votes"
      battle.finished?.should be_false

      battle.state = "closed_no_votes"
      battle.finished?.should be_true

      battle.state = "closed_ex_equo"
      battle.finished?.should be_true

      battle.state = "closed_more_votes"
      battle.finished?.should be_true

      battle.state = "closed"
      battle.finished?.should be_true

      battle.state = "closed_no_video"
      battle.finished?.should be_false

      battle.state = "closed_no_videos"
      battle.finished?.should be_false
    end

    it "#closed? should return bool (if battle is finished by not providing videos (DQ))" do
      battle.state = "awaiting_votes"
      battle.closed?.should be_false

      battle.state = "closed_no_votes"
      battle.closed?.should be_false

      battle.state = "closed_ex_equo"
      battle.closed?.should be_false

      battle.state = "closed_more_votes"
      battle.closed?.should be_false

      battle.state = "closed"
      battle.closed?.should be_false

      battle.state = "closed_no_video"
      battle.closed?.should be_true

      battle.state = "closed_no_videos"
      battle.closed?.should be_true
    end

    let!(:user1) { mock_model(User, :id => 1) }
    let!(:user2) { mock_model(User, :id => 2) }
    let!(:user3) { mock_model(User, :id => 3) }

    it "#participant? should return true if user participate in battle" do
      battle.stub!(:user_ids).and_return([1, 2])

      battle.participant?(user1).should be_true
      battle.participant?(user2).should be_true
      battle.participant?(user3).should be_false
    end

    it "#points should retrieve points cost for create/join" do
      battle.rule_id = 2
      battle.type_id = 1
      points = mock_model(Points, :rule_id => battle.rule_id, :type_id => battle.type_id, :win => 40)
      Points.stub!(:find_by_rule_id_and_type_id).with( battle.rule_id, battle.type.id ).and_return(points)

      battle.points.should eql 40
    end

    it "#compute_votes should return votes in format: [votes_to_player1, votes_to_player2]" do
      vote1  = mock_model(Vote, :vote_to => 1)
      vote2  = mock_model(Vote, :vote_to => 2)
      vote3  = mock_model(Vote, :vote_to => 1)
      battle.stub!(:users).and_return([user1, user2])

      battle.stub!(:votes).and_return([vote1, vote2, vote3])
      battle.compute_votes.should eql([2, 1])

      battle.stub!(:votes).and_return([])
      battle.compute_votes.should eql([0, 0])

      battle.stub!(:votes).and_return([vote1])
      battle.compute_votes.should eql([1, 0])

      battle.stub!(:votes).and_return([vote2])
      battle.compute_votes.should eql([0, 1])
    end

    pending "self#compute_states"

    pending "#update_users_states"

  end

end

# == Schema Information
#
# Table name: battles
#
#  id          :integer(4)      not null, primary key
#  type_id     :integer(4)
#  created_at  :datetime
#  updated_at  :datetime
#  start_date  :date
#  finish_date :date
#  rule_id     :integer(4)
#  lasts_for   :integer(4)
#  state       :string(255)
#