feat: Migrate tests to commons test package

Resolves #7

pom.xml

@@ -133,6 +133,12 @@
       <artifactId>quarkus-junit5-mockito</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.eclipsefoundation</groupId>
+      <artifactId>quarkus-test-common</artifactId>
+      <version>${eclipse-api-version}</version>
+      <scope>test</scope>
+    </dependency>
 
     <!-- Following H2/devservices deps are made to circumvent need for docker -->
     <dependency>
@@ -236,4 +242,4 @@
       </properties>
     </profile>
   </profiles>
-</project>
+</project>
\ No newline at end of file

src/test/java/org/eclipsefoundation/downloads/resources/DownloadsResourceTest.java

@@ -15,17 +15,16 @@ package org.eclipsefoundation.downloads.resources;
 import static io.restassured.RestAssured.given;
 import static io.restassured.module.jsv.JsonSchemaValidator.matchesJsonSchemaInClasspath;
 
-import javax.inject.Inject;
-
-import org.eclipsefoundation.downloads.namespaces.DownloadsUrlParameterNames;
 import org.eclipsefoundation.downloads.test.helper.SchemaNamespaceHelper;
+import org.eclipsefoundation.testing.helpers.TestCaseHelper;
+import org.eclipsefoundation.testing.templates.RestAssuredTemplates;
+import org.eclipsefoundation.testing.templates.RestAssuredTemplates.EndpointTestCase;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.TestInstance.Lifecycle;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-
 import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
 
 @TestInstance(Lifecycle.PER_CLASS)
 @QuarkusTest
