DEV Community: Swapnil Gupta

How to deploy Containerized Spring Boot Application on AWS using CodePipeline

Swapnil Gupta — Tue, 26 Mar 2024 12:10:48 +0000

Requirements :
1.Aws Account

Docker
Aws codePipeline
AWS ECS
Dockerfile
BuildSpec file

Understanding JWT Token in Spring Boot Security with Chat GPT AI

Swapnil Gupta — Mon, 18 Dec 2023 19:13:52 +0000

🚨 Tech Deep Dive: Spring Boot Security with JWTs - A Must for Developers with Chat GPT-4 Prompts

We cannot fight against AI for long but we can utilise to get the best out of it, so enjoy my new initiative of using ChatGPT-4 prompts in the comments to understand the thought process of development and content creation. Let me know if you need more topics, Starting today with JWT in Spring Boot!

https://chat.openai.com/share/fc1de031-bc62-490a-9359-398497c1cecb

🔍 JWT in the Limelight: Why It's a Game-Changer for Spring Boot-

Stateless Authentication: JWTs eliminate server-side storage of authentication tokens, reducing server load and enhancing scalability.
Compact and Self-contained: JWTs encapsulate user identity and claims in a compact JSON format, making them ideal for passing information between services.

🔧 Integrating JWT with Spring Boot: A Technical Walkthrough

Step 1: Security Configuration: Utilize Spring Security to set up a JWT-based authentication mechanism. This includes configuring a WebSecurityConfigurerAdapter to specify how security is managed.

Step 2: Custom Authentication Filter: Create a custom JwtRequestFilter to intercept requests. This filter should extract the JWT, validate it, and set the SecurityContextHolder with user details for authorized requests.

Step 3: JWT Utility Class: Implement a utility class for generating and validating JWTs. Use libraries like io.jsonwebtoken:jjwt for token creation, setting claims, expiration, and signing the token with a secret key.

Step 4: Exception Handling: Handle exceptions like ExpiredJwtException or MalformedJwtException to manage token validity and integrity.

🚀 Real-World Applications and Benefits

Microservices Authentication: JWTs are ideal for authenticating requests in a microservices architecture, ensuring each service can validate tokens independently.
Cross-Domain Authentication:** Use JWTs to authenticate users across different domains, essential for applications with multiple front-end portals.
Jwt tokens can help you to secure your frontend and backend both

🔐 Security Best Practices with JWT in Spring Boot

HTTPS Enforcement: Always transmit JWTs over HTTPS to prevent token interception and ensure confidentiality.
Strong Secret Keys:Use complex, unpredictable secret keys for signing JWTs to prevent token forgery.
Token Expiry: Implement short-lived tokens and refresh tokens strategy to minimize the impact of a compromised token.
Claim-based Authorization: Utilize JWT claims to enforce fine-grained access control in your application.

Let's connect and exchange more on this topic! Share your experiences, challenges, or questions in the comments.

SpringBoot #JWT #WebSecurity #JavaDevelopment #TechInsights #DeveloperCommunity

List in Java

Swapnil Gupta — Fri, 28 Jul 2023 19:38:49 +0000

Java List Interface Explained with Complex Example

In Java, the List interface is a part of the java.util package and represents an ordered collection of elements, allowing duplicates. It extends the Collection interface and provides additional methods to manipulate elements based on their index. The List interface is implemented by several classes in Java, including ArrayList, LinkedList, and others.

List Interface Overview

The List interface is generic, meaning it can work with any data type specified within angular brackets (<>). Here's the basic syntax of the List interface:

public interface List<E> extends Collection<E> {
    // List-specific methods
}

Some of the essential methods provided by the List interface include:

boolean add(E element): Appends the specified element to the end of the list.
void add(int index, E element): Inserts the specified element at the specified position in the list.
E get(int index): Returns the element at the specified position in the list.
int size(): Returns the number of elements in the list.
boolean isEmpty(): Returns true if the list is empty, false otherwise.
E remove(int index): Removes the element at the specified position in the list.
boolean remove(Object obj): Removes the first occurrence of the specified element from the list.
Complex Example: To-Do List Application

