Sample API tests

Author: wakaleo

pom.xml

@@ -91,9 +91,10 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>com.github.javafaker</groupId>
-            <artifactId>javafaker</artifactId>
-            <version>1.0.2</version>
+            <groupId>net.datafaker</groupId>
+            <artifactId>datafaker</artifactId>
+            <version>2.4.2</version>
+            <scope>test</scope>
         </dependency>
     </dependencies>
     <build>

src/test/java/com/serenitydojo/playwright/toolshop/domain/User.java

@@ -1,75 +1,48 @@
 package com.serenitydojo.playwright.toolshop.domain;
 
-import com.github.javafaker.Faker;
+import net.datafaker.Faker;
 
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.util.Date;
-
-/**
- * {
- *   "first_name": "John",
- *   "last_name": "Doe",
- *   "address": "Street 1",
- *   "city": "City",
- *   "state": "State",
- *   "country": "Country",
- *   "postcode": "1234AA",
- *   "phone": "0987654321",
- *   "dob": "1970-01-01",
- *   "password": "S1!uper-secret",
- *   "email": "[email protected]"
- * }
- */
 public record User(
-    String first_name,
-    String last_name,
-    String address,
-    String city,
-    String state,
-    String country,
-    String postcode,
-    String phone,
-    String dob,
-    String password,
-    String email
-) {
+        String first_name,
+        String last_name,
+        String address,
+        String city,
+        String state,
+        String country,
+        String postcode,
+        String phone,
+        String dob,
+        String password,
+        String email) {
     public static User randomUser() {
         Faker fake = new Faker();
-        int year = fake.number().numberBetween(1970,2000);
-        int month = fake.number().numberBetween(1,12);
-        int day = fake.number().numberBetween(1,28);
-        LocalDate date = LocalDate.of(year,month,day);
-        String formattedDate = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
-
         return new User(
                 fake.name().firstName(),
                 fake.name().lastName(),
                 fake.address().streetAddress(),
                 fake.address().city(),
                 fake.address().state(),
                 fake.address().country(),
-                fake.address().zipCode(),
+                fake.address().postcode(),
                 fake.phoneNumber().phoneNumber(),
-                formattedDate,
-                "Az1234£!3",
+                "1990-01-01",
+                "Az123!&xyz",
                 fake.internet().emailAddress()
         );
     }
 
     public User withPassword(String password) {
         return new User(
-                this.first_name,
-                this.last_name,
-                this.address,
-                this.city,
-                this.state,
-                this.country,
-                this.postcode,
-                this.phone,
-                this.dob,
+                first_name,
+                last_name,
+                address,
+                city,
+                state,
+                country,
+                postcode,
+                phone,
+                dob,
                 password,
-                this.email
-        );
+                email);
     }
 }

src/test/java/com/serenitydojo/playwright/toolshop/login/LoginPage.java

@@ -0,0 +1,138 @@
+package com.serenitydojo.playwright.toolshop.login;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.microsoft.playwright.APIRequest;
+import com.microsoft.playwright.APIRequestContext;
+import com.microsoft.playwright.APIResponse;
+import com.microsoft.playwright.Playwright;
+import com.microsoft.playwright.junit.UsePlaywright;
+import com.microsoft.playwright.options.RequestOptions;
+import com.serenitydojo.playwright.toolshop.domain.User;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.SoftAssertions.assertSoftly;
+
+@UsePlaywright
+public class RegisterUserAPITest {
+
+    private APIRequestContext request;
+    private Gson gson = new Gson();
+
+    @BeforeEach
+    void setup(Playwright playwright) {
+        request = playwright.request().newContext(
+                new APIRequest.NewContextOptions()
+                        .setBaseURL("https://api.practicesoftwaretesting.com")
+        );
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (request != null) {
+            request.dispose();
+        }
+    }
+
+    @Test
+    void should_register_user() {
+        User validUser = User.randomUser();
+
+        var response = request.post("/users/register",
+                RequestOptions.create()
+                        .setHeader("Content-Type", "application/json")
+                        .setData(validUser)
+        );
+
+        String responseBody = response.text();
+        User createdUser = gson.fromJson(responseBody, User.class);
+
+        JsonObject responseObject = gson.fromJson(responseBody, JsonObject.class);
+
+        assertSoftly(softly -> {
+            softly.assertThat(response.status())
+                    .as("Registration should return 201 created status code")
+                    .isEqualTo(201);
+
+            softly.assertThat(createdUser)
+                    .as("Created user should match the specified user without the password")
+                    .isEqualTo(validUser.withPassword(null));
+
+            assertThat(responseObject.has("password"))
+                    .as("No password should be returned")
+                    .isFalse();
+
+            softly.assertThat(responseObject.get("id").getAsString())
+                    .as("Registered user should have an id")
+                    .isNotEmpty();
+
+            softly.assertThat(
+                    response.headers().get("content-type")
+            ).contains("application/json");
+        });
+    }
+
+    @Test
+    void first_name_is_mandatory() {
+        User userWithNoName = new User(
+                null,
+                "Smith",
+                "Some street",
+                "Some city",
+                "Some state",
+                "Some country",
+                "123445",
+                "12345678899",
+                "1979-01-01",
+                "ABC123!£$%",
+                "[email protected]"
+        );
+
+        var response = request.post("/users/register",
+                RequestOptions.create()
+                        .setHeader("Content-Type", "application/json")
+                        .setData(userWithNoName)
+        );
+
+        assertSoftly(softly -> {
+            softly.assertThat(response.status()).isEqualTo(422);
+
+            JsonObject responseObject = gson.fromJson(response.text(), JsonObject.class);
+
+            softly.assertThat(responseObject.has("first_name")).isTrue();
+
+            String errorMessage = responseObject.get("first_name").getAsString();
+
+            softly.assertThat(errorMessage).isEqualTo("The first name field is required.");
+        });
+
+    }
+    @ParameterizedTest(name = "Password ''{0}'' should fail with error: {1}")
+    @CsvSource(delimiter = '|', quoteCharacter = '"', textBlock = """
+            ''                         | The password field must be at least 8 characters.
+            short                      | The password field must be at least 8 characters.
+            longerpassword             | The password field must contain at least one uppercase and one lowercase letter.
+            LONGERPASSWORD             | The password field must contain at least one uppercase and one lowercase letter.
+            LongerPassword             | The password field must contain at least one symbol.
+            LongerPassword!            | The password field must contain at least one number.
+            password123                | The password field must contain at least one uppercase and one lowercase letter.
+            PASSWORD123                | The password field must contain at least one uppercase and one lowercase letter.
+            """)
+    void testInvalidPasswords(String invalidPassword, String expectedError) {
+        User user = User.randomUser().withPassword(invalidPassword);
+
+        APIResponse response = request.post("/users/register",
+                RequestOptions.create()
+                        .setHeader("Content-Type", "application/json")
+                        .setData(user));
+
+        assertThat(response.status()).isEqualTo(422);
+        assertThat(response.text()).contains(expectedError);
+    }
+
+}