From 4e7e75cc82e45a6bd92477732c7d0439fdae8865 Mon Sep 17 00:00:00 2001 From: Glenn Renfro Date: Mon, 29 Aug 2016 16:14:21 -0400 Subject: [PATCH] Moved the Error size trimming from DAO to repository. * We had a discussion on this sometime back and it was decided at that time to keep these type of trims and verification in the Repository. * Fixed bug where trimming was taking 1 character too many * Updated ExitMessage maxSize test to verify size * Added ErrorMessage maxSize Test * While adding taskExplorer to the test noticed it was missing 2 basic tests and added those as well --- .../support/SimpleTaskRepository.java | 47 +++++++- .../support/SimpleTaskExplorerTests.java | 10 ++ .../SimpleTaskRepositoryJdbcTests.java | 107 +++++++++++++++++- 3 files changed, 154 insertions(+), 10 deletions(-) diff --git a/spring-cloud-task-core/src/main/java/org/springframework/cloud/task/repository/support/SimpleTaskRepository.java b/spring-cloud-task-core/src/main/java/org/springframework/cloud/task/repository/support/SimpleTaskRepository.java index ee1b6934..5efcfbb7 100644 --- a/spring-cloud-task-core/src/main/java/org/springframework/cloud/task/repository/support/SimpleTaskRepository.java +++ b/spring-cloud-task-core/src/main/java/org/springframework/cloud/task/repository/support/SimpleTaskRepository.java @@ -36,6 +36,7 @@ public class SimpleTaskRepository implements TaskRepository { public static final int MAX_EXIT_MESSAGE_SIZE = 2500; public static final int MAX_TASK_NAME_SIZE = 100; + public static final int MAX_ERROR_MESSAGE_SIZE = 2500; private final static Log logger = LogFactory.getLog(SimpleTaskRepository.class); @@ -45,12 +46,33 @@ public class SimpleTaskRepository implements TaskRepository { private boolean initialized = false; + private int maxExitMessageSize = MAX_EXIT_MESSAGE_SIZE; + + private int maxTaskNameSize = MAX_TASK_NAME_SIZE; + + private int maxErrorMessageSize = MAX_ERROR_MESSAGE_SIZE; + public SimpleTaskRepository(FactoryBean taskExecutionDaoFactoryBean){ Assert.notNull(taskExecutionDaoFactoryBean, "A FactoryBean that provides a TaskExecutionDao is required"); this.taskExecutionDaoFactoryBean = taskExecutionDaoFactoryBean; } + public SimpleTaskRepository(FactoryBean taskExecutionDaoFactoryBean, Integer maxExitMessageSize, + Integer maxTaskNameSize, Integer maxErrorMessageSize){ + Assert.notNull(taskExecutionDaoFactoryBean, "A FactoryBean that provides a TaskExecutionDao is required"); + if(maxTaskNameSize != null) { + this.maxTaskNameSize = maxTaskNameSize; + } + if(maxExitMessageSize != null) { + this.maxExitMessageSize = maxExitMessageSize; + } + if(maxErrorMessageSize != null) { + this.maxErrorMessageSize = maxErrorMessageSize; + } + this.taskExecutionDaoFactoryBean = taskExecutionDaoFactoryBean; + } + @Override public TaskExecution completeTaskExecution(long executionId, Integer exitCode, Date endTime, String exitMessage) { return completeTaskExecution(executionId, exitCode, endTime, exitMessage, null); @@ -62,7 +84,8 @@ public class SimpleTaskRepository implements TaskRepository { initialize(); validateExitInformation(executionId, exitCode, endTime); - exitMessage = trimExitMessage(exitMessage); + exitMessage = trimMessage(exitMessage, this.maxExitMessageSize); + errorMessage = trimMessage(errorMessage, this.maxErrorMessageSize); taskExecutionDao.completeTaskExecution(executionId, exitCode, endTime, exitMessage, errorMessage); logger.debug("Updating: TaskExecution with executionId="+executionId + " with the following {" @@ -114,9 +137,9 @@ public class SimpleTaskRepository implements TaskRepository { Assert.notNull(startTime, "TaskExecution start time cannot be null."); if (taskName != null && - taskName.length() > MAX_TASK_NAME_SIZE) { + taskName.length() > this.maxTaskNameSize) { throw new IllegalArgumentException("TaskName length exceeds " - + MAX_TASK_NAME_SIZE + " characters"); + + this.maxTaskNameSize + " characters"); } } @@ -126,12 +149,24 @@ public class SimpleTaskRepository implements TaskRepository { Assert.notNull(endTime, "TaskExecution endTime cannot be null."); } - private String trimExitMessage(String exitMessage){ + private String trimMessage(String exitMessage, int maxSize){ String result = exitMessage; if(exitMessage != null && - exitMessage.length() > MAX_EXIT_MESSAGE_SIZE) { - result = exitMessage.substring(0, MAX_EXIT_MESSAGE_SIZE - 1); + exitMessage.length() > maxSize) { + result = exitMessage.substring(0, maxSize); } return result; } + + public void setMaxExitMessageSize(int maxExitMessageSize) { + this.maxExitMessageSize = maxExitMessageSize; + } + + public void setMaxTaskNameSize(int maxTaskNameSize) { + this.maxTaskNameSize = maxTaskNameSize; + } + + public void setMaxErrorMessageSize(int maxErrorMessageSize) { + this.maxErrorMessageSize = maxErrorMessageSize; + } } diff --git a/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskExplorerTests.java b/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskExplorerTests.java index 7cce0f03..0bc5c07d 100644 --- a/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskExplorerTests.java +++ b/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskExplorerTests.java @@ -259,6 +259,16 @@ public class SimpleTaskExplorerTests { verifyPageResults(pageable, 0); } + @Test + public void findTasksForInvalidJob() { + assertNull(taskExplorer.getTaskExecutionIdByJobExecutionId(55555L)); + } + + @Test + public void findJobsExecutionIdsForInvalidTask () { + assertEquals(0, taskExplorer.getJobExecutionIdsByTaskExecutionId(555555L).size()); + } + private void verifyPageResults(Pageable pageable, int totalNumberOfExecs) { Map expectedResults = createSampleDataSet(totalNumberOfExecs); List sortedExecIds = getSortedOfTaskExecIds(expectedResults); diff --git a/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskRepositoryJdbcTests.java b/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskRepositoryJdbcTests.java index 2779ee43..ff24cf15 100644 --- a/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskRepositoryJdbcTests.java +++ b/spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskRepositoryJdbcTests.java @@ -29,6 +29,7 @@ import org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfigurati import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration; import org.springframework.cloud.task.configuration.SimpleTaskConfiguration; import org.springframework.cloud.task.repository.TaskExecution; +import org.springframework.cloud.task.repository.TaskExplorer; import org.springframework.cloud.task.repository.TaskRepository; import org.springframework.cloud.task.util.TaskExecutionCreator; import org.springframework.cloud.task.util.TestDBUtils; @@ -37,6 +38,8 @@ import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import static org.junit.Assert.assertEquals; + /** * Tests for the SimpleTaskRepository that uses JDBC as a datastore. * @@ -55,6 +58,9 @@ public class SimpleTaskRepositoryJdbcTests { @Autowired private DataSource dataSource; + @Autowired + private TaskExplorer taskExplorer; + @Test @DirtiesContext public void testCreateTaskExecutionNoParam() { @@ -90,13 +96,88 @@ public class SimpleTaskRepositoryJdbcTests { @Test @DirtiesContext - public void testCreateTaskExecutionNoParamMaxExitMessageSize(){ + public void testCreateTaskExecutionNoParamMaxExitDefaultMessageSize(){ TaskExecution expectedTaskExecution = TaskExecutionCreator.createAndStoreTaskExecutionNoParams(taskRepository); expectedTaskExecution.setExitMessage(new String(new char[SimpleTaskRepository.MAX_EXIT_MESSAGE_SIZE+1])); expectedTaskExecution.setEndTime(new Date()); - taskRepository.completeTaskExecution(expectedTaskExecution.getExecutionId(), - expectedTaskExecution.getExitCode(), new Date(), - expectedTaskExecution.getExitMessage()); + TaskExecution actualTaskExecution = completeTaskExecution(expectedTaskExecution, taskRepository); + assertEquals(SimpleTaskRepository.MAX_EXIT_MESSAGE_SIZE, actualTaskExecution.getExitMessage().length()); + } + + @Test + public void testCreateTaskExecutionNoParamMaxExitMessageSize() { + SimpleTaskRepository simpleTaskRepository = new SimpleTaskRepository(new TaskExecutionDaoFactoryBean(this.dataSource)); + simpleTaskRepository.setMaxExitMessageSize(5); + + TaskExecution expectedTaskExecution = TaskExecutionCreator.createAndStoreTaskExecutionNoParams(simpleTaskRepository); + expectedTaskExecution.setExitMessage(new String(new char[SimpleTaskRepository.MAX_EXIT_MESSAGE_SIZE + 1])); + expectedTaskExecution.setEndTime(new Date()); + TaskExecution actualTaskExecution = completeTaskExecution(expectedTaskExecution, simpleTaskRepository); + assertEquals(5, actualTaskExecution.getExitMessage().length()); + } + + @Test + @DirtiesContext + public void testCreateTaskExecutionNoParamMaxErrorDefaultMessageSize(){ + TaskExecution expectedTaskExecution = TaskExecutionCreator.createAndStoreTaskExecutionNoParams(taskRepository); + expectedTaskExecution.setErrorMessage(new String(new char[SimpleTaskRepository.MAX_ERROR_MESSAGE_SIZE+1])); + expectedTaskExecution.setEndTime(new Date()); + TaskExecution actualTaskExecution = completeTaskExecution(expectedTaskExecution, taskRepository); + assertEquals(SimpleTaskRepository.MAX_ERROR_MESSAGE_SIZE, actualTaskExecution.getErrorMessage().length()); + } + + @Test + public void testCreateTaskExecutionNoParamMaxErrorMessageSize() { + SimpleTaskRepository simpleTaskRepository = new SimpleTaskRepository(new TaskExecutionDaoFactoryBean(this.dataSource)); + simpleTaskRepository.setMaxErrorMessageSize(5); + + TaskExecution expectedTaskExecution = TaskExecutionCreator.createAndStoreTaskExecutionNoParams(simpleTaskRepository); + expectedTaskExecution.setErrorMessage(new String(new char[SimpleTaskRepository.MAX_ERROR_MESSAGE_SIZE + 1])); + expectedTaskExecution.setEndTime(new Date()); + TaskExecution actualTaskExecution = completeTaskExecution(expectedTaskExecution, simpleTaskRepository); + assertEquals(5, actualTaskExecution.getErrorMessage().length()); + } + + @Test(expected = IllegalArgumentException.class) + public void testMaxTaskNameSizeForConstructor() { + final int MAX_EXIT_MESSAGE_SIZE = 10; + final int MAX_ERROR_MESSAGE_SIZE = 20; + final int MAX_TASK_NAME_SIZE = 30; + SimpleTaskRepository simpleTaskRepository = new SimpleTaskRepository( + new TaskExecutionDaoFactoryBean(this.dataSource), MAX_EXIT_MESSAGE_SIZE, MAX_TASK_NAME_SIZE, + MAX_ERROR_MESSAGE_SIZE); + TaskExecution expectedTaskExecution = TestVerifierUtils.createSampleTaskExecutionNoArg(); + expectedTaskExecution.setTaskName(new String(new char[MAX_TASK_NAME_SIZE + 1])); + simpleTaskRepository.createTaskExecution(expectedTaskExecution.getTaskName(), + expectedTaskExecution.getStartTime(), expectedTaskExecution.getArguments()); + } + + @Test(expected = IllegalArgumentException.class) + public void testDefaultMaxTaskNameSizeForConstructor() { + SimpleTaskRepository simpleTaskRepository = new SimpleTaskRepository( + new TaskExecutionDaoFactoryBean(this.dataSource), null, null, null); + TaskExecution expectedTaskExecution = TestVerifierUtils.createSampleTaskExecutionNoArg(); + expectedTaskExecution.setTaskName(new String(new char[SimpleTaskRepository.MAX_TASK_NAME_SIZE + 1])); + simpleTaskRepository.createTaskExecution(expectedTaskExecution.getTaskName(), + expectedTaskExecution.getStartTime(), expectedTaskExecution.getArguments()); + } + + @Test + public void testMaxSizeConstructor() { + final int MAX_EXIT_MESSAGE_SIZE = 10; + final int MAX_ERROR_MESSAGE_SIZE = 20; + SimpleTaskRepository simpleTaskRepository = new SimpleTaskRepository( + new TaskExecutionDaoFactoryBean(this.dataSource), MAX_EXIT_MESSAGE_SIZE, null, + MAX_ERROR_MESSAGE_SIZE); + verifyTaskRepositoryConstructor(MAX_EXIT_MESSAGE_SIZE, MAX_ERROR_MESSAGE_SIZE, simpleTaskRepository); + } + + @Test + public void testDefaultConstructor() { + SimpleTaskRepository simpleTaskRepository = new SimpleTaskRepository( + new TaskExecutionDaoFactoryBean(this.dataSource), null, null, null); + verifyTaskRepositoryConstructor(SimpleTaskRepository.MAX_EXIT_MESSAGE_SIZE, + SimpleTaskRepository.MAX_ERROR_MESSAGE_SIZE, simpleTaskRepository); } @Test(expected=IllegalArgumentException.class) @@ -128,5 +209,23 @@ public class SimpleTaskRepositoryJdbcTests { expectedTaskExecution.setExitCode(-1); TaskExecutionCreator.completeExecution(taskRepository, expectedTaskExecution); } + + private TaskExecution completeTaskExecution(TaskExecution expectedTaskExecution, TaskRepository taskRepository) { + return taskRepository.completeTaskExecution(expectedTaskExecution.getExecutionId(), + expectedTaskExecution.getExitCode(), new Date(), + expectedTaskExecution.getExitMessage(), expectedTaskExecution.getErrorMessage()); + } + + private void verifyTaskRepositoryConstructor(Integer maxExitMessage, Integer maxErrorMessage, + TaskRepository taskRepository) { + TaskExecution expectedTaskExecution = TaskExecutionCreator.createAndStoreTaskExecutionNoParams(taskRepository); + expectedTaskExecution.setErrorMessage(new String(new char[maxErrorMessage+ 1])); + expectedTaskExecution.setExitMessage(new String(new char[maxExitMessage + 1])); + expectedTaskExecution.setEndTime(new Date()); + + TaskExecution actualTaskExecution = completeTaskExecution(expectedTaskExecution, taskRepository); + assertEquals(maxErrorMessage.intValue(), actualTaskExecution.getErrorMessage().length()); + assertEquals(maxExitMessage.intValue(), actualTaskExecution.getExitMessage().length()); + } }