Let's illustrate the use of the List interface with a complex example of a simple To-Do List application. In this application, we will create a list of tasks that users can add, remove, and mark as completed. We will use the ArrayList class to implement the List interface.

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class ToDoListApp {
    public static void main(String[] args) {
        List<String> toDoList = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        int choice;

        do {
            displayMenu();
            choice = scanner.nextInt();
            scanner.nextLine(); // Consume the newline character after reading the integer

            switch (choice) {
                case 1:
                    System.out.print("Enter the task to add: ");
                    String task = scanner.nextLine();
                    toDoList.add(task);
                    System.out.println("Task added: " + task);
                    break;

                case 2:
                    if (!toDoList.isEmpty()) {
                        System.out.println("Current Tasks:");
                        for (int i = 0; i < toDoList.size(); i++) {
                            System.out.println((i + 1) + ". " + toDoList.get(i));
                        }
                        System.out.print("Enter the task number to mark as completed: ");
                        int taskNumber = scanner.nextInt();
                        scanner.nextLine(); // Consume the newline character after reading the integer

                        if (taskNumber >= 1 && taskNumber <= toDoList.size()) {
                            String completedTask = toDoList.remove(taskNumber - 1);
                            System.out.println("Task completed: " + completedTask);
                        } else {
                            System.out.println("Invalid task number.");
                        }
                    } else {
                        System.out.println("No tasks to mark as completed. The list is empty.");
                    }
                    break;

                case 3:
                    if (!toDoList.isEmpty()) {
                        System.out.println("Current Tasks:");
                        for (String task : toDoList) {
                            System.out.println("- " + task);
                        }
                    } else {
                        System.out.println("No tasks to display. The list is empty.");
                    }
                    break;

                case 0:
                    System.out.println("Exiting the To-Do List application.");
                    break;

                default:
                    System.out.println("Invalid choice. Please try again.");
            }

        } while (choice != 0);

        scanner.close();
    }

    private static void displayMenu() {
        System.out.println("\n--- To-Do List ---");
        System.out.println("1. Add Task");
        System.out.println("2. Mark Task as Completed");
        System.out.println("3. View Tasks");
        System.out.println("0. Exit");
        System.out.print("Enter your choice: ");
    }
}

In this example, we use an ArrayList to store the tasks added by the user. The application presents a simple text-based menu to add tasks, mark tasks as completed, view current tasks, and exit the application.

Remember that this example is kept simple for illustration purposes and does not cover error handling or data persistence.

Conclusion

In this blog post, we explored the List interface in Java, which allows us to manage ordered collections of elements. We learned about its basic usage and common methods. To demonstrate its practical application, we developed a To-Do List application using the ArrayList class to implement the List interface. By understanding the List interface, you can effectively work with collections of elements in Java and build more complex applications that require data management and manipulation.

Remember, Java offers various collection interfaces and classes, and the choice of which one to use depends on your specific use case and requirements. Happy coding!

Streams Interview questions in Java

Swapnil Gupta — Wed, 26 Jul 2023 22:05:59 +0000

Link to Blog: https://dev.to/swapnilxi/stream-in-java-4p27

10 easy question to crack next java 8 Streams:

What is a Stream in Java 8?
- A stream is a sequence of objects that supports various methods which can be pipelined to produce the desired result. It introduces functional programming concepts in Java, which makes programming more efficient and easy.
What are the benefits of using Streams in Java?
- Streams allow for declarative programming (expressing what should be done, not how), parallel execution, and they can handle large datasets with optimized operations like filter, map, and reduce.
Can you name some common operations we can perform on a Stream?
- Common operations on streams include filter (to select elements based on a condition), map (to transform elements), reduce (to combine elements), collect (to accumulate elements into a collection), and forEach (to perform an action on each element).
Can you explain the difference between a sequential and a parallel Stream?
- Sequential streams work on a single thread whereas parallel streams utilize multiple threads. Parallel streams are more suitable for tasks on large datasets that can be performed independently and in parallel.
What is the difference between Intermediate and Terminal operations in a Stream?
- Intermediate operations are operations (like filter, map) that transform a Stream into another Stream. They are always lazy, executing an intermediate operation such as filter() does not actually perform any filtering, but instead creates a new Stream that, when traversed, contains the elements of the initial Stream that match the given Predicate. Terminal operations (like forEach, reduce) produce a result or a side-effect.
What is the short-circuiting operation in a Stream?
- Short-circuiting operations are operations (like limit, findFirst, findAny) that don't necessarily need to process the entire stream to produce a result. For example, "findFirst()" doesn't need to traverse the whole Stream if it has already found the first element.
Explain the 'map' function in Streams. Can you provide a simple example of its usage?
- The 'map' function takes a Function as an argument, which is applied to each element in the stream and transforms it into a new element. For example, you might use 'map' to transform a Stream of strings into their lengths: stream.map(s -> s.length()).
What does the 'collect' terminal operation do? Can you show how to use it to convert a Stream into a List?
- The 'collect' operation is used to receive elements from a stream and store them into a collection. An example of transforming a Stream into a List would be: List<String> list = stream.collect(Collectors.toList());
What is the difference between 'reduce' and 'collect'?
- 'reduce' is a terminal operation that takes a BinaryOperator as an argument and returns an Optional describing the reduced value, if any. This operation is used for combining elements of the stream to produce a single cumulative result. On the other hand, 'collect' is also a terminal operation but it's used to transform the elements of the stream into a different data structure or a value.
How can you create a parallel Stream from a collection? Explain the potential benefits and drawbacks of doing so.
- A parallel Stream can be created from a collection by calling parallelStream(). The benefit of this is that it can speed up operations by utilizing multiple threads of execution. However, it's important to note that not all tasks will see a benefit from parallelization and in some cases, it may even degrade performance due to the overhead of managing multiple threads. It's generally beneficial for large datasets with heavy computational tasks that can be performed independently.

