[TEST] increase coverage of environment service (#15840)

* [TEST] increase coverage of environment service

* spotless apply

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/impl/EnvironmentServiceTest.java

@@ -22,6 +22,7 @@ import static org.apache.dolphinscheduler.api.AssertionsHelper.assertThrowsServi
 import static org.apache.dolphinscheduler.api.constants.ApiFuncIdentificationConstant.ENVIRONMENT_CREATE;
 import static org.apache.dolphinscheduler.api.constants.ApiFuncIdentificationConstant.ENVIRONMENT_DELETE;
 import static org.apache.dolphinscheduler.api.constants.ApiFuncIdentificationConstant.ENVIRONMENT_UPDATE;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
 
@@ -29,9 +30,11 @@ import org.apache.dolphinscheduler.api.enums.Status;
 import org.apache.dolphinscheduler.api.permission.ResourcePermissionCheckService;
 import org.apache.dolphinscheduler.api.utils.PageInfo;
 import org.apache.dolphinscheduler.api.utils.Result;
+import org.apache.dolphinscheduler.api.utils.ServiceTestUtil;
 import org.apache.dolphinscheduler.common.constants.Constants;
 import org.apache.dolphinscheduler.common.enums.AuthorizationType;
 import org.apache.dolphinscheduler.common.enums.UserType;
+import org.apache.dolphinscheduler.common.utils.CodeGenerateUtils;
 import org.apache.dolphinscheduler.dao.entity.Environment;
 import org.apache.dolphinscheduler.dao.entity.EnvironmentWorkerGroupRelation;
 import org.apache.dolphinscheduler.dao.entity.User;
@@ -42,6 +45,7 @@ import org.apache.dolphinscheduler.dao.mapper.TaskDefinitionMapper;
 import org.apache.commons.collections4.CollectionUtils;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -53,6 +57,7 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
+import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.mockito.junit.jupiter.MockitoSettings;
@@ -91,6 +96,9 @@ public class EnvironmentServiceTest {
     @Mock
     private ResourcePermissionCheckService resourcePermissionCheckService;
 
+    @Mock
+    private CodeGenerateUtils codeGenerateUtils;
+
     public static final String testUserName = "environmentServerTest";
 
     public static final String environmentName = "Env1";
@@ -121,9 +129,24 @@ public class EnvironmentServiceTest {
 
         when(environmentMapper.insert(any(Environment.class))).thenReturn(1);
         when(relationMapper.insert(any(EnvironmentWorkerGroupRelation.class))).thenReturn(1);
+
+        assertThrowsServiceException(Status.DESCRIPTION_TOO_LONG_ERROR,
+                () -> environmentService.createEnvironment(adminUser, "testName", "test",
+                        ServiceTestUtil.randomStringWithLengthN(512), workerGroups));
         assertDoesNotThrow(
                 () -> environmentService.createEnvironment(adminUser, "testName", "test", "test", workerGroups));
 
+        when(environmentMapper.insert(any(Environment.class))).thenReturn(-1);
+        assertThrowsServiceException(Status.CREATE_ENVIRONMENT_ERROR,
+                () -> environmentService.createEnvironment(adminUser, "testName", "test", "test", workerGroups));
+
+        try (MockedStatic<CodeGenerateUtils> ignored = Mockito.mockStatic(CodeGenerateUtils.class)) {
+            when(CodeGenerateUtils.getInstance()).thenReturn(codeGenerateUtils);
+            when(codeGenerateUtils.genCode()).thenThrow(CodeGenerateUtils.CodeGenerateException.class);
+
+            assertThrowsServiceException(Status.INTERNAL_SERVER_ERROR_ARGS,
+                    () -> environmentService.createEnvironment(adminUser, "testName", "test", "test", workerGroups));
+        }
     }
 
     @Test
@@ -156,25 +179,54 @@ public class EnvironmentServiceTest {
         assertThrowsServiceException(Status.ENVIRONMENT_NAME_EXISTS, () -> environmentService
                 .updateEnvironmentByCode(adminUser, 2L, environmentName, getConfig(), getDesc(), workerGroups));
 
+        when(environmentMapper.update(any(Environment.class), any(Wrapper.class))).thenReturn(-1);
+        assertThrowsServiceException(Status.UPDATE_ENVIRONMENT_ERROR,
+                () -> environmentService.updateEnvironmentByCode(adminUser, 1L, "testName", "test", "test",
+                        workerGroups));
+
         when(environmentMapper.update(any(Environment.class), any(Wrapper.class))).thenReturn(1);
+
+        assertThrowsServiceException(Status.DESCRIPTION_TOO_LONG_ERROR,
+                () -> environmentService.updateEnvironmentByCode(adminUser, 2L, environmentName, getConfig(),
+                        ServiceTestUtil.randomStringWithLengthN(512), workerGroups));
+
         assertDoesNotThrow(() -> environmentService.updateEnvironmentByCode(adminUser, 1L, "testName", "test", "test",
                 workerGroups));
+
+        assertDoesNotThrow(() -> environmentService.updateEnvironmentByCode(adminUser, 1L, "testName", "test", "test",
+                ""));
+
+        when(relationMapper.queryByEnvironmentCode(any()))
+                .thenReturn(Collections.singletonList(getEnvironmentWorkerGroup()));
+        assertDoesNotThrow(() -> environmentService.updateEnvironmentByCode(adminUser, 1L, "testName", "test", "test",
+                ""));
     }
 
     @Test
     public void testQueryAllEnvironmentList() {
+        when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.ENVIRONMENT,
+                1, environmentServiceLogger)).thenReturn(Collections.emptySet());
+        Map<String, Object> result = environmentService.queryAllEnvironmentList(getAdminUser());
+        assertEquals(0, ((List<Environment>) result.get(Constants.DATA_LIST)).size());
+
         Set<Integer> ids = new HashSet<>();
         ids.add(1);
         when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.ENVIRONMENT,
                 1, environmentServiceLogger)).thenReturn(ids);
         when(environmentMapper.selectBatchIds(ids)).thenReturn(Lists.newArrayList(getEnvironment()));
 
