Merge 8912b20 into 8ca328b

CHANGELOG.md

@@ -5,6 +5,11 @@ on [Keep a CHANGELOG](http://keepachangelog.com/). This project adheres to
 
 ## [Unreleased]
 
+## [2.0.0-M14] - 2019-04-15
+### Changed
+- Simplify datasource usage and setup
+- Update framework to 6.0.0-M14
+
 ## [2.0.0-M13] - 2019-04-15
 ### Changed
 - Remove deprecated github_token entry from travis.yml

aggregate-snapshot/aggregate-snapshot-service/src/main/java/uk/gov/justice/services/eventsourcing/source/core/SnapshotAwareEventSource.java

@@ -1,7 +1,6 @@
 package uk.gov.justice.services.eventsourcing.source.core;
 
 import uk.gov.justice.services.eventsourcing.repository.jdbc.EventRepository;
-import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventConverter;
 import uk.gov.justice.services.eventsourcing.source.core.snapshot.SnapshotService;
 
 import java.util.UUID;
@@ -15,24 +14,21 @@ public class SnapshotAwareEventSource implements EventSource {
     private final EventStreamManager eventStreamManager;
     private final SnapshotService snapshotService;
     private final EventRepository eventRepository;
-    private final EventConverter eventConverter;
-    private final String name;
+    private final String eventSourceName;
 
     public SnapshotAwareEventSource(final EventStreamManager eventStreamManager,
                                     final EventRepository eventRepository,
                                     final SnapshotService snapshotService,
-                                    final EventConverter eventConverter,
-                                    final String name) {
+                                    final String eventSourceName) {
         this.eventStreamManager = eventStreamManager;
         this.eventRepository = eventRepository;
         this.snapshotService = snapshotService;
-        this.eventConverter = eventConverter;
-        this.name = name;
+        this.eventSourceName = eventSourceName;
     }
 
     @Override
     public EventStream getStreamById(final UUID streamId) {
-        return new SnapshotAwareEnvelopeEventStream(streamId, eventStreamManager, snapshotService, name);
+        return new SnapshotAwareEnvelopeEventStream(streamId, eventStreamManager, snapshotService, eventSourceName);
     }
 
     @Override

aggregate-snapshot/aggregate-snapshot-service/src/main/java/uk/gov/justice/services/eventsourcing/source/core/SnapshotAwareEventSourceFactory.java

@@ -2,15 +2,16 @@
 
 import uk.gov.justice.services.eventsourcing.repository.jdbc.EventRepository;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.EventRepositoryFactory;
-import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventConverter;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventJdbcRepository;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventJdbcRepositoryFactory;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.PublishedEventFinder;
+import uk.gov.justice.services.eventsourcing.repository.jdbc.event.PublishedEventFinderFactory;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.eventstream.EventStreamJdbcRepository;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.eventstream.EventStreamJdbcRepositoryFactory;
 import uk.gov.justice.services.eventsourcing.source.core.snapshot.SnapshotService;
 
 import javax.inject.Inject;
+import javax.sql.DataSource;
 
 public class SnapshotAwareEventSourceFactory {
 
@@ -26,19 +27,17 @@ public class SnapshotAwareEventSourceFactory {
     @Inject
     private EventStreamJdbcRepositoryFactory eventStreamJdbcRepositoryFactory;
 
-    @Inject
-    private EventConverter eventConverter;
-
     @Inject
     private SnapshotService snapshotService;
 
     @Inject
-    private PublishedEventFinder publishedEventFinder;
+    private PublishedEventFinderFactory publishedEventFinderFactory;
 
-    public EventSource create(final String jndiDatasource, final String eventSourceName) {
+    public EventSource create(final DataSource dataSource, final String eventSourceName) {
 
-        final EventJdbcRepository eventJdbcRepository = eventJdbcRepositoryFactory.eventJdbcRepository(jndiDatasource);
-        final EventStreamJdbcRepository eventStreamJdbcRepository = eventStreamJdbcRepositoryFactory.eventStreamJdbcRepository(jndiDatasource);
+        final EventJdbcRepository eventJdbcRepository = eventJdbcRepositoryFactory.eventJdbcRepository(dataSource);
+        final EventStreamJdbcRepository eventStreamJdbcRepository = eventStreamJdbcRepositoryFactory.eventStreamJdbcRepository(dataSource);
+        final PublishedEventFinder publishedEventFinder = publishedEventFinderFactory.create(dataSource);
 
         final EventRepository eventRepository = eventRepositoryFactory.eventRepository(
                 eventJdbcRepository,
@@ -51,7 +50,6 @@ public EventSource create(final String jndiDatasource, final String eventSourceN
                 eventStreamManager,
                 eventRepository,
                 snapshotService,
-                eventConverter,
                 eventSourceName);
     }
 }

aggregate-snapshot/aggregate-snapshot-service/src/main/java/uk/gov/justice/services/eventsourcing/source/core/SnapshotAwareEventSourceProducer.java

@@ -4,6 +4,7 @@
 
 import uk.gov.justice.services.cdi.QualifierAnnotationExtractor;
 import uk.gov.justice.services.eventsourcing.source.core.annotation.EventSourceName;
+import uk.gov.justice.services.jdbc.persistence.JdbcDataSourceProvider;
 import uk.gov.justice.subscription.domain.eventsource.EventSourceDefinition;
 import uk.gov.justice.subscription.domain.eventsource.Location;
 import uk.gov.justice.subscription.registry.EventSourceDefinitionRegistry;
@@ -24,14 +25,16 @@
 public class SnapshotAwareEventSourceProducer {
 
     @Inject
-    QualifierAnnotationExtractor qualifierAnnotationExtractor;
+    private QualifierAnnotationExtractor qualifierAnnotationExtractor;
 
     @Inject
-    EventSourceDefinitionRegistry eventSourceDefinitionRegistry;
+    private EventSourceDefinitionRegistry eventSourceDefinitionRegistry;
 
     @Inject
-    SnapshotAwareEventSourceFactory snapshotAwareEventSourceFactory;
+    private SnapshotAwareEventSourceFactory snapshotAwareEventSourceFactory;
 
+    @Inject
+    private JdbcDataSourceProvider jdbcDataSourceProvider;
 
     /**
      *
@@ -70,7 +73,9 @@ private EventSource createEventSourceFrom(final EventSourceDefinition eventSourc
         final Optional<String> dataSourceOptional = location.getDataSource();
 
         return dataSourceOptional
-                .map(dataSource -> snapshotAwareEventSourceFactory.create(dataSource, eventSourceDefinition.getName()))
+                .map(dataSource -> snapshotAwareEventSourceFactory.create(
+                        jdbcDataSourceProvider.getDataSource(dataSource),
+                        eventSourceDefinition.getName()))
                 .orElseThrow(() -> new CreationException(
                         format("No DataSource specified for EventSource '%s' specified in event-sources.yaml", eventSourceDefinition.getName())
                 ));

aggregate-snapshot/aggregate-snapshot-service/src/test/java/uk/gov/justice/services/core/aggregate/SnapshotAwareAggregateServiceIT.java

@@ -46,6 +46,7 @@
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventConverter;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventJdbcRepositoryFactory;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.PublishedEventFinder;
+import uk.gov.justice.services.eventsourcing.repository.jdbc.event.PublishedEventFinderFactory;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.eventstream.EventStreamJdbcRepositoryFactory;
 import uk.gov.justice.services.eventsourcing.source.core.EventAppender;
 import uk.gov.justice.services.eventsourcing.source.core.EventSource;
@@ -60,21 +61,20 @@
 import uk.gov.justice.services.eventsourcing.source.core.exception.EventStreamException;
 import uk.gov.justice.services.eventsourcing.source.core.snapshot.DefaultSnapshotService;
 import uk.gov.justice.services.eventsourcing.source.core.snapshot.DefaultSnapshotStrategy;
-import uk.gov.justice.services.jdbc.persistence.DefaultJdbcDataSourceProvider;
 import uk.gov.justice.services.jdbc.persistence.JdbcDataSourceProvider;
 import uk.gov.justice.services.jdbc.persistence.JdbcRepositoryException;
-import uk.gov.justice.services.jdbc.persistence.JdbcRepositoryHelper;
+import uk.gov.justice.services.jdbc.persistence.JdbcResultSetStreamer;
+import uk.gov.justice.services.jdbc.persistence.PreparedStatementWrapperFactory;
 import uk.gov.justice.services.messaging.DefaultJsonObjectEnvelopeConverter;
 import uk.gov.justice.services.messaging.JsonEnvelope;
 import uk.gov.justice.services.messaging.jms.DefaultEnvelopeConverter;
 import uk.gov.justice.services.messaging.jms.JmsEnvelopeSender;
 import uk.gov.justice.services.test.utils.persistence.DatabaseCleaner;
+import uk.gov.justice.services.test.utils.persistence.OpenEjbEventStoreDataSourceProvider;
 import uk.gov.justice.subscription.ParserProducer;
 import uk.gov.justice.subscription.SubscriptionHelper;
 import uk.gov.justice.subscription.YamlFileFinder;
 import uk.gov.justice.subscription.domain.eventsource.DefaultEventSourceDefinitionFactory;
-import uk.gov.justice.subscription.domain.eventsource.EventSourceDefinition;
-import uk.gov.justice.subscription.registry.EventSourceDefinitionRegistry;
 import uk.gov.justice.subscription.registry.EventSourceDefinitionRegistryProducer;
 import uk.gov.justice.subscription.yaml.parser.YamlParser;
 import uk.gov.justice.subscription.yaml.parser.YamlSchemaLoader;
@@ -90,13 +90,10 @@
 import java.util.UUID;
 import java.util.stream.Stream;
 
-import javax.annotation.Resource;
 import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.inject.Produces;
 import javax.inject.Inject;
 import javax.jms.Destination;
-import javax.naming.InitialContext;
-import javax.sql.DataSource;
 
 import org.apache.openejb.jee.WebApp;
 import org.apache.openejb.junit.ApplicationComposer;
@@ -128,8 +125,8 @@ public class SnapshotAwareAggregateServiceIT {
     private static final long SNAPSHOT_THRESHOLD = 25L;
     private static final String FRAMEWORK_CONTEXT_NAME = "framework";
 
-    @Resource(name = "openejb/Resource/frameworkeventstore")
-    private DataSource dataSource;
+    @Inject
+    private JdbcDataSourceProvider jdbcDataSourceProvider;
 
     @Inject
     private SnapshotRepository snapshotRepository;
@@ -149,23 +146,20 @@ public class SnapshotAwareAggregateServiceIT {
     @Inject
     private DefaultSnapshotService snapshotService;
 
-    @Inject
-    private EventSourceDefinitionRegistry eventSourceDefinitionRegistry;
-
     @Module
     @org.apache.openejb.testing.Classes(cdi = true, value = {
             ObjectInputStreamStrategy.class,
             CustomClassLoaderObjectInputStreamStrategy.class,
             DefaultObjectInputStreamStrategy.class,
             SnapshotJdbcRepository.class,
-            JdbcDataSourceProvider.class,
-            DefaultJdbcDataSourceProvider.class,
+            OpenEjbEventStoreDataSourceProvider.class,
 
             EventStreamJdbcRepositoryFactory.class,
             EventRepositoryFactory.class,
             TestEventInsertionStrategyProducer.class,
             EventJdbcRepositoryFactory.class,
-            JdbcRepositoryHelper.class,
+            JdbcResultSetStreamer.class,
+            PreparedStatementWrapperFactory.class,
             LoggerProducer.class,
 
             EventConverter.class,
@@ -209,6 +203,7 @@ public class SnapshotAwareAggregateServiceIT {
             DefaultEventSourceDefinitionFactory.class,
 
             SubscriptionHelper.class,
+            PublishedEventFinderFactory.class,
             PublishedEventFinder.class
     })
 
@@ -230,10 +225,6 @@ public Properties configuration() {
     @Before
     public void init() throws Exception {
 
-        final EventSourceDefinition defaultEventSourceDefinition = eventSourceDefinitionRegistry.getDefaultEventSourceDefinition();
-        final String jndiName = defaultEventSourceDefinition.getLocation().getDataSource().get();
-        final InitialContext initialContext = new InitialContext();
-        initialContext.bind(jndiName, dataSource);
         new DatabaseCleaner().cleanEventStoreTables(FRAMEWORK_CONTEXT_NAME);
         defaultAggregateService.register(new EventFoundEvent(EventA.class, "context.eventA"));
     }
@@ -494,7 +485,7 @@ private <T extends Aggregate> void createEventStreamAndApply(final UUID streamId
 
     private int rowCount(final String sql, final Object arg) {
 
-        try (final Connection connection = dataSource.getConnection();
+        try (final Connection connection = jdbcDataSourceProvider.getDataSource("don't care").getConnection();
              final PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
             preparedStatement.setObject(1, arg);
 

aggregate-snapshot/aggregate-snapshot-service/src/test/java/uk/gov/justice/services/eventsourcing/source/core/SnapshotAwareEventSourceFactoryTest.java

@@ -9,24 +9,25 @@
 
 import uk.gov.justice.services.eventsourcing.repository.jdbc.EventRepository;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.EventRepositoryFactory;
-import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventConverter;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventJdbcRepository;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.EventJdbcRepositoryFactory;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.event.PublishedEventFinder;
+import uk.gov.justice.services.eventsourcing.repository.jdbc.event.PublishedEventFinderFactory;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.eventstream.EventStreamJdbcRepository;
 import uk.gov.justice.services.eventsourcing.repository.jdbc.eventstream.EventStreamJdbcRepositoryFactory;
 import uk.gov.justice.services.eventsourcing.source.core.snapshot.SnapshotService;
+import uk.gov.justice.services.jdbc.persistence.JdbcDataSourceProvider;
+
+import javax.sql.DataSource;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
 
-
 @RunWith(MockitoJUnitRunner.class)
 public class SnapshotAwareEventSourceFactoryTest {
-    private static final String EVENT_SOURCE_NAME = "eventSourceName";
 
     @Mock
     private EventStreamManagerFactory eventStreamManagerFactory;
@@ -44,10 +45,10 @@ public class SnapshotAwareEventSourceFactoryTest {
     private SnapshotService snapshotService;
 
     @Mock
-    private EventConverter eventConverter;
+    private JdbcDataSourceProvider jdbcDataSourceProvider;
 
     @Mock
-    private PublishedEventFinder publishedEventFinder;
+    private PublishedEventFinderFactory publishedEventFinderFactory;
 
     @InjectMocks
     private SnapshotAwareEventSourceFactory snapshotAwareEventSourceFactory;
@@ -62,26 +63,28 @@ public void shouldCreateSnapshotAwareEventSource() throws Exception {
         final EventStreamJdbcRepository eventStreamJdbcRepository = mock(EventStreamJdbcRepository.class);
         final EventRepository eventRepository = mock(EventRepository.class);
         final EventStreamManager eventStreamManager = mock(EventStreamManager.class);
+        final DataSource dataSource = mock(DataSource.class);
+        final PublishedEventFinder publishedEventFinder = mock(PublishedEventFinder.class);
 
-        when(eventJdbcRepositoryFactory.eventJdbcRepository(jndiDatasource)).thenReturn(eventJdbcRepository);
-        when(eventStreamJdbcRepositoryFactory.eventStreamJdbcRepository(jndiDatasource)).thenReturn(eventStreamJdbcRepository);
+        when(jdbcDataSourceProvider.getDataSource(jndiDatasource)).thenReturn(dataSource);
+        when(eventJdbcRepositoryFactory.eventJdbcRepository(dataSource)).thenReturn(eventJdbcRepository);
+        when(eventStreamJdbcRepositoryFactory.eventStreamJdbcRepository(dataSource)).thenReturn(eventStreamJdbcRepository);
+        when(publishedEventFinderFactory.create(dataSource)).thenReturn(publishedEventFinder);
 
         when(eventRepositoryFactory.eventRepository(
                 eventJdbcRepository,
                 eventStreamJdbcRepository,
                 publishedEventFinder)).thenReturn(eventRepository);
 
-        when(eventStreamManagerFactory.eventStreamManager(eventRepository, EVENT_SOURCE_NAME)).thenReturn(eventStreamManager);
+        when(eventStreamManagerFactory.eventStreamManager(eventRepository, eventSourceName)).thenReturn(eventStreamManager);
 
-        final EventSource eventSource = snapshotAwareEventSourceFactory.create(jndiDatasource, eventSourceName);
+        final EventSource eventSource = snapshotAwareEventSourceFactory.create(dataSource, eventSourceName);
 
         assertThat(eventSource, is(instanceOf(SnapshotAwareEventSource.class)));
 
-
         assertThat(getValueOfField(eventSource, "eventStreamManager", EventStreamManager.class), is(eventStreamManager));
         assertThat(getValueOfField(eventSource, "eventRepository", EventRepository.class), is(eventRepository));
         assertThat(getValueOfField(eventSource, "snapshotService", SnapshotService.class), is(snapshotService));
-        assertThat(getValueOfField(eventSource, "eventConverter", EventConverter.class), is(eventConverter));
-        assertThat(getValueOfField(eventSource, "name", String.class), is(eventSourceName));
+        assertThat(getValueOfField(eventSource, "eventSourceName", String.class), is(eventSourceName));
     }
 }