11.** How to apply required logic and operation in Stream? **

filter Method.

Enjoy your journey through Java 8 streams and keep exploring more advanced topics as you go!

(Easy) What is a Stream in Java 8? How is it different from a traditional collection?
Understanding the basics of the Stream API and how it differs from other collections will provide a solid foundation for deeper exploration.

(Easy) Can you explain the difference between intermediate and terminal operations in Java 8 Streams?
Recognizing the distinct functions of these two types of operations is vital for using the Stream API effectively.

Computation on Demand: Unlike collections, which are data structures holding all their elements in memory, streams are computed on demand. This allows streams to represent large or infinite data sets, processing elements one at a time.
Functional in Nature: Operations on a stream produce a result, but do not modify the underlying data source, creating a new Stream instead. For collections, if you modify the collection, you directly change its content.
Lazy Evaluation: Many operations on streams, such as filter or map, are 'lazy', meaning they're not executed until a terminal operation is invoked on the stream. This can improve performance by allowing computations to be optimized and reduced.
Designed for Pipelining: Streams are designed for pipelining. They allow for operations to be performed in a chain (or 'pipeline'), improving readability and often performance as well.
Parallel Execution: The Stream API has built-in support for parallel execution, allowing operations to be transparently spread across multiple cores or threads. This is much more difficult with traditional collections.
One-time Use: Streams can be traversed only once. After that, a stream is said to be consumed. You'll need to create a new stream to traverse the data again. Collections, on the other hand, can be traversed multiple times.
No Storage: Streams do not have a storage or do not modify the data source, they just convey the data from its source.

(Easy) What is the purpose of the .map() function in Java 8's Stream API?
This question helps understand one of the most common operations used in Stream API.
(Medium) Can you demonstrate the usage of .filter() and .collect() methods with a simple example?
Practical implementation of these methods gives a deeper understanding of how they work.
(Medium) How would you generate an infinite Stream in Java 8?
This question goes a bit more into the unique possibilities of the Stream API.
(Medium) How can you convert a Stream into a Map in Java 8?
Converting between different data types is a key skill in dealing with streams.
(Hard) What are the differences between a sequential stream and a parallel stream? When might you use one over the other?
Understanding the performance implications of these two types of streams is crucial.
(Hard) Can you give an example of how to use .reduce() function in Java 8's Stream API?
This question tests your knowledge of more complex operations within the Stream API.
(Hard) What does the .flatMap() function do? Can you give an example of when it might be useful?
Deepening the understanding of more complex, often misunderstood operations in the Stream API.
(Very Hard) How would you handle checked exceptions in a Java 8 Stream?
This question probes the advanced concepts and your ability to handle edge cases using the Stream API.

How to import CSV data in spring boot to save in PostgreSQL: Spring Batch

Swapnil Gupta — Wed, 19 Jul 2023 21:11:27 +0000

This could be done using OpenCSV, Apache POI and Spring Batch

if you have small amount of Data we can use OpenCSV, if we are using Excel we can use Apache POI, today we tackling the large dataset set situation that we can use Spring Batch .

large dataset can be handled using Spring Batch .

SQL Query in Spring Boot

Swapnil Gupta — Thu, 22 Jun 2023 10:32:06 +0000

we will understand the usages by examples like one in the case of finding existing record through the object and other in the case of searching through api call

To find someone by email or record that is already exist in database records

UserRepository.java

public interface UserRepository extends JpaRepository<User,Integer>{
    Optional<User> findByUsername(String username);
    // Optional<User> findByEmail(String email);


    @Query("SELECT u.username, u.email FROM User u WHERE u.email = :email")
    Optional<User> findByEmail(@Param("email") String email);

}

To search a query

ProductRepository.java

@Query("SELECT p FROM Product p WHERE " +
            "p.name LIKE CONCAT('%',:query, '%')")
    List<Product> searchProducts(String query);

@Query tag is used in both the cases we will look for the differences in controller class

 @PostMapping("adduser")
    public ResponseEntity<String> createUser(@RequestBody User user) {          if(userService.isUserExists(user.getUsername(), user.getEmail())) {
            System.out.println("User exist already");
            return ResponseEntity.status(HttpStatus.CONFLICT).body("Username or Email already exists for : " + user.getEmail());
        }

          User createdUser = userService.createUser(user);
          System.out.println("new user created");
          return ResponseEntity.ok("User created successfully");
      }

@RequestBody is used to accept the body of user

if in case of Product search

  @GetMapping("/search")
    public ResponseEntity<List<Product>> searchProducts(@RequestParam("query") String query){
        return ResponseEntity.ok(service.searchProducts(query));
    }

@RequestParam is there, which can accept parameters and optional .

I want to keep it short and simple, will share more connect me on https://linkedin.com/in/swapnilxi

