feat(QTDI-1291): tests

Author: ozhelezniak-talend

component-server-parent/component-server/src/test/java/org/talend/sdk/component/server/front/ActionResourceImplTest.java

@@ -1,12 +1,12 @@
 /**
  * Copyright (C) 2006-2026 Talend Inc. - www.talend.com
- *
+ * <p>
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- *
+ * <p>
  * http://www.apache.org/licenses/LICENSE-2.0
- *
+ * <p>
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -30,6 +30,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import javax.inject.Inject;
 import javax.json.JsonObject;
@@ -44,7 +45,11 @@
 import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
+import org.talend.sdk.component.api.exception.ComponentException.ErrorOrigin;
+import org.talend.sdk.component.api.exception.DiscoverSchemaException.HandleErrorWith;
 import org.talend.sdk.component.api.record.Schema;
 import org.talend.sdk.component.api.service.healthcheck.HealthCheckStatus;
 import org.talend.sdk.component.api.service.record.RecordBuilderFactory;
@@ -60,7 +65,8 @@ class ActionResourceImplTest {
     @Inject
     private WebTarget base;
 
-    @RepeatedTest(2) // this also checks the cache and queries usage
+    @RepeatedTest(2)
+        // this also checks the cache and queries usage
     void actionIndex() {
         { // default
             final ActionList index = base.path("action/index").request(APPLICATION_JSON_TYPE).get(ActionList.class);
@@ -165,23 +171,32 @@ void testBackendException() {
         assertEquals("Action execution failed with: backend exception", errorPayload.getDescription());
     }
 
-    @Test
-    void testDiscoverSchemaException() {
+    @MethodSource("handleErrorWithSource")
+    @ParameterizedTest
+    void testDiscoverSchemaException(final HandleErrorWith origin) {
         final Response error = base
                 .path("action/execute")
                 .queryParam("type", "user")
                 .queryParam("family", "custom")
-                .queryParam("action", "discoverSchemaException")
+                .queryParam("action", "discoverSchemaException" + origin)
                 .request(APPLICATION_JSON_TYPE)
                 .post(Entity.entity(new HashMap<String, String>(), APPLICATION_JSON_TYPE));
         assertEquals(400, error.getStatus());
         final ErrorPayload errorPayload = error.readEntity(ErrorPayload.class);
         assertEquals(ErrorDictionary.ACTION_ERROR, errorPayload.getCode());
-        assertEquals("RETRY", errorPayload.getSubCode());
+        assertEquals(origin.toString(), errorPayload.getSubCode());
         assertNotNull(errorPayload.getDescription());
         assertTrue(errorPayload.getDescription().startsWith("Action execution failed with:"));
     }
 
+    static Stream<Arguments> handleErrorWithSource() {
+        return Stream.of(
+                Arguments.of(HandleErrorWith.RETRY),
+                Arguments.of(HandleErrorWith.EXECUTE_MOCK_JOB),
+                Arguments.of(HandleErrorWith.EXECUTE_LIFECYCLE)
+        );
+    }
+
     @Test
     void executeWithEnumParam() {
         final Response error = base
@@ -213,37 +228,37 @@ void checkSchemaSerialization() {
                 .post(Entity.entity(emptyMap(), APPLICATION_JSON_TYPE), String.class);
         final String expected =
                 """
-                {
-                  "entries":[
-                    {
-                      "elementSchema":{
-                        "entries":[
-                        ],
-                        "metadata":[
-                        ],
-                        "props":{
-
-                        },
-                        "type":"STRING"
-                      },
-                      "errorCapable":false,
-                      "metadata":false,
-                      "name":"array",
-                      "nullable":false,
-                      "props":{
-
-                      },
-                      "type":"ARRAY",
-                      "valid":true
-                    }
-                  ],
-                  "metadata":[
-                  ],
-                  "props":{
-                    "talend.fields.order":"array"
-                  },
-                  "type":"RECORD"
-                }""";
+                        {
+                          "entries":[
+                            {
+                              "elementSchema":{
+                                "entries":[
+                                ],
+                                "metadata":[
+                                ],
+                                "props":{
+                        
+                                },
+                                "type":"STRING"
+                              },
+                              "errorCapable":false,
+                              "metadata":false,
+                              "name":"array",
+                              "nullable":false,
+                              "props":{
+                        
+                              },
+                              "type":"ARRAY",
+                              "valid":true
+                            }
+                          ],
+                          "metadata":[
+                          ],
+                          "props":{
+                            "talend.fields.order":"array"
+                          },
+                          "type":"RECORD"
+                        }""";
         assertEquals(expected, schema);
     }
 
@@ -287,7 +302,7 @@ void checkDiscoverProcessorSchema() {
 
     @Disabled
     @ParameterizedTest
-    @ValueSource(strings = { "en", "fr" })
+    @ValueSource(strings = {"en", "fr"})
     void i18nParameterized(final String lang) {
         final Response error = base
                 .path("action/execute")
@@ -336,7 +351,7 @@ void checkLangIsAvailable() {
     }
 
     private void assertAction(final String component, final String type, final String name, final int params,
-            final ActionItem value) {
+                              final ActionItem value) {
         assertEquals(component, value.getComponent());
         assertEquals(type, value.getType());
         assertEquals(name, value.getName());

component-server-parent/component-server/src/test/java/org/talend/sdk/component/server/test/custom/CustomService.java

@@ -74,9 +74,21 @@ public Map<String, String> generateBackendException(final LocalConfiguration con
         throw new ComponentException(ErrorOrigin.BACKEND, "backend exception");
     }
 
-    @Action("discoverSchemaException")
-    public Map<String, String> generateDiscoverSchemaException(final LocalConfiguration configuration) {
+    @Action("discoverSchemaExceptionRETRY")
+    public Map<String, String> generateDiscoverSchemaExceptionRetry(final LocalConfiguration configuration) {
         throw new DiscoverSchemaException(
                 new ComponentException(ErrorOrigin.USER, "schema not found"), HandleErrorWith.RETRY);
     }
+
+    @Action("discoverSchemaExceptionEXECUTE_MOCK_JOB")
+    public Map<String, String> generateDiscoverSchemaExceptionMock(final LocalConfiguration configuration) {
+        throw new DiscoverSchemaException(
+                new ComponentException(ErrorOrigin.USER, "schema not found"), HandleErrorWith.EXECUTE_MOCK_JOB);
+    }
+
+    @Action("discoverSchemaExceptionEXECUTE_LIFECYCLE")
+    public Map<String, String> generateDiscoverSchemaExceptionLifecycle(final LocalConfiguration configuration) {
+        throw new DiscoverSchemaException(
+                new ComponentException(ErrorOrigin.USER, "schema not found"), HandleErrorWith.EXECUTE_LIFECYCLE);
+    }
 }