-        Map<String, Object> result = environmentService.queryAllEnvironmentList(getAdminUser());
+        result = environmentService.queryAllEnvironmentList(getAdminUser());
         logger.info(result.toString());
         Assertions.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
 
         List<Environment> list = (List<Environment>) (result.get(Constants.DATA_LIST));
         Assertions.assertEquals(1, list.size());
+
+        when(environmentMapper.selectBatchIds(ids)).thenReturn(Collections.emptyList());
+        result = environmentService.queryAllEnvironmentList(getAdminUser());
+        Assertions.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
+        list = (List<Environment>) (result.get(Constants.DATA_LIST));
+        Assertions.assertEquals(0, list.size());
     }
 
     @Test
@@ -186,9 +238,27 @@ public class EnvironmentServiceTest {
                 .thenReturn(page);
 
         Result result = environmentService.queryEnvironmentListPaging(getAdminUser(), 1, 10, environmentName);
-        logger.info(result.toString());
         PageInfo<Environment> pageInfo = (PageInfo<Environment>) result.getData();
         Assertions.assertTrue(CollectionUtils.isNotEmpty(pageInfo.getTotalList()));
+
+        assertDoesNotThrow(
+                () -> environmentService.queryEnvironmentListPaging(getGeneralUser(), 1, 10, environmentName));
+
+        when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(
+                AuthorizationType.ENVIRONMENT,
+                1,
+                environmentServiceLogger)).thenReturn(Collections.singleton(10));
+        when(environmentMapper.queryEnvironmentListPagingByIds(any(Page.class), any(List.class), any(String.class)))
+                .thenReturn(page);
+        result = environmentService.queryEnvironmentListPaging(getGeneralUser(), 1, 10, environmentName);
+        assertEquals(0, result.getCode());
+        assertEquals(1, ((PageInfo<?>) result.getData()).getTotalList().size());
+
+        page.setRecords(Collections.emptyList());
+        page.setTotal(0);
+        result = environmentService.queryEnvironmentListPaging(getGeneralUser(), 1, 10, environmentName);
+        assertEquals(0, result.getCode());
+        assertEquals(0, ((PageInfo<?>) result.getData()).getTotalList().size());
     }
 
     @Test
@@ -239,6 +309,10 @@ public class EnvironmentServiceTest {
         result = environmentService.deleteEnvironmentByCode(loginUser, 1L);
         logger.info(result.toString());
         Assertions.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
+
+        when(environmentMapper.deleteByCode(1L)).thenReturn(-1);
+        result = environmentService.deleteEnvironmentByCode(loginUser, 1L);
+        Assertions.assertEquals(Status.DELETE_ENVIRONMENT_ERROR, result.get(Constants.STATUS));
     }
 
     @Test
@@ -251,6 +325,9 @@ public class EnvironmentServiceTest {
         result = environmentService.verifyEnvironment(environmentName);
         logger.info(result.toString());
         Assertions.assertEquals(Status.ENVIRONMENT_NAME_EXISTS, result.get(Constants.STATUS));
+
+        when(environmentMapper.queryByEnvironmentName(environmentName)).thenReturn(null);
+        assertDoesNotThrow(() -> environmentService.verifyEnvironment(environmentName));
     }
 
     private Environment getEnvironment() {
@@ -264,6 +341,13 @@ public class EnvironmentServiceTest {
         return environment;
     }
 
+    private EnvironmentWorkerGroupRelation getEnvironmentWorkerGroup() {
+        EnvironmentWorkerGroupRelation relation = new EnvironmentWorkerGroupRelation();
+        relation.setEnvironmentCode(1L);
+        relation.setWorkerGroup("new_worker_group");
+        return relation;
+    }
+
     /**
      * create an environment description
      */

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/utils/ServiceTestUtil.java

@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.dolphinscheduler.api.utils;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+
+public class ServiceTestUtil {
+
+    public static String randomStringWithLengthN(int n) {
+        byte[] bitArray = new byte[n];
+        new Random().nextBytes(bitArray);
+        return new String(bitArray, StandardCharsets.UTF_8);
+    }
+}