Mockito example

Swapnil Gupta — Tue, 13 Jun 2023 13:05:46 +0000

Certainly! Here's an example of testing a private method and switch cases using only Mockito:

public class DiscountService {

    public double calculateDiscount(CustomerType customerType, double totalPrice) {
        double discountPercentage = calculateDiscountPercentage(customerType);
        return totalPrice - (totalPrice * discountPercentage);
    }

    private double calculateDiscountPercentage(CustomerType customerType) {
        switch (customerType) {
            case REGULAR:
                return 0.1;
            case PREMIUM:
                return 0.2;
            case VIP:
                return 0.3;
            default:
                throw new IllegalArgumentException("Invalid customer type: " + customerType);
        }
    }
}

And here's the corresponding test using Mockito:

@RunWith(MockitoJUnitRunner.class)
public class DiscountServiceTest {

    private DiscountService discountService;

    @Before
    public void setUp() {
        discountService = Mockito.spy(new DiscountService());
    }

    @Test
    public void testCalculateDiscount_RegularCustomer() throws Exception {
        // Arrange
        CustomerType customerType = CustomerType.REGULAR;
        double totalPrice = 100.0;

        Mockito.doReturn(0.1).when(discountService).calculateDiscountPercentage(customerType);

        // Act
        double discountedPrice = discountService.calculateDiscount(customerType, totalPrice);

        // Assert
        assertEquals(90.0, discountedPrice, 0.01);
        Mockito.verify(discountService, Mockito.times(1))
                .calculateDiscountPercentage(customerType);
    }

    // Additional test cases for other customer types
}

In this example:

We use the MockitoJUnitRunner and @Before annotation to set up the test.
We create a spy object for the DiscountService using Mockito.spy() to allow us to mock the private method.
We use Mockito.doReturn(0.1).when(discountService).calculateDiscountPercentage(customerType) to mock the behavior of the private method based on the customer type.
We invoke the calculateDiscount() method and verify that the discounted price is calculated correctly.
We use Mockito.verify(discountService, Mockito.times(1)).calculateDiscountPercentage(customerType) to verify that the private method was called with the correct arguments.

Again, note that testing private methods directly is generally not recommended. It is preferable to test the behavior of the private method indirectly by testing the public methods that rely on it.

Certainly! Here's a step-by-step explanation of how to test a private method and switch cases using Mockito:

Set up the Test Environment:
- Annotate your test class with @RunWith(MockitoJUnitRunner.class) to use the Mockito test runner.
- Create an instance of the class you want to test, in this case, DiscountService.
- Use Mockito.spy() to create a spy object that allows you to mock the behavior of the private method.

@RunWith(MockitoJUnitRunner.class)
public class DiscountServiceTest {

    private DiscountService discountService;

    @Before
    public void setUp() {
        discountService = Mockito.spy(new DiscountService());
    }

    // Rest of the test methods...
}

Mock the Private Method Behavior:
- Use Mockito.doReturn() to define the behavior of the private method when called with specific arguments.

@Test
public void testCalculateDiscount_RegularCustomer() throws Exception {
    // Arrange
    CustomerType customerType = CustomerType.REGULAR;
    double totalPrice = 100.0;

    Mockito.doReturn(0.1).when(discountService).calculateDiscountPercentage(customerType);

    // Act
    double discountedPrice = discountService.calculateDiscount(customerType, totalPrice);

    // Assert
    assertEquals(90.0, discountedPrice, 0.01);
    Mockito.verify(discountService, Mockito.times(1)).calculateDiscountPercentage(customerType);
}

Invoke the Public Method and Verify Results:
- Invoke the public method you want to test, such as calculateDiscount(), with the necessary arguments.
- Use assertions to verify that the expected results are obtained.
- Use Mockito.verify() to ensure that the private method was called with the correct arguments.

// ...

@Test
public void testCalculateDiscount_RegularCustomer() throws Exception {
    // Arrange
    CustomerType customerType = CustomerType.REGULAR;
    double totalPrice = 100.0;

    Mockito.doReturn(0.1).when(discountService).calculateDiscountPercentage(customerType);

    // Act
    double discountedPrice = discountService.calculateDiscount(customerType, totalPrice);

    // Assert
    assertEquals(90.0, discountedPrice, 0.01);
    Mockito.verify(discountService, Mockito.times(1)).calculateDiscountPercentage(customerType);
}

// ...

By following these steps, you can effectively test a private method and switch cases using Mockito. Remember that while testing private methods directly is possible with Mockito, it is generally recommended to focus on testing the behavior of public methods that rely on the private logic. This approach ensures that the desired behavior is tested through the public interface of your classes.

Example 2

Certainly! Here's an example that demonstrates how to test a private method with switch cases using Mockito's spy():

Consider a PaymentService class that processes payments based on different payment methods. The class has a private method, calculateFee, which calculates the fee based on the selected payment method.