@@ -34,139 +33,237 @@ public class DownloadsResourceTest {
     public static final String FILE_BY_ID_URL = DOWNLOADS_BASE_URL + "/file/{id}";
 
     public static final String RELEASE_BASE_URL = DOWNLOADS_BASE_URL + "/releases";
+
     public static final String LEGACY_RELEASE_URL = DOWNLOADS_BASE_URL + "/release/{releaseType}";
+    public static final String LEGACY_RELEASE_NAME_URL = LEGACY_RELEASE_URL + "?release_name={param}";
+    public static final String LEGACY_RELEASE_VERSION_URL = LEGACY_RELEASE_URL + "?release_version={param}";
+    public static final String LEGACY_RELEASE_NAME_VERSION_URL = LEGACY_RELEASE_URL
+            + "?release_name={param1}&release_version={param2}";
+
     public static final String RELEASES_URL = RELEASE_BASE_URL + "/{releaseType}/{releaseName}";
     public static final String RELEASE_VERSION_URL = RELEASES_URL + "/{releaseVersion}";
 
-    @Inject
-    ObjectMapper json;
+    /*
+     * FILE BY ID
+     */
+    public static final EndpointTestCase FILE_BY_ID_SUCCESS = TestCaseHelper.buildSuccessCase(FILE_BY_ID_URL,
+            new String[] { "1" }, SchemaNamespaceHelper.FILE_SCHEMA_PATH);
+
+    public static final EndpointTestCase FILE_BY_ID_NOT_FOUND = TestCaseHelper.buildNotFoundCase(FILE_BY_ID_URL,
+            new String[] { "99999" });
+
+    public static final EndpointTestCase FILE_BY_ID_INVALID_FORMAT = TestCaseHelper
+            .buildInvalidFormatCase(FILE_BY_ID_URL, new String[] { "1" }, ContentType.TEXT);
+
+    /*
+     * LEGACY RELEASE
+     */
+    public static final EndpointTestCase LEGACY_RELEASE_SUCCESS_NAME = TestCaseHelper.buildSuccessCase(
+            LEGACY_RELEASE_NAME_URL, new String[] { "epp", "2021-12" },
+            SchemaNamespaceHelper.RELEASES_SCHEMA_PATH);
+
+    public static final EndpointTestCase LEGACY_RELEASE_SUCCESS_NAME_VERSION = TestCaseHelper.buildSuccessCase(
+            LEGACY_RELEASE_NAME_VERSION_URL, new String[] { "epp", "2021-12", "r" },
+            SchemaNamespaceHelper.RELEASE_SCHEMA_PATH);
+
+    public static final EndpointTestCase LEGACY_RELEASE_INVALID_TYPE = TestCaseHelper.buildBadRequestCase(
+            LEGACY_RELEASE_NAME_VERSION_URL, new String[] { "new", "2021-12", "r" });
+
+    public static final EndpointTestCase LEGACY_RELEASE_NO_NAME = TestCaseHelper.buildBadRequestCase(
+            LEGACY_RELEASE_URL, new String[] { "eclipse_packages" });
+
+    public static final EndpointTestCase LEGACY_RELEASE_NO_NAME_VERSION = TestCaseHelper.buildBadRequestCase(
+            LEGACY_RELEASE_VERSION_URL, new String[] { "eclipse_packages", "r" });
+
+    public static final EndpointTestCase LEGACY_RELEASE_NAME_NOT_FOUND = TestCaseHelper.buildNotFoundCase(
+            LEGACY_RELEASE_NAME_URL, new String[] { "eclipse_packages", "nitro" });
+
+    public static final EndpointTestCase LEGACY_RELEASE_VERSION_NOT_FOUND = TestCaseHelper.buildNotFoundCase(
+            LEGACY_RELEASE_NAME_VERSION_URL, new String[] { "eclipse_packages", "epp", "nitro" });
+
+    public static final EndpointTestCase LEGACY_RELEASE_INVALID_FORMAT = TestCaseHelper
+            .buildInvalidFormatCase(LEGACY_RELEASE_NAME_URL, new String[] { "epp", "2021-12" },
+                    ContentType.TEXT);
+
+    /*
+     * GET RELEASES
+     */
+    public static final EndpointTestCase GET_RELEASES_SUCCESS = TestCaseHelper.buildSuccessCase(RELEASES_URL,
+            new String[] { "epp", "2021-06" }, SchemaNamespaceHelper.RELEASES_SCHEMA_PATH);
+
+    public static final EndpointTestCase GET_RELEASES_NOT_FOUND = TestCaseHelper.buildNotFoundCase(RELEASES_URL,
+            new String[] { "epp", "nitro" });
+
+    public static final EndpointTestCase GET_RELEASES_INVALID_TYPE = TestCaseHelper.buildBadRequestCase(
+            RELEASES_URL, new String[] { "new", "2021-06" });
+
+    public static final EndpointTestCase GET_RELEASES_INVALID_FORMAT = TestCaseHelper
+            .buildInvalidFormatCase(RELEASES_URL, new String[] { "epp", "2021-06" }, ContentType.TEXT);
+
+    /*
+     * GET RELEASE VERSION
+     */
+    public static final EndpointTestCase GET_RELEASE_VERSION_SUCCESS = TestCaseHelper.buildSuccessCase(
+            RELEASE_VERSION_URL, new String[] { "eclipse_packages", "2021-06", "r" }, SchemaNamespaceHelper.RELEASE_SCHEMA_PATH);
+
+    public static final EndpointTestCase GET_RELEASE_VERSION_NOT_FOUND_NAME = TestCaseHelper.buildNotFoundCase(
+            RELEASE_VERSION_URL, new String[] { "eclipse_packages", "nitro", "m1" });
+
+    public static final EndpointTestCase GET_RELEASE_VERSION_NOT_FOUND_VERSION = TestCaseHelper.buildNotFoundCase(
+            RELEASE_VERSION_URL, new String[] { "epp", "2020-03", "version1" });
 
+    public static final EndpointTestCase GET_RELEASE_VERSION_INVALID_TYPE = TestCaseHelper.buildBadRequestCase(
+            RELEASE_VERSION_URL, new String[] { "new", "2021-06", "r" });
+
+    public static final EndpointTestCase GET_RELEASE_VERSION_INVALID_FORMAT = TestCaseHelper
+            .buildInvalidFormatCase(RELEASE_VERSION_URL, new String[] { "epp", "2021-06", "m1" }, ContentType.TEXT);
+
+    /*
+     * FILE BY ID
+     */
     @Test
-    void getFileByID_missingFile() {
-        given().when().get(FILE_BY_ID_URL, "99999").then().statusCode(404);
+    void getFileByID_success() {
+        RestAssuredTemplates.testGet(FILE_BY_ID_SUCCESS);
     }
 
     @Test
-    void getFileByID_success() {
-        given().when().get(FILE_BY_ID_URL, "1").then().statusCode(200);
+    void getFileByID_success_validSchema() {
+        RestAssuredTemplates.testGet_validateSchema(FILE_BY_ID_SUCCESS);
     }
 
     @Test
-    void getFileByID_success_format() {
-        given().when().get(FILE_BY_ID_URL, "1").then().assertThat()
-                .body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.FILE_SCHEMA_PATH));
+    void getFileByID_success_validResponseFormat() {
+        RestAssuredTemplates.testGet_validateResponseFormat(FILE_BY_ID_SUCCESS);
     }
 
     @Test
-    void getReleaseLegacy_missingReleaseName() {
-        given().when().get(LEGACY_RELEASE_URL, "epp").then().statusCode(400);
-        given().when().get(LEGACY_RELEASE_URL, "eclipse_packages").then().statusCode(400);
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_VERSION_VALUE, "r").get(LEGACY_RELEASE_URL, "epp")
-                .then().statusCode(400);
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_VERSION_VALUE, "r")
-                .get(LEGACY_RELEASE_URL, "eclipse_packages").then().statusCode(400);
+    void getFileByID_failure_notFound() {
+        RestAssuredTemplates.testGet(FILE_BY_ID_NOT_FOUND);
     }
 
+    @Test
+    void getFileByID_failure_invalidRequestFormat() {
+        RestAssuredTemplates.testGet(FILE_BY_ID_INVALID_FORMAT);
+    }
+    //TODO: Add test for error format
+
+    /*
+     * LEGACY RELEASE
+     */
     @Test
     void getReleaseLegacy_success() {
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .get(LEGACY_RELEASE_URL, "epp").then().statusCode(200);
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .get(LEGACY_RELEASE_URL, "eclipse_packages").then().statusCode(200);
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .queryParam(DownloadsUrlParameterNames.RELEASE_VERSION_VALUE, "r").get(LEGACY_RELEASE_URL, "epp").then()
-                .statusCode(200);
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .queryParam(DownloadsUrlParameterNames.RELEASE_VERSION_VALUE, "r")
-                .get(LEGACY_RELEASE_URL, "eclipse_packages").then().statusCode(200);
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_SUCCESS_NAME);
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_SUCCESS_NAME_VERSION);
     }
 
     @Test
