mirror of
https://github.com/openSUSE/osem.git
synced 2026-08-13 19:54:02 +00:00
553 lines
24 KiB
Ruby
553 lines
24 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'spec_helper'
|
|
|
|
describe Track do
|
|
subject { create(:track) }
|
|
let(:track) { create(:track) }
|
|
let(:self_organized_track) { create(:track, :self_organized) }
|
|
|
|
describe 'association' do
|
|
it { is_expected.to belong_to(:program) }
|
|
it { is_expected.to belong_to(:submitter).class_name('User') }
|
|
it { is_expected.to belong_to(:room) }
|
|
it { is_expected.to belong_to(:selected_schedule).class_name('Schedule') }
|
|
it { is_expected.to have_many(:events) }
|
|
it { is_expected.to have_many(:schedules) }
|
|
end
|
|
|
|
describe 'validation' do
|
|
it { is_expected.to validate_presence_of(:name) }
|
|
it { is_expected.to allow_value('#ABCDEF').for(:color) }
|
|
it { is_expected.to allow_value('#124689').for(:color) }
|
|
it { is_expected.to validate_presence_of(:short_name) }
|
|
it { is_expected.to allow_value('My_track_name').for(:short_name) }
|
|
it { is_expected.to_not allow_value('My track name').for(:short_name) }
|
|
# there is a bug: https://github.com/thoughtbot/shoulda-matchers/issues/814
|
|
# it { is_expected.to validate_uniqueness_of(:short_name).ignoring_case_sensitivity.scoped_to(:program) }
|
|
it { is_expected.to validate_presence_of(:state) }
|
|
it { is_expected.to validate_inclusion_of(:state).in_array(%w[new to_accept accepted confirmed to_reject rejected canceled withdrawn]) }
|
|
it { is_expected.to validate_inclusion_of(:cfp_active).in_array([true, false]) }
|
|
|
|
context 'when self_organized_and_accepted_or_confirmed? returns true' do
|
|
before :each do
|
|
allow(subject).to receive(:self_organized_and_accepted_or_confirmed?).and_return(true)
|
|
end
|
|
|
|
it { is_expected.to validate_presence_of(:start_date) }
|
|
it { is_expected.to validate_presence_of(:end_date) }
|
|
it { is_expected.to validate_presence_of(:room) }
|
|
end
|
|
|
|
context 'when self_organized_and_accepted_or_confirmed? returns false' do
|
|
before :each do
|
|
allow(subject).to receive(:self_organized_and_accepted_or_confirmed?).and_return(false)
|
|
end
|
|
|
|
it { is_expected.to_not validate_presence_of(:start_date) }
|
|
it { is_expected.to_not validate_presence_of(:end_date) }
|
|
it { is_expected.to_not validate_presence_of(:room) }
|
|
end
|
|
|
|
context 'when self_organized? returns true' do
|
|
before :each do
|
|
allow(subject).to receive(:self_organized?).and_return(true)
|
|
end
|
|
|
|
it { is_expected.to validate_presence_of(:relevance) }
|
|
it { is_expected.to validate_presence_of(:description) }
|
|
end
|
|
|
|
context 'when self_organized? returns false' do
|
|
before :each do
|
|
allow(subject).to receive(:self_organized?).and_return(false)
|
|
end
|
|
|
|
it { is_expected.to_not validate_presence_of(:relevance) }
|
|
it { is_expected.to_not validate_presence_of(:description) }
|
|
end
|
|
|
|
describe '#dates_within_conference_dates' do
|
|
before :each do
|
|
@conference = create(:conference, start_date: 1.day.ago, end_date: 2.days.from_now)
|
|
end
|
|
|
|
context 'is valid' do
|
|
it 'when the track\'s dates are between the conference\'s dates' do
|
|
track = build(:track, start_date: @conference.start_date, end_date: @conference.end_date, program: @conference.program)
|
|
expect(track.valid?).to eq true
|
|
end
|
|
end
|
|
|
|
context 'is invalid' do
|
|
it 'when the track\'s start date is before the conference\'s start date' do
|
|
track = build(:track, start_date: 2.days.ago, end_date: Date.tomorrow, program: @conference.program)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:start_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
|
|
end
|
|
|
|
it 'when the track\'s start date is after the conference\'s end date' do
|
|
track = build(:track, start_date: 3.days.from_now, end_date: 4.days.from_now, program: @conference.program)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:start_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
|
|
end
|
|
|
|
it 'when the track\'s end date is before the conference\'s start date' do
|
|
track = build(:track, start_date: 3.days.ago, end_date: 2.days.ago, program: @conference.program)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:end_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
|
|
end
|
|
|
|
it 'when the track\'s end date is after the conference\'s end date' do
|
|
track = build(:track, start_date: Date.today, end_date: 3.days.from_now, program: @conference.program)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:end_date]).to eq ["can't be outside of the conference's dates (#{1.day.ago.to_date}-#{2.days.from_now.to_date})"]
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#start_date_before_end_date' do
|
|
before :each do
|
|
@conference = create(:conference, start_date: 1.day.ago, end_date: 2.days.from_now)
|
|
end
|
|
|
|
context 'is valid' do
|
|
it 'when the track\'s start date is before its end date' do
|
|
track = build(:track, start_date: Date.today, end_date: Date.tomorrow, program: @conference.program)
|
|
expect(track.valid?).to eq true
|
|
end
|
|
end
|
|
|
|
context 'is invalid' do
|
|
it 'when the track\'s start date is after it\'s end date' do
|
|
track = build(:track, start_date: 1.day.from_now, end_date: 1.day.ago)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:start_date]).to eq ['can\'t be after the end date']
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#valid_room' do
|
|
before :each do
|
|
@conference = create(:conference)
|
|
@conference.venue = create(:venue, name: 'The venue')
|
|
end
|
|
|
|
context 'is valid' do
|
|
it 'when the track\'s room belongs to the venue of the conference' do
|
|
room = create(:room, venue: @conference.venue)
|
|
track = build(:track, :self_organized, state: 'accepted', program: @conference.program, room: room)
|
|
expect(track.valid?).to eq true
|
|
end
|
|
end
|
|
|
|
context 'is invalid' do
|
|
it 'when the track\'s room doesn\'t belong to the venue of the track\'s conference' do
|
|
other_conference = create(:conference)
|
|
other_conference.venue = create(:venue)
|
|
room = create(:room, venue: other_conference.venue)
|
|
track = build(:track, :self_organized, state: 'accepted', program: @conference.program, room: room)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:room]).to eq ['must be a room of The venue']
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#overlapping' do
|
|
before :each do
|
|
@conference = create(:conference, start_date: Date.current - 1.day, end_date: Date.current + 2.days)
|
|
@conference.venue = create(:venue)
|
|
@room = create(:room, venue: @conference.venue)
|
|
end
|
|
|
|
context 'is valid' do
|
|
it 'when the tracks are in different rooms at the same time' do
|
|
other_room = create(:room, venue: @conference.venue)
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: other_room, start_date: Date.current, end_date: Date.current)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
|
|
expect(track.valid?).to eq true
|
|
end
|
|
|
|
it 'when it ends before the other tracks in the same room' do
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current - 1.day, end_date: Date.current - 1.day)
|
|
expect(track.valid?).to eq true
|
|
end
|
|
|
|
it 'when it starts after the other tracks in the same room' do
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current + 1.day, end_date: Date.current + 1.day)
|
|
expect(track.valid?).to eq true
|
|
end
|
|
end
|
|
|
|
context 'is invalid' do
|
|
it 'when it starts and/or ends with another track in the same room' do
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
|
|
end
|
|
|
|
it 'when it starts before another track and ends after the other starts and before it ends' do
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current + 2.days)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current - 1.day, end_date: Date.current + 1.day)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
|
|
end
|
|
|
|
it 'when it starts after another track and before it ends and ends after the other' do
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current + 2.days)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current + 1.day, end_date: Date.current + 3.days)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
|
|
end
|
|
|
|
it 'when it starts after another track and ends before the other' do
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current + 2.days)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current + 1.day, end_date: Date.current + 1.day)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
|
|
end
|
|
|
|
it 'when it starts before another track and ends after the other' do
|
|
create(:track, :self_organized, state: 'confirmed', program: @conference.program, room: @room, start_date: Date.current, end_date: Date.current)
|
|
track = build(:track, :self_organized, program: @conference.program, room: @room, start_date: Date.current - 1.day, end_date: Date.current + 1.day)
|
|
expect(track.valid?).to eq false
|
|
expect(track.errors[:track]).to eq ['has overlapping dates with a confirmed or accepted track in the same room']
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'scope' do
|
|
describe '#accepted' do
|
|
before :each do
|
|
@program = create(:program)
|
|
end
|
|
|
|
context 'includes' do
|
|
it 'when track is accepted' do
|
|
accepted_track = create(:track, state: 'accepted', program: @program)
|
|
expect(@program.tracks.accepted.include?(accepted_track)).to eq true
|
|
end
|
|
end
|
|
|
|
context 'excludes' do
|
|
%w[new to_accept confirmed to_reject rejected canceled withdrawn].each do |state|
|
|
it "when track is #{state.humanize}" do
|
|
not_accepted_track = create(:track, state: state, program: @program)
|
|
expect(@program.tracks.accepted.include?(not_accepted_track)).to eq false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#confirmed' do
|
|
before :each do
|
|
@program = create(:program)
|
|
end
|
|
|
|
context 'includes' do
|
|
it 'tracks with state \'confirmed\'' do
|
|
confirmed_track = create(:track, state: 'confirmed', program: @program)
|
|
expect(@program.tracks.confirmed.include?(confirmed_track)).to eq true
|
|
end
|
|
end
|
|
|
|
context 'excludes' do
|
|
%w[new to_accept accepted to_reject rejected canceled withdrawn].each do |state|
|
|
it "tracks with state '#{state}'" do
|
|
unconfirmed_track = create(:track, state: state, program: @program)
|
|
expect(@program.tracks.confirmed.include?(unconfirmed_track)).to eq false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#cfp_active' do
|
|
before :each do
|
|
@program = create(:program)
|
|
@cfp_active_track = create(:track, cfp_active: true, program: @program)
|
|
@non_cfp_active_track = create(:track, cfp_active: false, program: @program)
|
|
end
|
|
|
|
it 'include tracks with the cfp_active flag enabled' do
|
|
expect(@program.tracks.cfp_active.include?(@cfp_active_track)).to eq true
|
|
end
|
|
|
|
it 'excludes tracks with the cfp_active flag disabled' do
|
|
expect(@program.tracks.cfp_active.include?(@non_cfp_active_track)).to eq false
|
|
end
|
|
end
|
|
|
|
describe '#self_organized' do
|
|
before :each do
|
|
@program = create(:program)
|
|
track.program = @program
|
|
track.save!
|
|
self_organized_track.program = @program
|
|
self_organized_track.save!
|
|
end
|
|
|
|
it 'includes self-organized tracks' do
|
|
expect(@program.tracks.self_organized.include?(self_organized_track)).to eq true
|
|
end
|
|
|
|
it 'excludes regular tracks' do
|
|
expect(@program.tracks.self_organized.include?(track)).to eq false
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#self_organized?' do
|
|
it 'returns true when it has a submitter' do
|
|
expect(self_organized_track.submitter).to be_a User
|
|
expect(self_organized_track.self_organized?).to eq true
|
|
end
|
|
|
|
it 'returns false when it doesn\'t have a submitter' do
|
|
expect(track.submitter).to eq nil
|
|
expect(track.self_organized?).to eq false
|
|
end
|
|
end
|
|
|
|
describe '#transition_possible?' do
|
|
shared_examples 'transition_possible?' do |state, transition, expected|
|
|
it "returns #{expected} for #{transition} event, when the track's state is #{state}}" do
|
|
my_self_organized_track = create(:track, :self_organized, state: state)
|
|
expect(my_self_organized_track.transition_possible?(transition.to_sym)).to eq expected
|
|
end
|
|
end
|
|
|
|
states = [:new, :to_accept, :accepted, :confirmed, :to_reject, :rejected, :canceled, :withdrawn]
|
|
transitions = [:restart, :to_accept, :accept, :confirm, :to_reject, :reject, :cancel, :withdraw]
|
|
|
|
states_transitions = { new: { restart: false, to_accept: true, accept: true, confirm: false, to_reject: true, reject: true, cancel: false, withdraw: true },
|
|
to_accept: { restart: false, to_accept: false, accept: true, confirm: false, to_reject: true, reject: false, cancel: true, withdraw: true },
|
|
accepted: { restart: false, to_accept: false, accept: false, confirm: true, to_reject: false, reject: false, cancel: true, withdraw: true },
|
|
confirmed: { restart: false, to_accept: false, accept: false, confirm: false, to_reject: false, reject: false, cancel: true, withdraw: true },
|
|
to_reject: { restart: false, to_accept: true, accept: false, confirm: false, to_reject: false, reject: true, cancel: true, withdraw: true },
|
|
rejected: { restart: true, to_accept: false, accept: false, confirm: false, to_reject: false, reject: false, cancel: false, withdraw: false },
|
|
canceled: { restart: true, to_accept: false, accept: false, confirm: false, to_reject: false, reject: false, cancel: false, withdraw: false },
|
|
withdrawn: { restart: true, to_accept: false, accept: false, confirm: false, to_reject: false, reject: false, cancel: false, withdraw: false } }
|
|
|
|
states.each do |state|
|
|
transitions.each do |transition|
|
|
it_behaves_like 'transition_possible?', state, transition, states_transitions[state.to_sym][transition.to_sym]
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#assign_role_to_submitter' do
|
|
before :each do
|
|
Role.where(name: 'track_organizer', resource: self_organized_track).first_or_create
|
|
@submitter = self_organized_track.submitter
|
|
end
|
|
|
|
it 'gives the role of the track organizer to the submitter of the track' do
|
|
expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq false
|
|
self_organized_track.assign_role_to_submitter
|
|
expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq true
|
|
end
|
|
|
|
it 'is executed when the track is confirmed' do
|
|
self_organized_track.state = 'accepted'
|
|
self_organized_track.save!
|
|
expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq false
|
|
self_organized_track.confirm
|
|
expect(@submitter.has_cached_role?(:track_organizer, self_organized_track)).to eq true
|
|
end
|
|
end
|
|
|
|
describe '#revoke_role_and_cleanup' do
|
|
before :each do
|
|
Role.where(name: 'track_organizer', resource: self_organized_track).first_or_create
|
|
@a_track_organizer = create(:user)
|
|
self_organized_track.state = 'confirmed'
|
|
self_organized_track.cfp_active = true
|
|
self_organized_track.save!
|
|
@a_track_organizer.add_role 'track_organizer', self_organized_track
|
|
@event_of_self_organized_track = create(:event, program: self_organized_track.program, track: self_organized_track, state: 'confirmed')
|
|
@schedule_of_self_organized_track = create(:schedule, program: self_organized_track.program, track: self_organized_track)
|
|
end
|
|
|
|
it 'revokes the role of the track organizer' do
|
|
expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq true
|
|
self_organized_track.revoke_role_and_cleanup
|
|
@a_track_organizer.reload
|
|
expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq false
|
|
end
|
|
|
|
it 'destroys the track\'s schedules' do
|
|
expect(Schedule.find(@schedule_of_self_organized_track.id)).to eq @schedule_of_self_organized_track
|
|
self_organized_track.revoke_role_and_cleanup
|
|
expect(Schedule.find_by(id: @schedule_of_self_organized_track.id)).to eq nil
|
|
end
|
|
|
|
it 'removes the track from the events that have it set' do
|
|
expect(@event_of_self_organized_track.track).to eq self_organized_track
|
|
self_organized_track.revoke_role_and_cleanup
|
|
@event_of_self_organized_track.reload
|
|
expect(@event_of_self_organized_track.track).to eq nil
|
|
end
|
|
|
|
it 'sets the state of the track\'s events to new' do
|
|
expect(@event_of_self_organized_track.state).to eq 'confirmed'
|
|
self_organized_track.revoke_role_and_cleanup
|
|
@event_of_self_organized_track.reload
|
|
expect(@event_of_self_organized_track.state).to eq 'new'
|
|
end
|
|
|
|
it 'is executed when the track is canceled' do
|
|
self_organized_track.state = 'confirmed'
|
|
self_organized_track.save!
|
|
self_organized_track.cancel
|
|
@a_track_organizer.reload
|
|
expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq false
|
|
@event_of_self_organized_track.reload
|
|
expect(@event_of_self_organized_track.track).to eq nil
|
|
end
|
|
|
|
it 'is executed when the track is withdrawn' do
|
|
self_organized_track.withdraw
|
|
@a_track_organizer.reload
|
|
expect(@a_track_organizer.has_cached_role?(:track_organizer, self_organized_track)).to eq false
|
|
@event_of_self_organized_track.reload
|
|
expect(@event_of_self_organized_track.track).to eq nil
|
|
end
|
|
end
|
|
|
|
describe '#accepted?' do
|
|
context 'returns true' do
|
|
it 'when the state is "accepted"' do
|
|
self_organized_track.state = 'accepted'
|
|
self_organized_track.save!
|
|
expect(self_organized_track.accepted?).to eq true
|
|
end
|
|
end
|
|
|
|
context 'returns false' do
|
|
%w[new to_accept confirmed to_reject rejected canceled withdrawn].each do |state|
|
|
it "when the state is \"#{state}\"" do
|
|
self_organized_track.state = state
|
|
self_organized_track.save!
|
|
expect(self_organized_track.accepted?).to eq false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#confirmed?' do
|
|
context 'returns true' do
|
|
it 'when the state is "confirmed"' do
|
|
self_organized_track.state = 'confirmed'
|
|
self_organized_track.save!
|
|
expect(self_organized_track.confirmed?).to eq true
|
|
end
|
|
end
|
|
|
|
context 'returns false' do
|
|
%w[new to_accept accepted to_reject rejected canceled withdrawn].each do |state|
|
|
it "when the state is \"#{state}\"" do
|
|
self_organized_track.state = state
|
|
self_organized_track.save!
|
|
expect(self_organized_track.confirmed?).to eq false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# accepted? and confirmed? are mutually exclusive (they can't be both true)
|
|
describe '#self_organized_and_accepted_or_confirmed?' do
|
|
context 'returns true' do
|
|
context 'when self_organized? returns true' do
|
|
before :each do
|
|
allow(track).to receive(:self_organized?).and_return(true)
|
|
end
|
|
|
|
context 'accepted? returns true and confirmed? returns false' do
|
|
before :each do
|
|
allow(track).to receive(:accepted?).and_return(true)
|
|
allow(track).to receive(:confirmed?).and_return(false)
|
|
end
|
|
|
|
it { expect(track.self_organized_and_accepted_or_confirmed?).to eq true }
|
|
end
|
|
|
|
context 'accepted? returns false and confirmed? returns true' do
|
|
before :each do
|
|
allow(track).to receive(:accepted?).and_return(false)
|
|
allow(track).to receive(:confirmed?).and_return(true)
|
|
end
|
|
|
|
it { expect(track.self_organized_and_accepted_or_confirmed?).to eq true }
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'returns false' do
|
|
context 'when self_organized? returns true' do
|
|
before :each do
|
|
allow(track).to receive(:self_organized?).and_return(true)
|
|
end
|
|
|
|
context 'accepted? returns false and confirmed? returns false' do
|
|
before :each do
|
|
allow(track).to receive(:accepted?).and_return(false)
|
|
allow(track).to receive(:confirmed?).and_return(false)
|
|
end
|
|
|
|
it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
|
|
end
|
|
end
|
|
|
|
context 'when self_organized? returns false' do
|
|
before :each do
|
|
allow(track).to receive(:self_organized?).and_return(false)
|
|
end
|
|
|
|
context 'accepted? returns false and confirmed? returns false' do
|
|
before :each do
|
|
allow(track).to receive(:accepted?).and_return(false)
|
|
allow(track).to receive(:confirmed?).and_return(false)
|
|
end
|
|
|
|
it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
|
|
end
|
|
|
|
context 'accepted? returns true and confirmed? returns false' do
|
|
before :each do
|
|
allow(track).to receive(:accepted?).and_return(true)
|
|
allow(track).to receive(:confirmed?).and_return(false)
|
|
end
|
|
|
|
it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
|
|
end
|
|
|
|
context 'accepted? returns false and confirmed? returns true' do
|
|
before :each do
|
|
allow(track).to receive(:accepted?).and_return(false)
|
|
allow(track).to receive(:confirmed?).and_return(true)
|
|
end
|
|
|
|
it { expect(track.self_organized_and_accepted_or_confirmed?).to eq false }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe '#create_organizer_role' do
|
|
it 'creates the role of the track organizer' do
|
|
expect(Role.find_by(name: 'track_organizer', resource: self_organized_track)).to eq nil
|
|
self_organized_track.send(:create_organizer_role)
|
|
expect(Role.find_by(name: 'track_organizer', resource: self_organized_track).description).to eq 'For the organizers of the Track'
|
|
end
|
|
|
|
it 'is executed when the track is accepted' do
|
|
expect(Role.find_by(name: 'track_organizer', resource: self_organized_track)).to eq nil
|
|
self_organized_track.accept
|
|
expect(Role.find_by(name: 'track_organizer', resource: self_organized_track).description).to eq 'For the organizers of the Track'
|
|
end
|
|
end
|
|
end
|