Merge branch 'master' into org-name-in-conf

spec/controllers/admin/booths_controller_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Admin::BoothsController do
+
+  let(:admin) { create(:admin) }
+  let(:conference) { create(:conference) }
+  let(:booth) { create(:booth, title: 'Title', conference: conference) }
+  let(:admin) { create(:admin) }
+
+  context 'not logged in user' do
+
+    describe 'GET index' do
+      it 'does not render admin/booths#index' do
+        get :index, conference_id: conference.short_title
+        expect(response).to redirect_to(user_session_path)
+      end
+    end
+
+    describe 'GET show' do
+      it 'does not render admin/booths#show' do
+        get :show, id: booth.id, conference_id: conference.short_title
+        expect(response).to redirect_to(user_session_path)
+      end
+    end
+  end
+
+  context 'user is admin' do
+    before :each do
+      sign_in admin
+    end
+
+    describe 'GET index' do
+      before { get :index, conference_id: conference.short_title }
+
+      it 'assigns attributes for booths' do
+        expect(assigns(:booths)).to eq([booth])
+      end
+
+      it 'renders index template' do
+        expect(response).to render_template('index')
+      end
+    end
+
+    describe 'GET new' do
+      before { get :new, conference_id: conference.short_title }
+
+      it 'assigns attributes for booths' do
+        expect(assigns(:booth)).to be_a_new(Booth)
+      end
+
+      it 'renders new template' do
+        expect(response).to render_template('new')
+      end
+    end
+
+    describe 'POST #create' do
+      context 'successfully created' do
+        before { post :create, booth: attributes_for(:booth), conference_id: conference.short_title }
+
+        it 'creates a new booth' do
+          expected = expect do
+            post :create, booth: attributes_for(:booth), conference_id: conference.short_title
+          end
+          expected.to change { Booth.count }.by(1)
+        end
+
+        it 'redirects to admin booth index' do
+          expect(response).to redirect_to(admin_conference_booths_path)
+        end
+
+        it 'has responsibles' do
+          expect(booth.responsibles.count).to_not eq(0)
+        end
+
+        it 'shows success message' do
+          expect(flash[:notice]).to match('Booth successfully created.')
+        end
+      end
+
+      context 'create action fails' do
+        before { post :create, booth: attributes_for(:booth, title: ''), conference_id: conference.short_title }
+
+        it 'does not create any record' do
+          expected = expect do
+            post :create, booth: attributes_for(:booth, title: ''), conference_id: conference.short_title
+          end
+          expected.to_not change(Booth, :count)
+        end
+
+        it 'redirects to new' do
+          expect(response).to render_template('new')
+        end
+
+        it 'shows flash message' do
+          expect(flash[:error]).to eq("Creating booth failed. Title can't be blank.")
+        end
+      end
+    end
+
+    describe 'GET #edit' do
+      before { get :edit, id: booth.id, conference_id: conference.short_title }
+
+      it 'renders edit template' do
+        expect(response).to render_template('edit')
+      end
+
+      it 'assigns booth variable' do
+        expect(assigns(:booth)).to eq booth
+      end
+    end
+
+    describe 'PATCH #update' do
+      context 'updates suchessfully' do
+        before { patch :update, id: booth.id, booth: attributes_for(:booth, title: 'different'), conference_id: conference.short_title }
+        it 'redirects to admin booth index path' do
+          expect(response).to redirect_to admin_conference_booths_path
+        end
+
+        it 'shows success message' do
+          expect(flash[:notice]).to match 'Successfully updated booth.'
+        end
+
+        it 'updates booth' do
+          booth.reload
+          expect(booth.title).to eq('different')
+        end
+      end
+    end
+  end
+end

spec/controllers/admin/ticket_scannings_controller_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Admin::TicketScanningsController do
+  let(:admin) { create(:admin) }
+  let(:conference) { create(:conference) }
+  let(:user) { create(:user) }
+  let(:paid_ticket_purchase) { create(:ticket_purchase, conference: conference, user: user) }
+  let(:physical_ticket) { create(:physical_ticket, ticket_purchase: paid_ticket_purchase) }
+
+  context 'logged in as user with no role' do
+    before :each do
+      sign_in user
+    end
+    describe 'POST #create' do
+      it 'does not create new ticket scanning' do
+        expected = expect do
+          post :create, physical_ticket_id: physical_ticket.token
+        end
+        expected.to_not change(TicketScanning, :count)
+      end
+
+      it 'redirects to root' do
+        post :create, physical_ticket_id: physical_ticket.token
+        expect(flash[:alert]).to eq('You are not authorized to access this page.')
+        expect(response).to redirect_to(root_path)
+      end
+    end
+  end
+
+  context 'logged in as admin' do
+    before :each do
+      sign_in admin
+    end
+    describe 'POST #create' do
+      context 'with valid physical_ticket' do
+        it 'creates new ticket scanning' do
+          expected = expect do
+            post :create, physical_ticket_id: physical_ticket.token
+          end
+          expected.to change { TicketScanning.count }.by(1)
+        end
+
+        it 'redirects to index' do
+          post :create, physical_ticket_id: physical_ticket.token
+          expect(flash[:notice]).to eq("Ticket with token #{physical_ticket.token} successfully scanned.")
+          expect(response).to redirect_to(conferences_path)
+        end
+      end
+
+      context 'with Invalid physical_ticket' do
+        it 'raises exception' do
+          expected = expect do
+            post :create, physical_ticket_id: 'XXXX'
+          end
+          expected.to raise_exception(ActiveRecord::RecordNotFound)
+        end
+      end
+    end
+  end
+end

spec/controllers/admin/tracks_controller_spec.rb

@@ -5,7 +5,7 @@ describe Admin::TracksController do
 
   let(:conference) { create(:conference) }
   let!(:track) { create(:track, program: conference.program, color: '#800080') }
-  let!(:self_organized_track) { create(:track, :self_organized, program: conference.program) }
+  let!(:self_organized_track) { create(:track, :self_organized, program: conference.program, name: 'My awesome track') }
 
   before :each do
     sign_in(admin)
@@ -80,6 +80,11 @@ describe Admin::TracksController do
       it 'creates new track' do
         expect(Track.find(assigns(:track).id)).to be_a Track
       end
+
+      it 'the new tracks has the correct attributes' do
+        expect(assigns(:track).state).to eq 'confirmed'
+        expect(assigns(:track).cfp_active).to eq true
+      end
     end
 
     context 'save fails' do
@@ -223,16 +228,45 @@ describe Admin::TracksController do
       before :each do
         self_organized_track.cfp_active = false
         self_organized_track.save!
-        patch :toggle_cfp_inclusion, conference_id: conference.short_title, id: self_organized_track.short_name
-        self_organized_track.reload
       end
 