-    void getReleaseLegacy_invalidReleaseType() {
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .get(LEGACY_RELEASE_URL, "new").then().statusCode(400);
+    void getReleaseLegacy_success_validSchema() {
+        RestAssuredTemplates.testGet_validateSchema(LEGACY_RELEASE_SUCCESS_NAME);
+        RestAssuredTemplates.testGet_validateSchema(LEGACY_RELEASE_SUCCESS_NAME_VERSION);
     }
 
     @Test
-    void getReleaseLegacy_error_format() {
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .get(LEGACY_RELEASE_URL, "wrong").then().assertThat()
-                .body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.ERROR_SCHEMA_PATH));
+    void getReleaseLegacy_success_validResponseFormat() {
+        RestAssuredTemplates.testGet_validateResponseFormat(LEGACY_RELEASE_SUCCESS_NAME);
+        RestAssuredTemplates.testGet_validateResponseFormat(LEGACY_RELEASE_SUCCESS_NAME_VERSION);
     }
 
     @Test
-    void getReleaseLegacy_success_format() {
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .get(LEGACY_RELEASE_URL, "epp").then().assertThat()
-                .body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.RELEASES_SCHEMA_PATH));
+    void getReleaseLegacy_failure_missingReleaseName() {
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_NO_NAME);
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_NO_NAME_VERSION);
     }
 
     @Test
-    void getReleaseLegacyWithVersion_success_format() {
-        given().when().queryParam(DownloadsUrlParameterNames.RELEASE_NAME_VALUE, "2021-12")
-                .queryParam(DownloadsUrlParameterNames.RELEASE_VERSION_VALUE, "r").get(LEGACY_RELEASE_URL, "epp").then()
-                .assertThat().body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.RELEASE_SCHEMA_PATH));
+    void getReleaseLegacy_failure_invalidReleaseType() {
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_INVALID_TYPE);
     }
 
     @Test
-    void getRelease_missingRelease() {
-        given().when().get(RELEASES_URL, "epp", "missing-version").then().statusCode(404);
+    void getReleaseLEgacy_failure_nameNotFound() {
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_NAME_NOT_FOUND);
     }
 
