When writing the unit test, which one should I prefer as the expected value?

I'm developing a project. The subject of this project, companies send message to users. Each company has a message limit and the system throws an exception based on the language chosen by the company when the message limit is exceeded.

I wrote unit test for the exception.

// given
Company company = new Company("Comp1", 2); // constructor (company name, language)  **  2 -> EN
User user = new User("User1");
Email email = new Email("Email Test", "Test");
int emailLimit = company.getEmailLimit();
    
// when
for (int i = 0; i < emailLimit; i++) {
     company.SendEmail(email, user);
}
Throwable throwable = catchThrowable(() -> company.SendEmail(email, user));

// then
assertThat(throwable).isInstanceOf(MessageLimitException.class);

I also want to check the message content.

There is a class named "ErrorMessages" that manages the content of the error message.

public class ErrorMessages {

   private static String[] messageLimitErrorMessage = {
        "Message Limit Error",   // 0 -> default
        "Mesaj limiti aşıldı",   // 1 -> TR
        "Message limit exceeded" // 2 -> EN
   };

   public static String messageLimitException(int languageIndex) {
        return messageLimitErrorMessage[languageIndex];
   };

}

Which one should I prefer as the expected value?

// Option 1
assertThat(throwable).hasMessage(ErrorMessages.messageLimitException(company.getLanguage()));

// or

// Option 2
assertThat(throwable).hasMessage("Message limit exceeded");

Both are correct but which one should I prefer for the accuracy of the test, Option 1 or 2 ?

Thanks for your answer in advance.

There is no definitive answer to this question. It depends what you're trying to achieve. If the exact error message that is returned is important (e.g. part of the spec) then you should choose Option 2. If you don't want to hard code the message into the test (e.g. because it may change) then you can choose Option 1.

In general a test should focus on one specific thing that it's trying to test. Testing the exact error message might be better off done in a separate unit test (e.g. where you could test all of the different messages). Personally, I don't usually bother to write tests for error messages, unless there is something special about them (e.g. they have some kind of variability within the message itself). You only have so much time and it's probably better spent elsewhere.

You should also consider using Java's built-in support for internationalized message bundles. It lets you hold Locale-specific messages in properties files and loads them in for you.

"As the tests become more specific, the code becomes more generic."

Writing the test with a very specific expectation, decouples it from the implementation, and allows the code to become more generic over time.

This should tell you that you should probably use option 2.

Here's Robert Martin's take on it.