-      it 'assigns the correct track' do
-        expect(assigns(:track)).to eq self_organized_track
+      context 'toggles successfully' do
+        before :each do
+          patch :toggle_cfp_inclusion, conference_id: conference.short_title, id: self_organized_track.short_name, format: :js
+          self_organized_track.reload
+        end
+
+        it 'assigns the correct track' do
+          expect(assigns(:track)).to eq self_organized_track
+        end
+
+        it 'shows success message in flash notice' do
+          expect(flash[:notice]).to match('Successfully changed cfp inclusion of My awesome track to true')
+        end
+
+        it 'becomes true' do
+          expect(self_organized_track.cfp_active).to eq true
+        end
       end
 
-      it 'becomes true' do
-        expect(self_organized_track.cfp_active).to eq true
+      context 'save fails' do
+        before :each do
+          allow_any_instance_of(Track).to receive(:save).and_return(false)
+          patch :toggle_cfp_inclusion, conference_id: conference.short_title, id: self_organized_track.short_name, format: :js
+          self_organized_track.reload
+        end
+
+        it 'assigns the correct track' do
+          expect(assigns(:track)).to eq self_organized_track
+        end
+
+        it 'shows error message in flash notice' do
+          expect(flash[:error]).to match('Failed to toggle cfp inclusion of My awesome track to true')
+        end
+
+        it 'stays false' do
+          expect(self_organized_track.cfp_active).to eq false
+        end
       end
     end
 
@@ -240,7 +274,124 @@ describe Admin::TracksController do
       before :each do
         self_organized_track.cfp_active = true
         self_organized_track.save!
-        patch :toggle_cfp_inclusion, conference_id: conference.short_title, id: self_organized_track.short_name
+      end
+
+      context 'toggles successfully' do
+        before :each do
+          patch :toggle_cfp_inclusion, conference_id: conference.short_title, id: self_organized_track.short_name, format: :js
+          self_organized_track.reload
+        end
+
+        it 'assigns the correct track' do
+          expect(assigns(:track)).to eq self_organized_track
+        end
+
+        it 'shows success message in flash notice' do
+          expect(flash[:notice]).to match('Successfully changed cfp inclusion of My awesome track to false')
+        end
+
+        it 'becomes false' do
+          expect(self_organized_track.cfp_active).to eq false
+        end
+      end
+
+      context 'save fails' do
+        before :each do
+          allow_any_instance_of(Track).to receive(:save).and_return(false)
+          patch :toggle_cfp_inclusion, conference_id: conference.short_title, id: self_organized_track.short_name, format: :js
+          self_organized_track.reload
+        end
+
+        it 'assigns the correct track' do
+          expect(assigns(:track)).to eq self_organized_track
+        end
+
+        it 'shows error message in flash notice' do
+          expect(flash[:error]).to match('Failed to toggle cfp inclusion of My awesome track to false')
+        end
+
+        it 'stays true' do
+          expect(self_organized_track.cfp_active).to eq true
+        end
+      end
+    end
+  end
+
+  describe 'PATCH #restart' do
+    before :each do
+      self_organized_track.state = 'canceled'
+      self_organized_track.save!
+      patch :restart, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Review for My awesome track started!'
+    end
+
+    it 'changes the track\'s state to new' do
+      expect(self_organized_track.state).to eq 'new'
+    end
+  end
+
+  describe 'PATCH #to_accept' do
+    before :each do
+      patch :to_accept, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track marked as a possible acceptance!'
+    end
+
+    it 'changes the track\'s state to to_accept' do
+      expect(self_organized_track.state).to eq 'to_accept'
+    end
+  end
+
+  describe 'PATCH #accept' do
+    shared_examples 'fails to accept' do |start_date, end_date, room|
+      before :each do
+        self_organized_track.start_date = start_date ? Date.today : nil
+        self_organized_track.end_date = end_date ? Date.today : nil
+        if room
+          conference.venue = create(:venue)
+          self_organized_track.room = create(:room, venue: conference.venue)
+        else
+          self_organized_track.room = nil
+        end
+        self_organized_track.save!
+
+        patch :accept, conference_id: conference.short_title, id: self_organized_track.short_name
+        self_organized_track.reload
+      end
+
+      it 'redirects to Tracks#edit' do
+        expect(response).to redirect_to edit_admin_conference_program_track_path(conference.short_title, self_organized_track)
+      end
+
+      it 'shows message in flash alert' do
+        expect(flash[:alert]).to eq 'Please make sure that the track has a room and start/end dates before accepting it'
+      end
+    end
+
+    context 'has start_date, end_date and room' do
+      before :each do
+        self_organized_track.start_date = Date.today
+        self_organized_track.end_date = Date.today
+        conference.venue = create(:venue)
+        self_organized_track.room = create(:room, venue: conference.venue)
+        self_organized_track.save!
+
+        patch :accept, conference_id: conference.short_title, id: self_organized_track.short_name
         self_organized_track.reload
       end
 
@@ -248,9 +399,121 @@ describe Admin::TracksController do
         expect(assigns(:track)).to eq self_organized_track
       end
 
-      it 'becomes false' do
-        expect(self_organized_track.cfp_active).to eq false
+      it 'shows message in flash notice' do
+        expect(flash[:notice]).to eq 'Track My awesome track accepted!'
       end
+
+      it 'changes the track\'s state to accepted' do
+        expect(self_organized_track.state).to eq 'accepted'
+      end
+    end
+
+    context 'has start_date and end_date' do
+      it_behaves_like 'fails to accept', true, true, false
+    end
+
+    context 'has start_date and room' do
+      it_behaves_like 'fails to accept', true, false, true
+    end
+
+    context 'has start_date' do
+      it_behaves_like 'fails to accept', true, false, false
+    end
+
+    context 'has end_date and room' do
+      it_behaves_like 'fails to accept', false, true, true
+    end
+
+    context 'has end_date' do
+      it_behaves_like 'fails to accept', false, true, false
+    end
+
+    context 'has room' do
+      it_behaves_like 'fails to accept', false, false, true
+    end
+
+    context 'has non of start_date, end_date, room' do
+      it_behaves_like 'fails to accept', false, false, false
+    end
+  end
+
+  describe 'PATCH #confirm' do
+    before :each do
+      self_organized_track.state = 'accepted'
+      self_organized_track.save!
+      patch :confirm, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track confirmed!'
+    end
+
+    it 'changes the track\'s state to confirmed' do
+      expect(self_organized_track.state).to eq 'confirmed'
+    end
+  end
+
+  describe 'PATCH #to_reject' do
+    before :each do
+      patch :to_reject, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track marked as a possible rejection!'
+    end
+
+    it 'changes the track\'s state to to_reject' do
+      expect(self_organized_track.state).to eq 'to_reject'
+    end
+  end
+
+  describe 'PATCH #reject' do
+    before :each do
+      patch :reject, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track rejected!'
+    end
+
+    it 'changes the track\'s state to rejected' do
+      expect(self_organized_track.state).to eq 'rejected'
+    end
+  end
+
+  describe 'PATCH #cancel' do
+    before :each do
+      self_organized_track.state = 'confirmed'
+      self_organized_track.save!
+      patch :cancel, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track canceled!'
+    end
+
+    it 'changes the track\'s state to canceled' do
+      expect(self_organized_track.state).to eq 'canceled'
     end
   end
 end