public class PaymentService {

    public double processPayment(double amount, PaymentMethod paymentMethod) {
        double fee = calculateFee(paymentMethod);
        return amount + fee;
    }

    private double calculateFee(PaymentMethod paymentMethod) {
        double fee;
        switch (paymentMethod) {
            case CREDIT_CARD:
                fee = 0.02;
                break;
            case DEBIT_CARD:
                fee = 0.01;
                break;
            case PAYPAL:
                fee = 0.03;
                break;
            default:
                throw new IllegalArgumentException("Invalid payment method: " + paymentMethod);
        }
        return fee;
    }
}

To test the private method calculateFee with switch cases, we can use the spy() method and Mockito.doCallRealMethod():

import org.mockito.Mockito;

public class PaymentServiceTest {

    @Test
    public void testCalculateFee() throws Exception {
        // Create a spy object of the PaymentService class
        PaymentService paymentService = Mockito.spy(new PaymentService());

        // Call the private method directly using Mockito.doCallRealMethod()
        double fee = Mockito.doCallRealMethod()
                .when(paymentService)
                .calculateFee(Mockito.any(PaymentMethod.class));

        // Assert the fee value for different payment methods
        assertEquals(0.02, paymentService.calculateFee(PaymentMethod.CREDIT_CARD), 0.01);
        assertEquals(0.01, paymentService.calculateFee(PaymentMethod.DEBIT_CARD), 0.01);
        assertEquals(0.03, paymentService.calculateFee(PaymentMethod.PAYPAL), 0.01);
    }
}

In this example:

We create a spy object of the PaymentService class using Mockito.spy(new PaymentService()).
We use Mockito.doCallRealMethod() to instruct Mockito to call the real implementation of the private method when it's invoked.
We assert the fee value returned by the calculateFee() method for different payment methods.

Note that in this example, we're testing the private method indirectly by invoking the public method that depends on it. By using spy() and doCallRealMethod(), we can ensure that the private method is executed with its real implementation while testing the overall behavior of the public method.

Remember that testing private methods directly is generally not recommended. It's preferable to focus on testing the behavior of public methods that rely on the private logic to ensure comprehensive testing.

Certainly! Here's a step-by-step explanation of how to test a private method with switch cases using Mockito's spy():

Create a Spy Object:
- To test a private method, we need to create a spy object using Mockito.spy().
- A spy object wraps an existing instance of a class and allows us to mock specific behaviors while still retaining the original functionality.
- In our example, we'll create a spy object of the PaymentService class.

PaymentService paymentService = Mockito.spy(new PaymentService());

Mock the Private Method Behavior:
- We'll use Mockito.doCallRealMethod() to instruct Mockito to call the real implementation of the private method when it's invoked.
- This allows us to test the private method indirectly by invoking the public method that depends on it.
- In our example, we'll mock the behavior of the private method, calculateFee, which calculates the fee based on the payment method.

Mockito.doCallRealMethod()
       .when(paymentService)
       .calculateFee(Mockito.any(PaymentMethod.class));

Invoke the Public Method and Assert Results:
- Since we've mocked the behavior of the private method, we can now invoke the public method that relies on it.
- In our example, we'll call the calculateFee() method for different payment methods and assert the expected fee values.
- We can use assertions, such as assertEquals, to verify that the fee values are as expected.

assertEquals(0.02, paymentService.calculateFee(PaymentMethod.CREDIT_CARD), 0.01);
assertEquals(0.01, paymentService.calculateFee(PaymentMethod.DEBIT_CARD), 0.01);
assertEquals(0.03, paymentService.calculateFee(PaymentMethod.PAYPAL), 0.01);

In this scenario, by using spy() and doCallRealMethod(), we create a spy object of the class under test and allow the private method to be executed with its real implementation. This way, we can test the overall behavior of the public method while indirectly testing the private method with switch cases.

Remember that it's generally recommended to focus on testing the behavior of public methods that rely on the private logic rather than testing private methods directly. This approach ensures that the desired behavior is tested through the public interface of your classes.

Example 3

Certainly! Here's a more complex example that involves testing a private method with switch cases using Mockito's spy():

Consider a ShippingService class that calculates the shipping cost based on the destination and shipping method. The class has a private method, calculateCost, which calculates the cost based on the destination country and shipping method type.

public class ShippingService {

    public double calculateShippingCost(String destinationCountry, ShippingMethod shippingMethod, double weight) {
        double cost = calculateCost(destinationCountry, shippingMethod);
        return cost * weight;
    }

    private double calculateCost(String destinationCountry, ShippingMethod shippingMethod) {
        double cost;
        switch (destinationCountry) {
            case "USA":
                cost = calculateCostForUSAShipping(shippingMethod);
                break;
            case "Canada":
                cost = calculateCostForCanadaShipping(shippingMethod);
                break;
            case "UK":
                cost = calculateCostForUKShipping(shippingMethod);
                break;
            default:
                throw new IllegalArgumentException("Invalid destination country: " + destinationCountry);
        }
        return cost;
    }

