Refactor model tests to use rspec's be_valid/be_invalid

spec/models/board_spec.rb

@@ -5,23 +5,27 @@ RSpec.describe Board, type: :model do
   let(:board) { FactoryBot.create(:board) }
   let(:noname_board) { FactoryBot.build(:noname_board) }
 
+  it 'should be valid' do
+    expect(board).to be_valid
+  end
+
   it 'has a non-nil name' do
-    expect(noname_board.valid?).to be_falsy
+    expect(noname_board).to be_invalid
   end
 
   it 'has an unique name' do
     board
     board2 = Board.new(name: board.name, description: "This board has the same name as board!")
 
-    expect(board2.valid?).to be_falsy
+    expect(board2).to be_invalid
   end
 
   it 'has a description that can be nil or empty' do
     nildescription_board = Board.new(name: "nil board", description: nil)
     emptydescription_board = Board.new(name: "empty board", description: "")
 
-    expect(nildescription_board.valid?).to be_truthy
-    expect(emptydescription_board.valid?).to be_truthy
+    expect(nildescription_board).to be_valid
+    expect(emptydescription_board).to be_valid
   end
 
 end

spec/models/post_status_spec.rb

@@ -3,20 +3,22 @@ require 'rails_helper'
 RSpec.describe PostStatus, type: :model do
   let(:post_status) { FactoryBot.create(:post_status) }
 
+  it 'should be valid' do
+    expect(post_status).to be_valid
+  end
+
   it 'must have a name' do
     emptyname = FactoryBot.build(:post_status, name: "")
     nilname = FactoryBot.build(:post_status, name: nil)
 
-    expect(emptyname.valid?).to be_falsy
-    expect(nilname.valid?).to be_falsy
-    expect(post_status.valid?).to be_truthy
+    expect(emptyname).to be_invalid
+    expect(nilname).to be_invalid
   end
 
   it 'has a unique name' do
     post_status2 = FactoryBot.build(:post_status, name: post_status.name)
     
-    expect(post_status2.valid?).to be_falsy
-    expect(post_status.valid?).to be_truthy
+    expect(post_status2).to be_invalid
   end
 
   it 'has a valid hex color' do
@@ -27,11 +29,11 @@ RSpec.describe PostStatus, type: :model do
     validcolor = FactoryBot.build(:post_status, color: "#fff")
     validcolor2 = FactoryBot.build(:post_status, color: "#ffffff")
 
-    expect(nilcolor.valid?).to be_falsy
-    expect(emptycolor.valid?).to be_falsy
-    expect(invalidcolor.valid?).to be_falsy
-    expect(invalidcolor2.valid?).to be_falsy
-    expect(validcolor.valid?).to be_truthy
-    expect(validcolor2.valid?).to be_truthy
+    expect(nilcolor).to be_invalid
+    expect(emptycolor).to be_invalid
+    expect(invalidcolor).to be_invalid
+    expect(invalidcolor2).to be_invalid
+    expect(validcolor).to be_valid
+    expect(validcolor2).to be_valid
   end
 end

spec/models/user_spec.rb

@@ -8,32 +8,49 @@ RSpec.describe User, type: :model do
   let(:short_user) { FactoryBot.build(:user, full_name: "a") }
   let(:long_user) { FactoryBot.build(:user, full_name: "a" * 33) }
 
+  it 'should be valid' do
+    expect(user).to be_valid
+  end
+
   it 'creates a user with role "user" by default' do
-    expect(user.role).to eq('user')
+    expect(User.new.role).to eq("user")
+  end
+
+  it 'can have the following roles: "user", "moderator" and "admin"' do
+    user = FactoryBot.build(:user)
+    moderator = FactoryBot.build(:moderator)
+    admin = FactoryBot.build(:admin)
+
+    expect(user.role).to eq("user")
+    expect(moderator.role).to eq("moderator")
+    expect(admin.role).to eq("admin")
+
+    expect(user).to be_valid
+    expect(moderator).to be_valid
+    expect(admin).to be_valid
   end
 
   it 'has a non-nil and non-empty full name' do
-    expect(nilname_user.valid?).to be_falsy
-    expect(emptyname_user.valid?).to be_falsy
+    expect(nilname_user).to be_invalid
+    expect(emptyname_user).to be_invalid
   end
 
   it 'has a full name between 2 and 32 characters' do
-    expect(short_user.valid?).to be_falsy
-    expect(long_user.valid?).to be_falsy
+    expect(short_user).to be_invalid
+    expect(long_user).to be_invalid
 
 
     short_user.full_name = "a" * 2;
     long_user.full_name = "a" * 32;
 
-    expect(short_user.valid?).to be_truthy
-    expect(long_user.valid?).to be_truthy
+    expect(short_user).to be_valid
+    expect(long_user).to be_valid
   end
 
   it 'has an email that must contain a @' do
     invalid_email_user = User.new(full_name: "Valid name", email: "invalid email", password: "password")
 
-    expect(invalid_email_user.valid?).to be_falsy
-    expect(user.valid?).to be_truthy
+    expect(invalid_email_user).to be_invalid
   end
 
 end