spec/controllers/booths_controller_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe BoothsController do
+
+  let(:user) { create(:user) }
+  let(:conference) { create(:conference) }
+  let(:booth) { create(:booth, title: 'Title', conference: conference) }
+
+  context 'user is signed in with submitter role' do
+    before :each do
+      create(:cfp, program: conference.program, cfp_type: 'booths')
+      sign_in booth.submitter
+    end
+
+    describe 'GET index' do
+      before { get :index, conference_id: conference.short_title }
+
+      it 'assigns attributes for booths' do
+        expect(assigns(:booths)).to eq([booth])
+      end
+
+      it 'renders index template' do
+        expect(response).to render_template('index')
+      end
+    end
+
+    describe 'GET #new' do
+      before { get :new, conference_id: conference.short_title }
+
+      it 'assigns attributes for booths' do
+        expect(assigns(:booth)).to be_a_new(Booth)
+      end
+
+      it 'renders new template' do
+        expect(response).to render_template('new')
+      end
+    end
+
+    describe 'POST #create' do
+      context 'successfully created' do
+        before { post :create, booth: attributes_for(:booth), conference_id: conference.short_title }
+
+        it 'creates a new booth' do
+          expect(Booth.count).to_not eq(0)
+        end
+
+        it 'redirects to booth index' do
+          expect(response).to redirect_to(conference_booths_path)
+        end
+
+        it 'has responsibles' do
+          expect(booth.responsibles.count).to_not eq(0)
+        end
+
+        it 'shows success message' do
+          expect(flash[:notice]).to match('Booth successfully created.')
+        end
+      end
+
+      context 'create action fails' do
+        before { post :create, booth: attributes_for(:booth, title: ''), conference_id: conference.short_title }
+
+        it 'does not create any record' do
+          expected = expect do
+            post :create, booth: attributes_for(:booth, title: ''), conference_id: conference.short_title
+          end
+          expected.to_not change(Booth, :count)
+        end
+
+        it 'redirects to new' do
+          expect(response).to render_template('new')
+        end
+
+        it 'shows flash message' do
+          expect(flash[:error]).to eq("Creating booth failed. Title can't be blank.")
+        end
+      end
+    end
+
+    describe 'GET #edit' do
+      before { get :edit, id: booth.id, conference_id: conference.short_title }
+
+      it 'renders edit template' do
+        expect(response).to render_template('edit')
+      end
+
+      it 'assigns booth variable' do
+        expect(assigns(:booth)).to eq booth
+      end
+    end
+
+    describe 'PATCH #update' do
+      context 'updates suchessfully' do
+        before { patch :update, id: booth.id, booth: attributes_for(:booth, title: 'different'), conference_id: conference.short_title }
+
+        it 'redirects to booth index path' do
+          expect(response).to redirect_to conference_booths_path
+        end
+
+        it 'shows success message' do
+          expect(flash[:notice]).to match 'Booth successfully updated!'
+        end
+
+        it 'updates booth' do
+          booth.reload
+          expect(booth.title).to eq('different')
+        end
+      end
+    end
+  end
+end

spec/controllers/physical_ticket_controller_spec.rb

@@ -9,7 +9,7 @@ describe PhysicalTicketController do
   describe 'GET #show' do
     before :each do
       sign_in user
-      get :show, id: physical_ticket.id, conference_id: conference.short_title
+      get :show, id: physical_ticket.token, conference_id: conference.short_title
     end
 
     it 'assigns ticket_layout' do

spec/controllers/subscriptions_controller_spec.rb

@@ -24,7 +24,7 @@ describe SubscriptionsController do
 
       it 'shows success message in flash notice' do
         post :create, conference_id: conference.short_title
-        expect(flash[:notice]).to match("You have been subscribed to receive email notifications for #{conference.short_title}")
+        expect(flash[:notice]).to match("You have subscribed to receive email notifications for #{conference.title}")
       end
 
       it 'subscribes user to conference' do
@@ -47,7 +47,7 @@ describe SubscriptionsController do
 
     it 'shows success message in flash notice' do
       delete :destroy, conference_id: conference.short_title
-        expect(flash[:notice]).to match("You have been unsubscribed and now you will not be receiving email notifications for #{conference.short_title}.")
+        expect(flash[:notice]).to match("You have unsubscribed and you will not be receiving email notifications for #{conference.title}.")
     end
   end
 end

spec/controllers/tracks_controller_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
 describe TracksController do
-  # A regular user should be used when the track requests have been enabled
   let(:user) { create(:admin) }
 
   let(:conference) { create(:conference) }
   let!(:regular_track) { create(:track, program: conference.program) }
-  let!(:self_organized_track) { create(:track, :self_organized, program: conference.program, submitter: user, color: '#800080') }
+  let!(:self_organized_track) { create(:track, :self_organized, program: conference.program, submitter: user, name: 'My awesome track', color: '#800080') }
 
   before :each do
     sign_in(user)
@@ -61,7 +60,7 @@ describe TracksController do
   describe 'POST #create' do
     context 'saves successfuly' do
       before :each do
-        post :create, track: attributes_for(:track, short_name: 'my_track'), conference_id: conference.short_title
+        post :create, track: attributes_for(:track, :self_organized, short_name: 'my_track'), conference_id: conference.short_title
       end
 
       it 'redirects to tracks index path' do
@@ -87,7 +86,7 @@ describe TracksController do
     context 'save fails' do
       before :each do
         allow_any_instance_of(Track).to receive(:save).and_return(false)
-        post :create, track: attributes_for(:track, short_name: 'my_track'), conference_id: conference.short_title
+        post :create, track: attributes_for(:track, :self_organized, short_name: 'my_track'), conference_id: conference.short_title
       end
 
       it 'assigns a new track with the correct conference' do
@@ -127,7 +126,7 @@ describe TracksController do
   describe 'PATCH #update' do
     context 'updates successfully' do
       before :each do
-        patch :update, track: attributes_for(:track, color: '#FF0000'),
+        patch :update, track: attributes_for(:track, :self_organized, color: '#FF0000'),
                        conference_id: conference.short_title,
                        id: self_organized_track.short_name
       end
@@ -153,7 +152,7 @@ describe TracksController do
     context 'update fails' do
       before :each do
         allow_any_instance_of(Track).to receive(:save).and_return(false)
-        patch :update, track: attributes_for(:track, color: '#FF0000'),
+        patch :update, track: attributes_for(:track, :self_organized, color: '#FF0000'),
                        conference_id: conference.short_title,
                        id: self_organized_track.short_name
       end
@@ -176,4 +175,67 @@ describe TracksController do
       end
     end
   end