    private double calculateCostForUSAShipping(ShippingMethod shippingMethod) {
        switch (shippingMethod) {
            case STANDARD:
                return 5.0;
            case EXPRESS:
                return 10.0;
            default:
                throw new IllegalArgumentException("Invalid shipping method: " + shippingMethod);
        }
    }

    private double calculateCostForCanadaShipping(ShippingMethod shippingMethod) {
        switch (shippingMethod) {
            case STANDARD:
                return 7.0;
            case EXPRESS:
                return 12.0;
            default:
                throw new IllegalArgumentException("Invalid shipping method: " + shippingMethod);
        }
    }

    private double calculateCostForUKShipping(ShippingMethod shippingMethod) {
        switch (shippingMethod) {
            case STANDARD:
                return 8.0;
            case EXPRESS:
                return 14.0;
            default:
                throw new IllegalArgumentException("Invalid shipping method: " + shippingMethod);
        }
    }
}

To test the private method calculateCost with switch cases, we can use the spy() method and Mockito.doCallRealMethod():

import org.mockito.Mockito;

public class ShippingServiceTest {

    @Test
    public void testCalculateCost() throws Exception {
        // Create a spy object of the ShippingService class
        ShippingService shippingService = Mockito.spy(new ShippingService());

        // Call the private method directly using Mockito.doCallRealMethod()
        double cost = Mockito.doCallRealMethod()
                .when(shippingService)
                .calculateCost(Mockito.anyString(), Mockito.any(ShippingMethod.class));

        // Assert the cost value for different destination countries and shipping methods
        assertEquals(5.0, shippingService.calculateCost("USA", ShippingMethod.STANDARD), 0.01);
        assertEquals(10.0, shippingService.calculateCost("USA", ShippingMethod.EXPRESS), 0.01);

        assertEquals(7.0, shippingService.calculateCost("Canada", ShippingMethod.STANDARD), 0.01);
        assertEquals(12.0, shippingService.calculateCost("Canada", ShippingMethod.EXPRESS), 0.01);

        assertEquals(8.0, shippingService.calculateCost("UK", ShippingMethod.STANDARD), 0.01);
        assertEquals(14.0, shippingService.calculateCost("UK", ShippingMethod.EXPRESS), 0.01);
    }
}

In this example:

We create a spy object of the ShippingService class using Mockito.spy(new ShippingService()).
We use Mockito.doCallRealMethod() to instruct Mockito to call the real

implementation of the private method when it's invoked.

We assert the cost value returned by the calculateCost() method for different destination countries and shipping methods.

By using spy() and doCallRealMethod(), we create a spy object of the class under test and allow the private method to be executed with its real implementation. This way, we can test the overall behavior of the public method while indirectly testing the private methods with switch cases.

Remember to focus on testing the behavior of public methods that rely on the private logic rather than testing private methods directly. This approach ensures that the desired behavior is tested through the public interface of your classes.

Certainly! Here are some additional test cases you can add to the ShippingServiceTest class for the calculateCost method:

@Test
public void testCalculateCost_InvalidDestinationCountry() {
    // Arrange
    ShippingService shippingService = Mockito.spy(new ShippingService());
    String invalidCountry = "InvalidCountry";
    ShippingMethod shippingMethod = ShippingMethod.STANDARD;

    // Act and Assert
    assertThrows(IllegalArgumentException.class, () -> shippingService.calculateCost(invalidCountry, shippingMethod));
    Mockito.verify(shippingService).calculateCost(invalidCountry, shippingMethod);
}

@Test
public void testCalculateCost_InvalidShippingMethod() {
    // Arrange
    ShippingService shippingService = Mockito.spy(new ShippingService());
    String destinationCountry = "USA";
    ShippingMethod invalidMethod = null;

    // Act and Assert
    assertThrows(IllegalArgumentException.class, () -> shippingService.calculateCost(destinationCountry, invalidMethod));
    Mockito.verify(shippingService).calculateCost(destinationCountry, invalidMethod);
}

@Test
public void testCalculateShippingCost() {
    // Arrange
    ShippingService shippingService = Mockito.spy(new ShippingService());
    String destinationCountry = "USA";
    ShippingMethod shippingMethod = ShippingMethod.EXPRESS;
    double weight = 2.5;

    // Act
    double cost = shippingService.calculateShippingCost(destinationCountry, shippingMethod, weight);

    // Assert
    assertEquals(25.0, cost, 0.01);
    Mockito.verify(shippingService).calculateCost(destinationCountry, shippingMethod);
}

In the testCalculateCost_InvalidDestinationCountry test case, we verify that an IllegalArgumentException is thrown when an invalid destination country is provided. Similarly, in the testCalculateCost_InvalidShippingMethod test case, we check that an IllegalArgumentException is thrown when an invalid shipping method is passed.

