Refactor Teammate#state to use Active Record Enum

app/models/teammate.rb

@@ -1,9 +1,4 @@
 class Teammate < ApplicationRecord
-  PENDING = "pending"
-  ACCEPTED = "accepted"
-  DECLINED = "declined"
-  STATES = ["pending", "accepted", "declined"]
-
   STAFF_ROLES = ['reviewer', 'program team', 'organizer']
   PROGRAM_TEAM_ROLES = ['program team', 'organizer']
 
@@ -17,6 +12,8 @@ class Teammate < ApplicationRecord
     IN_APP_ONLY => 'In App Only'
   }
 
+  enum :state, {pending: 'pending', accepted: 'accepted', declined: 'declined'}
+
   belongs_to :event
   belongs_to :user, optional: true
 
@@ -34,24 +31,21 @@ class Teammate < ApplicationRecord
   scope :program_team, -> { where(role: PROGRAM_TEAM_ROLES) }
   scope :reviewer, -> { where(role: STAFF_ROLES) }
 
-  scope :pending, -> { where(state: PENDING) }
-  scope :accepted, -> { where(state: ACCEPTED) }
-  scope :active, -> { where(state: ACCEPTED) }
-  scope :declined, -> { where(state: DECLINED) }
-  scope :invitations, -> { where(state: [PENDING, DECLINED]) }
+  scope :active, -> { accepted }
+  scope :invitations, -> { where(state: [:pending, :declined]) }
 
   scope :all_emails, -> { where(notification_preference: ALL) }
 
   def accept(user)
     self.user = user
     self.accepted_at = Time.current
-    self.state = ACCEPTED
+    self.state = :accepted
     save
   end
 
   def decline
     self.declined_at = Time.current
-    self.state = DECLINED
+    self.state = :declined
     save
   end
 
@@ -63,13 +57,9 @@ def ratings_count(current_event)
     self.user.ratings.not_withdrawn.for_event(current_event).size
   end
 
-  def pending?
-    state == PENDING
-  end
-
   def invite
     self.token = Digest::SHA1.hexdigest(Time.current.to_s + email + rand(1000).to_s)
-    self.state = PENDING
+    self.state = :pending
     self.invited_at = Time.current
     save
   end

db/seeds.rb

@@ -133,34 +133,34 @@ def create_seed_data
     email: admin.email,
     role: "organizer",
     mention_name: "admin",
-    state: Teammate::ACCEPTED
+    state: :accepted
   ).first_or_create
   seed_event.teammates.where(
     user: organizer,
     email: organizer.email,
     role: "organizer",
     mention_name: "organizer",
-    state: Teammate::ACCEPTED
+    state: :accepted
   ).first_or_create
   seed_event.teammates.where(
     user: track_director,
     email: track_director.email,
     role: "program team",
     mention_name: "track_director",
-    state: Teammate::ACCEPTED
+    state: :accepted
   ).first_or_create
   seed_event.teammates.where(
     user: reviewer,
     email: reviewer.email,
     role: "reviewer",
     mention_name: "reviewer",
-    state: Teammate::ACCEPTED
+    state: :accepted
   ).first_or_create
   seed_event.teammates.where(
     user: speaker_reviewer,
     email: speaker_reviewer.email,
     role: "reviewer",
-    state: Teammate::ACCEPTED
+    state: :accepted
   ).first_or_create # can't be mentioned
 
   # Proposals - there are no proposals that are either fully "accepted" or offically "not accepted"
@@ -430,8 +430,8 @@ def create_seed_data
   end
 
   # Event Team
-  sapphire_event.teammates.where(user: admin, email: admin.email, role: "organizer", state: Teammate::ACCEPTED).first_or_create
-  sapphire_event.teammates.where(user: organizer, email: organizer.email, role: "organizer", state: Teammate::ACCEPTED).first_or_create
+  sapphire_event.teammates.where(user: admin, email: admin.email, role: "organizer", state: :accepted).first_or_create
+  sapphire_event.teammates.where(user: organizer, email: organizer.email, role: "organizer", state: :accepted).first_or_create
 
   ### ScheduleConf -- this is an event that is ready to be scheduled
   schedule_conf_open_date = Date.yesterday
@@ -466,8 +466,8 @@ def create_seed_data
   end
 
   # Event Team
