gh-424 Add the ability to retrieve the last TaskExecution for Tasks

- Add the ability to retrieve the last TaskExecution to:
  - MapTaskExecutionDao
  - JdbcTaskExecutionDao
- Refactor `JdbcTaskExecutionDao` and use `NamedParameterJdbcTemplate` for all persistence store calls
- Add the following TaskExecution methods to TaskExplorer:
  - getLatestTaskExecutionsByTaskNames
  - getLatestTaskExecutionForTaskName
- Add Tests
- Ensure that code is JDK7 compatible due to backporting needs
- Ensure commit backports to 1.2.x

Polishing on tests during merge

spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/dao/BaseTaskExecutionDaoTestCases.java

@@ -0,0 +1,309 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * 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
+ *
+ *      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.springframework.cloud.task.repository.dao;
+
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.TimeZone;
+
+import org.junit.Test;
+import org.springframework.cloud.task.repository.TaskExecution;
+import org.springframework.test.annotation.DirtiesContext;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Defines test cases that shall be shared between {@link JdbcTaskExecutionDaoTests} and {@link MapTaskExecutionDaoTests}.
+ *
+ * @author Gunnar Hillert
+ */
+public class BaseTaskExecutionDaoTestCases {
+
+	protected TaskExecutionDao dao;
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionsByTaskNamesWithNullParameter()  {
+		try {
+			dao.getLatestTaskExecutionsByTaskNames(null);
+		}
+		catch (IllegalArgumentException e) {
+			assertEquals("At least 1 task name must be provided.", e.getMessage());
+			return;
+		}
+		fail("Expected an IllegalArgumentException to be thrown.");
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionsByTaskNamesWithEmptyArrayParameter()  {
+		try {
+			dao.getLatestTaskExecutionsByTaskNames(new String[0]);
+		}
+		catch (IllegalArgumentException e) {
+			assertEquals("At least 1 task name must be provided.", e.getMessage());
+			return;
+		}
+		fail("Expected an IllegalArgumentException to be thrown.");
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionsByTaskNamesWithArrayParametersContainingNullAndEmptyValues()  {
+		try {
+			dao.getLatestTaskExecutionsByTaskNames("foo", null, "bar", " ");
+		}
+		catch (IllegalArgumentException e) {
+			assertEquals("Task names must not contain any empty elements but 2 of 4 were empty or null.", e.getMessage());
+			return;
+		}
+		fail("Expected an IllegalArgumentException to be thrown.");
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionsByTaskNamesWithSingleTaskName()  {
+		initializeRepositoryNotInOrderWithMultipleTaskExecutions();
+		final List<TaskExecution> latestTaskExecutions = dao.getLatestTaskExecutionsByTaskNames("FOO1");
+		assertTrue("Expected only 1 taskExecution but got " + latestTaskExecutions.size(), latestTaskExecutions.size() == 1);
+
+		final TaskExecution lastTaskExecution = latestTaskExecutions.get(0);
+		assertEquals("FOO1", lastTaskExecution.getTaskName());
+
+		final Calendar dateTime = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		dateTime.setTime(lastTaskExecution.getStartTime());
+
+		assertEquals(2015, dateTime.get(Calendar.YEAR));
+		assertEquals(2, dateTime.get(Calendar.MONTH) + 1);
+		assertEquals(22, dateTime.get(Calendar.DAY_OF_MONTH));
+		assertEquals(23, dateTime.get(Calendar.HOUR_OF_DAY));
+		assertEquals(59, dateTime.get(Calendar.MINUTE));
+		assertEquals(0, dateTime.get(Calendar.SECOND));
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionsByTaskNamesWithMultipleTaskNames()  {
+		initializeRepositoryNotInOrderWithMultipleTaskExecutions();
+		final List<TaskExecution> latestTaskExecutions = dao.getLatestTaskExecutionsByTaskNames("FOO1", "FOO3", "FOO4");
+		assertTrue("Expected 3 taskExecutions but got " + latestTaskExecutions.size(), latestTaskExecutions.size() == 3);
+
+		final Calendar dateTimeFoo3 = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		dateTimeFoo3.setTime(latestTaskExecutions.get(0).getStartTime());
+
+		assertEquals(2016, dateTimeFoo3.get(Calendar.YEAR));
+		assertEquals(8, dateTimeFoo3.get(Calendar.MONTH) + 1);
+		assertEquals(20, dateTimeFoo3.get(Calendar.DAY_OF_MONTH));
+		assertEquals(14, dateTimeFoo3.get(Calendar.HOUR_OF_DAY));
+		assertEquals(45, dateTimeFoo3.get(Calendar.MINUTE));
+		assertEquals(0, dateTimeFoo3.get(Calendar.SECOND));
+
+		final Calendar dateTimeFoo1 = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		dateTimeFoo1.setTime(latestTaskExecutions.get(1).getStartTime());
+
+		assertEquals(2015, dateTimeFoo1.get(Calendar.YEAR));
+		assertEquals(2, dateTimeFoo1.get(Calendar.MONTH) + 1);
+		assertEquals(22, dateTimeFoo1.get(Calendar.DAY_OF_MONTH));
+		assertEquals(23, dateTimeFoo1.get(Calendar.HOUR_OF_DAY));
+		assertEquals(59, dateTimeFoo1.get(Calendar.MINUTE));
+		assertEquals(0, dateTimeFoo1.get(Calendar.SECOND));
+
+		final Calendar dateTimeFoo4 = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		dateTimeFoo4.setTime(latestTaskExecutions.get(2).getStartTime());
+
+		assertEquals(2015, dateTimeFoo4.get(Calendar.YEAR));
+		assertEquals(2, dateTimeFoo4.get(Calendar.MONTH) + 1);
+		assertEquals(20, dateTimeFoo4.get(Calendar.DAY_OF_MONTH));
+		assertEquals(14, dateTimeFoo4.get(Calendar.HOUR_OF_DAY));
+		assertEquals(45, dateTimeFoo4.get(Calendar.MINUTE));
+		assertEquals(0, dateTimeFoo4.get(Calendar.SECOND));
+	}
+
+	/**
+	 * This test is a special use-case. While not common, it is theoretically possible, that a task may have
+	 * executed with the exact same start time multiple times. In that case we should still only get 1 returned
+	 * {@link TaskExecution}.
+	 */
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionsByTaskNamesWithIdenticalTaskExecutions()  {
+		long executionIdOffset = initializeRepositoryNotInOrderWithMultipleTaskExecutions();
+		final List<TaskExecution> latestTaskExecutions = dao.getLatestTaskExecutionsByTaskNames("FOO5");
+		assertTrue("Expected only 1 taskExecution but got " + latestTaskExecutions.size(), latestTaskExecutions.size() == 1);
+
+		final Calendar dateTime = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		dateTime.setTime(latestTaskExecutions.get(0).getStartTime());
+
+		assertEquals(2015, dateTime.get(Calendar.YEAR));
+		assertEquals(2, dateTime.get(Calendar.MONTH) + 1);
+		assertEquals(22, dateTime.get(Calendar.DAY_OF_MONTH));
+		assertEquals(23, dateTime.get(Calendar.HOUR_OF_DAY));
+		assertEquals(59, dateTime.get(Calendar.MINUTE));
+		assertEquals(0, dateTime.get(Calendar.SECOND));
+		assertEquals(9 + executionIdOffset, latestTaskExecutions.get(0).getExecutionId());
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionForTaskNameWithNullParameter()  {
+		try {
+			dao.getLatestTaskExecutionForTaskName(null);
+		}
+		catch (IllegalArgumentException e) {
+			assertEquals("The task name must not be empty.", e.getMessage());
+			return;
+		}
+		fail("Expected an IllegalArgumentException to be thrown.");
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionForTaskNameWithEmptyStringParameter()  {
+		try {
+			dao.getLatestTaskExecutionForTaskName("");
+		}
+		catch (IllegalArgumentException e) {
+			assertEquals("The task name must not be empty.", e.getMessage());
+			return;
+		}
+		fail("Expected an IllegalArgumentException to be thrown.");
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionForNonExistingTaskName()  {
+		initializeRepositoryNotInOrderWithMultipleTaskExecutions();
+		final TaskExecution latestTaskExecution = dao.getLatestTaskExecutionForTaskName("Bar5");
+		assertNull("Expected the latestTaskExecution to be null but got" + latestTaskExecution, latestTaskExecution);
+	}
+
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionForExistingTaskName()  {
+		initializeRepositoryNotInOrderWithMultipleTaskExecutions();
+		final TaskExecution latestTaskExecution = dao.getLatestTaskExecutionForTaskName("FOO1");
+		assertNotNull("Expected the latestTaskExecution not to be null", latestTaskExecution);
+
+		final Calendar dateTime = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		dateTime.setTime(latestTaskExecution.getStartTime());
+
+		assertEquals(2015, dateTime.get(Calendar.YEAR));
+		assertEquals(2, dateTime.get(Calendar.MONTH) + 1);
+		assertEquals(22, dateTime.get(Calendar.DAY_OF_MONTH));
+		assertEquals(23, dateTime.get(Calendar.HOUR_OF_DAY));
+		assertEquals(59, dateTime.get(Calendar.MINUTE));
+		assertEquals(0, dateTime.get(Calendar.SECOND));
+	}
+
+	/**
+	 * This test is a special use-case. While not common, it is theoretically possible, that a task may have
+	 * executed with the exact same start time multiple times. In that case we should still only get 1 returned
+	 * {@link TaskExecution}.
+	 */
+	@Test
+	@DirtiesContext
+	public void getLatestTaskExecutionForTaskNameWithIdenticalTaskExecutions()  {
+		long executionIdOffset = initializeRepositoryNotInOrderWithMultipleTaskExecutions();
+		final TaskExecution latestTaskExecution = dao.getLatestTaskExecutionForTaskName("FOO5");
+		assertNotNull("Expected the latestTaskExecution not to be null", latestTaskExecution);
+
+		final Calendar dateTime = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		dateTime.setTime(latestTaskExecution.getStartTime());
+
+		assertEquals(2015, dateTime.get(Calendar.YEAR));
+		assertEquals(2, dateTime.get(Calendar.MONTH) + 1);
+		assertEquals(22, dateTime.get(Calendar.DAY_OF_MONTH));
+		assertEquals(23, dateTime.get(Calendar.HOUR_OF_DAY));
+		assertEquals(59, dateTime.get(Calendar.MINUTE));
+		assertEquals(0, dateTime.get(Calendar.SECOND));
+		assertEquals(9 + executionIdOffset, latestTaskExecution.getExecutionId());
+	}
+
+	protected long initializeRepositoryNotInOrderWithMultipleTaskExecutions() {
+
+		final TaskExecution foo1_0 = getTaskExecution("FOO1", "externalC");
+		foo1_0.setStartTime(getDate(2015, 2, 22, 23, 59));
+
+		final TaskExecution foo1_1 = getTaskExecution("FOO1", "externalC");
+		foo1_1.setStartTime(getDate(2015, 2, 20, 14, 45));
+
+		final TaskExecution foo1_2 = getTaskExecution("FOO1", "externalC");
+		foo1_2.setStartTime(getDate(2015, 1, 19, 14, 30));
+
+		final TaskExecution foo1_3 = getTaskExecution("FOO1", "externalC");
+		foo1_3.setStartTime(getDate(2015, 1, 20, 14, 45));
+
+		TaskExecution foo2 = getTaskExecution("FOO2", "externalA");
+		foo2.setStartTime(getDate(2015, 4, 20, 14, 45));
+
+		TaskExecution foo3 = getTaskExecution("FOO3", "externalB");
+		foo3.setStartTime(getDate(2016, 8, 20, 14, 45));
+
+		TaskExecution foo4 = getTaskExecution("FOO4", "externalB");
+		foo4.setStartTime(getDate(2015, 2, 20, 14, 45));
+
+		final TaskExecution foo5_0 = getTaskExecution("FOO5", "externalC");
+		foo5_0.setStartTime(getDate(2015, 2, 22, 23, 59));
+
+		final TaskExecution foo5_1 = getTaskExecution("FOO5", "externalC");
+		foo5_1.setStartTime(getDate(2015, 2, 22, 23, 59));
+
+		final TaskExecution foo5_2 = getTaskExecution("FOO5", "externalC");
+		foo5_2.setStartTime(getDate(2015, 2, 22, 23, 59));
+
+		long executionIdOffset = this.createTaskExecution(foo1_0);
+		this.createTaskExecution(foo1_1);
+		this.createTaskExecution(foo1_2);
+		this.createTaskExecution(foo1_3);
+
+		this.createTaskExecution(foo2);
+		this.createTaskExecution(foo3);
+		this.createTaskExecution(foo4);
+
+		this.createTaskExecution(foo5_0);
+		this.createTaskExecution(foo5_1);
+		this.createTaskExecution(foo5_2);
+
+		return executionIdOffset;
+	}
+
+	private Date getDate(int year, int month, int day, int hour, int minute) {
+		Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+		calendar.clear();
+		calendar.set(year, month - 1, day, hour, minute);
+		return calendar.getTime();
+	}
+
+	private long createTaskExecution(TaskExecution te) {
+		return dao.createTaskExecution(te.getTaskName(), te.getStartTime(), te.getArguments(), te.getExternalExecutionId()).getExecutionId();
+	}
+
+	protected TaskExecution getTaskExecution(String taskName,
+			String externalExecutionId) {
+		TaskExecution taskExecution = new TaskExecution();
+		taskExecution.setTaskName(taskName);
+		taskExecution.setExternalExecutionId(externalExecutionId);
+		taskExecution.setStartTime(new Date());
+		return taskExecution;
+	}
+}

spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/dao/JdbcTaskExecutionDaoTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,12 +21,12 @@ import java.util.Collections;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.UUID;
+
 import javax.sql.DataSource;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
 import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
@@ -49,25 +49,25 @@ import static org.junit.Assert.assertEquals;
  * Executes unit tests on JdbcTaskExecutionDao.
  *
  * @author Glenn Renfro
+ * @author Gunnar Hillert
  */
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes = {TestConfiguration.class,
 		EmbeddedDataSourceConfiguration.class,
 		PropertyPlaceholderAutoConfiguration.class})
-public class JdbcTaskExecutionDaoTests {
+public class JdbcTaskExecutionDaoTests extends BaseTaskExecutionDaoTestCases {
 
 	@Autowired
 	private DataSource dataSource;
 
-	private JdbcTaskExecutionDao dao;
-
 	@Autowired
 	TaskRepository repository;
 
 	@Before
 	public void setup(){
-		dao = new JdbcTaskExecutionDao(dataSource);
+		final JdbcTaskExecutionDao dao = new JdbcTaskExecutionDao(dataSource);
 		dao.setTaskIncrementer(TestDBUtils.getIncrementer(dataSource));
+		super.dao = dao;
 	}
 
 	@Test
@@ -221,13 +221,4 @@ public class JdbcTaskExecutionDaoTests {
 		repository.createTaskExecution(getTaskExecution("FOO2", "externalA"));
 		repository.createTaskExecution(getTaskExecution("FOO3", "externalB"));
 	}
-
-	private TaskExecution getTaskExecution(String taskName,
-			String externalExecutionId) {
-		TaskExecution taskExecution = new TaskExecution();
-		taskExecution.setTaskName(taskName);
-		taskExecution.setExternalExecutionId(externalExecutionId);
-		taskExecution.setStartTime(new Date());
-		return taskExecution;
-	}
 }

spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/dao/MapTaskExecutionDaoTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,7 +27,6 @@ import java.util.UUID;
 
 import org.junit.Before;
 import org.junit.Test;
-
 import org.springframework.cloud.task.repository.TaskExecution;
 import org.springframework.cloud.task.util.TestVerifierUtils;
 
@@ -37,15 +36,18 @@ import static org.junit.Assert.assertNull;
 
 /**
  * Executes unit tests on MapTaskExecutionDaoTests.
+ *
  * @author Glenn Renfro
+ * @author Gunnar Hillert
  */
-public class MapTaskExecutionDaoTests {
+public class MapTaskExecutionDaoTests extends BaseTaskExecutionDaoTestCases{
 
-	private MapTaskExecutionDao dao;
+	private MapTaskExecutionDao mapTaskExecutionDao;
 
 	@Before
 	public void setUp() {
-		this.dao = new MapTaskExecutionDao();
+		this.mapTaskExecutionDao = new MapTaskExecutionDao();
+		super.dao = this.mapTaskExecutionDao;
 	}
 
 	@Test
@@ -59,7 +61,7 @@ public class MapTaskExecutionDaoTests {
 		this.dao.startTaskExecution(expectedTaskExecution.getExecutionId(), expectedTaskExecution.getTaskName(),
 				expectedTaskExecution.getStartTime(), expectedTaskExecution.getArguments(),
 				expectedTaskExecution.getExternalExecutionId());
-		Map<Long, TaskExecution> taskExecutionMap = this.dao.getTaskExecutions();
+		Map<Long, TaskExecution> taskExecutionMap = this.mapTaskExecutionDao.getTaskExecutions();
 		assertNotNull("taskExecutionMap must not be null", taskExecutionMap);
 		TestVerifierUtils.verifyTaskExecution(expectedTaskExecution,
 				taskExecutionMap.get(expectedTaskExecution.getExecutionId()));
@@ -70,7 +72,7 @@ public class MapTaskExecutionDaoTests {
 		TaskExecution expectedTaskExecution = dao.createTaskExecution(null, null,
 				new ArrayList<String>(0), null);
 
-		Map<Long, TaskExecution> taskExecutionMap = this.dao.getTaskExecutions();
+		Map<Long, TaskExecution> taskExecutionMap = this.mapTaskExecutionDao.getTaskExecutions();
 		TestVerifierUtils.verifyTaskExecution(expectedTaskExecution,
 				taskExecutionMap.get(expectedTaskExecution.getExecutionId()));
 	}
@@ -89,7 +91,7 @@ public class MapTaskExecutionDaoTests {
 		expectedTaskExecution = this.dao.createTaskExecution(expectedTaskExecution.getTaskName(),
 				expectedTaskExecution.getStartTime(), expectedTaskExecution.getArguments(),
 				expectedTaskExecution.getExternalExecutionId());
-		Map<Long, TaskExecution> taskExecutionMap = this.dao.getTaskExecutions();
+		Map<Long, TaskExecution> taskExecutionMap = this.mapTaskExecutionDao.getTaskExecutions();
 		assertNotNull("taskExecutionMap must not be null", taskExecutionMap);
 		TestVerifierUtils.verifyTaskExecution(expectedTaskExecution,
 				taskExecutionMap.get(expectedTaskExecution.getExecutionId()));
@@ -104,7 +106,7 @@ public class MapTaskExecutionDaoTests {
 		this.dao.completeTaskExecution(expectedTaskExecution.getExecutionId(),
 				expectedTaskExecution.getExitCode(), expectedTaskExecution.getEndTime(),
 				expectedTaskExecution.getExitMessage());
-		Map<Long, TaskExecution> taskExecutionMap = this.dao.getTaskExecutions();
+		Map<Long, TaskExecution> taskExecutionMap = this.mapTaskExecutionDao.getTaskExecutions();
 		assertNotNull("taskExecutionMap must not be null", taskExecutionMap);
 		TestVerifierUtils.verifyTaskExecution(expectedTaskExecution,
 				taskExecutionMap.get(expectedTaskExecution.getExecutionId()));
@@ -124,10 +126,10 @@ public class MapTaskExecutionDaoTests {
 					expectedTaskExecution.getExitCode(), expectedTaskExecution.getEndTime(),
 					expectedTaskExecution.getExitMessage());
 		}
-		Set jobIds = new HashSet<Long>(2);
+		Set<Long> jobIds = new HashSet<>(2);
 		jobIds.add(123L);
 		jobIds.add(456L);
-		this.dao.getBatchJobAssociations().put(
+		this.mapTaskExecutionDao.getBatchJobAssociations().put(
 				expectedTaskExecutionList.get(0).getExecutionId(), jobIds);
 
 		assertEquals(Long.valueOf(expectedTaskExecutionList.get(0).getExecutionId()),
@@ -141,7 +143,7 @@ public class MapTaskExecutionDaoTests {
 	public void testStartExecutionWithNullExternalExecutionIdExisting(){
 		TaskExecution expectedTaskExecution =
 				initializeTaskExecutionWithExternalExecutionId();
-		Map<Long, TaskExecution> taskExecutionMap = this.dao.getTaskExecutions();
+		Map<Long, TaskExecution> taskExecutionMap = this.mapTaskExecutionDao.getTaskExecutions();
 		this.dao.startTaskExecution(expectedTaskExecution.getExecutionId(), expectedTaskExecution.getTaskName(),
 				expectedTaskExecution.getStartTime(), expectedTaskExecution.getArguments(),
 				null);
@@ -153,7 +155,7 @@ public class MapTaskExecutionDaoTests {
 	public void testStartExecutionWithNullExternalExecutionIdNonExisting(){
 		TaskExecution expectedTaskExecution =
 				initializeTaskExecutionWithExternalExecutionId();
-		Map<Long, TaskExecution> taskExecutionMap = this.dao.getTaskExecutions();
+		Map<Long, TaskExecution> taskExecutionMap = this.mapTaskExecutionDao.getTaskExecutions();
 		this.dao.startTaskExecution(expectedTaskExecution.getExecutionId(), expectedTaskExecution.getTaskName(),
 				expectedTaskExecution.getStartTime(), expectedTaskExecution.getArguments(),
 				"BAR");
@@ -167,4 +169,5 @@ public class MapTaskExecutionDaoTests {
 				expectedTaskExecution.getStartTime(), expectedTaskExecution.getArguments(),
 				"FOO1");
 	}
+
 }

spring-cloud-task-core/src/test/java/org/springframework/cloud/task/repository/support/SimpleTaskExplorerTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,7 +31,6 @@ import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Random;
 import java.util.Set;
 import java.util.TreeSet;
 
@@ -59,6 +58,7 @@ import org.springframework.data.domain.Pageable;
 
 /**
  * @author Glenn Renfro
+ * @author Gunnar Hillert
  */
 @RunWith(Parameterized.class)
 public class SimpleTaskExplorerTests {
@@ -124,7 +124,7 @@ public class SimpleTaskExplorerTests {
 
 	@Test
 	public void taskExecutionNotFound() {
-		Map< Long, TaskExecution> expectedResults = createSampleDataSet(5);
+		createSampleDataSet(5);
 
 		TaskExecution actualTaskExecution =
 				taskExplorer.getTaskExecution(-5);
@@ -147,7 +147,7 @@ public class SimpleTaskExplorerTests {
 
 	@Test
 	public void getTaskCount() {
-		Map<Long, TaskExecution> expectedResults = createSampleDataSet(33);
+		createSampleDataSet(33);
 		assertEquals(String.format(
 				"task count did not match expected result for test Type %s",
 				testType),
@@ -192,7 +192,6 @@ public class SimpleTaskExplorerTests {
 	public void findTasksByName() {
 		final int TEST_COUNT = 5;
 		final int COMPLETE_COUNT = 7;
-		Random randomGenerator = new Random();
 
 		Map<Long, TaskExecution> expectedResults = new HashMap<>();
 		//Store completed jobs
@@ -271,12 +270,50 @@ public class SimpleTaskExplorerTests {
 		assertEquals(0, taskExplorer.getJobExecutionIdsByTaskExecutionId(555555L).size());
 	}
 
+	@Test
+	public void getLatestTaskExecutionForTaskName() {
+		Map<Long, TaskExecution> expectedResults = createSampleDataSet(5);
+		for (Map.Entry<Long, TaskExecution> taskExecutionMapEntry: expectedResults.entrySet()) {
+			TaskExecution latestTaskExecution =
+					taskExplorer.getLatestTaskExecutionForTaskName(taskExecutionMapEntry.getValue().getTaskName());
+			assertNotNull(String.format(
+					"expected a taskExecution but got null for test type %s", testType),
+					latestTaskExecution);
+			TestVerifierUtils.verifyTaskExecution(
+					expectedResults.get(latestTaskExecution.getExecutionId()),
+					latestTaskExecution);
+		}
+	}
+
+	@Test
+	public void getLatestTaskExecutionsByTaskNames() {
+		Map<Long, TaskExecution> expectedResults = createSampleDataSet(5);
+
+		final List<String> taskNamesAsList = new ArrayList<>();
+
+		for (TaskExecution taskExecution : expectedResults.values()) {
+			taskNamesAsList.add(taskExecution.getTaskName());
+		}
+
+		final List<TaskExecution> latestTaskExecutions = taskExplorer.getLatestTaskExecutionsByTaskNames(
+				taskNamesAsList.toArray(new String[taskNamesAsList.size()]));
+
+		for (TaskExecution latestTaskExecution : latestTaskExecutions) {
+			assertNotNull(String.format(
+					"expected a taskExecution but got null for test type %s", testType),
+					latestTaskExecution);
+			TestVerifierUtils.verifyTaskExecution(
+					expectedResults.get(latestTaskExecution.getExecutionId()),
+					latestTaskExecution);
+		}
+	}
+
 	private void verifyPageResults(Pageable pageable, int totalNumberOfExecs) {
 		Map<Long, TaskExecution> expectedResults = createSampleDataSet(totalNumberOfExecs);
 		List<Long> sortedExecIds = getSortedOfTaskExecIds(expectedResults);
 		Iterator<Long> expectedTaskExecutionIter = sortedExecIds.iterator();
 		//Verify pageable totals
-		Page taskPage = taskExplorer.findAll(pageable);
+		Page<TaskExecution> taskPage = taskExplorer.findAll(pageable);
 		int pagesExpected = (int) Math.ceil(totalNumberOfExecs / ((double) pageable.getPageSize()));
 		assertEquals("actual page count return was not the expected total",
 				pagesExpected,
@@ -356,7 +393,7 @@ public class SimpleTaskExplorerTests {
 
 	private List<Long> getSortedOfTaskExecIds(Map<Long, TaskExecution> taskExecutionMap){
 		List<Long> sortedExecIds = new ArrayList<>(taskExecutionMap.size());
-		TreeSet sortedSet = getTreeSet();
+		TreeSet<TaskExecution> sortedSet = getTreeSet();
 		sortedSet.addAll(taskExecutionMap.values());
 		Iterator <TaskExecution> iterator = sortedSet.descendingIterator();
 		while(iterator.hasNext()){
@@ -365,7 +402,7 @@ public class SimpleTaskExplorerTests {
 		return sortedExecIds;
 	}
 
-	private TreeSet getTreeSet(){
+	private TreeSet<TaskExecution> getTreeSet(){
 		return new TreeSet<TaskExecution>(new Comparator<TaskExecution>() {
 			@Override
 			public int compare(TaskExecution e1, TaskExecution e2) {