The testCalculateShippingCost test case verifies the overall behavior of the calculateShippingCost method by asserting the calculated cost for a specific destination country, shipping method, and weight.

These additional test cases provide coverage for exceptional scenarios and ensure that the private method is being called with the correct parameters.

Remember to update the test class annotations accordingly to include the new test methods.

Certainly! Here are a few more test cases you can add to the ShippingServiceTest class for the calculateShippingCost method:

@Test
public void testCalculateShippingCost_ZeroWeight() {
    // Arrange
    ShippingService shippingService = Mockito.spy(new ShippingService());
    String destinationCountry = "USA";
    ShippingMethod shippingMethod = ShippingMethod.STANDARD;
    double weight = 0.0;

    // Act
    double cost = shippingService.calculateShippingCost(destinationCountry, shippingMethod, weight);

    // Assert
    assertEquals(0.0, cost, 0.01);
    Mockito.verify(shippingService).calculateCost(destinationCountry, shippingMethod);
}

@Test
public void testCalculateShippingCost_NegativeWeight() {
    // Arrange
    ShippingService shippingService = Mockito.spy(new ShippingService());
    String destinationCountry = "USA";
    ShippingMethod shippingMethod = ShippingMethod.EXPRESS;
    double weight = -2.5;

    // Act
    double cost = shippingService.calculateShippingCost(destinationCountry, shippingMethod, weight);

    // Assert
    assertEquals(-25.0, cost, 0.01); // Negative cost due to negative weight
    Mockito.verify(shippingService).calculateCost(destinationCountry, shippingMethod);
}

@Test
public void testCalculateShippingCost_RoundCost() {
    // Arrange
    ShippingService shippingService = Mockito.spy(new ShippingService());
    String destinationCountry = "Canada";
    ShippingMethod shippingMethod = ShippingMethod.STANDARD;
    double weight = 3.8;

    // Act
    double cost = shippingService.calculateShippingCost(destinationCountry, shippingMethod, weight);

    // Assert
    assertEquals(26.6, cost, 0.01); // Rounded cost for weight = 3.8 and cost = 7.0
    Mockito.verify(shippingService).calculateCost(destinationCountry, shippingMethod);
}

In the testCalculateShippingCost_ZeroWeight test case, we check that the cost is correctly calculated as zero when the weight is zero.

The testCalculateShippingCost_NegativeWeight test case ensures that the cost can be calculated correctly even when the weight is negative. It may result in a negative cost due to the negative weight value.

The testCalculateShippingCost_RoundCost test case verifies that the cost is rounded to two decimal places for weights that result in non-integer costs. It checks the rounding behavior of the shipping cost.

These additional test cases cover different scenarios such as zero weight, negative weight, and rounding of costs, ensuring that the calculateShippingCost method handles such cases correctly.

Remember to update the test class annotations accordingly to include the new test methods.

Bonus

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

public class MyTestClass {

private MyService myService;

@BeforeAll
public void setup() {
    // Perform common setup for all test methods
    myService = new MyService();
}

@Test
public void testMethodA() {
    // Arrange
    MyService spyService = Mockito.spy(myService);

    // Perform specific setup for testMethodA
    Mockito.when(spyService.someMethod()).thenReturn("Mocked Value");

    // Act and Assert
    // ... Test logic for testMethodA
}

@Test
public void testMethodB() {
    // Arrange
    MyService spyService = Mockito.spy(myService);

    // Perform specific setup for testMethodB
    // ... Example: Mockito.when(spyService.someOtherMethod()).thenReturn("Mocked Value");

    // Act and Assert
    // ... Test logic for testMethodB
}

}

Arrays.fill in Java

Swapnil Gupta — Thu, 26 Jan 2023 09:11:04 +0000

Ever thought how to fill the whole array with same value in Java !?
in CPP, we use memset or can initialise with any value, when it comes to java, we use Arrays.Fill().

Arrays.fill(name of Array, value), it takes the name of array and value

index

we can use form start index to end index to fill the particular value

int ar[] = {2, 2, 2, 2, 2, 2, 2, 2, 2};
  // Fill from index 1 to index 4.
Arrays.fill(ar, 1, 5, 10);
System.out.println(Arrays.toString(ar));

[2, 10, 10, 10, 10, 2, 2, 2, 2]

it is very helpful in Dp or when you want to assign same value.

multiple values

 public static void main(String[] args)
    {
        int [][]ar = new int [3][4];

        // Fill each row with 10. 
        for (int[] row : ar)
            Arrays.fill(row, 10);

        System.out.println(Arrays.deepToString(ar));
    }

we have used Arrays.deepToString() method Printing 2D array.

using stream method

double[][] arr = new double[20][4];
Arrays.stream(arr).forEach(a -> Arrays.fill(a, 0));

3D array

 int[][][] ar = new int[3][4][5];

        // Fill each row with -1. 
        for (int[][] row : ar) {
            for (int[] rowColumn : row) {
                Arrays.fill(rowColumn, -1);
            }
        }

        System.out.println(Arrays.deepToString(ar));
    }

