Fixes 984 Cleanup TaskResourceTest

catalog-rest-service/src/main/java/org/openmetadata/catalog/resources/tasks/TaskResource.java

@@ -27,13 +27,11 @@ import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.parameters.RequestBody;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import org.openmetadata.catalog.api.data.CreateTask;
-import org.openmetadata.catalog.entity.data.Chart;
 import org.openmetadata.catalog.entity.data.Task;
 import org.openmetadata.catalog.jdbi3.CollectionDAO;
 import org.openmetadata.catalog.jdbi3.TaskRepository;
 import org.openmetadata.catalog.jdbi3.TaskRepository.TaskEntityInterface;
 import org.openmetadata.catalog.resources.Collection;
-import org.openmetadata.catalog.resources.databases.TableResource.TableList;
 import org.openmetadata.catalog.security.CatalogAuthorizer;
 import org.openmetadata.catalog.security.SecurityUtil;
 import org.openmetadata.catalog.type.EntityHistory;

catalog-rest-service/src/test/java/org/openmetadata/catalog/resources/EntityResourceTest.java

@@ -6,12 +6,22 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInfo;
 import org.openmetadata.catalog.CatalogApplicationTest;
+import org.openmetadata.catalog.Entity;
+import org.openmetadata.catalog.api.services.CreateDatabaseService;
+import org.openmetadata.catalog.api.services.CreateDatabaseService.DatabaseServiceType;
 import org.openmetadata.catalog.api.services.CreateMessagingService;
 import org.openmetadata.catalog.api.services.CreateMessagingService.MessagingServiceType;
+import org.openmetadata.catalog.api.services.CreatePipelineService;
+import org.openmetadata.catalog.api.services.CreatePipelineService.PipelineServiceType;
+import org.openmetadata.catalog.entity.services.DatabaseService;
 import org.openmetadata.catalog.entity.services.MessagingService;
+import org.openmetadata.catalog.entity.services.PipelineService;
 import org.openmetadata.catalog.entity.teams.Team;
 import org.openmetadata.catalog.entity.teams.User;
+import org.openmetadata.catalog.jdbi3.DatabaseServiceRepository.DatabaseServiceEntityInterface;
 import org.openmetadata.catalog.jdbi3.MessagingServiceRepository.MessagingServiceEntityInterface;
+import org.openmetadata.catalog.jdbi3.PipelineServiceRepository.PipelineServiceEntityInterface;
+import org.openmetadata.catalog.resources.services.DatabaseServiceResourceTest;
 import org.openmetadata.catalog.resources.services.MessagingServiceResourceTest;
 import org.openmetadata.catalog.resources.teams.TeamResourceTest;
 import org.openmetadata.catalog.resources.teams.UserResourceTest;
@@ -29,6 +39,7 @@ import javax.json.JsonPatch;
 import javax.ws.rs.client.WebTarget;
 import javax.ws.rs.core.Response.Status;
 import java.io.IOException;
+import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -43,6 +54,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertIterableEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.openmetadata.catalog.resources.services.PipelineServiceResourceTest.createService;
 import static org.openmetadata.catalog.util.TestUtils.UpdateType.MINOR_UPDATE;
 import static org.openmetadata.catalog.util.TestUtils.UpdateType.NO_CHANGE;
 import static org.openmetadata.catalog.util.TestUtils.adminAuthHeaders;
