private long runCycle(HollowProducer producer, final int cycleNumber) { return producer.runCycle(new Populator() { public void populate(WriteState state) throws Exception { state.add(Integer.valueOf(cycleNumber)); } }); }
private long initializeData(HollowProducer producer) { return producer.runCycle(new Populator() { public void populate(WriteState state) throws Exception { state.add(new TypeA(1, "one", 1)); state.add(new TypeA(2, "two", 2)); state.add(new TypeA(3, "three", 3)); state.add(new TypeA(4, "four", 4)); state.add(new TypeA(5, "five", 5)); state.add(new TypeB(1, "1")); state.add(new TypeB(2, "2")); state.add(new TypeB(3, "3")); state.add(new TypeB(4, "4")); } }); }
private long runCycle(HollowProducer producer, final int cycleNumber) { return producer.runCycle(state -> state.add(cycleNumber)); } }
private void initializeData(HollowProducer producer) { producer.runCycle(state -> { for (int i = 0; i < ELEMENTS; ++i) { state.add(new SimpleType(i, i)); } }); }
@Test public void testCycleSkip() { Mockito.when(singleProducerEnforcer.isPrimary()).thenReturn(false); this.producer.runCycle(null); Mockito.verify(listener).onCycleSkip( HollowProducerListener.CycleSkipReason.NOT_PRIMARY_PRODUCER); Mockito.verify(listener, Mockito.never()).onCycleStart( ArgumentMatchers.anyLong()); }
@Test public void testCycleStartEnd() { Mockito.when(singleProducerEnforcer.isPrimary()).thenReturn(true); this.producer.runCycle(Mockito.mock(HollowProducer.Populator.class)); Mockito.verify(listener).onCycleStart(ArgumentMatchers.anyLong()); Mockito.verify(listener).onCycleComplete( Mockito.any(HollowProducerListener.ProducerStatus.class), ArgumentMatchers.anyLong(), Mockito.any(TimeUnit.class)); } }
@Test public void testValidate_onlyAdditions() { BiPredicate<GenericHollowObject, GenericHollowObject> filter = getMockBiPredicate(); when(filter.test(any(GenericHollowObject.class), any(GenericHollowObject.class))).thenReturn(true); ObjectModificationValidator<HollowAPI, GenericHollowObject> validator = createValidator(filter); HollowProducer producer = getProducer(validator); producer.runCycle(writeState -> writeState.add(new TypeA(1, "fo", "bar"))); verify(filter, never()).test( any(GenericHollowObject.class), any(GenericHollowObject.class)); producer.runCycle(writeState -> { writeState.add(new TypeA(1, "fo", "bar")); writeState.add(new TypeA(2, "fo", "baz")); }); verify(filter, never()).test( any(GenericHollowObject.class), any(GenericHollowObject.class)); }
@Test public void testValidate_onlyRemovals() { @SuppressWarnings("unchecked") BiPredicate<GenericHollowObject, GenericHollowObject> filter = getMockBiPredicate(); when(filter.test(any(GenericHollowObject.class), any(GenericHollowObject.class))).thenReturn(true); ObjectModificationValidator<HollowAPI, GenericHollowObject> validator = createValidator(filter); HollowProducer producer = getProducer(validator); producer.runCycle(writeState -> { writeState.add(new TypeA(1, "fo", "bar")); writeState.add(new TypeA(2, "fo", "baz")); }); verify(filter, never()).test( any(GenericHollowObject.class), any(GenericHollowObject.class)); producer.runCycle(writeState -> writeState.add(new TypeA(1, "fo", "bar"))); verify(filter, never()).test( any(GenericHollowObject.class), any(GenericHollowObject.class)); }
@Test public void testPopulateNoChangesVersion() { HollowProducer producer = createProducer(tmpFolder); long v1 = producer.runCycle(ws -> { ws.add(1); }); // Run cycle with no changes long v2 = producer.runCycle(ws -> { ws.add(1); }); long v3 = producer.runCycle(ws -> { ws.add(2); }); Assert.assertEquals(v1, v2); Assert.assertTrue(v3 > v2); }
@Test public void testValidate_validationFailure() { BiPredicate<GenericHollowObject, GenericHollowObject> filter = (a, b) -> a.getObject("data").getString("value").length() <= b.getObject("data").getString("value").length(); ObjectModificationValidator<HollowAPI, GenericHollowObject> validator = createValidator(filter); HollowProducer producer = getProducer(validator); producer.runCycle(writeState -> writeState.add(new TypeA(1, "fo", "bar"))); try { producer.runCycle(writeState -> writeState.add(new TypeA(1, "fo", "ba"))); fail("Expected validation exception"); } catch (ValidationStatusException e) { // expected } }
@Test public void testRollsBackStateEngineOnPublishFailure() throws Exception { HollowProducer producer = spy(createProducer(tmpFolder, schema)); Assert.assertEquals("Should have no populated ordinals", 0, producer.getWriteEngine().getTypeState("TestPojo").getPopulatedBitSet().cardinality()); doThrow(new RuntimeException("Publish failed")).when(producer).publish( any(ListenerSupport.Listeners.class), any(Long.class), any(Artifacts.class)); try { producer.runCycle(newState -> newState.add(new TestPojoV1(1, 1))); } catch (RuntimeException e) { // expected } Assert.assertEquals("Should still have no populated ordinals", 0, producer.getWriteEngine().getTypeState("TestPojo").getPopulatedBitSet().cardinality()); }
private long testPublishV2(HollowProducer producer, final int size, final int valueMultiplier) { producer.runCycle(newState -> { for (int i = 1; i <= size; i++) { newState.add(new TestPojoV2(i, i * valueMultiplier, i * valueMultiplier)); } }); Assert.assertNotNull(lastProducerStatus); Assert.assertEquals(Status.SUCCESS, lastProducerStatus.getStatus()); return lastProducerStatus.getVersion(); }
private long testPublishV1(HollowProducer producer, final int size, final int valueMultiplier) { producer.runCycle(newState -> { for (int i = 1; i <= size; i++) { newState.add(new TestPojoV1(i, i * valueMultiplier)); } }); Assert.assertNotNull(lastProducerStatus); Assert.assertEquals(Status.SUCCESS, lastProducerStatus.getStatus()); return lastProducerStatus.getVersion(); }
@Test public void testNullMetricsCollector() { HollowProducer producer = HollowProducer.withPublisher(blobStore) .withBlobStager(new HollowInMemoryBlobStager()) .build(); long version = producer.runCycle(new HollowProducer.Populator() { public void populate(HollowProducer.WriteState state) throws Exception { state.add(Integer.valueOf(1)); } }); HollowConsumer consumer = HollowConsumer.withBlobRetriever(blobStore) .withMetricsCollector(null) .build(); consumer.triggerRefreshTo(version); }
@Test public void publishAndLoadASnapshot() { HollowProducer producer = HollowProducer.withPublisher(blobStore) .withBlobStager(new HollowInMemoryBlobStager()) .build(); /// Showing verbose version of `runCycle(producer, 1);` long version = producer.runCycle(state -> state.add(1)); HollowConsumer consumer = HollowConsumer.withBlobRetriever(blobStore).build(); consumer.triggerRefreshTo(version); Assert.assertEquals(version, consumer.getCurrentVersionId()); }
@Test public void duplicateDetectionSuccessTest() { HollowProducer producer = HollowProducer.withPublisher(blobStore) .withBlobStager(new HollowInMemoryBlobStager()) .withListener(new DuplicateDataDetectionValidator("TypeWithPrimaryKey")) .build(); //runCycle(producer, 1); producer.runCycle(newState -> { newState.add(new TypeWithPrimaryKey(1, "Brad Pitt", "klsdjfla;sdjkf")); newState.add(new TypeWithPrimaryKey(1, "Angelina Jolie", "as;dlkfjasd;l")); }); HollowConsumer consumer = HollowConsumer.withBlobRetriever(blobStore).build(); consumer.triggerRefresh(); Assert.assertEquals(2, consumer.getStateEngine().getTypeState("TypeWithPrimaryKey").getPopulatedOrdinals() .cardinality()); }
@Test public void metricsWhenPublishingFails() { HollowProducer producer = HollowProducer.withPublisher(blobStore) .withBlobStager(new HollowInMemoryBlobStager()) .build(); try { producer.runCycle(new HollowProducer.Populator() { public void populate(HollowProducer.WriteState state) throws Exception { state.add(null); } }); } catch (Exception ignored){ } HollowProducerMetrics hollowProducerMetrics = producer.getMetrics(); Assert.assertEquals(hollowProducerMetrics.getCyclesSucceeded(), 0); Assert.assertEquals(hollowProducerMetrics.getCyclesCompleted(), 1); Assert.assertEquals(hollowProducerMetrics.getCycleFailed(), 1); } }
@Test public void metricsWhenPublishingSnapshot() { HollowProducer producer = HollowProducer.withPublisher(blobStore) .withBlobStager(new HollowInMemoryBlobStager()) .build(); producer.runCycle(new HollowProducer.Populator() { public void populate(HollowProducer.WriteState state) throws Exception { state.add(Integer.valueOf(1)); } }); HollowProducerMetrics hollowProducerMetrics = producer.getMetrics(); Assert.assertEquals(hollowProducerMetrics.getCyclesSucceeded(), 1); Assert.assertEquals(hollowProducerMetrics.getCyclesCompleted(), 1); Assert.assertEquals(hollowProducerMetrics.getTotalPopulatedOrdinals(), 1); Assert.assertEquals(hollowProducerMetrics.getSnapshotsCompleted(), 1); }
@Test public void metricsWhenLoadingSnapshot() { HollowProducer producer = HollowProducer.withPublisher(blobStore) .withBlobStager(new HollowInMemoryBlobStager()) .build(); long version = producer.runCycle(new HollowProducer.Populator() { public void populate(HollowProducer.WriteState state) throws Exception { state.add(Integer.valueOf(1)); } }); HollowConsumer consumer = HollowConsumer.withBlobRetriever(blobStore).build(); consumer.triggerRefreshTo(version); HollowConsumerMetrics hollowConsumerMetrics = consumer.getMetrics(); Assert.assertEquals(version, consumer.getCurrentVersionId()); Assert.assertEquals(hollowConsumerMetrics.getCurrentVersion(), consumer.getCurrentVersionId()); Assert.assertEquals(hollowConsumerMetrics.getRefreshSucceded(), 1); Assert.assertEquals(hollowConsumerMetrics.getTotalPopulatedOrdinals(), 1); }
@Test public void metricsCollectorWhenPublishingSnapshot() { FakePublisherHollowMetricsCollector metricsCollector = new FakePublisherHollowMetricsCollector(); HollowProducer producer = HollowProducer.withPublisher(blobStore) .withMetricsCollector(metricsCollector) .withBlobStager(new HollowInMemoryBlobStager()) .build(); producer.runCycle(new HollowProducer.Populator() { public void populate(HollowProducer.WriteState state) throws Exception { state.add(Integer.valueOf(1)); } }); HollowProducerMetrics hollowProducerMetrics = metricsCollector.getMetrics(); Assert.assertEquals(metricsCollector.getMetricsCollected(), true); Assert.assertEquals(hollowProducerMetrics.getCyclesSucceeded(), 1); Assert.assertEquals(hollowProducerMetrics.getCyclesCompleted(), 1); Assert.assertEquals(hollowProducerMetrics.getTotalPopulatedOrdinals(), 1); Assert.assertEquals(hollowProducerMetrics.getSnapshotsCompleted(), 1); }