Expose method on SchedulerClient for checking if a single execution exists.

src/main/java/com/github/kagkarlsson/scheduler/Scheduler.java

@@ -167,6 +167,11 @@ public <T> void getScheduledExecutionsForTask(String taskName, Class<T> dataClas
 		this.delegate.getScheduledExecutionsForTask(taskName, dataClass, consumer);
 	}
 
+	@Override
+	public Optional<ScheduledExecution<Object>> getScheduledExecution(TaskInstanceId taskInstanceId) {
+		return this.delegate.getScheduledExecution(taskInstanceId);
+	}
+
 	public List<Execution> getFailingExecutions(Duration failingAtLeastFor) {
 		return taskRepository.getExecutionsFailingLongerThan(failingAtLeastFor);
 	}

src/main/java/com/github/kagkarlsson/scheduler/SchedulerClient.java

@@ -42,6 +42,8 @@ public interface SchedulerClient {
 
 	<T> void getScheduledExecutionsForTask(String taskName, Class<T> dataClass, Consumer<ScheduledExecution<T>> consumer);
 
+	Optional<ScheduledExecution<Object>> getScheduledExecution(TaskInstanceId taskInstanceId);
+
 	class Builder {
 
 		private final DataSource dataSource;
@@ -144,6 +146,12 @@ public <T> void getScheduledExecutionsForTask(String taskName, Class<T> dataClas
 			taskRepository.getScheduledExecutions(taskName, execution -> consumer.accept(new ScheduledExecution<>(dataClass, execution)));
 		}
 
+		@Override
+		public Optional<ScheduledExecution<Object>> getScheduledExecution(TaskInstanceId taskInstanceId) {
+			Optional<Execution> e = taskRepository.getExecution(taskInstanceId.getTaskName(), taskInstanceId.getId());
+			return e.map(oe -> new ScheduledExecution<>(Object.class, oe));
+		}
+
 		private void notifyListeners(ClientEvent.EventType eventType, TaskInstanceId taskInstanceId, Instant executionTime) {
 			try {
 				schedulerClientEventListener.newEvent(new ClientEvent(new ClientEvent.ClientEventContext(eventType, taskInstanceId, executionTime)));

src/main/java/com/github/kagkarlsson/scheduler/TaskRepository.java

@@ -16,6 +16,7 @@
 package com.github.kagkarlsson.scheduler;
 
 import com.github.kagkarlsson.scheduler.task.Execution;
+import com.github.kagkarlsson.scheduler.task.TaskInstanceId;
 
 import java.time.Duration;
 import java.time.Instant;
@@ -43,4 +44,5 @@ public interface TaskRepository {
 	List<Execution> getExecutionsFailingLongerThan(Duration interval);
 
 	Optional<Execution> getExecution(String taskName, String taskInstanceId);
+
 }

src/main/java/com/github/kagkarlsson/scheduler/task/TaskInstanceId.java

@@ -15,6 +15,8 @@
  */
 package com.github.kagkarlsson.scheduler.task;
 
+import java.util.Objects;
+
 public interface TaskInstanceId {
     String getTaskName();
     String getId();
@@ -41,5 +43,18 @@ public String getId() {
             return this.id;
         }
 
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            StandardTaskInstanceId that = (StandardTaskInstanceId) o;
+            return Objects.equals(taskName, that.taskName) &&
+                    Objects.equals(id, that.id);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(taskName, id);
+        }
     }
 }

src/test/java/com/github/kagkarlsson/scheduler/SchedulerClientTest.java

@@ -1,5 +1,7 @@
 package com.github.kagkarlsson.scheduler;
 
+import co.unruly.matchers.OptionalMatchers;
+import com.github.kagkarlsson.scheduler.task.TaskInstanceId;
 import com.github.kagkarlsson.scheduler.testhelper.ManualScheduler;
 import com.github.kagkarlsson.scheduler.testhelper.SettableClock;
 import com.github.kagkarlsson.scheduler.testhelper.TestHelper;
@@ -9,6 +11,7 @@
 import com.github.kagkarlsson.scheduler.task.TaskInstance;
 import com.google.common.collect.Lists;
 import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matchers;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -18,6 +21,7 @@
 
 import static java.time.Duration.ofSeconds;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
 import static org.junit.Assert.assertThat;
 
 public class SchedulerClientTest {
@@ -84,6 +88,16 @@ public void client_should_be_able_to_fetch_executions_for_task() {
         assertThat(countExecutionsForTask(client, oneTimeTaskB.getName(), Void.class), is(3));
     }
 
+    @Test
+    public void client_should_be_able_to_fetch_single_scheduled_execution() {
+        SchedulerClient client = SchedulerClient.Builder.create(DB.getDataSource(), oneTimeTaskA).build();
+        client.schedule(oneTimeTaskA.instance("1"), settableClock.now());
+
+        assertThat(client.getScheduledExecution(TaskInstanceId.of(oneTimeTaskA.getName(), "1")), not(OptionalMatchers.empty()));
+        assertThat(client.getScheduledExecution(TaskInstanceId.of(oneTimeTaskA.getName(), "2")), OptionalMatchers.empty());
+        assertThat(client.getScheduledExecution(TaskInstanceId.of(oneTimeTaskB.getName(), "1")), OptionalMatchers.empty());
+    }
+
     private int countAllExecutions(SchedulerClient client) {
         AtomicInteger counter = new AtomicInteger(0);
         client.getScheduledExecutions((ScheduledExecution<Object> execution) -> {counter.incrementAndGet();});