Blog

JetBrains AI Assistant : Revolutionizing Tech Solutions

by Chris Adams | Apr 16, 2025 | Automation Testing, Blog, Latest Post | 0 comments

In the ever-evolving world of software development, efficiency and speed are key. As projects grow in complexity and deadlines tighten, AI-powered tools have become vital for streamlining workflows and improving productivity. One such game-changing tool is JetBrains AI Assistant a powerful feature now built directly into popular JetBrains IDEs like IntelliJ IDEA, PyCharm, and WebStorm. JetBrains AI brings intelligent support to both developers and testers by assisting with code generation, refactoring, and test automation. It helps developers write cleaner code faster and aids testers in quickly understanding test logic, creating new test cases, and maintaining robust test suites.

Whether you’re a seasoned developer or an automation tester, JetBrains AI acts like a smart coding companion making complex tasks simpler, reducing manual effort, and enhancing overall code quality. In this blog, we’ll dive into how JetBrains AI works and show its capabilities by simply demonstrating its real-world benefits.

What is JetBrains AI Assistant?

JetBrains AI Assistant is an intelligent coding assistant embedded within your JetBrains IDE. Powered by large language models (LLMs), it’s designed to help techies—whether you’re into development, testing, or automation—handle everyday coding tasks more efficiently.

Here’s what it can do:

• Generate new code or test scripts from natural language prompts
• Provide smart in-line suggestions and auto-completions while you code
• Explain unfamiliar code in plain English—great for understanding legacy code or complex logic
• Refactor existing code or tests to follow best practices and improve readability
• Generate documentation and commit messages automatically

Whether you’re kicking off a new project or maintaining a long-standing codebase, JetBrains AI helps techies work faster, cleaner, and smarter—no matter your role. Let’s see how to get started with JetBrains AI.

Installing JetBrains AI Plugin in IntelliJ IDEA

Requirements

• IntelliJ IDEA 2023.2 or later (Community or Ultimate)
• JetBrains Account (Free to sign up)

1)Click the AI Assistant icon in the top-left corner of IntelliJ IDEA.

2)Click on Install Plugin.

3)Once You Installed You will login or register

4)Once logged in, you’ll see an option to Start Free Trial to activate JetBrains AI features.

5)This is the section where you can enter and submit your prompt

Let’s Start with a Simple Java Program

Now that we’ve explored what JetBrains AI Assistant can do, let’s see it in action with a hands-on example. To demonstrate its capabilities, we’ll walk through a basic Java calculator project. This example highlights how the AI Assistant can help generate code, complete logic, explain functionality, refactor structure, document classes, and even suggest commit messages—all within a real coding scenario.

Whether you’re a developer writing core features or a tester creating test logic, this simple program is a great starting point to understand how JetBrains AI can enhance your workflow.

1. Code Generation

Prompt: “Generate a Java class that implements a basic calculator with add, subtract, multiply, and divide methods.”

JetBrains AI can instantly create a boilerplate Calculator class for you. Here’s a sample result:

2. Code Completion

While typing inside a method, JetBrains AI predicts what you intend to write next. For example, when you start writing the add method, it might auto-suggest the return statement based on the method name and parameters.

