mirror of
https://github.com/open-metadata/OpenMetadata.git
synced 2025-11-01 11:09:14 +00:00
Fixes 984 Cleanup TaskResourceTest
This commit is contained in:
sureshms
parent
93921814af
commit
9fb35690e9
@ -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;
|
||||
|
||||
@ -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")
|
||||
.withServiceType(MessagingServiceType.Kafka).withBrokers(List.of("192.168.1.1:0"));
|
||||
MessagingService service = MessagingServiceResourceTest.createService(createService, adminAuthHeaders());
|
||||
KAFKA_REFERENCE = new MessagingServiceEntityInterface(service).getEntityReference();
|
||||
// Create snowflake database service
|
||||
CreateDatabaseService createDatabaseService = new CreateDatabaseService()
|
||||
.withName(DatabaseServiceResourceTest.getName(test, 1))
|
||||
.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"));
|
||||
service = MessagingServiceResourceTest.createService(createService, adminAuthHeaders());
|
||||
PULSAR_REFERENCE = new MessagingServiceEntityInterface(service).getEntityReference();
|
||||
createDatabaseService.withName("redshiftDB").withServiceType(DatabaseServiceType.Redshift);
|
||||
databaseService = DatabaseServiceResourceTest.createService(createDatabaseService, adminAuthHeaders());
|
||||
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();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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());
|
||||
}
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user