-  schedule_event.teammates.where(user: admin, email: admin.email, role: "organizer", state: Teammate::ACCEPTED).first_or_create
-  schedule_event.teammates.where(user: organizer, email: organizer.email, role: "organizer", state: Teammate::ACCEPTED).first_or_create
+  schedule_event.teammates.where(user: admin, email: admin.email, role: "organizer", state: :accepted).first_or_create
+  schedule_event.teammates.where(user: organizer, email: organizer.email, role: "organizer", state: :accepted).first_or_create
 
   # Session Formats
   schedule_conf_formats = {}

spec/controllers/teammates_controller_spec.rb

@@ -9,11 +9,11 @@
     before { sign_in(user) }
 
     it "creates an accepted teammate for current user" do
-      expect(invitation.state).to eq(Teammate::PENDING)
+      expect(invitation).to be_pending
       get :accept, params: {token: invitation.token}
       expect(user).to be_reviewer_for_event(invitation.event)
       invitation.reload
-      expect(invitation.state).to eq(Teammate::ACCEPTED)
+      expect(invitation).to be_accepted
     end
   end
 
@@ -25,7 +25,7 @@
 
     it "sets invitation state to declined" do
       get :decline, params: {token: invitation.token}
-      expect(invitation.reload.state).to eq(Teammate::DECLINED)
+      expect(invitation.reload).to be_declined
     end
   end
 

spec/factories/teammates.rb

@@ -13,7 +13,7 @@
     trait :has_been_invited do
       token { "token" }
       role { "reviewer" }
-      state { Teammate::PENDING }
+      state { :pending }
     end
 
     trait :reviewer do

spec/support/shared_examples/an_open_event.rb

@@ -12,9 +12,9 @@
   let(:no_reviews_user) { create :user }
   let(:invited_user) { create :user }
 
-  let(:teammate1) { create :teammate, :program_team, event: event, user: user1, state: Teammate::ACCEPTED }
-  let(:teammate2) { create :teammate, :reviewer, event: event, user: user2, state: Teammate::ACCEPTED }
-  let(:no_reviews_teammate) { create :teammate, :reviewer, event: event, user: no_reviews_user, state: Teammate::ACCEPTED }
+  let(:teammate1) { create :teammate, :program_team, event: event, user: user1, state: :accepted }
+  let(:teammate2) { create :teammate, :reviewer, event: event, user: user2, state: :accepted }
+  let(:no_reviews_teammate) { create :teammate, :reviewer, event: event, user: no_reviews_user, state: :accepted }
   let(:invited_teammate) { create :teammate, :has_been_invited, event: event, user: invited_user }
 
   let(:track1) { create :track, name: 'Open-source', event: event }

spec/system/profile_spec.rb

@@ -35,7 +35,7 @@
   end
 
   scenario 'A user updates their event email preference' do
-    teammate = create(:teammate, role: 'organizer', user: user, state: Teammate::ACCEPTED)
+    teammate = create(:teammate, role: 'organizer', user: user, state: :accepted)
     visit(event_path(teammate.event))
     visit(notifications_profile_path)
     choose(Teammate::NOTIFICATION_PREFERENCES[Teammate::MENTIONS])

spec/system/staff/teammates_spec.rb

@@ -4,13 +4,13 @@
   let(:invitation) { create(:teammate, :has_been_invited) }
 
   let!(:organizer_user) { create(:user) }
-  let!(:organizer_teammate) { create(:teammate, :organizer, user: organizer_user, event: invitation.event, state: Teammate::ACCEPTED) }
+  let!(:organizer_teammate) { create(:teammate, :organizer, user: organizer_user, event: invitation.event, state: :accepted) }
 
   let!(:reviewer_user) { create(:user) }
-  let!(:reviewer_teammate) { create(:teammate, :reviewer, user: reviewer_user, event: invitation.event, state: Teammate::ACCEPTED) }
+  let!(:reviewer_teammate) { create(:teammate, :reviewer, user: reviewer_user, event: invitation.event, state: :accepted) }
 
   let!(:program_team_user) { create(:user) }
-  let!(:program_team_teammate) { create(:teammate, :program_team, user: program_team_user, event: invitation.event, state: Teammate::ACCEPTED) }
+  let!(:program_team_teammate) { create(:teammate, :program_team, user: program_team_user, event: invitation.event, state: :accepted) }
 
   before { login_as(organizer_user) }