@@ -58,8 +70,18 @@ public abstract class EntityResourceTest<T> extends CatalogApplicationTest {
   public static Team TEAM1;
   public static EntityReference TEAM_OWNER1;
 
+  public static EntityReference SNOWFLAKE_REFERENCE;
+  public static EntityReference REDSHIFT_REFERENCE;
+  public static EntityReference MYSQL_REFERENCE;
+  public static EntityReference BIGQUERY_REFERENCE;
+
   public static EntityReference KAFKA_REFERENCE;
   public static EntityReference PULSAR_REFERENCE;
+  public static EntityReference AIRFLOW_REFERENCE;
+  public static EntityReference PREFECT_REFERENCE;
+
+  public static final TagLabel USER_ADDRESS_TAG_LABEL = new TagLabel().withTagFQN("User.Address");
+  public static final TagLabel USER_BANK_ACCOUNT_TAG_LABEL = new TagLabel().withTagFQN("User.BankAccount");
   public static final TagLabel TIER1_TAG_LABEL = new TagLabel().withTagFQN("Tier.Tier1");
   public static final TagLabel TIER2_TAG_LABEL = new TagLabel().withTagFQN("Tier.Tier2");
 
@@ -77,14 +99,50 @@ public abstract class EntityResourceTest<T> extends CatalogApplicationTest {
     TEAM1 = TeamResourceTest.createTeam(TeamResourceTest.create(test), adminAuthHeaders());
     TEAM_OWNER1 = new EntityReference().withId(TEAM1.getId()).withType("team");
 
-    CreateMessagingService createService = new CreateMessagingService().withName("kafka")
+    // Create snowflake database service
-            .withServiceType(MessagingServiceType.Kafka).withBrokers(List.of("192.168.1.1:0"));
+    CreateDatabaseService createDatabaseService = new CreateDatabaseService()
-    MessagingService service = MessagingServiceResourceTest.createService(createService, adminAuthHeaders());
+            .withName(DatabaseServiceResourceTest.getName(test, 1))
-    KAFKA_REFERENCE = new MessagingServiceEntityInterface(service).getEntityReference();
+            .withServiceType(DatabaseServiceType.Snowflake).withJdbc(TestUtils.JDBC_INFO);
+    DatabaseService databaseService = DatabaseServiceResourceTest.createService(createDatabaseService,
+            adminAuthHeaders());
+    SNOWFLAKE_REFERENCE = new EntityReference().withName(databaseService.getName()).withId(databaseService.getId())
+            .withType(Entity.DATABASE_SERVICE);
 
-    createService.withName("pulsar").withServiceType(MessagingServiceType.Pulsar).withBrokers(List.of("192.168.1.1:0"));
+    createDatabaseService.withName("redshiftDB").withServiceType(DatabaseServiceType.Redshift);
-    service = MessagingServiceResourceTest.createService(createService, adminAuthHeaders());
+    databaseService = DatabaseServiceResourceTest.createService(createDatabaseService, adminAuthHeaders());
-    PULSAR_REFERENCE = new MessagingServiceEntityInterface(service).getEntityReference();
+    REDSHIFT_REFERENCE = new DatabaseServiceEntityInterface(databaseService).getEntityReference();
+
+    createDatabaseService.withName("bigQueryDB").withServiceType(DatabaseServiceType.BigQuery);
+    databaseService = DatabaseServiceResourceTest.createService(createDatabaseService, adminAuthHeaders());
+    BIGQUERY_REFERENCE = new DatabaseServiceEntityInterface(databaseService).getEntityReference();
+
+    createDatabaseService.withName("mysqlDB").withServiceType(DatabaseServiceType.MySQL);
+    databaseService = DatabaseServiceResourceTest.createService(createDatabaseService, adminAuthHeaders());
+    MYSQL_REFERENCE = new DatabaseServiceEntityInterface(databaseService).getEntityReference();
+
+    // Create Kafka messaging service
+    CreateMessagingService createMessaging = new CreateMessagingService().withName("kafka")
+            .withServiceType(MessagingServiceType.Kafka).withBrokers(List.of("192.168.1.1:0"));
+    MessagingService messagingService = MessagingServiceResourceTest.createService(createMessaging, adminAuthHeaders());
+    KAFKA_REFERENCE = new MessagingServiceEntityInterface(messagingService).getEntityReference();
+
+    // Create Pulsar messaging service
+    createMessaging.withName("pulsar").withServiceType(MessagingServiceType.Pulsar)
+            .withBrokers(List.of("192.168.1.1:0"));
+    messagingService = MessagingServiceResourceTest.createService(createMessaging, adminAuthHeaders());
+    PULSAR_REFERENCE = new MessagingServiceEntityInterface(messagingService).getEntityReference();
+
+    // Create Airflow pipeline service
+    CreatePipelineService createPipeline = new CreatePipelineService().withName("airflow")
+            .withServiceType(PipelineServiceType.Airflow).withPipelineUrl(new URI("http://localhost:0"));
+    PipelineService pipelineService = createService(createPipeline, adminAuthHeaders());
+    AIRFLOW_REFERENCE = new PipelineServiceEntityInterface(pipelineService).getEntityReference();
+
+    // Create Prefect pipeline service
+    createPipeline.withName("prefect").withServiceType(PipelineServiceType.Prefect)
+            .withPipelineUrl(new URI("http://localhost:0"));
+    pipelineService = createService(createPipeline, adminAuthHeaders());
+    PREFECT_REFERENCE = new PipelineServiceEntityInterface(pipelineService).getEntityReference();
   }
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

catalog-rest-service/src/test/java/org/openmetadata/catalog/resources/dashboards/DashboardResourceTest.java

@@ -80,8 +80,6 @@ public class DashboardResourceTest extends EntityResourceTest<Dashboard> {
   public static EntityReference LOOKER_REFERENCE;
   public static EntityReference SUPERSET_INVALID_SERVICE_REFERENCE;
   public static List<EntityReference> CHART_REFERENCES;
-  public static final TagLabel TIER_1 = new TagLabel().withTagFQN("Tier.Tier1");
-  public static final TagLabel USER_ADDRESS_TAG_LABEL = new TagLabel().withTagFQN("User.Address");
 
   public DashboardResourceTest() {
     super(Dashboard.class, "dashboards", DashboardResource.FIELDS);
@@ -110,7 +108,6 @@ public class DashboardResourceTest extends EntityResourceTest<Dashboard> {
       Chart chart = ChartResourceTest.createChart(createChart, adminAuthHeaders());
       CHART_REFERENCES.add(new ChartEntityInterface(chart).getEntityReference());
     }
-
   }
 
   @Test
@@ -362,7 +359,7 @@ public class DashboardResourceTest extends EntityResourceTest<Dashboard> {
     assertNull(dashboard.getOwner());
     assertNotNull(dashboard.getService());
 
-    List<TagLabel> dashboardTags = singletonList(TIER_1);
+    List<TagLabel> dashboardTags = singletonList(TIER1_TAG_LABEL);
 
     //
     // Add displayName, description, owner when previously they were null

catalog-rest-service/src/test/java/org/openmetadata/catalog/resources/databases/DatabaseResourceTest.java

@@ -65,10 +65,6 @@ import static org.openmetadata.catalog.util.TestUtils.authHeaders;
 
 public class DatabaseResourceTest extends EntityResourceTest<Database> {
   private static final Logger LOG = LoggerFactory.getLogger(DatabaseResourceTest.class);
-  public static EntityReference SNOWFLAKE_REFERENCE;
-  public static EntityReference REDSHIFT_REFERENCE;
-  public static EntityReference MYSQL_REFERENCE;
-  public static EntityReference BIGQUERY_REFERENCE;
 
   public DatabaseResourceTest() {
     super(Database.class, "databases", DatabaseResource.FIELDS);
@@ -77,23 +73,6 @@ public class DatabaseResourceTest extends EntityResourceTest<Database> {
   @BeforeAll
   public static void setup(TestInfo test) throws HttpResponseException, URISyntaxException {
     EntityResourceTest.setup(test);
-
-    CreateDatabaseService createService = new CreateDatabaseService().withName("snowflakeDB")
-            .withServiceType(DatabaseServiceType.Snowflake).withJdbc(TestUtils.JDBC_INFO);
-    DatabaseService service = DatabaseServiceResourceTest.createService(createService, adminAuthHeaders());
-    SNOWFLAKE_REFERENCE = new DatabaseServiceEntityInterface(service).getEntityReference();
-
-    createService.withName("redshiftDB").withServiceType(DatabaseServiceType.Redshift);
-    service = DatabaseServiceResourceTest.createService(createService, adminAuthHeaders());
-    REDSHIFT_REFERENCE = new DatabaseServiceEntityInterface(service).getEntityReference();
-
-    createService.withName("bigQueryDB").withServiceType(DatabaseServiceType.BigQuery);
-    service = DatabaseServiceResourceTest.createService(createService, adminAuthHeaders());
-    BIGQUERY_REFERENCE = new DatabaseServiceEntityInterface(service).getEntityReference();
-
-    createService.withName("mysqlDB").withServiceType(DatabaseServiceType.MySQL);
-    service = DatabaseServiceResourceTest.createService(createService, adminAuthHeaders());
-    MYSQL_REFERENCE = new DatabaseServiceEntityInterface(service).getEntityReference();
   }
 
   @Test

catalog-rest-service/src/test/java/org/openmetadata/catalog/resources/databases/TableResourceTest.java

@@ -28,8 +28,6 @@ import org.openmetadata.catalog.CatalogApplicationTest;
 import org.openmetadata.catalog.Entity;
 import org.openmetadata.catalog.api.data.CreateDatabase;
 import org.openmetadata.catalog.api.data.CreateTable;
-import org.openmetadata.catalog.api.services.CreateDatabaseService;
-import org.openmetadata.catalog.api.services.CreateDatabaseService.DatabaseServiceType;
 import org.openmetadata.catalog.entity.data.Database;
 import org.openmetadata.catalog.entity.data.Table;
 import org.openmetadata.catalog.entity.services.DatabaseService;
@@ -119,15 +117,12 @@ import static org.openmetadata.common.utils.CommonUtil.getDateStringByOffset;
 public class TableResourceTest extends EntityResourceTest<Table> {
   private static final Logger LOG = LoggerFactory.getLogger(TableResourceTest.class);
   public static Database DATABASE;
-  public static final TagLabel USER_ADDRESS_TAG_LABEL = new TagLabel().withTagFQN("User.Address");
-  public static final TagLabel USER_BANK_ACCOUNT_TAG_LABEL = new TagLabel().withTagFQN("User.BankAccount");
 
   public static final List<Column> COLUMNS = Arrays.asList(
           getColumn("c1", BIGINT, USER_ADDRESS_TAG_LABEL),
           getColumn("c2", ColumnDataType.VARCHAR, USER_ADDRESS_TAG_LABEL).withDataLength(10),
           getColumn("c3", BIGINT, USER_BANK_ACCOUNT_TAG_LABEL));
 
-  public static EntityReference SNOWFLAKE_REFERENCE;
 
   public TableResourceTest() {
     super(Table.class, "tables", TableResource.FIELDS);
@@ -136,14 +131,6 @@ public class TableResourceTest extends EntityResourceTest<Table> {
   @BeforeAll
   public static void setup(TestInfo test) throws HttpResponseException, URISyntaxException {
     EntityResourceTest.setup(test);
-
-    CreateDatabaseService createSnowflake = new CreateDatabaseService()
-            .withName(DatabaseServiceResourceTest.getName(test, 1))
-            .withServiceType(DatabaseServiceType.Snowflake).withJdbc(TestUtils.JDBC_INFO);
-    DatabaseService service = createService(createSnowflake, adminAuthHeaders());
-    SNOWFLAKE_REFERENCE = new EntityReference().withName(service.getName()).withId(service.getId())
-            .withType(Entity.DATABASE_SERVICE);
-
     CreateDatabase create = DatabaseResourceTest.create(test).withService(SNOWFLAKE_REFERENCE);
     DATABASE = createAndCheckDatabase(create, adminAuthHeaders());
   }

catalog-rest-service/src/test/java/org/openmetadata/catalog/resources/tasks/TaskResourceTest.java

@@ -26,11 +26,9 @@ import org.openmetadata.catalog.CatalogApplicationTest;
 import org.openmetadata.catalog.Entity;
 import org.openmetadata.catalog.api.data.CreateTask;
 import org.openmetadata.catalog.api.services.CreatePipelineService;
-import org.openmetadata.catalog.api.services.CreatePipelineService.PipelineServiceType;
 import org.openmetadata.catalog.entity.data.Task;
 import org.openmetadata.catalog.entity.services.PipelineService;
 import org.openmetadata.catalog.exception.CatalogExceptionMessage;
-import org.openmetadata.catalog.jdbi3.PipelineServiceRepository.PipelineServiceEntityInterface;
 import org.openmetadata.catalog.jdbi3.TaskRepository.TaskEntityInterface;
 import org.openmetadata.catalog.resources.EntityResourceTest;
 import org.openmetadata.catalog.resources.tasks.TaskResource.TaskList;
@@ -40,14 +38,10 @@ import org.openmetadata.catalog.type.TagLabel;
 import org.openmetadata.catalog.util.EntityInterface;
 import org.openmetadata.catalog.util.JsonUtils;
 import org.openmetadata.catalog.util.TestUtils;
-import org.openmetadata.catalog.util.TestUtils.UpdateType;
-import org.openmetadata.common.utils.JsonSchemaUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import javax.json.JsonPatch;
 import javax.ws.rs.client.WebTarget;
-import javax.ws.rs.core.Response.Status;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Arrays;
@@ -78,29 +72,15 @@ import static org.openmetadata.catalog.util.TestUtils.authHeaders;
 
 public class TaskResourceTest extends EntityResourceTest<Task> {
   private static final Logger LOG = LoggerFactory.getLogger(TaskResourceTest.class);
-  public static EntityReference AIRFLOW_REFERENCE;
-  public static EntityReference PREFECT_REFERENCE;
-  public static final TagLabel USER_ADDRESS_TAG_LABEL = new TagLabel().withTagFQN("User.Address");
-  public static final TagLabel TIER_1 = new TagLabel().withTagFQN("Tier.Tier1");
 
   public TaskResourceTest() {
     super(Task.class, "tasks", TaskResource.FIELDS);
   }
 
-
   @BeforeAll
   public static void setup(TestInfo test) throws HttpResponseException, URISyntaxException {
     EntityResourceTest.setup(test);
 
-    CreatePipelineService createService = new CreatePipelineService().withName("airflow")
-            .withServiceType(PipelineServiceType.Airflow).withPipelineUrl(new URI("http://localhost:0"));
-    PipelineService service = createService(createService, adminAuthHeaders());
-    AIRFLOW_REFERENCE = new PipelineServiceEntityInterface(service).getEntityReference();
-
-    createService.withName("prefect").withServiceType(PipelineServiceType.Prefect)
-            .withPipelineUrl(new URI("http://localhost:0"));
-    service = createService(createService, adminAuthHeaders());
-    PREFECT_REFERENCE = new PipelineServiceEntityInterface(service).getEntityReference();
   }
 
   @Override
@@ -163,20 +143,20 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
   public void post_validTasks_as_admin_200_OK(TestInfo test) throws HttpResponseException, URISyntaxException {
     // Create team with different optional fields
     CreateTask create = create(test);
-    createAndCheckTask(create, adminAuthHeaders());
+    createAndCheckEntity(create, adminAuthHeaders());
 
     create.withName(getTaskName(test, 1)).withDescription("description");
-    createAndCheckTask(create, adminAuthHeaders());
+    createAndCheckEntity(create, adminAuthHeaders());
   }
 
   @Test
   public void post_taskWithUserOwner_200_ok(TestInfo test) throws HttpResponseException, URISyntaxException {
-    createAndCheckTask(create(test).withOwner(USER_OWNER1), adminAuthHeaders());
+    createAndCheckEntity(create(test).withOwner(USER_OWNER1), adminAuthHeaders());
   }
 
   @Test
   public void post_taskWithTeamOwner_200_ok(TestInfo test) throws HttpResponseException, URISyntaxException {
-    createAndCheckTask(create(test).withOwner(TEAM_OWNER1).withDisplayName("chart1"), adminAuthHeaders());
+    createAndCheckEntity(create(test).withOwner(TEAM_OWNER1).withDisplayName("chart1"), adminAuthHeaders());
   }
 
   @Test
@@ -229,7 +209,7 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
 
     // Create task for each service and test APIs
     for (EntityReference service : differentServices) {
-      createAndCheckTask(create(test).withService(service), adminAuthHeaders());
+      createAndCheckEntity(create(test).withService(service), adminAuthHeaders());
 
       // List tasks by filtering on service name and ensure right tasks are returned in the response
       TaskList list = listTasks("service", service.getName(), adminAuthHeaders());
@@ -333,10 +313,10 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
     Date endDate = new DateTime("2021-12-13T20:20:39+00:00").toDate();
     CreateTask request = create(test).withService(AIRFLOW_REFERENCE)
             .withDescription("description").withTaskUrl(taskURI);
-    createAndCheckTask(request, adminAuthHeaders());
+    createAndCheckEntity(request, adminAuthHeaders());
 
     // Updating description is ignored when backend already has description
-    Task task = updateTask(request.withTaskUrl(taskURI).withTaskSQL(taskSQL)
+    Task task = updateEntity(request.withTaskUrl(taskURI).withTaskSQL(taskSQL)
                     .withTaskType("test").withStartDate(startDate).withEndDate(endDate),
             OK, adminAuthHeaders());
     assertEquals(taskURI, task.getTaskUrl());
@@ -346,19 +326,6 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
     assertEquals(endDate, task.getEndDate());
   }
 
-  @Test
-  public void put_taskUpdateOwner_200(TestInfo test) throws HttpResponseException, URISyntaxException {
-    CreateTask request = create(test).withService(AIRFLOW_REFERENCE).withDescription("");
-    Task task = createAndCheckTask(request, adminAuthHeaders());
-
-    // Change ownership from USER_OWNER1 to TEAM_OWNER1
-    task = updateAndCheckTask(task, request.withOwner(TEAM_OWNER1), OK, adminAuthHeaders(), MINOR_UPDATE);
-
-    // Remove ownership
-    task = updateAndCheckTask(task, request.withOwner(null), OK, adminAuthHeaders(), MINOR_UPDATE);
-    assertNull(task.getOwner());
-  }
-
   @Test
   public void get_nonExistentTask_404_notFound() {
     HttpResponseException exception = assertThrows(HttpResponseException.class, () ->
@@ -371,7 +338,7 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
   public void get_taskWithDifferentFields_200_OK(TestInfo test) throws HttpResponseException, URISyntaxException {
     CreateTask create = create(test).withDescription("description").withOwner(USER_OWNER1)
             .withService(AIRFLOW_REFERENCE);
-    Task task = createAndCheckTask(create, adminAuthHeaders());
+    Task task = createAndCheckEntity(create, adminAuthHeaders());
     validateGetWithDifferentFields(task, false);
   }
 
@@ -379,7 +346,7 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
   public void get_taskByNameWithDifferentFields_200_OK(TestInfo test) throws HttpResponseException, URISyntaxException {
     CreateTask create = create(test).withDescription("description").withOwner(USER_OWNER1)
             .withService(AIRFLOW_REFERENCE);
-    Task task = createAndCheckTask(create, adminAuthHeaders());
+    Task task = createAndCheckEntity(create, adminAuthHeaders());
     validateGetWithDifferentFields(task, true);
   }
 
@@ -407,7 +374,7 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
     //
     // Update description, tier, owner
     //
-    taskTags = List.of(USER_ADDRESS_TAG_LABEL, TIER_1);
+    taskTags = List.of(USER_ADDRESS_TAG_LABEL, TIER1_TAG_LABEL);
     origJson = JsonUtils.pojoToJson(task);
     task.withDescription("description1").withOwner(USER_OWNER1).withTags(taskTags);
     change = getChangeDescription(task.getVersion()).withFieldsUpdated(Arrays.asList("description", "owner", "tags"));
@@ -418,7 +385,7 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
     //
     // Remove description and owner - remove a tag
     //
-    taskTags = List.of(TIER_1);
+    taskTags = List.of(TIER1_TAG_LABEL);
     origJson = JsonUtils.pojoToJson(task);
     task.withDescription(null).withOwner(null).withTags(taskTags);
     change = getChangeDescription(task.getVersion()).withFieldsDeleted(Arrays.asList("description","owner"))
@@ -439,56 +406,6 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
     assertResponse(exception, NOT_FOUND, entityNotFound(Entity.TASK, NON_EXISTENT_ENTITY));
   }
 
-  public static Task createAndCheckTask(CreateTask create,
-                                        Map<String, String> authHeaders) throws HttpResponseException {
-    String updatedBy = TestUtils.getPrincipal(authHeaders);
-    Task task = createTask(create, authHeaders);
-    assertEquals(0.1, task.getVersion());
-    validateTask(task, task.getDisplayName(), create.getDescription(), create.getOwner(), create.getService(),
-            create.getTags(), create.getTaskUrl(), updatedBy);
-    return getAndValidate(task.getId(), create, authHeaders, updatedBy);
-  }
-
-  public static Task updateAndCheckTask(Task before, CreateTask create, Status status,
-                                        Map<String, String> authHeaders, UpdateType updateType)
-          throws HttpResponseException {
-    String updatedBy = TestUtils.getPrincipal(authHeaders);
-    Task updatedTask = updateTask(create, status, authHeaders);
-    validateTask(updatedTask, create.getDescription(), create.getOwner(), create.getService(), create.getTags(),
-            create.getTaskUrl(), updatedBy);
-    if (before == null) {
-      assertEquals(0.1, updatedTask.getVersion()); // First version created
-    } else {
-      TestUtils.validateUpdate(before.getVersion(), updatedTask.getVersion(), updateType);
-    }
-
-    // GET the newly updated task and validate
-    return getAndValidate(updatedTask.getId(), create, authHeaders, updatedBy);
-  }
-
-  // Make sure in GET operations the returned task has all the required information passed during creation
-  public static Task getAndValidate(UUID taskId,
-                                    CreateTask create,
-                                    Map<String, String> authHeaders,
-                                    String expectedUpdatedBy) throws HttpResponseException {
-    // GET the newly created task by ID and validate
-    Task task = getTask(taskId, "service,owner", authHeaders);
-    validateTask(task, create.getDescription(), create.getOwner(), create.getService(), create.getTags(),
-            create.getTaskUrl(), expectedUpdatedBy);
-
-    // GET the newly created task by name and validate
-    String fqn = task.getFullyQualifiedName();
-    task = getTaskByName(fqn, "service,owner", authHeaders);
-    return validateTask(task, create.getDescription(), create.getOwner(), create.getService(), create.getTags(),
-           create.getTaskUrl(), expectedUpdatedBy);
-  }
-
-  public static Task updateTask(CreateTask create,
-                                Status status,
-                                Map<String, String> authHeaders) throws HttpResponseException {
-    return TestUtils.put(getResource("tasks"), create, Task.class, status, authHeaders);
-  }
-
   public static Task createTask(CreateTask create,
                                 Map<String, String> authHeaders) throws HttpResponseException {
     return TestUtils.post(getResource("tasks"), create, Task.class, authHeaders);
@@ -520,52 +437,6 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
     assertNotNull(task.getService());
   }
 
-  private static Task validateTask(Task  task, String expectedDisplayName, String expectedDescription,
-                                     EntityReference expectedOwner, EntityReference expectedService,
-                                     List<TagLabel> expectedTags, URI expectedTaskUrl, String expectedUpdatedBy)
-          throws HttpResponseException {
-    Task newTask = validateTask(task, expectedDescription, expectedOwner, expectedService, expectedTags,
-            expectedTaskUrl, expectedUpdatedBy);
-    assertEquals(expectedDisplayName, newTask.getDisplayName());
-    return task;
-  }
-
-  private static Task validateTask(Task task, String expectedDescription, EntityReference expectedOwner,
-                                    EntityReference expectedService, List<TagLabel> expectedTags,
-                                   URI expectedTaskUrl, String expectedUpdatedBy)
-          throws HttpResponseException {
-    assertNotNull(task.getId());
-    assertNotNull(task.getHref());
-    assertEquals(expectedDescription, task.getDescription());
-    assertEquals(expectedUpdatedBy, task.getUpdatedBy());
-    assertEquals(expectedTaskUrl, task.getTaskUrl());
-
-    // Validate owner
-    if (expectedOwner != null) {
-      TestUtils.validateEntityReference(task.getOwner());
-      assertEquals(expectedOwner.getId(), task.getOwner().getId());
-      assertEquals(expectedOwner.getType(), task.getOwner().getType());
-      assertNotNull(task.getOwner().getHref());
-    }
-
-    // Validate service
-    if (expectedService != null) {
-      TestUtils.validateEntityReference(task.getService());
-      assertEquals(expectedService.getId(), task.getService().getId());
-      assertEquals(expectedService.getType(), task.getService().getType());
-    }
-    TestUtils.validateTags(task.getFullyQualifiedName(), expectedTags, task.getTags());
-    return task;
-  }
-
-  private Task patchTask(UUID taskId, String originalJson, Task updatedTask,
-                           Map<String, String> authHeaders)
-          throws JsonProcessingException, HttpResponseException {
-    String updatedTaskJson = JsonUtils.pojoToJson(updatedTask);
-    JsonPatch patch = JsonSchemaUtil.getJsonPatch(originalJson, updatedTaskJson);
-    return TestUtils.patch(getResource("tasks/" + taskId), patch, Task.class, authHeaders);
-  }
-
   public static void getTask(UUID id, Map<String, String> authHeaders) throws HttpResponseException {
     getTask(id, null, authHeaders);
   }
@@ -632,4 +503,4 @@ public class TaskResourceTest extends EntityResourceTest<Task> {
     return TestUtils.post(CatalogApplicationTest.getResource("services/pipelineServices"),
             create, PipelineService.class, authHeaders);
   }
-}
+}