+
+  describe 'PATCH #restart' do
+    before :each do
+      self_organized_track.state = 'withdrawn'
+      self_organized_track.save!
+      patch :restart, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track re-submitted.'
+    end
+
+    it 'changes the track\'s state to new' do
+      expect(self_organized_track.state).to eq 'new'
+    end
+  end
+
+  describe 'PATCH #confirm' do
+    before :each do
+      self_organized_track.state = 'accepted'
+      self_organized_track.save!
+      patch :confirm, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track confirmed.'
+    end
+
+    it 'changes the track\'s state to confirmed' do
+      expect(self_organized_track.state).to eq 'confirmed'
+    end
+  end
+
+  describe 'PATCH #withdraw' do
+    before :each do
+      self_organized_track.state = 'confirmed'
+      self_organized_track.save!
+      patch :withdraw, conference_id: conference.short_title, id: self_organized_track.short_name
+      self_organized_track.reload
+    end
+
+    it 'assigns the correct track' do
+      expect(assigns(:track)).to eq self_organized_track
+    end
+
+    it 'shows message in flash notice' do
+      expect(flash[:notice]).to eq 'Track My awesome track withdrawn.'
+    end
+
+    it 'changes the track\'s state to withdrawn' do
+      expect(self_organized_track.state).to eq 'withdrawn'
+    end
+  end
 end

spec/factories/booth_request.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :booth_request do
+    booth
+    user
+    role 'responsible'
+
+  end
+end

spec/factories/booths.rb

@@ -8,8 +8,7 @@ FactoryGirl.define do
 
     conference
 
-    after(:build) do |booth|
-      booth.responsibles << create(:user)
-    end
+    submitter { create(:user) }
+    responsible_ids { [create(:user).id] }
   end
 end

spec/factories/tracks.rb

@@ -4,12 +4,18 @@ FactoryGirl.define do
     description { Faker::Lorem.sentence }
     color { Faker::Color.hex_color }
     short_name { SecureRandom.urlsafe_base64(5) }
+    state 'confirmed'
+    cfp_active true
     program
 
     trait :self_organized do
       association :submitter, factory: :user
       state 'new'
       cfp_active false
+      start_date { Date.today }
+      end_date { Date.today }
+      room
+      relevance { Faker::Hipster.paragraph(2) }
     end
   end
 end

spec/features/cfp_ability_spec.rb

@@ -64,29 +64,51 @@ feature 'Has correct abilities' do
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
-      # Both event and booth exists
+      # Event and booth cfps exist
       cfb = create(:cfp, cfp_type: 'booths', program: conference.program)
       visit new_admin_conference_program_cfp_path(conference.short_title)
-      expect(current_path).to eq root_path
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
 
       visit edit_admin_conference_program_cfp_path(conference.short_title, conference.program.cfp)
       expect(current_path).to eq(edit_admin_conference_program_cfp_path(conference.short_title, conference.program.cfp))
 
