From 4e97d6c609077423ac41dc68076f625f2e9e15a7 Mon Sep 17 00:00:00 2001 From: Sonu Kumar Date: Sat, 6 Feb 2021 12:47:54 +0530 Subject: [PATCH 1/3] Test cases --- .../rqueue/core/impl/BaseMessageSender.java | 35 ++-- .../core/middleware/RedisLockMiddleware.java | 23 +-- .../sonus21/rqueue/listener/QueueDetail.java | 2 +- .../core/context/DefaultContextTest.java | 70 +++++++ .../impl/RqueueEndpointManagerImplTest.java | 74 +++++++ .../impl/RqueueMessageEnqueuerImplTest.java | 117 ++++++++++++ .../impl/RqueueMessageManagerImplTest.java | 110 +++++++++++ .../middleware/ContextMiddlewareTest.java | 52 +++++ .../core/middleware/LockMiddlewareTest.java | 131 +++++++++++++ .../middleware/LoggingMiddlewareTest.java | 47 +++++ .../middleware/RedisLockMiddlewareTest.java | 180 ++++++++++++++++++ .../sonus21/rqueue/utils/TestUtils.java | 43 ++++- .../unit/RqueueMetricsAutoConfigTest.java | 73 +++++++ 13 files changed, 920 insertions(+), 37 deletions(-) create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/context/DefaultContextTest.java create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueEndpointManagerImplTest.java create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageEnqueuerImplTest.java create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageManagerImplTest.java create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/ContextMiddlewareTest.java create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LockMiddlewareTest.java create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LoggingMiddlewareTest.java create mode 100644 rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddlewareTest.java create mode 100644 rqueue-spring-boot-starter/src/test/java/com/github/sonus21/rqueue/spring/boot/tests/unit/RqueueMetricsAutoConfigTest.java diff --git a/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/impl/BaseMessageSender.java b/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/impl/BaseMessageSender.java index 39713d09..a0f4e06f 100644 --- a/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/impl/BaseMessageSender.java +++ b/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/impl/BaseMessageSender.java @@ -1,23 +1,24 @@ /* - * Copyright 2020 Sonu Kumar + * Copyright 2021 Sonu Kumar * - * 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 + * 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 * - * https://www.apache.org/licenses/LICENSE-2.0 + * https://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. * - * 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 com.github.sonus21.rqueue.core.impl; import static com.github.sonus21.rqueue.core.support.RqueueMessageUtils.buildMessage; import static com.github.sonus21.rqueue.core.support.RqueueMessageUtils.buildPeriodicMessage; +import static com.github.sonus21.rqueue.utils.Constants.DEFAULT_PRIORITY_KEY; import static com.github.sonus21.rqueue.utils.Constants.MIN_DELAY; import static com.github.sonus21.rqueue.utils.Validator.validateQueue; import static org.springframework.util.Assert.notNull; @@ -34,6 +35,9 @@ import com.github.sonus21.rqueue.utils.PriorityUtils; import com.github.sonus21.rqueue.web.service.RqueueMessageMetadataService; import java.time.Duration; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.messaging.MessageHeaders; @@ -141,14 +145,19 @@ protected String pushPeriodicMessage( } protected Object deleteAllMessages(QueueDetail queueDetail) { - return MessageSweeper.getInstance( - rqueueConfig, messageTemplate, rqueueMessageMetadataService) + return MessageSweeper.getInstance(rqueueConfig, messageTemplate, rqueueMessageMetadataService) .deleteMessage(MessageDeleteRequest.builder().queueDetail(queueDetail).build()); } protected void registerQueueInternal(String queueName, String... priorities) { validateQueue(queueName); notNull(priorities, "priorities cannot be null"); + Map priorityMap = new HashMap<>(); + priorityMap.put(DEFAULT_PRIORITY_KEY, 1); + for (String priority : priorities) { + priorityMap.put(priority, 1); + } + QueueDetail queueDetail = QueueDetail.builder() .name(queueName) @@ -158,6 +167,7 @@ protected void registerQueueInternal(String queueName, String... priorities) { .delayedQueueChannelName(rqueueConfig.getDelayedQueueChannelName(queueName)) .processingQueueName(rqueueConfig.getProcessingQueueName(queueName)) .processingQueueChannelName(rqueueConfig.getProcessingQueueChannelName(queueName)) + .priority(priorityMap) .build(); EndpointRegistry.register(queueDetail); for (String priority : priorities) { @@ -172,6 +182,7 @@ protected void registerQueueInternal(String queueName, String... priorities) { .processingQueueName(rqueueConfig.getProcessingQueueName(queueName) + suffix) .processingQueueChannelName( rqueueConfig.getProcessingQueueChannelName(queueName) + suffix) + .priority(Collections.singletonMap(DEFAULT_PRIORITY_KEY, 1)) .build(); EndpointRegistry.register(queueDetail); } diff --git a/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddleware.java b/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddleware.java index 7a27be6a..87d4944d 100644 --- a/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddleware.java +++ b/rqueue-core/src/main/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddleware.java @@ -20,8 +20,6 @@ import com.github.sonus21.rqueue.config.RqueueConfig; import com.github.sonus21.rqueue.core.Job; import java.time.Duration; -import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; import org.springframework.data.redis.connection.RedisConnectionFactory; /** @@ -33,10 +31,13 @@ public abstract class RedisLockMiddleware implements LockMiddleware { private final RqueueRedisTemplate template; - private final Set acquiredLocks = ConcurrentHashMap.newKeySet(); public RedisLockMiddleware(RedisConnectionFactory redisConnectionFactory) { - template = new RqueueRedisTemplate<>(redisConnectionFactory); + this(new RqueueRedisTemplate<>(redisConnectionFactory)); + } + + public RedisLockMiddleware(RqueueRedisTemplate template) { + this.template = template; } /** @@ -56,7 +57,7 @@ public RedisLockMiddleware(RedisConnectionFactory redisConnectionFactory) { * @return duration for this lock */ protected Duration getLockDuration(Job job) { - return job.getQueueDetail().visibilityTimeoutDuration(); + return job.getQueueDetail().visibilityDuration(); } @Override @@ -64,21 +65,15 @@ public void releaseLock(Job job, String lockIdentifier) { if (lockIdentifier == null) { return; } - if (acquiredLocks.contains(lockIdentifier)) { - template.delete(lockIdentifier); - acquiredLocks.remove(lockIdentifier); - } + template.delete(lockIdentifier); } @Override public String acquireLock(Job job) { String lockIdentifier = getLockIdentifier(job); - if (acquiredLocks.contains(lockIdentifier)) { - return null; - } Duration lockDuration = getLockDuration(job); - if (template.setIfAbsent(lockIdentifier, RqueueConfig.getBrokerId(), lockDuration)) { - acquiredLocks.add(lockIdentifier); + if (Boolean.TRUE.equals( + template.setIfAbsent(lockIdentifier, RqueueConfig.getBrokerId(), lockDuration))) { return lockIdentifier; } return null; diff --git a/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/QueueDetail.java b/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/QueueDetail.java index b877182d..449b87f5 100644 --- a/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/QueueDetail.java +++ b/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/QueueDetail.java @@ -150,7 +150,7 @@ private QueueDetail cloneQueueDetail( .build(); } - public Duration visibilityTimeoutDuration() { + public Duration visibilityDuration() { return Duration.ofMillis(visibilityTimeout); } } diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/context/DefaultContextTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/context/DefaultContextTest.java new file mode 100644 index 00000000..165221e3 --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/context/DefaultContextTest.java @@ -0,0 +1,70 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.context; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.CoreUnitTest; +import org.junit.jupiter.api.Test; + +@CoreUnitTest +class DefaultContextTest extends TestBase { + + @Test + void withValueWithEmptyParentContext() { + Context context = DefaultContext.withValue(DefaultContext.EMPTY, "test", "test"); + assertEquals("test", context.getValue("test")); + assertNull(context.getValue("testX")); + } + + @Test + void withValueWithNullParentContext() { + Context context = DefaultContext.withValue(null, "test", "test"); + assertEquals("test", context.getValue("test")); + assertNull(context.getValue("testX")); + } + + @Test + void withValueWithNullKey() { + assertThrows( + IllegalArgumentException.class, () -> DefaultContext.withValue(null, null, "test")); + } + + @Test + void withValueOverrideValueInChildContext() { + Context context = DefaultContext.withValue(DefaultContext.EMPTY, "test", "test"); + Context newContext = DefaultContext.withValue(context, "test", "foo"); + assertEquals("foo", newContext.getValue("test")); + assertNull(newContext.getValue("testX")); + } + + @Test + void withValueNewKeyValueInChildContext() { + Context context = DefaultContext.withValue(DefaultContext.EMPTY, "test", "test"); + Context newContext = DefaultContext.withValue(context, "test2", "foo"); + assertEquals("foo", newContext.getValue("test2")); + } + + @Test + void getValueWithNullKey() { + Context context = DefaultContext.withValue(DefaultContext.EMPTY, "test", 12345); + assertThrows(IllegalArgumentException.class, () -> context.getValue(null)); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueEndpointManagerImplTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueEndpointManagerImplTest.java new file mode 100644 index 00000000..169e0910 --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueEndpointManagerImplTest.java @@ -0,0 +1,74 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.impl; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; + +import com.github.sonus21.rqueue.common.RqueueLockManager; +import com.github.sonus21.rqueue.config.RqueueConfig; +import com.github.sonus21.rqueue.core.DefaultRqueueMessageConverter; +import com.github.sonus21.rqueue.core.EndpointRegistry; +import com.github.sonus21.rqueue.core.RqueueEndpointManager; +import com.github.sonus21.rqueue.core.RqueueMessageTemplate; +import com.github.sonus21.rqueue.listener.RqueueMessageHeaders; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.data.redis.connection.RedisConnectionFactory; +import org.springframework.messaging.MessageHeaders; +import org.springframework.messaging.converter.MessageConverter; + +class RqueueEndpointManagerImplTest { + + private final RqueueMessageTemplate messageTemplate = mock(RqueueMessageTemplate.class); + private final RqueueLockManager rqueueLockManager = mock(RqueueLockManager.class); + private final String queue = "test-queue"; + private final RqueueConfig rqueueConfig = + new RqueueConfig(mock(RedisConnectionFactory.class), false, 1); + MessageConverter messageConverter = new DefaultRqueueMessageConverter(); + MessageHeaders messageHeaders = RqueueMessageHeaders.emptyMessageHeaders(); + private final RqueueEndpointManager rqueueEndpointManager = + new RqueueEndpointManagerImpl(messageTemplate, messageConverter, messageHeaders); + + @BeforeEach + public void init() throws IllegalAccessException { + FieldUtils.writeField(rqueueEndpointManager, "rqueueConfig", rqueueConfig, true); + EndpointRegistry.delete(); + } + + @AfterEach + public void clean() { + EndpointRegistry.delete(); + } + + @Test + void isQueueRegistered() { + assertFalse(rqueueEndpointManager.isQueueRegistered(queue)); + rqueueEndpointManager.registerQueue(queue); + assertTrue(rqueueEndpointManager.isQueueRegistered(queue)); + } + + @Test + void getQueueConfig() { + rqueueEndpointManager.registerQueue(queue, "high", "medium", "low"); + assertEquals(4, rqueueEndpointManager.getQueueConfig(queue).size()); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageEnqueuerImplTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageEnqueuerImplTest.java new file mode 100644 index 00000000..56d5f75d --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageEnqueuerImplTest.java @@ -0,0 +1,117 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.impl; + +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.mock; + +import com.github.sonus21.rqueue.core.DefaultRqueueMessageConverter; +import com.github.sonus21.rqueue.core.EndpointRegistry; +import com.github.sonus21.rqueue.core.RqueueMessageEnqueuer; +import com.github.sonus21.rqueue.core.RqueueMessageTemplate; +import com.github.sonus21.rqueue.listener.QueueDetail; +import com.github.sonus21.rqueue.listener.RqueueMessageHeaders; +import com.github.sonus21.rqueue.utils.Constants; +import com.github.sonus21.rqueue.utils.TestUtils; +import java.util.UUID; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.springframework.messaging.MessageHeaders; +import org.springframework.messaging.converter.MessageConverter; + +class RqueueMessageEnqueuerImplTest { + + private static final String queue = "test-queue"; + private static final QueueDetail queueDetail = TestUtils.createQueueDetail(queue); + private final RqueueMessageTemplate messageTemplate = mock(RqueueMessageTemplate.class); + private final String messageId = UUID.randomUUID().toString(); + MessageConverter messageConverter = new DefaultRqueueMessageConverter(); + MessageHeaders messageHeaders = RqueueMessageHeaders.emptyMessageHeaders(); + private final RqueueMessageEnqueuer rqueueMessageEnqueuer = + new RqueueMessageEnqueuerImpl(messageTemplate, messageConverter, messageHeaders); + + @BeforeAll + public static void init() { + EndpointRegistry.register(queueDetail); + } + + @AfterAll + public static void clean() { + EndpointRegistry.delete(); + } + + @Test + void enqueueWithRetry() { + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueueWithRetry(queue, "test", -1)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueueWithRetry(queue, null, 1)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueueWithRetry(null, "test", 10)); + + rqueueMessageEnqueuer.enqueueWithRetry(queue, "test-message", 1); + } + + @Test + void enqueueInWithRetry() { + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueueInWithRetry(queue, "test", 1, -1L)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueueInWithRetry(queue, "test", -1, 1000L)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueueInWithRetry(queue, null, 1, 1000L)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueueInWithRetry(null, "test", 1, 1000L)); + + rqueueMessageEnqueuer.enqueueInWithRetry(queue, "test-message", 1, 1000L); + } + + @Test + void enqueuePeriodic() { + String id = UUID.randomUUID().toString(); + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueuePeriodic(queue, id, "test", -1L)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueuePeriodic(queue, id, null, 5 * Constants.ONE_MILLI)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueuePeriodic(queue, null, "test", 5 * Constants.ONE_MILLI)); + + assertThrows( + IllegalArgumentException.class, + () -> rqueueMessageEnqueuer.enqueuePeriodic(null, id, "test", 5 * Constants.ONE_MILLI)); + + rqueueMessageEnqueuer.enqueuePeriodic(queue, id, "test-message", 5 * Constants.ONE_MILLI); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageManagerImplTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageManagerImplTest.java new file mode 100644 index 00000000..f9136afa --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/impl/RqueueMessageManagerImplTest.java @@ -0,0 +1,110 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.impl; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.CoreUnitTest; +import com.github.sonus21.rqueue.common.RqueueLockManager; +import com.github.sonus21.rqueue.core.DefaultRqueueMessageConverter; +import com.github.sonus21.rqueue.core.RqueueMessageManager; +import com.github.sonus21.rqueue.core.RqueueMessageTemplate; +import com.github.sonus21.rqueue.exception.LockCanNotBeAcquired; +import com.github.sonus21.rqueue.listener.RqueueMessageHeaders; +import com.github.sonus21.rqueue.utils.TestUtils; +import com.github.sonus21.rqueue.web.service.RqueueMessageMetadataService; +import java.util.UUID; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.messaging.MessageHeaders; +import org.springframework.messaging.converter.MessageConverter; + +@CoreUnitTest +class RqueueMessageManagerImplTest extends TestBase { + + private final RqueueMessageTemplate messageTemplate = mock(RqueueMessageTemplate.class); + private final RqueueLockManager rqueueLockManager = mock(RqueueLockManager.class); + private final String messageId = UUID.randomUUID().toString(); + private final String queue = "test-queue"; + private final RqueueMessageMetadataService rqueueMessageMetadataService = + mock(RqueueMessageMetadataService.class); + MessageConverter messageConverter = new DefaultRqueueMessageConverter(); + MessageHeaders messageHeaders = RqueueMessageHeaders.emptyMessageHeaders(); + private final RqueueMessageManager rqueueMessageManager = + new RqueueMessageManagerImpl(messageTemplate, messageConverter, messageHeaders); + + @BeforeEach + public void init() throws IllegalAccessException { + FieldUtils.writeField( + rqueueMessageManager, "rqueueMessageMetadataService", rqueueMessageMetadataService, true); + FieldUtils.writeField( + rqueueMessageManager, "rqueueLockManager", rqueueLockManager, true); + } + + @Test + void getMessageDoesNotExist() { + assertNull(rqueueMessageManager.getMessage(queue, messageId)); + verify(rqueueMessageMetadataService, times(1)).getByMessageId(anyString(), anyString()); + } + + @Test + void getRqueueMessageDoesNotExist() { + assertNull(rqueueMessageManager.getRqueueMessage(queue, messageId)); + verify(rqueueMessageMetadataService, times(1)).getByMessageId(anyString(), anyString()); + } + + @Test + void getMessageExist() { + doReturn(TestUtils.createMessageMetadata(messageConverter, queue)) + .when(rqueueMessageMetadataService) + .getByMessageId(queue, messageId); + assertNotNull(rqueueMessageManager.getMessage(queue, messageId)); + } + + @Test + void existLockCanNotBeAquired() { + doReturn(false).when(rqueueLockManager).acquireLock(anyString(), anyString(), any()); + assertThrows(LockCanNotBeAcquired.class, () -> rqueueMessageManager.exist(queue, messageId)); + } + + @Test + void existLockAcquiredAndMessageExist() { + doReturn(true).when(rqueueLockManager).acquireLock(anyString(), anyString(), any()); + doReturn(TestUtils.createMessageMetadata(messageConverter, queue)) + .when(rqueueMessageMetadataService) + .getByMessageId(queue, messageId); + assertTrue(rqueueMessageManager.exist(queue, messageId)); + } + + @Test + void existLockAcquiredAndMessageDoesNotExist() { + doReturn(true).when(rqueueLockManager).acquireLock(anyString(), anyString(), any()); + assertFalse(rqueueMessageManager.exist(queue, messageId)); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/ContextMiddlewareTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/ContextMiddlewareTest.java new file mode 100644 index 00000000..625c3b5a --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/ContextMiddlewareTest.java @@ -0,0 +1,52 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.middleware; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.mock; + +import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.CoreUnitTest; +import com.github.sonus21.rqueue.core.Job; +import com.github.sonus21.rqueue.core.context.DefaultContext; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.jupiter.api.Test; + +@CoreUnitTest +class ContextMiddlewareTest extends TestBase { + + @Test + void handleReturnNullContext() { + ContextMiddleware contextMiddleware = job -> null; + assertThrows( + IllegalStateException.class, () -> contextMiddleware.handle(mock(Job.class), null)); + } + + @Test + void handle() throws Exception { + ContextMiddleware contextMiddleware = job -> DefaultContext.EMPTY; + AtomicInteger atomicInteger = new AtomicInteger(); + contextMiddleware.handle( + mock(Job.class), + () -> { + atomicInteger.incrementAndGet(); + return null; + }); + assertEquals(1, atomicInteger.get()); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LockMiddlewareTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LockMiddlewareTest.java new file mode 100644 index 00000000..31aeef66 --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LockMiddlewareTest.java @@ -0,0 +1,131 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.middleware; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; + +import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.CoreUnitTest; +import com.github.sonus21.rqueue.core.Job; +import com.github.sonus21.rqueue.models.enums.JobStatus; +import java.time.Duration; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.jupiter.api.Test; + +@CoreUnitTest +class LockMiddlewareTest extends TestBase { + + @Test + void handleLockIsNotAcquired() throws Exception { + AtomicInteger atomicInteger = new AtomicInteger(); + AtomicInteger releaseLockCounter = new AtomicInteger(); + LockMiddleware lockMiddleware = + new LockMiddleware() { + @Override + public String acquireLock(Job job) { + return null; + } + + @Override + public void releaseLock(Job job, String lockIdentifier) { + releaseLockCounter.incrementAndGet(); + } + }; + Job job = mock(Job.class); + + lockMiddleware.handle( + job, + () -> { + atomicInteger.incrementAndGet(); + return null; + }); + verify(job, times(1)) + .release(JobStatus.FAILED, LockMiddleware.REASON, lockMiddleware.releaseIn(job)); + assertEquals(1, releaseLockCounter.get()); + assertEquals(0, atomicInteger.get()); + } + + @Test + void handleLockIsAcquired() throws Exception { + AtomicInteger atomicInteger = new AtomicInteger(); + AtomicInteger releaseLockCounter = new AtomicInteger(); + LockMiddleware lockMiddleware = + new LockMiddleware() { + @Override + public String acquireLock(Job job) { + return "test-lock"; + } + + @Override + public void releaseLock(Job job, String lockIdentifier) { + releaseLockCounter.incrementAndGet(); + assertEquals(lockIdentifier, "test-lock"); + } + }; + Job job = mock(Job.class); + + lockMiddleware.handle( + job, + () -> { + atomicInteger.incrementAndGet(); + return null; + }); + verifyNoInteractions(job); + assertEquals(1, releaseLockCounter.get()); + assertEquals(1, atomicInteger.get()); + } + + @Test + void handleLockIsNotAcquireReleaseIn() throws Exception { + AtomicInteger atomicInteger = new AtomicInteger(); + AtomicInteger releaseLockCounter = new AtomicInteger(); + LockMiddleware lockMiddleware = + new LockMiddleware() { + @Override + public String acquireLock(Job job) { + return null; + } + + @Override + public void releaseLock(Job job, String lockIdentifier) { + releaseLockCounter.incrementAndGet(); + assertNull(lockIdentifier); + } + + @Override + public Duration releaseIn(Job job) { + return Duration.ofMinutes(10); + } + }; + Job job = mock(Job.class); + + lockMiddleware.handle( + job, + () -> { + atomicInteger.incrementAndGet(); + return null; + }); + verify(job, times(1)).release(JobStatus.FAILED, LockMiddleware.REASON, Duration.ofMinutes(10)); + assertEquals(1, releaseLockCounter.get()); + assertEquals(0, atomicInteger.get()); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LoggingMiddlewareTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LoggingMiddlewareTest.java new file mode 100644 index 00000000..28e5b6c0 --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/LoggingMiddlewareTest.java @@ -0,0 +1,47 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.middleware; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.CoreUnitTest; +import com.github.sonus21.rqueue.core.Job; +import com.github.sonus21.rqueue.utils.TestUtils; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.jupiter.api.Test; + +@CoreUnitTest +class LoggingMiddlewareTest extends TestBase { + + @Test + void handle() throws Exception { + LoggingMiddleware loggingMiddleware = new LoggingMiddleware(); + Job job = mock(Job.class); + doReturn(TestUtils.createMessage("test-queue")).when(job).getRqueueMessage(); + AtomicInteger atomicInteger = new AtomicInteger(); + loggingMiddleware.handle( + job, + () -> { + atomicInteger.incrementAndGet(); + return null; + }); + assertEquals(1, atomicInteger.get()); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddlewareTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddlewareTest.java new file mode 100644 index 00000000..8e88988f --- /dev/null +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/middleware/RedisLockMiddlewareTest.java @@ -0,0 +1,180 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.core.middleware; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.CoreUnitTest; +import com.github.sonus21.rqueue.common.RqueueRedisTemplate; +import com.github.sonus21.rqueue.config.RqueueConfig; +import com.github.sonus21.rqueue.core.Job; +import com.github.sonus21.rqueue.listener.QueueDetail; +import com.github.sonus21.rqueue.utils.Constants; +import com.github.sonus21.rqueue.utils.TestUtils; +import com.github.sonus21.rqueue.utils.TimeoutUtils; +import java.time.Duration; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.atomic.AtomicInteger; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +@CoreUnitTest +class RedisLockMiddlewareTest extends TestBase { + + private final Job job = mock(Job.class); + private final RqueueRedisTemplate redisTemplate = mock(RqueueRedisTemplate.class); + private final QueueDetail queueDetail = TestUtils.createQueueDetail("test-queue"); + private final String key = "job-xxx"; + private final ExecutorService executor = Executors.newSingleThreadExecutor(); + + @BeforeEach + public void init() { + doReturn(key).when(job).getId(); + doReturn(queueDetail).when(job).getQueueDetail(); + } + + @Test + void handleLockCouldNotAcquireLock() throws Exception { + RedisLockMiddleware lockMiddleware = + new RedisLockMiddleware(redisTemplate) { + @Override + protected String getLockIdentifier(Job job) { + return job.getId(); + } + }; + doReturn(false) + .when(redisTemplate) + .setIfAbsent(key, RqueueConfig.getBrokerId(), queueDetail.visibilityDuration()); + lockMiddleware.handle( + job, + () -> { + fail("lock is acquired"); + return null; + }); + verify(redisTemplate, times(0)).delete(key); + } + + @Test + void handleAcquireLock() throws Exception { + RedisLockMiddleware lockMiddleware = + new RedisLockMiddleware(redisTemplate) { + @Override + protected String getLockIdentifier(Job job) { + return job.getId(); + } + }; + doReturn(true) + .when(redisTemplate) + .setIfAbsent(key, RqueueConfig.getBrokerId(), queueDetail.visibilityDuration()); + AtomicInteger atomicInteger = new AtomicInteger(); + lockMiddleware.handle( + job, + () -> { + atomicInteger.incrementAndGet(); + return null; + }); + verify(redisTemplate, times(1)).delete(key); + assertEquals(1, atomicInteger.get()); + } + + @Test + void lockCouldNotAcquiredWithDifferentReleaseTime() throws Exception { + RedisLockMiddleware lockMiddleware = + new RedisLockMiddleware(redisTemplate) { + @Override + protected String getLockIdentifier(Job job) { + return job.getId(); + } + + @Override + protected Duration getLockDuration(Job job) { + return Duration.ofSeconds(5); + } + }; + doReturn(true) + .when(redisTemplate) + .setIfAbsent(key, RqueueConfig.getBrokerId(), Duration.ofSeconds(5)); + AtomicInteger atomicInteger = new AtomicInteger(); + lockMiddleware.handle( + job, + () -> { + atomicInteger.incrementAndGet(); + return null; + }); + verify(redisTemplate, times(1)).delete(key); + assertEquals(1, atomicInteger.get()); + } + + @Test + void handleAcquireLockMultipleJobs() throws Exception { + AtomicInteger atomicInteger = new AtomicInteger(); + AtomicInteger terminationCounter = new AtomicInteger(); + AtomicInteger lockCounter = new AtomicInteger(); + RedisLockMiddleware lockMiddleware = + new RedisLockMiddleware(redisTemplate) { + @Override + protected String getLockIdentifier(Job job) { + return job.getId(); + } + }; + doAnswer( + invocation -> { + int val = lockCounter.incrementAndGet(); + if (val == 1) { + return Boolean.TRUE; + } + return Boolean.FALSE; + }) + .when(redisTemplate) + .setIfAbsent(key, RqueueConfig.getBrokerId(), queueDetail.visibilityDuration()); + lockMiddleware.handle( + job, + () -> { + executor.submit( + () -> { + atomicInteger.incrementAndGet(); + TimeoutUtils.sleep(5 * Constants.ONE_MILLI); + terminationCounter.incrementAndGet(); + }); + return null; + }); + + lockMiddleware.handle( + job, + () -> { + executor.submit( + () -> { + atomicInteger.incrementAndGet(); + TimeoutUtils.sleep(5 * Constants.ONE_MILLI); + terminationCounter.incrementAndGet(); + }); + return null; + }); + TimeoutUtils.waitFor(() -> lockCounter.get() == 2, "both lock method to be called"); + TimeoutUtils.waitFor(() -> atomicInteger.get() >= 1, "method to be executed"); + TimeoutUtils.waitFor(() -> terminationCounter.get() >= 1, "handler to terminate"); + verify(redisTemplate, times(1)).delete(key); + } +} diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/utils/TestUtils.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/utils/TestUtils.java index 889da037..04275640 100644 --- a/rqueue-core/src/test/java/com/github/sonus21/rqueue/utils/TestUtils.java +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/utils/TestUtils.java @@ -1,27 +1,33 @@ /* - * Copyright 2020 Sonu Kumar + * Copyright 2021 Sonu Kumar * - * 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 + * 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 * - * https://www.apache.org/licenses/LICENSE-2.0 + * https://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. * - * 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 com.github.sonus21.rqueue.utils; import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.core.DefaultRqueueMessageConverter; +import com.github.sonus21.rqueue.core.RqueueMessage; +import com.github.sonus21.rqueue.core.support.RqueueMessageUtils; import com.github.sonus21.rqueue.listener.QueueDetail; import com.github.sonus21.rqueue.models.Concurrency; +import com.github.sonus21.rqueue.models.db.MessageMetadata; import com.github.sonus21.rqueue.models.db.QueueConfig; +import com.github.sonus21.rqueue.models.enums.MessageStatus; import java.util.HashMap; import java.util.Map; +import org.springframework.messaging.converter.MessageConverter; public final class TestUtils extends TestBase { private TestUtils() {} @@ -92,4 +98,21 @@ public static QueueDetail createQueueDetail(String name, String dlq) { public static QueueDetail createQueueDetail(String name, long visibilityTimeout, String dlq) { return createQueueDetail(name, 3, visibilityTimeout, dlq); } + + public static MessageMetadata createMessageMetadata(String queueName) { + return createMessageMetadata(new DefaultRqueueMessageConverter(), queueName); + } + + public static RqueueMessage createMessage(String queueName) { + return createMessage(new DefaultRqueueMessageConverter(), queueName); + } + + public static MessageMetadata createMessageMetadata( + MessageConverter messageConverter, String queue) { + return new MessageMetadata(createMessage(messageConverter, queue), MessageStatus.ENQUEUED); + } + + private static RqueueMessage createMessage(MessageConverter messageConverter, String queue) { + return RqueueMessageUtils.generateMessage(messageConverter, queue); + } } diff --git a/rqueue-spring-boot-starter/src/test/java/com/github/sonus21/rqueue/spring/boot/tests/unit/RqueueMetricsAutoConfigTest.java b/rqueue-spring-boot-starter/src/test/java/com/github/sonus21/rqueue/spring/boot/tests/unit/RqueueMetricsAutoConfigTest.java new file mode 100644 index 00000000..48add185 --- /dev/null +++ b/rqueue-spring-boot-starter/src/test/java/com/github/sonus21/rqueue/spring/boot/tests/unit/RqueueMetricsAutoConfigTest.java @@ -0,0 +1,73 @@ +/* + * Copyright 2021 Sonu Kumar + * + * 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 + * + * https://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 com.github.sonus21.rqueue.spring.boot.tests.unit; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import com.github.sonus21.TestBase; +import com.github.sonus21.rqueue.metrics.RqueueMetricsRegistry; +import com.github.sonus21.rqueue.spring.boot.RqueueMetricsAutoConfig; +import com.github.sonus21.rqueue.spring.boot.RqueueMetricsProperties; +import com.github.sonus21.rqueue.spring.boot.tests.SpringBootUnitTest; +import io.micrometer.core.instrument.Tags; +import java.util.Collections; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.junit.jupiter.api.Test; +import org.springframework.boot.actuate.autoconfigure.metrics.MetricsProperties; + +@SpringBootUnitTest +class RqueueMetricsAutoConfigTest extends TestBase { + + @Test + void rqueueMetricsRegistryNoAdditionalTags() { + RqueueMetricsAutoConfig rqueueMetricsAutoConfig = new RqueueMetricsAutoConfig(); + MetricsProperties metricsProperties = new MetricsProperties(); + RqueueMetricsProperties rqueueMetricsProperties = new RqueueMetricsProperties(); + RqueueMetricsRegistry rqueueMetricsRegistry = + rqueueMetricsAutoConfig.rqueueMetricsRegistry(metricsProperties, rqueueMetricsProperties); + assertNotNull(rqueueMetricsRegistry); + assertEquals(Tags.empty(), rqueueMetricsProperties.getMetricTags()); + } + + @Test + void rqueueMetricsRegistryTagsFromRqueueProperties() { + RqueueMetricsAutoConfig rqueueMetricsAutoConfig = new RqueueMetricsAutoConfig(); + MetricsProperties metricsProperties = new MetricsProperties(); + RqueueMetricsProperties rqueueMetricsProperties = new RqueueMetricsProperties(); + rqueueMetricsProperties.setTags(Collections.singletonMap("dc", "test")); + RqueueMetricsRegistry rqueueMetricsRegistry = + rqueueMetricsAutoConfig.rqueueMetricsRegistry(metricsProperties, rqueueMetricsProperties); + assertNotNull(rqueueMetricsRegistry); + assertEquals(Tags.of("dc", "test"), rqueueMetricsProperties.getMetricTags()); + } + + @Test + void rqueueMetricsRegistryMergedTags() throws IllegalAccessException { + RqueueMetricsAutoConfig rqueueMetricsAutoConfig = new RqueueMetricsAutoConfig(); + MetricsProperties metricsProperties = new MetricsProperties(); + RqueueMetricsProperties rqueueMetricsProperties = new RqueueMetricsProperties(); + rqueueMetricsProperties.setTags(Collections.singletonMap("dc", "test")); + FieldUtils.writeField( + metricsProperties, "tags", Collections.singletonMap("region", "ap-south-1"), true); + RqueueMetricsRegistry rqueueMetricsRegistry = + rqueueMetricsAutoConfig.rqueueMetricsRegistry(metricsProperties, rqueueMetricsProperties); + assertNotNull(rqueueMetricsRegistry); + assertEquals( + Tags.of("region", "ap-south-1", "dc", "test"), rqueueMetricsProperties.getMetricTags()); + } +} From 585bf7b1e388f629b472ea52756e77a04def1400 Mon Sep 17 00:00:00 2001 From: Sonu Kumar Date: Sat, 6 Feb 2021 14:06:59 +0530 Subject: [PATCH 2/3] more test cases --- .../rqueue/listener/RqueueMessageHandler.java | 16 +- .../core/RqueueEndpointManagerTest.java | 31 +-- .../listener/RqueueMessageHandlerTest.java | 182 ++++++++++++++++-- 3 files changed, 193 insertions(+), 36 deletions(-) diff --git a/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/RqueueMessageHandler.java b/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/RqueueMessageHandler.java index 60bed8bd..cfd61e68 100644 --- a/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/RqueueMessageHandler.java +++ b/rqueue-core/src/main/java/com/github/sonus21/rqueue/listener/RqueueMessageHandler.java @@ -188,12 +188,13 @@ protected void registerHandlerMethod(Object handler, Method method, MappingInfor for (String pattern : getDirectLookupDestinations(mapping)) { MappingInformation oldMapping = destinationLookup.get(pattern); if (oldMapping != null && !oldMapping.equals(mapping)) { + List methods = handlerMethods.get(oldMapping); throw new IllegalStateException( "More than one listeners are registered to same queue\n" - + "Existing mapping [" - + oldMapping - + "] \nNew Mapping: [" - + mapping + + "Existing Methods " + + methods + + "\nNew Method: [" + + method + "]"); } this.destinationLookup.put(pattern, mapping); @@ -247,10 +248,15 @@ private void executeMatches(Set matchesIn, Message message, String loo } @AllArgsConstructor - public static class HandlerMethodWithPrimary { + static class HandlerMethodWithPrimary { HandlerMethod method; boolean primary; + + @Override + public String toString() { + return method.toString(); + } } private MappingInformation getMappingInformation( diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/RqueueEndpointManagerTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/RqueueEndpointManagerTest.java index c63216d6..484c2f2e 100644 --- a/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/RqueueEndpointManagerTest.java +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/core/RqueueEndpointManagerTest.java @@ -1,17 +1,17 @@ /* - * Copyright 2020 Sonu Kumar + * Copyright 2021 Sonu Kumar * - * 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 + * 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 * - * https://www.apache.org/licenses/LICENSE-2.0 + * https://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. * - * 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 com.github.sonus21.rqueue.core; @@ -24,11 +24,13 @@ import com.github.sonus21.rqueue.config.RqueueConfig; import com.github.sonus21.rqueue.core.impl.RqueueEndpointManagerImpl; import org.apache.commons.lang3.reflect.FieldUtils; +import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @CoreUnitTest class RqueueEndpointManagerTest extends TestBase { + private final RqueueEndpointManager rqueueEndpointManager = new RqueueEndpointManagerImpl( mock(RqueueMessageTemplate.class), new DefaultRqueueMessageConverter(), null); @@ -37,11 +39,16 @@ class RqueueEndpointManagerTest extends TestBase { @BeforeEach public void init() throws IllegalAccessException { FieldUtils.writeField(rqueueEndpointManager, "rqueueConfig", rqueueConfig, true); + EndpointRegistry.delete(); + } + + @AfterEach + public void clean() { + EndpointRegistry.delete(); } @Test void registerQueue() { - rqueueEndpointManager.registerQueue("test", "high"); rqueueEndpointManager.isQueueRegistered("test"); rqueueEndpointManager.isQueueRegistered("test", "high"); @@ -50,6 +57,6 @@ void registerQueue() { @Test void getQueueConfig() { rqueueEndpointManager.registerQueue("test2", "high"); - assertEquals(1, rqueueEndpointManager.getQueueConfig("test2").size()); + assertEquals(2, rqueueEndpointManager.getQueueConfig("test2").size()); } } diff --git a/rqueue-core/src/test/java/com/github/sonus21/rqueue/listener/RqueueMessageHandlerTest.java b/rqueue-core/src/test/java/com/github/sonus21/rqueue/listener/RqueueMessageHandlerTest.java index 761958db..c01de045 100644 --- a/rqueue-core/src/test/java/com/github/sonus21/rqueue/listener/RqueueMessageHandlerTest.java +++ b/rqueue-core/src/test/java/com/github/sonus21/rqueue/listener/RqueueMessageHandlerTest.java @@ -1,38 +1,44 @@ /* - * Copyright 2020 Sonu Kumar + * Copyright 2021 Sonu Kumar * - * 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 + * 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 * - * https://www.apache.org/licenses/LICENSE-2.0 + * https://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. * - * 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 com.github.sonus21.rqueue.listener; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; import com.github.sonus21.TestBase; import com.github.sonus21.rqueue.CoreUnitTest; +import com.github.sonus21.rqueue.annotation.RqueueHandler; import com.github.sonus21.rqueue.annotation.RqueueListener; -import com.github.sonus21.rqueue.converter.GenericMessageConverter; import com.github.sonus21.rqueue.core.DefaultRqueueMessageConverter; +import com.github.sonus21.rqueue.exception.TimedOutException; import com.github.sonus21.rqueue.models.Concurrency; import com.github.sonus21.rqueue.utils.Constants; +import com.github.sonus21.rqueue.utils.TimeoutUtils; import java.lang.reflect.Method; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; +import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; import lombok.AllArgsConstructor; import lombok.Data; import lombok.Getter; @@ -46,20 +52,24 @@ import org.springframework.messaging.Message; import org.springframework.messaging.MessageHandler; import org.springframework.messaging.MessageHeaders; +import org.springframework.messaging.converter.MessageConverter; import org.springframework.messaging.handler.annotation.MessageExceptionHandler; import org.springframework.messaging.support.MessageBuilder; +import org.springframework.stereotype.Component; @CoreUnitTest +@SuppressWarnings("unchecked") class RqueueMessageHandlerTest extends TestBase { + private static final String testQueue = "test-queue"; private static final String messagePayloadQueue = "message-queue"; private static final String smartQueue = "smart-queue"; private static final String slowQueue = "slow-queue"; private static final String exceptionQueue = "exception-queue"; - private String message = "This is a test message."; - private GenericMessageConverter messageConverter = new GenericMessageConverter(); - private MessagePayload messagePayload = new MessagePayload(message, message); - private String payloadConvertedMessage = + private final String message = "This is a test message."; + private final MessageConverter messageConverter = new DefaultRqueueMessageConverter(); + private final MessagePayload messagePayload = new MessagePayload(message, message); + private final String payloadConvertedMessage = ((Message) messageConverter.toMessage(messagePayload, null)).getPayload(); private Message buildMessage(String queueName, String message) { @@ -234,7 +244,7 @@ void concurrencyResolverInvalidValue() { .getEnvironment() .getPropertySources() .addLast(new MapPropertySource("test", map)); - assertThrows(BeanCreationException.class, () -> applicationContext.refresh()); + assertThrows(BeanCreationException.class, applicationContext::refresh); } @Test @@ -283,7 +293,7 @@ void concurrencyResolverMinMaxMaxIsSmallerThanMin() { .getEnvironment() .getPropertySources() .addLast(new MapPropertySource("test", map)); - assertThrows(BeanCreationException.class, () -> applicationContext.refresh()); + assertThrows(BeanCreationException.class, applicationContext::refresh); } @Test @@ -298,7 +308,7 @@ void priorityResolverInvalidValue() { .getEnvironment() .getPropertySources() .addLast(new MapPropertySource("test", map)); - assertThrows(BeanCreationException.class, () -> applicationContext.refresh()); + assertThrows(BeanCreationException.class, applicationContext::refresh); } @Test @@ -313,7 +323,84 @@ void priorityResolverInvalidValue2() { .getEnvironment() .getPropertySources() .addLast(new MapPropertySource("test", map)); - assertThrows(BeanCreationException.class, () -> applicationContext.refresh()); + assertThrows(BeanCreationException.class, applicationContext::refresh); + } + + @Test + void duplicatePrimaryHandler() { + StaticApplicationContext applicationContext = new StaticApplicationContext(); + applicationContext.registerSingleton( + "messageHandler", MultiMessageWithDuplicatePrimaryHandlerHolders.class); + applicationContext.registerSingleton("rqueueMessageHandler", RqueueMessageHandler.class); + + Map map = Collections.singletonMap("queue.name", "user-ban"); + applicationContext + .getEnvironment() + .getPropertySources() + .addLast(new MapPropertySource("test", map)); + assertThrows(BeanCreationException.class, applicationContext::refresh); + } + + @Test + void multipleMessageHandler() { + StaticApplicationContext applicationContext = new StaticApplicationContext(); + applicationContext.registerSingleton("messageHandler", MultiMessageHandlerHolders.class); + applicationContext.registerSingleton("rqueueMessageHandler", RqueueMessageHandler.class); + Map map = Collections.singletonMap("queue.name", "user-ban"); + applicationContext + .getEnvironment() + .getPropertySources() + .addLast(new MapPropertySource("test", map)); + applicationContext.refresh(); + RqueueMessageHandler rqueueMessageHandler = + applicationContext.getBean("rqueueMessageHandler", RqueueMessageHandler.class); + List handlerMethodWithPrimaries = null; + for (Entry> informationListEntry : + rqueueMessageHandler.getHandlerMethodMap().entrySet()) { + handlerMethodWithPrimaries = informationListEntry.getValue(); + } + assertNotNull(handlerMethodWithPrimaries); + assertEquals(4, handlerMethodWithPrimaries.size()); + assertEquals(1, rqueueMessageHandler.getHandlerMethodMap().size()); + } + + @Test + void multipleMessageHandlerMethodCall() throws TimedOutException { + StaticApplicationContext applicationContext = new StaticApplicationContext(); + applicationContext.registerSingleton("messageHandler", MultiMessageHandlerHolders.class); + applicationContext.registerSingleton("rqueueMessageHandler", RqueueMessageHandler.class); + Map map = Collections.singletonMap("queue.name", "user-ban"); + applicationContext + .getEnvironment() + .getPropertySources() + .addLast(new MapPropertySource("test", map)); + applicationContext.refresh(); + RqueueMessageHandler rqueueMessageHandler = + applicationContext.getBean("rqueueMessageHandler", RqueueMessageHandler.class); + MultiMessageHandlerHolders multiMessageHandlerHolders = + applicationContext.getBean("messageHandler", MultiMessageHandlerHolders.class); + + rqueueMessageHandler.handleMessage(buildMessage("user-ban", "test-data")); + TimeoutUtils.waitFor( + () -> 4 == multiMessageHandlerHolders.lastReceivedMessage.size(), + "all handlers to be invoked"); + } + + @Test + void multipleMessageHandlerWithDuplicateMapping() throws TimedOutException { + StaticApplicationContext applicationContext = new StaticApplicationContext(); + applicationContext.registerSingleton("messageHandler", MultiMessageHandlerHolders.class); + applicationContext.registerSingleton("messageHandler2", MessageHandlersWithProperty.class); + applicationContext.registerSingleton("rqueueMessageHandler", RqueueMessageHandler.class); + Map map = new HashMap<>(); + map.put("queue.name", slowQueue); + map.put("slow.queue.name", slowQueue); + map.put("fast.queue.name", smartQueue); + applicationContext + .getEnvironment() + .getPropertySources() + .addLast(new MapPropertySource("test", map)); + assertThrows(BeanCreationException.class, applicationContext::refresh); } @Test @@ -445,9 +532,66 @@ public void onMessage(String value) { } } + @Getter + @Setter + @RqueueListener(value = "${queue.name}") + @Component + private static class MultiMessageHandlerHolders { + + private Map lastReceivedMessage = new ConcurrentHashMap<>(); + + @RqueueHandler + public void onMessage(String value) { + lastReceivedMessage.put("onMessage", value); + } + + @RqueueHandler(primary = true) + public void onMessage2(String value) { + lastReceivedMessage.put("onMessage2", value); + } + + @RqueueHandler + public void onMessage3(String value) { + lastReceivedMessage.put("onMessage3", value); + } + + @RqueueHandler + public void onMessage4(String value) { + lastReceivedMessage.put("onMessage4", value); + } + } + + @Getter + @Setter + @RqueueListener(value = "${queue.name}") + private static class MultiMessageWithDuplicatePrimaryHandlerHolders { + + private String lastReceivedMessage; + + @RqueueHandler(primary = true) + public void onMessage(String value) { + lastReceivedMessage = value; + } + + @RqueueHandler(primary = true) + public void onMessage2(String value) { + lastReceivedMessage = value; + } + + public void onMessage3(String value) { + lastReceivedMessage = value; + } + + @RqueueHandler + public void onMessage4(String value) { + lastReceivedMessage = value; + } + } + @Getter @Setter private static class MessageHandlerWithConcurrency { + private String lastReceivedMessage; @RqueueListener(value = "${queue.name}", concurrency = "${queue.concurrency}") From 54376c1a72f08cfac48b357142cf2854f5dfe31d Mon Sep 17 00:00:00 2001 From: Sonu Kumar Date: Sat, 6 Feb 2021 15:14:55 +0530 Subject: [PATCH 3/3] changed image --- docs/static/rqueue-message-flow.jpg | Bin 59101 -> 62139 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/docs/static/rqueue-message-flow.jpg b/docs/static/rqueue-message-flow.jpg index 7855d10ffb3dd6eabf4893fe597d9dea81d6a1bd..dfe04d65468c17b797c33ce5a17d8fb6ee575e9a 100644 GIT binary patch literal 62139 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

D$26tP=R{!Axd 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