Error States and Result Types

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// The exception model in action
public class UserService {
    private UserRepository repository;
    private EmailService emailService;
    
    public User createUser(String email, String password) {
        // Each of these methods might throw exceptions
        validateEmail(email);           // throws InvalidEmailException
        validatePassword(password);     // throws WeakPasswordException
        
        if (repository.existsByEmail(email)) {
            throw new EmailAlreadyExistsException(email);
        }
        
        User user = new User(email, hashPassword(password));
        repository.save(user);          // throws DatabaseException
        emailService.sendWelcome(user); // throws EmailServiceException
        
        return user;
    }
}
 
// Caller must handle or propagate exceptions
public class UserController {
    private UserService userService;
    
    public Response handleRegistration(Request request) {
        try {
            User user = userService.createUser(
                request.getEmail(),
                request.getPassword()
            );
            return Response.created(user);
        } catch (InvalidEmailException e) {
            return Response.badRequest("Invalid email format");
        } catch (WeakPasswordException e) {
            return Response.badRequest("Password too weak");
        } catch (EmailAlreadyExistsException e) {
            return Response.conflict("Email already registered");
        } catch (DatabaseException e) {
            log.error("Database error", e);
            return Response.serverError("Please try again later");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// The error state model in Rust
use thiserror::Error;
 
#[derive(Error, Debug)]
pub enum CreateUserError {
    #[error("Invalid email format: {0}")]
    InvalidEmail(String),
    #[error("Password too weak: {0}")]
    WeakPassword(String),
    #[error("Email already exists: {0}")]
    EmailExists(String),
    #[error("Database error: {0}")]
    Database(#[from] DatabaseError),
    #[error("Email service error: {0}")]
    EmailService(#[from] EmailServiceError),
}
 
impl UserService {
    pub fn create_user(
        &self, 
        email: &str, 
        password: &str
    ) -> Result<User, CreateUserError> {
        // Each operation returns a Result that must be handled
        self.validate_email(email)?;      // ? propagates errors
        self.validate_password(password)?;
        
        if self.repository.exists_by_email(email)? {
            return Err(CreateUserError::EmailExists(email.into()));
        }
        
        let user = User::new(email, self.hash_password(password));
        self.repository.save(&user)?;
        self.email_service.send_welcome(&user)?;
        
        Ok(user)
    }
}
 
// Caller must handle the Result
impl UserController {
    pub fn handle_registration(&self, request: Request) -> Response {
        match self.user_service.create_user(&request.email, &request.password) {
            Ok(user) => Response::created(user),
            Err(CreateUserError::InvalidEmail(msg)) => {
                Response::bad_request(&format!("Invalid email: {}", msg))
            }
            Err(CreateUserError::WeakPassword(msg)) => {
                Response::bad_request(&format!("Weak password: {}", msg))
            }
            Err(CreateUserError::EmailExists(_)) => {
                Response::conflict("Email already registered")
            }
            Err(CreateUserError::Database(e)) => {
                log::error!("Database error: {:?}", e);
                Response::server_error("Please try again later")
            }
            Err(CreateUserError::EmailService(e)) => {
                log::warn!("Email service error: {:?}", e);
                // User created but email failed - might still return success
                Response::created_with_warning("Welcome email failed")
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class TransferService {
    public void transferMoney(Account from, Account to, Money amount) {
        // Acquire locks in consistent order to prevent deadlock
        Lock fromLock = lockManager.acquire(from);
        Lock toLock = lockManager.acquire(to);
        
        try {
            from.debit(amount);      // Can this throw?
            to.credit(amount);       // Can this throw?
            
            auditLog.record(from, to, amount);  // Can this throw?
            notificationService.notify(from.getOwner(), "Transfer complete");
        } finally {
            toLock.release();
            fromLock.release();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

impl TransferService {
    pub fn transfer_money(
        &self,
        from: &mut Account,
        to: &mut Account,
        amount: Money,
    ) -> Result<TransferReceipt, TransferError> {
        // With Result types, every fallible operation is visible
        let _from_lock = self.lock_manager.acquire(from)?;
        let _to_lock = self.lock_manager.acquire(to)?;
        
        // Explicit: this can fail with InsufficientFunds
        from.debit(amount)?;
        
        // If credit fails, we need to compensate
        if let Err(e) = to.credit(amount) {
            // Rollback the debit
            from.credit(amount).expect("Rollback must succeed");
            return Err(e.into());
        }
        
        // Audit log failure is logged but doesn't fail the transfer
        if let Err(e) = self.audit_log.record(from, to, amount) {
            log::error!("Audit log failed: {:?}", e);
            // Continue - transfer succeeded
        }
        
        // Notification failure is just a warning
        if let Err(e) = self.notification_service.notify(
            from.get_owner(), 
            "Transfer complete"
        ) {
            log::warn!("Notification failed: {:?}", e);
        }
        
        Ok(TransferReceipt::new(from, to, amount))
    }
}
 
// Reading this code, every possible failure point is visible.
// The handling strategy for each is explicit and reviewable.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn create_user_with_invalid_email_returns_validation_error() {
        let service = UserService::new(mock_repository(), mock_email());
        
        let result = service.create_user("not-an-email", "ValidPass123!");
        
        // Error is a value we can assert on
        assert!(result.is_err());
        match result.unwrap_err() {
            CreateUserError::InvalidEmail(msg) => {
                assert!(msg.contains("@"));
            }
            other => panic!("Expected InvalidEmail, got {:?}", other),
        }
    }
    
    #[test]
    fn create_user_with_existing_email_returns_conflict() {
        let mut mock_repo = mock_repository();
        mock_repo.expect_exists_by_email()
            .returning(|_| Ok(true));  // Email exists
        
        let service = UserService::new(mock_repo, mock_email());
        
        let result = service.create_user("taken@example.com", "ValidPass123!");
        
        assert!(matches!(result, Err(CreateUserError::EmailExists(_))));
    }
    
    #[test]
    fn create_user_database_failure_is_propagated() {
        let mut mock_repo = mock_repository();
        mock_repo.expect_save()
            .returning(|_| Err(DatabaseError::ConnectionLost));
        
        let service = UserService::new(mock_repo, mock_email());
        
        let result = service.create_user("new@example.com", "ValidPass123!");
        
        assert!(matches!(result, Err(CreateUserError::Database(_))));
    }
}