+      # Event, booth, track cfps exist
+      call_for_tracks = create(:cfp, cfp_type: 'tracks', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq root_path
+
+      # Booth and track cfps exist
       conference.program.cfp.destroy!
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
 
       # Only booth exists
+      call_for_tracks.destroy!
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
       visit edit_admin_conference_program_cfp_path(conference.short_title, cfb)
       expect(current_path). to eq(edit_admin_conference_program_cfp_path(conference.short_title, cfb))
 
+      # No cfp exists
       cfb.destroy
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
+      # Only Tracks cfp exists
+      call_for_tracks = create(:cfp, cfp_type: 'tracks', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
+
+      visit edit_admin_conference_program_cfp_path(conference.short_title, call_for_tracks)
+      expect(current_path).to eq edit_admin_conference_program_cfp_path(conference.short_title, call_for_tracks)
+
+      # Event and track cfps exist
+      create(:cfp, cfp_type: 'events', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
+
+      call_for_tracks.destroy!
       create(:event, program: conference.program)
       visit edit_admin_conference_program_event_path(conference.short_title, conference.program.events.first)
       expect(current_path).to eq(edit_admin_conference_program_event_path(conference.short_title, conference.program.events.first))
@@ -269,6 +291,12 @@ feature 'Has correct abilities' do
       visit edit_admin_conference_resource_path(conference.short_title, conference.resources.first)
       expect(current_path).to eq(edit_admin_conference_resource_path(conference.short_title, conference.resources.first))
 
+      visit admin_users_path
+      expect(current_path).to eq(root_path)
+
+      visit admin_user_path(user_cfp)
+      expect(current_path).to eq(root_path)
+
       visit admin_revision_history_path
       expect(current_path).to eq(root_path)
     end

spec/features/conference_spec.rb

@@ -73,6 +73,15 @@ feature Conference do
   end
 
   describe 'admin' do
+    let!(:conference) { create(:conference) }
+
+    scenario 'has organization name in menu bar for conference views', feature: true, js: true do
+      sign_in user
+      visit admin_conference_path(conference.short_title)
+
+      expect(find('.navbar-brand').text).to eq(conference.organization.name)
+    end
+
     it_behaves_like 'add and update conference'
   end
 end

spec/features/info_desk_ability_spec.rb

@@ -237,6 +237,12 @@ feature 'Has correct abilities' do
       visit admin_conference_program_tracks_path(conference.short_title)
       expect(current_path).to eq(root_path)
 
+      visit admin_users_path
+      expect(current_path).to eq(root_path)
+
+      visit admin_user_path(user_info_desk)
+      expect(current_path).to eq(root_path)
+
       visit admin_conference_emails_path(conference.short_title)
       expect(current_path).to eq(root_path)
     end

spec/features/organization_admin_ability_spec.rb

@@ -106,29 +106,51 @@ feature 'Has correct abilities' do
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
-      # Both event and booth exists
+      # Event and booth cfps exist
       cfb = create(:cfp, cfp_type: 'booths', program: conference.program)
       visit new_admin_conference_program_cfp_path(conference.short_title)
-      expect(current_path).to eq root_path
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
 
       visit edit_admin_conference_program_cfp_path(conference.short_title, conference.program.cfp)
       expect(current_path).to eq(edit_admin_conference_program_cfp_path(conference.short_title, conference.program.cfp))
 
+      # Event, booth, track cfps exist
+      call_for_tracks = create(:cfp, cfp_type: 'tracks', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq root_path
+
+      # Booth and track cfps exist
       conference.program.cfp.destroy!
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
 
       # Only booth exists
+      call_for_tracks.destroy!
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
       visit edit_admin_conference_program_cfp_path(conference.short_title, cfb)
       expect(current_path). to eq(edit_admin_conference_program_cfp_path(conference.short_title, cfb))
 
+      # No cfp exists
       cfb.destroy
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
+      # Only Tracks cfp exists
+      call_for_tracks = create(:cfp, cfp_type: 'tracks', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
+
+      visit edit_admin_conference_program_cfp_path(conference.short_title, call_for_tracks)
+      expect(current_path).to eq edit_admin_conference_program_cfp_path(conference.short_title, call_for_tracks)
+
+      # Event and track cfps exist
+      create(:cfp, cfp_type: 'events', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
+
+      call_for_tracks.destroy!
       visit admin_conference_program_events_path(conference.short_title)
       expect(current_path).to eq(admin_conference_program_events_path(conference.short_title))
 

spec/features/organizer_ability_spec.rb

@@ -112,29 +112,51 @@ feature 'Has correct abilities' do
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
-      # Both event and booth exists
+      # Event and booth cfps exist
       cfb = create(:cfp, cfp_type: 'booths', program: conference.program)
       visit new_admin_conference_program_cfp_path(conference.short_title)
-      expect(current_path).to eq root_path
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
 
       visit edit_admin_conference_program_cfp_path(conference.short_title, conference.program.cfp)
       expect(current_path).to eq(edit_admin_conference_program_cfp_path(conference.short_title, conference.program.cfp))
 
+      # Event, booth, track cfps exist
+      call_for_tracks = create(:cfp, cfp_type: 'tracks', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq root_path
+
+      # Booth and track cfps exist
       conference.program.cfp.destroy!
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
 
       # Only booth exists
+      call_for_tracks.destroy!
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
       visit edit_admin_conference_program_cfp_path(conference.short_title, cfb)
       expect(current_path). to eq(edit_admin_conference_program_cfp_path(conference.short_title, cfb))
 
+      # No cfp exists
       cfb.destroy
       visit new_admin_conference_program_cfp_path(conference.short_title)
       expect(current_path).to eq(new_admin_conference_program_cfp_path(conference.short_title))
 
+      # Only Tracks cfp exists
+      call_for_tracks = create(:cfp, cfp_type: 'tracks', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
+
+      visit edit_admin_conference_program_cfp_path(conference.short_title, call_for_tracks)
+      expect(current_path).to eq edit_admin_conference_program_cfp_path(conference.short_title, call_for_tracks)
+
+      # Event and track cfps exist
+      create(:cfp, cfp_type: 'events', program: conference.program)
+      visit new_admin_conference_program_cfp_path(conference.short_title)
+      expect(current_path).to eq new_admin_conference_program_cfp_path(conference.short_title)
+
+      call_for_tracks.destroy!
       visit admin_conference_program_events_path(conference.short_title)
       expect(current_path).to eq(admin_conference_program_events_path(conference.short_title))
 
@@ -266,6 +288,12 @@ feature 'Has correct abilities' do
       visit edit_admin_conference_resource_path(conference.short_title, conference.resources.first)
       expect(current_path).to eq(edit_admin_conference_resource_path(conference.short_title, conference.resources.first))
 
+      visit admin_users_path
+      expect(current_path).to eq(root_path)
+
+      visit admin_user_path(user_organizer)
+      expect(current_path).to eq(root_path)
+
       visit admin_revision_history_path
       expect(current_path).to eq(admin_revision_history_path)
     end

spec/features/proposals_spec.rb

@@ -28,23 +28,23 @@ feature Event do
 
     scenario 'rejects a proposal', feature: true, js: true do
       visit admin_conference_program_events_path(conference.short_title)
-      expect(page.has_content?('Example Proposal')).to be true
+      expect(page).to have_content 'Example Proposal'
 
       click_button 'New'
       click_link "reject_event_#{@event.id}"
-      expect(flash).to eq('Event rejected!')
+      expect(page).to have_content 'Event rejected!'
       @event.reload
       expect(@event.state).to eq('rejected')
     end
 
     scenario 'accepts a proposal', feature: true, js: true do
       visit admin_conference_program_events_path(conference.short_title)
-      expect(page.has_content?('Example Proposal')).to be true
+      expect(page).to have_content 'Example Proposal'
 
       click_button 'New'
       click_link "accept_event_#{@event.id}"
-      expect(flash).to eq('Event accepted!')
-      expect(page.has_content?('Unconfirmed')).to be true
+      expect(page).to have_content 'Event accepted!'
+      expect(page).to have_content 'Unconfirmed'
       @event.reload
       expect(@event.state).to eq('unconfirmed')
     end
@@ -52,11 +52,11 @@ feature Event do
     scenario 'restarts review of a proposal', feature: true, js: true do
       @event.reject!(@options)
       visit admin_conference_program_events_path(conference.short_title)
-      expect(page.has_content?('Example Proposal')).to be true
+      expect(page).to have_content 'Example Proposal'
 
       click_button 'Rejected'
       click_link "restart_event_#{@event.id}"
-      expect(flash).to eq('Review started!')
+      expect(page).to have_content 'Review started!'
       @event.reload
       expect(@event.state).to eq('new')
     end
@@ -83,7 +83,7 @@ feature Event do
       fill_in 'event_abstract', with: 'Lorem ipsum abstract'
 
       click_button 'Create Proposal'
-      expect(flash).to eq('Proposal was successfully submitted.')
+      expect(page).to have_content 'Proposal was successfully submitted.'
 
       expect(Event.count).to eq(expected_count_event)
       expect(User.count).to eq(expected_count_user)
@@ -101,7 +101,7 @@ feature Event do
       select('Easy', from: 'event[difficulty_level_id]')
 
       click_button 'Update Proposal'
-      expect(flash).to eq('Proposal was successfully updated.')
+      expect(page).to have_content 'Proposal was successfully updated.'
     end
 
     scenario 'signed_in user submits a valid proposal', feature: true, js: true do
@@ -119,7 +119,7 @@ feature Event do
       fill_in 'event_description', with: 'Lorem ipsum description'
 
       click_button 'Create Proposal'
-      expect(flash).to eq('Proposal was successfully submitted.')
+      expect(page).to have_content 'Proposal was successfully submitted.'
 
       expect(current_path).to eq(conference_program_proposals_path(conference.short_title))
       expect(Event.count).to eq(expected_count)
@@ -128,11 +128,10 @@ feature Event do
     scenario 'confirms a proposal', feature: true, js: true do
       sign_in participant
       visit conference_program_proposals_path(conference.short_title)
-      expect(page.has_content?('Example Proposal')).to be true
+      expect(page).to have_content 'Example Proposal'
       expect(@event.state).to eq('unconfirmed')
       click_link "confirm_proposal_#{@event.id}"
-      expect(flash)
-        .to eq('The proposal was confirmed. Please register to attend the conference.')
+      expect(page).to have_content 'The proposal was confirmed. Please register to attend the conference.'
       expect(current_path).to eq(new_conference_conference_registration_path(conference.short_title))
       @event.reload
       expect(@event.state).to eq('confirmed')
@@ -142,9 +141,9 @@ feature Event do
       sign_in participant
       @event.confirm!
       visit conference_program_proposals_path(conference.short_title)
-      expect(page.has_content?('Example Proposal')).to be true
+      expect(page).to have_content 'Example Proposal'
       click_link "delete_proposal_#{@event.id}"
-      expect(flash).to eq('Proposal was successfully withdrawn.')
+      expect(page).to have_content 'Proposal was successfully withdrawn.'
       @event.reload
       expect(@event.state).to eq('withdrawn')
     end

spec/features/splashpage_spec.rb

@@ -61,4 +61,15 @@ feature Splashpage do
       expect(current_path).to eq(root_path)
     end
   end
+
+  context 'public splashpage already created' do
+    let!(:splashpage) { create(:splashpage, conference: conference, public: true)}
+
+    scenario 'should have organization name', feature: true, js: true do
+      sign_in participant
+      visit conference_path(conference.short_title)
+
+      expect(page).to have_text(conference.organization.name)
+    end
+  end
 end

spec/features/track_organizer_ability_spec.rb

@@ -5,10 +5,10 @@ feature 'Has correct abilities' do
   let(:organization) { create(:organization) }
   let(:conference) { create(:full_conference, organization: organization) }
   let(:self_organized_track) { create(:track, :self_organized, program: conference.program) }
-  let(:role_track_organizer) { Role.find_by(name: 'track_organizer', resource: self_organized_track) }
+  let(:role_track_organizer) { Role.where(name: 'track_organizer', resource: self_organized_track).first_or_create }
   let(:user_track_organizer) { create(:user, role_ids: [role_track_organizer.id]) }
 
-  context 'when user is info desk' do
+  context 'when user is track organizer' do
     before do
       sign_in user_track_organizer
     end

spec/features/tracks_spec.rb

@@ -39,7 +39,7 @@ feature Track do
       within('table#tracks') do
         expect(page.has_content?(track.name)).to be false
         expect(page.has_content?(track.description)).to be false
-        expect(page.assert_selector('tr', count: 1)).to be true
+        expect(page.has_content?('No data available in table')).to eq true
       end
     end
 

spec/models/ability_spec.rb

@@ -26,6 +26,7 @@ describe 'User' do
 
     let(:program_with_cfp) { create(:program, :with_cfp) }
     let(:program_without_cfp) { create(:program) }
+    let(:program_with_call_for_tracks) { create(:cfp, cfp_type: 'tracks').program }
     let(:conference_with_open_registration) { create(:conference) }
     let!(:open_registration_period) { create(:registration_period, conference: conference_with_open_registration, start_date: Date.current - 6.days) }
     let(:conference_with_closed_registration) { create(:conference) }
@@ -82,6 +83,10 @@ describe 'User' do
 
       let(:user_event_with_cfp) { create(:event, users: [user], program: program_with_cfp) }
       let(:user_commercial) { create(:commercial, commercialable: user_event_with_cfp) }
+      let(:user_self_organized_track) { create(:track, :self_organized, submitter: user) }
+      let(:accepted_user_self_organized_track) { create(:track, :self_organized, submitter: user, state: 'accepted') }
+      let(:confirmed_user_self_organized_track) { create(:track, :self_organized, submitter: user, state: 'confirmed') }
+      let(:other_self_organized_track) { create(:track, :self_organized) }
 
       it{ should be_able_to(:manage, user) }
 
@@ -101,7 +106,6 @@ describe 'User' do
 
       it{ should be_able_to(:update, user_event_with_cfp) }
       it{ should be_able_to(:show, user_event_with_cfp) }
-      it{ should be_able_to(:delete, user_event_with_cfp) }
       it{ should_not be_able_to(:new, Event.new(program: program_without_cfp)) }
       it{ should_not be_able_to(:create, Event.new(program: program_without_cfp)) }
       # TODO: At moment it's not possible to manually add someone else as event_user
@@ -114,6 +118,31 @@ describe 'User' do
       it{ should be_able_to(:create, user_event_with_cfp.commercials.new) }
       it{ should be_able_to(:manage, user_commercial) }
       it{ should_not be_able_to(:manage, commercial_event_unconfirmed) }
+
+      it{ should be_able_to(:new, Track.new(program: program_with_call_for_tracks)) }
+      it{ should be_able_to(:create, Track.new(program: program_with_call_for_tracks)) }
+      it{ should_not be_able_to(:new, Track.new(program: program_without_cfp)) }
+      it{ should_not be_able_to(:create, Track.new(program: program_without_cfp)) }
+
+      it{ should be_able_to(:index, user_self_organized_track) }
+      it{ should be_able_to(:show, user_self_organized_track) }
+      it{ should be_able_to(:restart, user_self_organized_track) }
+      it{ should be_able_to(:confirm, user_self_organized_track) }
+      it{ should be_able_to(:withdraw, user_self_organized_track) }
+      it{ should_not be_able_to(:index, other_self_organized_track) }
+      it{ should_not be_able_to(:show, other_self_organized_track) }
+      it{ should_not be_able_to(:restart, other_self_organized_track) }
+      it{ should_not be_able_to(:confirm, other_self_organized_track) }
+      it{ should_not be_able_to(:withdraw, other_self_organized_track) }
+
+      it{ should be_able_to(:edit, user_self_organized_track) }
+      it{ should be_able_to(:update, user_self_organized_track) }
+      it{ should_not be_able_to(:edit, accepted_user_self_organized_track) }
+      it{ should_not be_able_to(:update, accepted_user_self_organized_track) }
+      it{ should_not be_able_to(:edit, confirmed_user_self_organized_track) }
+      it{ should_not be_able_to(:update, confirmed_user_self_organized_track) }
+      it{ should_not be_able_to(:edit, other_self_organized_track) }
+      it{ should_not be_able_to(:update, other_self_organized_track) }
     end
   end
 end

spec/models/admin_ability_spec.rb

@@ -44,7 +44,7 @@ describe 'User with admin role' do
     let!(:my_event_schedule) { create(:event_schedule, schedule: my_schedule) }
     let!(:other_event_schedule) { create(:event_schedule, schedule: other_schedule) }
 
-    let!(:my_self_organized_track) { create(:track, :self_organized, program: my_conference.program) }
+    let!(:my_self_organized_track) { create(:track, :self_organized, program: my_conference.program, state: 'confirmed') }
 
     context 'user #is_admin?' do
       let(:venue) { my_conference.venue }
@@ -64,6 +64,10 @@ describe 'User with admin role' do
       it{ should_not be_able_to(:edit, Role.find_by(name: 'organization_admin', resource: other_organization)) }
       it{ should_not be_able_to(:show, Role.find_by(name: 'organization_admin', resource: other_organization)) }
 
+      it{ should_not be_able_to(:new, User.new) }
+      it{ should_not be_able_to(:create, User.new) }
+      it{ should_not be_able_to(:manage, User) }
+
       %w[organizer cfp info_desk volunteers_coordinator].each do |role|
         it{ should_not be_able_to(:toggle_user, Role.find_by(name: role, resource: other_conference)) }
         it{ should_not be_able_to(:update, Role.find_by(name: role, resource: other_conference)) }
@@ -75,7 +79,7 @@ describe 'User with admin role' do
       context 'accesses track organizers' do
         before :each do
           other_self_organized_track = create(:track, :self_organized)
-          @other_track_organizer_role = Role.find_by(name: 'track_organizer', resource: other_self_organized_track)
+          @other_track_organizer_role = Role.where(name: 'track_organizer', resource: other_self_organized_track).first_or_create
         end
 
         it{ should_not be_able_to(:toggle_user, @other_track_organizer_role) }
@@ -101,7 +105,7 @@ describe 'User with admin role' do
 
       context 'accesses track organizers' do
         before :each do
-          @track_organizer_role = Role.find_by(name: 'track_organizer', resource: my_self_organized_track)
+          @track_organizer_role = Role.where(name: 'track_organizer', resource: my_self_organized_track).first_or_create
         end
 
         if role_name == 'track_organizer'
@@ -219,7 +223,7 @@ describe 'User with admin role' do
 
       context 'can manage track organizers' do
         before :each do
-          @track_organizer_role = Role.find_by(name: 'track_organizer', resource: my_self_organized_track)
+          @track_organizer_role = Role.where(name: 'track_organizer', resource: my_self_organized_track).first_or_create
         end
 
         it{ should be_able_to(:toggle_user, @track_organizer_role) }
@@ -437,7 +441,8 @@ describe 'User with admin role' do
     end
 
     context 'when user has the role track_organizer' do
-      let(:role) { Role.find_by(name: 'track_organizer', resource: my_self_organized_track) }
+
+      let(:role) { Role.where(name: 'track_organizer', resource: my_self_organized_track).first_or_create }
       let(:user) { create(:user, role_ids: [role.id]) }
       let(:new_track) { build(:track, program: my_conference.program) }
 
@@ -500,6 +505,8 @@ describe 'User with admin role' do
       it{ should be_able_to(:show, my_conference.program) }
       it{ should be_able_to(:update, new_track) }
       it{ should be_able_to(:manage, my_self_organized_track) }
+      it{ should_not be_able_to(:edit, my_self_organized_track) }
+      it{ should_not be_able_to(:update, my_self_organized_track) }
 
       it_behaves_like 'user with any role'
       it_behaves_like 'user with non-organizer role', 'track_organizer'

spec/models/booth_spec.rb

@@ -33,16 +33,17 @@ describe 'Booth' do
       end
     end
 
-    states = [:new, :withdrawn, :to_accept, :accepted, :to_reject, :rejected, :canceled]
+    states = [:new, :withdrawn, :to_accept, :accepted, :to_reject, :rejected, :canceled, :confirmed]
     transitions = [:restart, :withdraw, :accept, :reject, :to_accept, :to_reject, :cancel]
 
-    states_transitions = { new: { restart: false, withdraw: true, accept: true, to_accept: true, to_reject: true, reject: true, cancel: false },
-                           withdrawn: { restart: true, withdraw: false, accept: false, to_accept: false, to_reject: false, reject: false, cancel: false },
-                           to_accept: { restart: true, withdraw: true, accept: true, to_accept: false, to_reject: true, reject: false, cancel: false },
-                           to_reject: { restart: true, withdraw: true, accept: false, to_accept: true, to_reject: false, reject: true, cancel: false },
-                           accepted: { restart: false, withdraw: true, accept: false, to_accept: false, to_reject: false, reject: false, cancel: true },
-                           rejected: { restart: false, withdraw: true, accept: false, to_accept: false, to_reject: false, reject: false, cancel: true },
-                           canceled: { restart: true, withdraw: false, accept: false, to_accept: false, to_reject: false, reject: false, cancel: false } }
+    states_transitions = { new: { restart: false, withdraw: true, accept: true, to_accept: true, to_reject: true, reject: true, cancel: false, confirm: false },
+                           withdrawn: { restart: true, withdraw: false, accept: false, to_accept: false, to_reject: false, reject: false, cancel: false, confirm: false },
+                           to_accept: { restart: false, withdraw: true, accept: true, to_accept: false, to_reject: true, reject: false, cancel: true, confirm: false },
+                           to_reject: { restart: false, withdraw: true, accept: false, to_accept: true, to_reject: false, reject: true, cancel: true, confirm: false },
+                           accepted: { restart: false, withdraw: true, accept: false, to_accept: false, to_reject: false, reject: false, cancel: true, confirm: true },
+                           rejected: { restart: true, withdraw: true, accept: false, to_accept: false, to_reject: false, reject: false, cancel: true, confirm: false },
+                           canceled: { restart: true, withdraw: false, accept: false, to_accept: false, to_reject: false, reject: false, cancel: false, confirm: false },
+                           confirmed: { restart: false, withdraw: true, accept: false, to_accept: false, to_reject: false, reject: false, cancel: true, confirm: false } }
 
     states.each do |state|
       transitions.each do |transition|

spec/models/cfp_spec.rb

@@ -5,21 +5,35 @@ describe Cfp do
   let!(:conference) { create(:conference, end_date: Date.today) }
   let!(:cfp) { create(:cfp, start_date: Date.today - 2, end_date: Date.today - 1, program_id: conference.program.id) }
 
-  describe 'scope' do
-    describe '#for_events' do
-      it 'returns the cfp for events' do
-        expect(conference.program.cfps.for_events).to be_a Cfp
-        expect(conference.program.cfps.for_events.cfp_type).to eq('events')
-      end
-    end
-  end
-
   describe 'validations' do
     it { is_expected.to validate_presence_of(:cfp_type) }
     it { is_expected.to validate_inclusion_of(:cfp_type).in_array(Cfp::TYPES) }
     it { is_expected.to validate_uniqueness_of(:cfp_type).scoped_to(:program_id).case_insensitive }
   end
 
+  describe '.for_events' do
+    it 'returns the cfp for events when it exists' do
+      expect(conference.program.cfps.for_events).to be_a Cfp
+      expect(conference.program.cfps.for_events.cfp_type).to eq('events')
+    end
+
+    it 'returns nil when the cfp for events doesn\'t exist' do
+      conference.program.cfp.destroy
+      expect(conference.program.cfps.for_events).to eq nil
+    end
+  end
+
+  describe '.for_tracks' do
+    it 'returns the cfp for tracks when it exists' do
+      call_for_tracks = create(:cfp, cfp_type: 'tracks', program: conference.program, end_date: Date.today)
+      expect(conference.program.cfps.for_tracks).to eq call_for_tracks
+    end
+
+    it 'returns nil when the cfp for tracks doesn\'t exist' do
+      expect(conference.program.cfps.for_tracks).to eq nil
+    end
+  end
+
   describe '#before_end_of_conference' do
     describe 'fails to save cfp' do
       it 'when cfp end_date is after conference end_date' do

spec/models/conference_spec.rb

@@ -606,8 +606,8 @@ describe Conference do
   describe 'tracks_distribution' do
     before do
       subject.email_settings = create(:email_settings)
-      @track_one = create(:track, name: 'Track One', color: '#000000')
-      @track_two = create(:track, name: 'Track Two', color: '#ffffff')
+      @track_one = create(:track, name: 'Track One', color: '#000000', program: subject.program)
+      @track_two = create(:track, name: 'Track Two', color: '#ffffff', program: subject.program)
     end
 
     describe '#tracks_distribution' do

spec/models/event_spec.rb

@@ -96,6 +96,40 @@ describe Event do
         end
       end
     end
+
+    describe '#acceptable_track' do
+      context 'is valid' do
+        it 'when the track belong to the same program, is confirmed and is included in the cfp' do
+          track = create(:track, state: 'confirmed', cfp_active: true, program: conference.program)
+          event = build(:event, program: conference.program, track: track)
+          expect(event.valid?).to eq true
+        end
+      end
+
+      context 'is invalid' do
+        it 'when the track doesn\'t have the same program' do
+          track = create(:track, state: 'confirmed', cfp_active: true)
+          event = build(:event, program: conference.program, track: track)
+          expect(event.valid?).to eq false
+          expect(event.errors[:track]).to eq ['is invalid']
+        end
+
+        it 'when the track is unconfirmed' do
+          track = create(:track, cfp_active: true, program: conference.program)
+          allow(track).to receive(:confirmed?).and_return(false)
+          event = build(:event, program: conference.program, track: track)
+          expect(event.valid?).to eq false
+          expect(event.errors[:track]).to eq ['is invalid']
+        end
+
+        it 'when the track isn\'t included in the cfp' do
+          track = create(:track, state: 'confirmed', cfp_active: false, program: conference.program)
+          event = build(:event, program: conference.program, track: track)
+          expect(event.valid?).to eq false
+          expect(event.errors[:track]).to eq ['is invalid']
+        end
+      end
+    end
   end
 
   describe '#comments_count' do

spec/models/program_spec.rb

@@ -253,28 +253,34 @@ describe Program do
   end
 
   describe '#remaining_cfp_types' do
-    it 'returns an array with the types for which a cfp doesn\'t exist, when only the Event type does' do
-      expect(program.remaining_cfp_types).to eq(Cfp::TYPES)
+    it 'returns an array without the \'events\' type, when the cfp for events exists' do
       create(:cfp, cfp_type: 'events', program: program)
-      expect(program.remaining_cfp_types).to eq(['booths'])
+      expect(program.remaining_cfp_types).to be_a Array
+      expect(program.remaining_cfp_types.include?('events')).to eq false
     end
 
-    it 'returns an array with the types for which a cfp doesn\'t exist, when only the Booth type does' do
-      expect(program.remaining_cfp_types).to eq(Cfp::TYPES)
+    it 'returns an array without the \'booths\' type, when the cfp for booths exists' do
       create(:cfp, cfp_type: 'booths', program: program)
-      expect(program.remaining_cfp_types).to eq(['events'])
+      expect(program.remaining_cfp_types).to be_a Array
+      expect(program.remaining_cfp_types.include?('booths')).to eq false
     end
 
-    it 'returns an empty array when all the cfp types exist' do
-      expect(program.remaining_cfp_types).to eq(Cfp::TYPES)
+    it 'returns an array without the \'tracks\' type, when the cfp for tracks exists' do
+      create(:cfp, cfp_type: 'tracks', program: program)
+      expect(program.remaining_cfp_types).to be_a Array
+      expect(program.remaining_cfp_types.include?('tracks')).to eq false
+    end
+
+    it 'returns an empty array when cfps for all the types exist' do
       create(:cfp, cfp_type: 'events', program: program)
       create(:cfp, cfp_type: 'booths', program: program)
+      create(:cfp, cfp_type: 'tracks', program: program)
       expect(program.remaining_cfp_types).to eq([])
     end
 
-    it 'returns all the possible cfp types when there is no existed cfp type' do
+    it 'returns all the possible cfp types when there is no cfp' do
       expect(program.remaining_cfp_types).to eq(Cfp::TYPES)
-      expect(program.remaining_cfp_types). to eq(%w[events booths])
+      expect(program.remaining_cfp_types). to eq(%w[events booths tracks])
     end
   end
 end

spec/models/room_spec.rb

@@ -12,6 +12,7 @@ describe Room do
   describe 'association' do
     it { should belong_to(:venue) }
     it { should have_many(:event_schedules).dependent(:destroy) }
+    it { should have_many(:tracks) }
   end
 
   describe 'callback' do

spec/models/track_spec.rb

@@ -8,6 +8,7 @@ describe Track do
   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 have_many(:events) }
   end
 
@@ -23,23 +24,157 @@ describe Track do
     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) }
     it { is_expected.to validate_uniqueness_of(:short_name).scoped_to(:program_id) }
+    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' do
+    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(:state) }
-      it { is_expected.to validate_inclusion_of(:cfp_active).in_array([true, false]) }
+      it { is_expected.to validate_presence_of(:relevance) }
+      it { is_expected.to validate_presence_of(:description) }
     end
 
-    context 'when regular' do
+    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(:state) }
-      it { is_expected.to_not validate_inclusion_of(:cfp_active) }
+      it { is_expected.to_not validate_presence_of(:relevance) }
+      it { is_expected.to_not validate_presence_of(:description) }
+    end
+
+    describe '#valid_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 start date is before it\'s end date and between the conference start/end dates' 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 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 before the conference start date (#{1.day.ago.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 before the conference start date (#{1.day.ago.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 after the conference end 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 after the conference end date (#{2.days.from_now.to_date})"]
+        end
+
+        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
+  end
+
+  describe 'scope' do
+    describe '#confirmed' do
+      before :each do
+        @program = create(:program)
+      end
+
+      context 'includes' do
+        it 'when track is 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 "when track is #{state.humanize}" 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
   end
 
@@ -54,4 +189,226 @@ describe Track do
       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: false, 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: false, 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_role?(:track_organizer, self_organized_track)).to eq false
+      self_organized_track.assign_role_to_submitter
+      expect(@submitter.has_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_role?(:track_organizer, self_organized_track)).to eq false
+      self_organized_track.confirm
+      expect(@submitter.has_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
+      @an_event_of_the_track = create(:event, program: self_organized_track.program, track: self_organized_track)
+    end
+
+    it 'revokes the role of the track organizer' do
+      expect(@a_track_organizer.has_role?(:track_organizer, self_organized_track)).to eq true
+      self_organized_track.revoke_role_and_cleanup
+      expect(@a_track_organizer.has_role?(:track_organizer, self_organized_track)).to eq false
+    end
+
+    it 'removes the track from the events that have it set' do
+      expect(@an_event_of_the_track.track).to eq self_organized_track
+      self_organized_track.revoke_role_and_cleanup
+      @an_event_of_the_track.reload
+      expect(@an_event_of_the_track.track).to eq nil
+    end
+
+    it 'is executed when the track is canceled' do
+      self_organized_track.state = 'confirmed'
+      self_organized_track.save!
+      self_organized_track.cancel
+      expect(@a_track_organizer.has_role?(:track_organizer, self_organized_track)).to eq false
+      @an_event_of_the_track.reload
+      expect(@an_event_of_the_track.track).to eq nil
+    end
+
+    it 'is executed when the track is withdrawn' do
+      self_organized_track.withdraw
+      expect(@a_track_organizer.has_role?(:track_organizer, self_organized_track)).to eq false
+      @an_event_of_the_track.reload
+      expect(@an_event_of_the_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