Rakuten Interview Questions Cheat Sheet (DRAFT) by woshiamiaojiang

@SpringBootApplication
public class SpringBootApiExample {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootApiExample.class, args);
    }

    // DTO (Data Transfer Object) class for request body validation
    @Validated
    static class RequestData {
        @NotBlank(message = "Message cannot be blank")
        private String message;

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }
    }

    // Custom exception handler for 400 Bad Request and 500 Internal Server Error
    @RestControllerAdvice
    static class CustomExceptionHandler {
        @ExceptionHandler(MethodArgumentNotValidException.class)
        ResponseEntity<String> handleValidationException(MethodArgumentNotValidException ex) {
            String errorMessage = ex.getBindingResult().getFieldError().getDefaultMessage();
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorMessage);
        }

        @ExceptionHandler(Exception.class)
        ResponseEntity<String> handleInternalServerError(Exception ex) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Internal Server Error");
        }
    }

    // POST endpoint with request body validation and authorization check
    @PostMapping("/api/post")
    @Secured("ROLE_USER")
    ResponseEntity<String> postEndpoint(
            @Valid @RequestBody RequestData requestData,
            @AuthenticationPrincipal User authenticatedUser
    ) {
        // You can access the authenticated user's information if needed
        String username = authenticatedUser.getUsername();

        // Process the request data (e.g., save it to a database)
        String message = requestData.getMessage();
        return ResponseEntity.ok("Received POST request with message: " + message);
    }

    // GET endpoint with authorization check
    @GetMapping("/api/get")
    @Secured("ROLE_ADMIN")
    ResponseEntity<String> getEndpoint() {
        // Process the GET request
        return ResponseEntity.ok("Received GET request");
    }
}

Integration Testing in Java:

Setup Testing Environment: Integration testing often requires setting up a test environment that resembles the production environment. This includes configuring databases, external services, and any other dependencies.

Choose a Testing Approach:

Embedded Containers: You can use embedded containers like Spring Boot's @SpringBootTest for testing Spring-based applications. These containers provide a controlled environment for integration testing.
Docker Containers: Another approach is to use Docker containers to spin up test versions of external services and databases. Tools like Testcontainers can help with this.
Write Integration Tests: Write test cases that focus on testing the interactions between different components or services. These tests typically cover scenarios like API calls, database operations, and messaging between components.

java
Copy code
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MyIntegrationTest {

    @LocalServerPort
    private int port;

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testApiEndpoint() {
        String url = "http://localhost:" + port + "/api/some-endpoint";
        String response = restTemplate.getForObject(url, String.class);
        // Perform assertions on the response
    }
}
Run Integration Tests: Similar to unit tests, use your build tool or IDE to run integration tests. Integration tests may take longer to execute than unit tests because they often involve external dependencies.

Clean Up: Ensure that your tests clean up any resources or data created during testing to leave the environment in a clean state.