understanding

double[][] arr = new double[5][2];
Arrays.fill(arr[0], 0);
Arrays.fill(arr[1], 0);
Arrays.fill(arr[2], 0);
Arrays.fill(arr[3], 0);
Arrays.fill(arr[4], 0);

Integer to String and String to Integer in Java

Swapnil Gupta — Mon, 02 Jan 2023 18:17:02 +0000

We can use value of :

Alexander Nikiforov on website ( teamtreeHouse)
on Oct 2, 2016
In Java you should use valueOf method for both conversions:

https://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html#valueOf(java.lang.String)

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#valueOf(int)

So to convert int to String you write:

int number = 1;
String stringFromNumber = String.valueOf(number);
// shorthand will be
String stringFromNumber = number + "";

To convert int to String is harder, because you have to account for NumberFormatException, see Docs links above:

String numberString = "1";
int intFromString;
try {
  intFromString = Integer.valueOf(numberString);
} catch (NumberFormatException nfe) {
   // do something
   System.out.println(numberString + " is not a number");
}

we can use parseInt:

This method is used to get the primitive data type of a certain String. parseXxx() is a static method and can have one argument or two.

Syntax
Following are all the variants of this method −

static int parseInt(String s)
static int parseInt(String s, int radix)

public class Test { 

   public static void main(String args[]) {
      int x =Integer.parseInt("9");
      double c = Double.parseDouble("5");
      int b = Integer.parseInt("444",16);

      System.out.println(x);
      System.out.println(c);
      System.out.println(b);
   }
}

9
5.0
1092

ArrayList to Array Conversion in Java

Swapnil Gupta — Mon, 19 Dec 2022 06:38:24 +0000

https://codeahoy.com/java/How-To-Convery-ArrayList-To-Array/

Method 1-

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    for (int i=0; i < ret.length; i++)
    {
        ret[i] = integers.get(i).intValue();
    }
    return ret;
}

Method 2-

List<Integer> ans =  new ArrayList<Integer>();
int[] n = (int[])ans.toArray(int[ans.size()]);

Method 3- using Steam
int[] arr = list.stream().mapToInt(i -> i).toArray();

(from stackoverflow)

If you are using java-8 there's also another way to do this.

int[] arr = list.stream().mapToInt(i -> i).toArray();
What it does is:

getting a Stream from the list
obtaining an IntStream by mapping each element to itself (identity function), unboxing the int value hold by each Integer object (done automatically since Java 5)
getting the array of int by calling toArray
You could also explicitly call intValue via a method reference, i.e:

int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

LeetCode: Greatest Sum Divisible by 3

Swapnil Gupta — Wed, 02 Nov 2022 13:23:59 +0000

LeetCode Discussion

class Solution {
    public int maxSumDivThree(int[] nums) {
        int res = 0, leftOne = 20000, leftTwo = 20000;
        for(int n:nums){
            res+=n;
            if(n%3==1){
                leftTwo = Math.min(leftTwo,leftOne+n);
                leftOne = Math.min(leftOne,n);
            }
            if(n%3==2) {
                leftOne = Math.min(leftOne,leftTwo+n);
                leftTwo = Math.min(leftTwo,n);
            }
        }
        if(res%3==0) return res;
        if(res%3==1) return res-leftOne;
        return res - leftTwo;

    }
}
Dp solution for K problem:

class Solution {
    public int maxSumDivThree(int[] nums) {
        return maxSumDivK(nums,3);
    }
    public int maxSumDivK(int[] nums, int k){
        if(k==0) return -1;
        int[] dp = new int[k];
        for(int num : nums){
            int tmp[] = Arrays.copyOf(dp,k);
            for(int i=0;i<k;i++){
                dp[(num+tmp[i])%k] = Math.max(dp[(num+tmp[i])%k],num+tmp[i]);
            }
        }
        return dp[0];
    }
}

Binary Search: Recursive and Iterative method

Swapnil Gupta — Wed, 02 Nov 2022 12:09:39 +0000

LeetCode discussion


class Solution {

    // iterative
    public int search(int[] nums, int target) {

        // Corner case
        if(nums == null || nums.length == 0) return -1;

        int low = 0;
        int high = nums.length-1;

        while(low <= high){
            int mid = (high-low)/2 + low;
            if(nums[mid] == target) return mid;
            if(nums[mid] < target) low = mid + 1;
            else high = mid  - 1;
        }
        return -1;
    }

    // Recursive 
    public static int Rsearch(int[] nums, int low, int high, int target){

        if(low > high) return -1;

        int mid = low + (high-low)/2;
        if(target == nums[mid])
            return mid;
        else if(target < nums[mid])
            return Rsearch(nums, low, mid-1, target);
        else
            return Rsearch(nums, mid+1, high, target);
    }
}

A good blog to read about binary Search callicoder