Prompt: Start writing public int add(int a, int b) { and wait for the AI to auto-complete.

Enter this in the AI Assistant chat.The AI will generate updated code where a and b are taken from the user via console input.

3. Code Explanation

You can ask JetBrains AI to explain any method or class.

Prompt: “Explain what the divide method does.”

Output:

This method takes two integers and returns the result of dividing the first by the second. It also checks if the divisor is zero to prevent a runtime exception.

Perfect for junior developers or anyone trying to understand unfamiliar code.

4. Refactoring Suggestions

JetBrains AI can suggest improvements if your code is too verbose or doesn’t follow best practices.

Prompt: “Refactor this Calculator class to make it more modular.”

5. Documentation Generation

Adding documentation is often the most skipped part of development, but not anymore.

Prompt: “Add JavaDoc comments for this Calculator class.”

JetBrains AI will generate JavaDoc for each method, helping improve code readability and aligning with project documentation standards.

6. Commit Message Suggestions

After writing or updating your Calculator class, ask:

Prompt: “Generate a commit message for adding the Calculator class with basic operations.”

Conclusion

JetBrains AI Assistant is not just another plugin it’s your smart programming companion. From writing your first method to generating JavaDoc and commit messages, it makes the development process smoother, smarter, and more efficient. As we saw in this blog, even a basic Java calculator app becomes a perfect canvas to showcase AI’s potential in coding. If you’re a developer looking to boost productivity, improve code quality, and reduce burnout, JetBrains AI is a game-changer.

Frequently Asked Questions

Spring Boot for Automation Testing: A Tester’s Guide

by Anika Chakraborty | Apr 7, 2025 | Automation Testing, Blog, Latest Post | 0 comments

Automation testing is essential in today’s software development. Most people know about tools like Selenium, Cypress, and Postman. But many don’t realize that Spring Boot can also be really useful for testing. Spring Boot, a popular Java framework, offers great features that testers can use for automating API tests, backend validations, setting up test data, and more. Its integration with the Spring ecosystem makes automation setups faster and more reliable. It also works smoothly with other testing tools like Cucumber and Selenium, making it a great choice for building complete automation frameworks.

This blog will help testers understand how they can leverage Spring Boot for automation testing and why it’s not just a developer’s tool anymore!

Key Features of Spring Boot that Enhance Automation

One of the biggest advantages of using Spring Boot for automation testing is its auto-configuration feature. Instead of dealing with complex XML files, Spring Boot figures out most of the setup automatically based on the libraries you include. This saves a lot of time when starting a new test project.

Spring Boot also makes it easy to build standalone applications. It bundles everything you need into a single JAR file, so you don’t have to worry about setting up external servers or containers. This makes running and sharing your tests much simpler.

Another helpful feature is the ability to create custom configuration classes. With annotations and Java-based settings, you can easily change how your application behaves during tests—like setting up test databases or mocking external services.

Spring Boot simplifies Java-based application development and comes with built-in support for testing. Benefits include:

• Built-in testing libraries (JUnit, Mockito, AssertJ, etc.)
• Easy integration with CI/CD pipelines
• Dependency injection simplifies test configuration
• Embedded server for end-to-end tests

Types of Tests Testers Can Do with Spring Boot

Why Should Testers Use Spring Boot for Automation Testing?

Step-by-Step Setup: Spring Boot Automation Testing Environment

Step 1: Install Prerequisites

Before you begin, install the following tools on your system:

Java Development Kit (JDK)

• Download and install Java JDK 11 or higher
• Verify with: java -version

Maven (Build Tool)

• Download from https://maven.apache.org
• Verify with: mvn -version

IDE (Integrated Development Environment)

• Use IntelliJ IDEA or Eclipse for coding and managing the project.

Git

• Install Git for version control from https://git-scm.com

Step 2: Configure pom.xml with Required Dependencies

Edit the pom.xml to add the necessary dependencies for testing.

Here’s an example:

<dependencies>
    <!-- Spring Boot Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- Selenium -->
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>4.18.1</version>
        <scope>test</scope>
    </dependency>

    <!-- RestAssured -->
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>5.4.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Cucumber -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-java</artifactId>
        <version>7.15.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-spring</artifactId>
        <version>7.15.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Run mvn clean install to download and set up all dependencies.

Step 3: Organize Your Project Structure

Create the following basic folder structure:

src
├── main
│   └── java
│       └── com.example.demo (your main app code)
├── test
│   └── java
│       └── com.example.demo (your test code)

Step 4: Create Sample Test Classes

@SpringBootTest
public class SampleUnitTest {

    @Test
    void sampleTest() {
        Assertions.assertTrue(true);
    }
}

1. API Automation Testing with Spring Boot

Goal: Automate API testing like GET, POST, PUT, DELETE requests.

In Spring Boot, TestRestTemplate is commonly used for API calls in tests.

Example: Test GET API for fetching user details

User API Endpoint:

GET /users/1

Sample Response:

{
  "id": 1,
  "name": "John Doe",
  "email": "[email protected]"
}

Test Class with Code:

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserApiTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void testGetUserById() {
        ResponseEntity<User> response = restTemplate.getForEntity("/users/1", User.class);

        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertEquals("John Doe", response.getBody().getName());
    }
}

Explanation:

2. Test Data Setup using Spring Data JPA

In automation, managing test data is crucial. Spring Boot allows you to set up data directly in the database before running your tests.

Example: Insert User Data Before Test Runs

@SpringBootTest
class UserDataSetupTest {

    @Autowired
    private UserRepository userRepository;

    @BeforeEach
    void insertTestData() {
        userRepository.save(new User("John Doe", "[email protected]"));
    }

    @Test
    void testUserExists() {
        List<User> users = userRepository.findAll();
        assertFalse(users.isEmpty());
    }
}

Explanation:

• @BeforeEach → Runs before every test.
• userRepository.save() → Inserts data into DB.
• No need for SQL scripts — use Java objects directly!

3. Mocking External APIs using MockMvc

MockMvc is a powerful tool in Spring Boot to test controllers without starting the full server.

Example: Mock POST API for Creating User

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void testCreateUser() throws Exception {
        mockMvc.perform(post("/users")
                .content("{\"name\": \"John\", \"email\": \"[email protected]\"}")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(status().isCreated());
    }
}

Explanation:

4. End-to-End Integration Testing (API + DB)

Example: Validate API Response + DB Update

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Autowired
    private UserRepository userRepository;

    @Test
    void testAddUserAndValidateDB() {
        User newUser = new User("Alex", "[email protected]");

        ResponseEntity<User> response = restTemplate.postForEntity("/users", newUser, User.class);

        assertEquals(HttpStatus.CREATED, response.getStatusCode());

        List<User> users = userRepository.findAll();
        assertTrue(users.stream().anyMatch(u -> u.getName().equals("Alex")));
    }
}

Explanation:

• Calls POST API to add user.
• Validates response code.
• Checks in DB if user actually inserted.

5. Mock External Services using WireMock

Useful for simulating 3rd party API responses.

@SpringBootTest
@AutoConfigureWireMock(port = 8089)
class ExternalApiMockTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void testExternalApiMocking() {
        stubFor(get(urlEqualTo("/external-api"))
                .willReturn(aResponse().withStatus(200).withBody("Success")));

        ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:8089/external-api", String.class);

        assertEquals("Success", response.getBody());
    }
}

Best Practices for Testers using Spring Boot

• Follow clean code practices.
• Use Profiles for different environments (dev, test, prod).
• Keep test configuration separate.
• Reuse components via dependency injection.
• Use Mocking wherever possible.
• Add proper logging for better debugging.
• Integrate with CI/CD for automated test execution

Conclusion

Spring Boot is no longer limited to backend development — it has emerged as a powerful tool for testers, especially for API automation, backend testing, and test data management. Testers who learn to leverage Spring Boot can build scalable, maintainable, and robust automation frameworks with ease. By combining Spring Boot with other testing tools and frameworks, testers can elevate their automation skills beyond UI testing and become full-fledged automation experts. At Codoid, we’ve adopted Spring Boot in our testing toolkit to streamline API automation and improve efficiency across projects.

Frequently Asked Questions

Playwright Mobile Automation for Seamless Web Testing

by Rajesh K | Apr 3, 2025 | Automation Testing, Blog, Latest Post | 12 comments

Playwright is a fast and modern testing framework known for its efficiency and automation capabilities. It is great for web testing, including Playwright Mobile Automation, which provides built-in support for emulating real devices like smartphones and tablets. Features like custom viewports, user agent simulation, touch interactions, and network throttling help create realistic mobile testing environments without extra setup. Unlike Selenium and Appium, which rely on third-party tools, Playwright offers native mobile emulation and faster execution, making it a strong choice for testing web applications on mobile browsers. However, Playwright does not support native app testing for Android or iOS, as it focuses only on web browsers and web views.

In this blog, the setup process for mobile web automation in Playwright will be explained in detail. The following key aspects will be covered:

• Emulating Mobile Devices
• Using Custom Mobile Viewports
• Real Device Setup & Execution

Before proceeding with mobile web automation, it is essential to ensure that Playwright is properly installed on your machine. In this section, a step-by-step guide will be provided to help set up Playwright along with its dependencies. The installation process includes the following steps:

Setting Up Playwright

Before starting with mobile web automation, ensure that you have Node.js installed on your system. Playwright requires Node.js to run JavaScript-based automation scripts.

1. Verify Node.js Installation

To check if Node.js is installed, open a terminal or command prompt and run:

node -v

If Node.js is installed, this command will return the installed version. If not, download and install the latest version from the official Node.js website.

2. Install Playwright and Its Dependencies

Once Node.js is set up, install Playwright using npm (Node Package Manager) with the following commands:

npm install @playwright/test

npx playwright install

• The first command installs the Playwright testing framework.
• The second command downloads and installs the required browser binaries, including Chromium, Firefox, and WebKit, to enable cross-browser testing.

3. Verify Playwright Installation

To ensure that Playwright is installed correctly, you can check its version by running:

npx playwright --version

This will return the installed Playwright version, confirming a successful setup.

4. Initialize a Playwright Test Project (Optional)

If you plan to use Playwright’s built-in test framework, initialize a test project with:

npx playwright test --init

This sets up a basic folder structure with example tests, Playwright configurations, and dependencies.

Once Playwright is installed and configured, you are ready to start automating mobile web applications. The next step is configuring the test environment for mobile emulation.

Emulating Mobile Devices

Playwright provides built-in mobile device emulation, enabling you to test web applications on various popular devices such as Pixel 5, iPhone 12, and Samsung Galaxy S20. This feature ensures that your application behaves consistently across different screen sizes, resolutions, and touch interactions, making it an essential tool for responsive web testing.

1. Understanding Mobile Device Emulation in Playwright

Playwright’s device emulation is powered by predefined device profiles, which include settings such as:

• Viewport size (width and height)
• User agent string (to simulate mobile browsers)
• Touch support
• Device scale factor
• Network conditions (optional)

These configurations allow you to mimic real mobile devices without requiring an actual physical device.

2. Example Code for Emulating a Mobile Device

Here’s an example script that demonstrates how to use Playwright’s mobile emulation with the Pixel 5 device:

const { test, expect, devices } = require('@playwright/test');


// Apply Pixel 5 emulation settings

test.use({ ...devices['Pixel 5'] });


test('Verify page title on mobile', async ({ page }) => {

    // Navigate to the target website

    await page.goto('https://playwright.dev/');


    // Simulate a short wait time for page load

    await page.waitForTimeout(2000);


    // Capture a screenshot of the mobile view

    await page.screenshot({ path: 'pixel5.png' });


    // Validate the page title to ensure correct loading

    await expect(page).toHaveTitle("Fast and reliable end-to-end testing for modern web apps | Playwright");

});

3. How This Script Works

• It imports test, expect, and devices from Playwright.
• The test.use({…devices[‘Pixel 5’]}) method applies the Pixel 5 emulation settings.
• The script navigates to the Playwright website.
• It waits for 2 seconds, simulating real user behavior.
• A screenshot is captured to visually verify the UI appearance on the Pixel 5 emulation.
• The script asserts the page title, ensuring that the correct page is loaded.

4. Running the Script

Save this script in a test file (e.g., mobile-test.spec.js) and execute it using the following command:

npx playwright test mobile-test.spec.js

If Playwright is set up correctly, the test will run in emulation mode and generate a screenshot named pixel5.png in your project folder.

5. Testing on Other Mobile Devices

To test on different devices, simply change the emulation settings:

test.use({ ...devices['iPhone 12'] }); // Emulates iPhone 12

test.use({ ...devices['Samsung Galaxy S20'] }); // Emulates Samsung Galaxy S20

Playwright includes a wide range of device profiles, which can be found by running:

npx playwright devices

Using Custom Mobile Viewports

Playwright provides built-in mobile device emulation, but sometimes your test may require a device that is not available in Playwright’s predefined list. In such cases, you can manually define a custom viewport, user agent, and touch capabilities to accurately simulate the target device.

1. Why Use Custom Mobile Viewports?

• Some new or less common mobile devices may not be available in Playwright’s devices list.
• Custom viewports allow testing on specific screen resolutions and device configurations.
• They provide flexibility when testing progressive web apps (PWAs) or applications with unique viewport breakpoints.

2. Example Code for Custom Viewport

The following Playwright script manually configures a Samsung Galaxy S10 viewport and device properties:

const { test, expect } = require('@playwright/test');


test.use({

  viewport: { width: 414, height: 896 }, // Samsung Galaxy S10 resolution

  userAgent: 'Mozilla/5.0 (Linux; Android 10; SM-G973F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Mobile Safari/537.36',

  isMobile: true, // Enables mobile-specific behaviors

  hasTouch: true  // Simulates touch screen interactions

});


test('Open page with custom mobile resolution', async ({ page }) => {

    // Navigate to the target webpage

    await page.goto('https://playwright.dev/');


    // Simulate real-world waiting behavior

    await page.waitForTimeout(2000);


    // Capture a screenshot of the webpage

    await page.screenshot({ path: 'android_custom.png' });


    // Validate that the page title is correct

    await expect(page).toHaveTitle("Fast and reliable end-to-end testing for modern web apps | Playwright");

});

3. How This Script Works

• viewport: { width: 414, height: 896 } → Sets the screen size to Samsung Galaxy S10 resolution.
• userAgent: ‘Mozilla/5.0 (Linux; Android 10; SM-G973F)…’ → Spoofs the browser user agent to mimic a real Galaxy S10 browser.
• isMobile: true → Enables mobile-specific browser behaviors, such as dynamic viewport adjustments.
• hasTouch: true → Simulates a touchscreen, allowing for swipe and tap interactions.
• The test navigates to Playwright’s website, waits for 2 seconds, takes a screenshot, and verifies the page title.