+    @Test
+    void getReleaseLEgacy_failure_versionNotFound() {
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_VERSION_NOT_FOUND);
+    }
+
+    @Test
+    void getReleaseLegacy_failure_invalidRequestFormat() {
+        RestAssuredTemplates.testGet(LEGACY_RELEASE_INVALID_FORMAT);
+    }
+    // TODO: Add test for error format
+
+    /*
+     * GET RELEASE
+     */
     @Test
     void getRelease_success() {
-        given().when().get(RELEASES_URL, "epp", "2021-12").then().statusCode(200);
+        RestAssuredTemplates.testGet(GET_RELEASES_SUCCESS);
     }
 
     @Test
-    void getRelease_invalidReleaseType() {
-        given().when().get(RELEASES_URL, "old", "2021-12").then().statusCode(400);
+    void getRelease_success_validSchema() {
+        RestAssuredTemplates.testGet_validateSchema(GET_RELEASES_SUCCESS);
     }
 
     @Test
-    void getRelease_error_format() {
-        given().when().get(RELEASES_URL, "old", "2021-12").then().assertThat()
-                .body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.ERROR_SCHEMA_PATH));
+    void getRelease_success_validResponseFormat() {
+        RestAssuredTemplates.testGet_validateResponseFormat(GET_RELEASES_SUCCESS);
     }
 
     @Test
-    void getRelease_success_format() {
-        given().when().get(RELEASES_URL, "eclipse_packages",
-                "2021-12").then().assertThat()
-                .body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.RELEASES_SCHEMA_PATH));
+    void getRelease_failure_notFound() {
+        RestAssuredTemplates.testGet(GET_RELEASES_NOT_FOUND);
     }
 
     @Test
-    void getReleaseVersion_missingRelease() {
-        given().when().get(RELEASE_VERSION_URL, "epp", "missing-version", "r").then().statusCode(404);
+    void getRelease_failure_invalidReleaseType() {
+        RestAssuredTemplates.testGet(GET_RELEASES_INVALID_TYPE);
     }
 
     @Test
-    void getReleaseVersion_missingVersion() {
-        given().when().get(RELEASE_VERSION_URL, "epp", "2021-12", "some-release").then().statusCode(404);
+    void getRelease_failure_invalidRequestFormat() {
+        RestAssuredTemplates.testGet(GET_RELEASES_INVALID_FORMAT);
     }
+    // TODO: Add test for error format
 
+    /*
+     * GET RELEASE VERSION
+     */
     @Test
     void getReleaseVersion_success() {
-        given().when().get(RELEASE_VERSION_URL, "eclipse_packages", "2021-12", "r").then().statusCode(200);
+        RestAssuredTemplates.testGet(GET_RELEASE_VERSION_SUCCESS);
+    }
+
+    @Test
+    void getReleaseVersion_success_validSchema() {
+        RestAssuredTemplates.testGet_validateSchema(GET_RELEASE_VERSION_SUCCESS);
     }
 
     @Test
-    void getReleaseVersion_invalidreleaseType() {
-        given().when().get(RELEASE_VERSION_URL, "eclipse_packs", "2021-12", "r").then().statusCode(400);
+    void getReleaseVersion_success_validResponseFormat() {
+        RestAssuredTemplates.testGet_validateResponseFormat(GET_RELEASE_VERSION_SUCCESS);
     }
 
     @Test
-    void getReleaseVersion_error_format() {
-        given().when().get(
-                RELEASE_VERSION_URL, "old", "2021-12", "r").then().assertThat()
-                .body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.ERROR_SCHEMA_PATH));
+    void getReleaseVersion_failure_nameNotFound() {
+        RestAssuredTemplates.testGet(GET_RELEASE_VERSION_NOT_FOUND_NAME);
     }
 
     @Test
-    void getReleaseVersion_success_format() {
-        given().when().get(RELEASE_VERSION_URL, "eclipse_packages",
-                "2021-12", "r").then().assertThat()
-                .body(matchesJsonSchemaInClasspath(SchemaNamespaceHelper.RELEASE_SCHEMA_PATH));
+    void getReleaseVersion_failure_versionNotFound() {
+        RestAssuredTemplates.testGet(GET_RELEASE_VERSION_NOT_FOUND_VERSION);
+    }
+
+    @Test
+    void getReleaseVersion_failure_invalidReleaseType() {
+        RestAssuredTemplates.testGet(GET_RELEASE_VERSION_INVALID_TYPE);
+    }
+
+    void getReleaseVersion_failure_invalidRequestFormat() {
+        RestAssuredTemplates.testGet(GET_RELEASE_VERSION_INVALID_FORMAT);
     }
+    // TODO: Add test for error format
 }