4. Running the Test

To execute this test, save it in a file (e.g., custom-viewport.spec.js) and run:

npx playwright test custom-viewport.spec.js

After execution, a screenshot named android_custom.png will be saved in your project folder.

5. Testing Other Custom Viewports

You can modify the script to test different resolutions by changing the viewport size and user agent.

Example: Custom iPad Pro 12.9 Viewport

test.use({

  viewport: { width: 1024, height: 1366 },

  userAgent: 'Mozilla/5.0 (iPad; CPU OS 14_6 like Mac OS X) AppleWebKit/537.36 (KHTML, like Gecko) Version/14.1.1 Mobile/15E148 Safari/537.36',

  isMobile: false, // iPads are often treated as desktops

  hasTouch: true

});

Example: Low-End Android Device (320×480, Old Android Browser)

test.use({

  viewport: { width: 320, height: 480 },

  userAgent: 'Mozilla/5.0 (Linux; U; Android 4.2.2; en-us; GT-S7562) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30',

  isMobile: true,

  hasTouch: true

});

Real Device Setup & Execution

Playwright enables automation testing on real Android devices and emulators using Android Debug Bridge (ADB). This capability allows testers to validate their applications in actual mobile environments, ensuring accurate real-world behavior.

Unlike Android, Playwright does not currently support real-device testing on iOS due to Apple’s restrictions on third-party browser automation. Safari automation on iOS requires WebDriver-based solutions like Appium or Apple’s XCUITest, as Apple does not provide a direct automation API similar to ADB for Android. However, Playwright’s team is actively working on expanding iOS support through WebKit debugging, but full-fledged real-device automation is still in the early stages.

Below is a step-by-step guide to setting up and executing Playwright tests on an Android device.

Preconditions: Setting Up Your Android Device for Testing

1. Install Android Command-Line Tools

• Download and install the Android SDK Command-Line Tools from the official Android Developer website.
• Set up the ANDROID_HOME environment variable and add platform-tools to the system PATH.

2. Enable USB Debugging on Your Android Device

• Go to Settings > About Phone > Tap “Build Number” 7 times to enable Developer Mode.
• Open Developer Options and enable USB Debugging.
• If using a real device, connect it via USB and authorize debugging when prompted.

3. Ensure ADB is Installed & Working

Run the following command to verify that ADB (Android Debug Bridge) detects the connected device:

adb devices

Running Playwright Tests on a Real Android Device

Sample Playwright Script for Android Device Automation

const { _android: android } = require('playwright');

const { expect } = require('@playwright/test');


(async () => {

  // Get the list of connected Android devices

  const devices = await android.devices();

  if (devices.length === 0) {

    console.log("No Android devices found!");

    return;

  }


  // Connect to the first available Android device

  const device = devices[0];

  console.log(`Connected to: ${device.model()} (Serial: ${device.serial()})`);


  // Launch the Chrome browser on the Android device

  const context = await device.launchBrowser();

  console.log('Chrome browser launched!');


  // Open a new browser page

  const page = await context.newPage();

  console.log('New page opened!');


  // Navigate to a website

  await page.goto('https://webkit.org/');

  console.log('Page loaded!');


  // Print the current URL

  console.log(await page.evaluate(() => window.location.href));


  // Verify if an element is visible

  await expect(page.locator("//h1[contains(text(),'engine')]")).toBeVisible();

  console.log('Element found!');


  // Capture a screenshot of the page

  await page.screenshot({ path: 'page.png' });

  console.log('Screenshot taken!');


  // Close the browser session

  await context.close();


  // Disconnect from the device

  await device.close();

})();

How the Script Works

• Retrieves connected Android devices using android.devices().
• Connects to the first available Android device.
• Launches Chrome on the Android device and opens a new page.
• Navigates to https://webkit.org/ and verifies that a page element (e.g., h1 containing “engine”) is visible.
• Takes a screenshot and saves it as page.png.
• Closes the browser and disconnects from the device.

Executing the Playwright Android Test

To run the test, save the script as android-test.js and execute it using:

node android-test.js

If the setup is correct, the test will launch Chrome on the Android device, navigate to the webpage, validate elements, and capture a screenshot.

Screenshot saved from real device

Frequently Asked Questions