tags) {
6 | }
7 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/config/TestConfig.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.config;
2 |
3 | import org.nanonative.nano.services.logging.model.LogLevel;
4 |
5 | import java.util.concurrent.CountDownLatch;
6 | import java.util.concurrent.atomic.AtomicReference;
7 | import java.util.function.Supplier;
8 |
9 | import static java.util.Optional.ofNullable;
10 | import static java.util.concurrent.TimeUnit.MILLISECONDS;
11 | import static org.nanonative.nano.helper.NanoUtils.tryExecute;
12 |
13 | public class TestConfig {
14 |
15 | /**
16 | * Defines the log level for testing purposes, allowing for easy adjustment during debugging.
17 | * This can be particularly useful when trying to isolate or identify specific issues within tests.
18 | */
19 | public static final LogLevel TEST_LOG_LEVEL = LogLevel.WARN;
20 |
21 | /**
22 | * Specifies the number of times tests should be repeated to ensure concurrency reliability. This setting aims to strike a balance between thorough testing and practical execution times.
23 | * It's advised to maintain this value around 100 repeats. Higher values might affect the reliability of timing-sensitive assertions due to the varying capabilities of different testing environments.
24 | *
25 | * This concurrency configuration supports the following objectives:
26 | * - Thread Safety: Ensures that components behave correctly when accessed by multiple threads simultaneously.
27 | * - Validates Performance Under Load: Confirms that the system can handle high levels of concurrency without significant performance degradation.
28 | * - Guarantees Correct Event Handling: Verifies that events are processed accurately and in order even when handled concurrently.
29 | * - Ensures Robustness and Stability: Checks for the resilience of the system under concurrent usage, ensuring it remains stable and performs consistently.
30 | * - Prepares for Real-World Scenarios: Mimics real-world application usage to ensure the system can handle concurrent operations effectively.
31 | * - Promotes Confidence in Security: Helps identify potential security vulnerabilities that could be exploited through concurrent execution.
32 | */
33 | public static final int TEST_REPEAT = 128;
34 | public static final int TEST_TIMEOUT = 1024 + (int) (Math.sqrt(TEST_REPEAT) * 50);
35 |
36 | public static boolean await(final CountDownLatch latch) throws InterruptedException {
37 | return latch.await(TEST_TIMEOUT, MILLISECONDS);
38 | }
39 |
40 | public static T waitForNonNull(final Supplier waitFor) {
41 | return waitForNonNull(waitFor, 2000);
42 | }
43 |
44 | public static T waitForNonNull(final Supplier waitFor, final long timeoutMs) {
45 | final long startTime = System.currentTimeMillis();
46 | final AtomicReference result = new AtomicReference<>(null);
47 | while (result.get() == null && (System.currentTimeMillis() - startTime) < timeoutMs) {
48 | ofNullable(waitFor.get()).ifPresentOrElse(result::set, () -> tryExecute(null, () -> Thread.sleep(100)));
49 | }
50 | return result.get();
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/model/ConfigTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.model;
2 |
3 | import org.junit.jupiter.api.Test;
4 |
5 | import static org.nanonative.nano.helper.config.ConfigRegister.configDescriptionOf;
6 | import static org.nanonative.nano.helper.config.ConfigRegister.registerConfig;
7 | import static org.assertj.core.api.Assertions.assertThat;
8 |
9 | class ConfigTest {
10 |
11 | @Test
12 | void testNewConfig() {
13 | assertThat(registerConfig("AA:BB.CC-DD+ff", "ABC123")).isEqualTo("aa_bb_cc_dd_ff");
14 | assertThat(configDescriptionOf("AA:BB.CC-DD+ff")).isEqualTo("ABC123");
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/model/ContextTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.model;
2 |
3 | import org.junit.jupiter.api.RepeatedTest;
4 | import org.junit.jupiter.api.parallel.Execution;
5 | import org.junit.jupiter.api.parallel.ExecutionMode;
6 | import org.nanonative.nano.core.Nano;
7 | import org.nanonative.nano.core.config.TestConfig;
8 | import org.nanonative.nano.helper.event.EventChannelRegister;
9 | import org.nanonative.nano.helper.event.model.Event;
10 | import org.nanonative.nano.model.TestService;
11 |
12 | import java.time.LocalTime;
13 | import java.util.Map;
14 | import java.util.concurrent.CountDownLatch;
15 | import java.util.function.Consumer;
16 |
17 | import static java.time.temporal.ChronoUnit.MILLIS;
18 | import static java.util.concurrent.TimeUnit.MILLISECONDS;
19 | import static org.assertj.core.api.Assertions.assertThat;
20 | import static org.assertj.core.api.Assertions.assertThatThrownBy;
21 | import static org.nanonative.nano.core.config.TestConfig.TEST_TIMEOUT;
22 | import static org.nanonative.nano.core.model.Context.CONTEXT_CLASS_KEY;
23 | import static org.nanonative.nano.core.model.Context.CONTEXT_NANO_KEY;
24 | import static org.nanonative.nano.core.model.Context.CONTEXT_TRACE_ID_KEY;
25 | import static org.nanonative.nano.core.model.Context.EVENT_APP_HEARTBEAT;
26 | import static org.nanonative.nano.helper.NanoUtils.waitForCondition;
27 | import static org.nanonative.nano.services.logging.LogService.CONFIG_LOG_LEVEL;
28 |
29 | @SuppressWarnings("java:S5778")
30 | @Execution(ExecutionMode.CONCURRENT)
31 | class ContextTest {
32 |
33 | private static final int TEST_CHANNEL_ID = EventChannelRegister.registerChannelId("TEST_EVENT");
34 |
35 | @RepeatedTest(TestConfig.TEST_REPEAT)
36 | void testNewContext_withNano() throws InterruptedException {
37 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TestConfig.TEST_LOG_LEVEL));
38 | final Context context = new Context(null, nano.getClass()).put(CONTEXT_NANO_KEY, nano);
39 | final Consumer myListener = event -> {};
40 | assertContextBehaviour(context);
41 |
42 | // Verify event listener
43 | assertThat(nano.listeners().get(EVENT_APP_HEARTBEAT)).hasSize(1);
44 | assertThat(context.subscribeEvent(EVENT_APP_HEARTBEAT, myListener)).isEqualTo(context);
45 | assertThat(nano.listeners().get(EVENT_APP_HEARTBEAT)).hasSize(2);
46 | assertThat(context.unsubscribeEvent(EVENT_APP_HEARTBEAT, myListener)).isEqualTo(context);
47 | assertThat(nano.listeners().get(EVENT_APP_HEARTBEAT)).hasSize(1);
48 |
49 | // Verify event sending
50 | final CountDownLatch eventLatch = new CountDownLatch(4);
51 | final int channelId = context.registerChannelId("TEST_EVENT");
52 | context.subscribeEvent(channelId, event -> eventLatch.countDown());
53 | context.sendEvent(channelId, () -> "AA");
54 | final Event event = context.sendEventR(channelId, () -> "BB");
55 | context.broadcastEvent(channelId, () -> "CC");
56 | context.broadcastEventR(channelId, () -> "DD");
57 | assertThat(event).isNotNull();
58 | assertThat(event.payload()).isEqualTo("BB");
59 | assertThat(event.channel()).isEqualTo("TEST_EVENT");
60 | assertThat(event.channelId()).isEqualTo(channelId);
61 | assertThat(event.context()).isEqualTo(context);
62 | assertThat(event.isAcknowledged()).isFalse();
63 | assertThat(eventLatch.await(TEST_TIMEOUT, MILLISECONDS)).isTrue();
64 | assertThat(eventLatch.getCount()).isZero();
65 | assertThat(channelId).isEqualTo(TEST_CHANNEL_ID);
66 |
67 | // Verify services
68 | final TestService testService = new TestService();
69 | assertThat(context.run(testService)).isEqualTo(context);
70 | assertThat(waitForCondition(() -> context.services().contains(testService), TEST_TIMEOUT)).isTrue();
71 | assertThat(context.service(testService.getClass())).isEqualTo(testService);
72 | assertThat(context.services(TestService.class)).containsExactly(testService);
73 |
74 | // Verify schedule once
75 | final CountDownLatch latch1 = new CountDownLatch(1);
76 | context.run(latch1::countDown, 16, MILLISECONDS);
77 | assertThat(latch1.await(TEST_TIMEOUT, MILLISECONDS))
78 | .withFailMessage("latch1 \nExpected: 1 \n Actual: " + latch1.getCount())
79 | .isTrue();
80 |
81 | // Verify schedule multiple time with stop
82 | final CountDownLatch latch2 = new CountDownLatch(4);
83 | context.run(latch2::countDown, 0, 16, MILLISECONDS);
84 | assertThat(latch2.await(TEST_TIMEOUT, MILLISECONDS))
85 | .withFailMessage("latch2 \nExpected: 4 \n Actual: " + latch2.getCount())
86 | .isTrue();
87 |
88 | final CountDownLatch latch3 = new CountDownLatch(1);
89 | context.run(latch3::countDown, LocalTime.now().plus(16, MILLIS));
90 | assertThat(latch3.await(TEST_TIMEOUT, MILLISECONDS))
91 | .withFailMessage("latch3 \nExpected: 1 \n Actual: " + latch3.getCount())
92 | .isTrue();
93 |
94 | assertThat(nano.stop(this.getClass()).waitForStop().isReady()).isFalse();
95 | }
96 |
97 | @RepeatedTest(TestConfig.TEST_REPEAT)
98 | void testNewContext_withoutNano() {
99 | final Context context = Context.createRootContext(ContextTest.class);
100 | final Consumer myListener = event -> {};
101 | assertContextBehaviour(context);
102 | assertThatThrownBy(() -> context.subscribeEvent(EVENT_APP_HEARTBEAT, myListener)).isInstanceOf(NullPointerException.class);
103 | assertThatThrownBy(() -> context.unsubscribeEvent(EVENT_APP_HEARTBEAT, myListener)).isInstanceOf(NullPointerException.class);
104 | }
105 |
106 | @RepeatedTest(TestConfig.TEST_REPEAT)
107 | void testNewEmptyContext_withoutClass_willCreateRootContext() {
108 | final Context context = Context.createRootContext(ContextTest.class);
109 | assertContextBehaviour(context);
110 | final Context subContext = context.newContext(null);
111 | assertThat(subContext.traceId()).startsWith(ContextTest.class.getSimpleName() + "/");
112 | }
113 |
114 | @RepeatedTest(TestConfig.TEST_REPEAT)
115 | void testRunHandled_withException() throws InterruptedException {
116 | final Context context = Context.createRootContext(ContextTest.class);
117 | final CountDownLatch latch = new CountDownLatch(2);
118 | assertContextBehaviour(context);
119 | assertThat(context.runHandled(unhandled -> latch.countDown(), () -> {
120 | throw new RuntimeException("Nothing to see here, just a test exception");
121 | })).isEqualTo(context);
122 | assertThat(context.runReturnHandled(unhandled -> latch.countDown(), () -> {
123 | throw new RuntimeException("Nothing to see here, just a test exception");
124 | })).isNotNull();
125 | assertThat(latch.await(1000, MILLISECONDS)).isTrue();
126 | assertThat(latch.getCount()).isZero();
127 | }
128 |
129 |
130 | @RepeatedTest(TestConfig.TEST_REPEAT)
131 | void testRunAwaitHandled_withException() throws InterruptedException {
132 | final Context context = Context.createRootContext(ContextTest.class);
133 | final CountDownLatch latch = new CountDownLatch(1);
134 | assertContextBehaviour(context);
135 | context.runAwaitHandled(unhandled -> latch.countDown(), () -> {
136 | throw new RuntimeException("Nothing to see here, just a test exception");
137 | });
138 | assertThat(latch.await(1000, MILLISECONDS)).isTrue();
139 | assertThat(latch.getCount()).isZero();
140 | }
141 |
142 | @RepeatedTest(TestConfig.TEST_REPEAT)
143 | void testRunAwait_withException() {
144 | final Context context = Context.createRootContext(ContextTest.class);
145 | assertContextBehaviour(context);
146 | context.runAwait(() -> {
147 | throw new RuntimeException("Nothing to see here, just a test exception");
148 | });
149 | //TODO: create an unhandled element and check if the error was unhandled
150 | }
151 |
152 | private void assertContextBehaviour(final Context context) {
153 | assertThat(context)
154 | .hasSize(3)
155 | .containsKeys(CONTEXT_NANO_KEY, CONTEXT_TRACE_ID_KEY, CONTEXT_CLASS_KEY);
156 |
157 | context.put("AA", "BB");
158 | assertThat(context)
159 | .hasSize(4)
160 | .containsKeys(CONTEXT_NANO_KEY, CONTEXT_TRACE_ID_KEY, CONTEXT_CLASS_KEY, CONTEXT_TRACE_ID_KEY)
161 | .containsKey("AA");
162 |
163 | assertThat(context.newContext(this.getClass()))
164 | .hasSize(5)
165 | .containsKeys(CONTEXT_NANO_KEY, CONTEXT_TRACE_ID_KEY, CONTEXT_CLASS_KEY, CONTEXT_TRACE_ID_KEY)
166 | .containsKey("AA");
167 |
168 | assertThat(context.newContext(this.getClass()))
169 | .hasSize(5)
170 | .containsKeys(CONTEXT_NANO_KEY, CONTEXT_TRACE_ID_KEY, CONTEXT_CLASS_KEY, CONTEXT_TRACE_ID_KEY);
171 |
172 | //Verify trace id is shared between contexts
173 | assertThat(context.newContext(this.getClass()).asList(CONTEXT_TRACE_ID_KEY)).hasSize(1).doesNotContain(context.traceId());
174 | final Context subContext = context.newContext(this.getClass());
175 | assertThat(subContext.asList(CONTEXT_TRACE_ID_KEY)).hasSize(1).doesNotContain(context.traceId());
176 | assertThat(subContext.traceId()).isNotEqualTo(context.traceId());
177 | assertThat(subContext.traceId(0)).isEqualTo(subContext.traceId()).isNotEqualTo(context.traceId());
178 | assertThat(subContext.traceId(1)).isNotEqualTo(subContext.traceId()).isEqualTo(context.traceId());
179 | assertThat(subContext.traceId(99)).isEqualTo(subContext.traceId()).isNotEqualTo(context.traceId());
180 | assertThat(subContext.traceIds()).containsExactlyInAnyOrder(context.traceId(), subContext.traceId());
181 | }
182 |
183 | @RepeatedTest(TestConfig.TEST_REPEAT)
184 | void testToString() {
185 | final Context context = Context.createRootContext(ContextTest.class);
186 | assertThat(context).hasToString("{\"size\":" + context.size() + ",\"class\":\"" + this.getClass().getSimpleName() + "\"}");
187 |
188 | }
189 |
190 | }
191 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/model/LockedBooleanTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.model;
2 |
3 | import org.nanonative.nano.core.config.TestConfig;
4 | import org.nanonative.nano.helper.LockedBoolean;
5 | import org.assertj.core.api.Assertions;
6 | import org.junit.jupiter.api.RepeatedTest;
7 | import org.junit.jupiter.api.parallel.Execution;
8 | import org.junit.jupiter.api.parallel.ExecutionMode;
9 |
10 | import java.util.concurrent.CountDownLatch;
11 | import java.util.concurrent.atomic.AtomicInteger;
12 | import java.util.stream.IntStream;
13 |
14 | import static org.assertj.core.api.Assertions.assertThat;
15 |
16 | @Execution(ExecutionMode.CONCURRENT)
17 | class LockedBooleanTest {
18 |
19 | @RepeatedTest(TestConfig.TEST_REPEAT)
20 | void setState_shouldBlock() throws InterruptedException {
21 | final CountDownLatch latch = new CountDownLatch(10);
22 | final LockedBoolean lockedBoolean = new LockedBoolean();
23 |
24 | IntStream.range(0, 10).parallel().forEach(i -> NanoThreadTest.TEST_EXECUTOR.submit(() -> {
25 | lockedBoolean.set(i % 2 == 0);
26 | latch.countDown();
27 | }));
28 |
29 | Assertions.assertThat(TestConfig.await(latch)).isTrue();
30 | }
31 |
32 | @RepeatedTest(TestConfig.TEST_REPEAT)
33 | void setState_withConsumer_shouldBlock() throws InterruptedException {
34 | final CountDownLatch latch = new CountDownLatch(10);
35 | final LockedBoolean lockedBoolean = new LockedBoolean(false);
36 | final AtomicInteger trueSetCounter = new AtomicInteger(0);
37 | final AtomicInteger falseSetCounter = new AtomicInteger(0);
38 |
39 | IntStream.range(0, 10).parallel().forEach(i -> NanoThreadTest.TEST_EXECUTOR.submit(() -> {
40 | if (i % 2 == 0) {
41 | lockedBoolean.set(true, state -> trueSetCounter.incrementAndGet());
42 | } else {
43 | lockedBoolean.set(false, state -> falseSetCounter.incrementAndGet());
44 | }
45 | latch.countDown();
46 | }));
47 |
48 | Assertions.assertThat(TestConfig.await(latch)).isTrue();
49 | assertThat(trueSetCounter.get() + falseSetCounter.get()).isEqualTo(10);
50 | }
51 |
52 | @RepeatedTest(TestConfig.TEST_REPEAT)
53 | void run_withConditionAndConsumer_shouldBlock() throws InterruptedException {
54 | final CountDownLatch latch = new CountDownLatch(10);
55 | final LockedBoolean lockedBoolean = new LockedBoolean(false);
56 |
57 | IntStream.range(0, 10).parallel().forEach(i -> NanoThreadTest.TEST_EXECUTOR.submit(() -> lockedBoolean.run(state -> latch.countDown())));
58 |
59 | Assertions.assertThat(TestConfig.await(latch)).isTrue();
60 | assertThat(lockedBoolean.get()).isFalse();
61 | }
62 |
63 | @RepeatedTest(TestConfig.TEST_REPEAT)
64 | void run_withConsumer_shouldBlock() {
65 | final LockedBoolean lockedBoolean = new LockedBoolean(false);
66 | final AtomicInteger runCounter = new AtomicInteger(0);
67 |
68 | for (int i = 0; i < 20; i++) {
69 | final boolean odd = i % 2 == 0;
70 | lockedBoolean.run(odd, state -> runCounter.incrementAndGet());
71 | }
72 |
73 | assertThat(lockedBoolean.get()).isFalse();
74 | assertThat(runCounter).hasValue(10);
75 | }
76 |
77 | @RepeatedTest(TestConfig.TEST_REPEAT)
78 | void setState_withCondition_shouldBlock() {
79 | final LockedBoolean lockedBoolean = new LockedBoolean(true);
80 |
81 | for (int i = 0; i < 10; i++) {
82 | final boolean odd = i % 2 == 0;
83 | lockedBoolean.set(odd, !odd);
84 | }
85 |
86 | assertThat(lockedBoolean.get()).isTrue();
87 | }
88 |
89 | @RepeatedTest(TestConfig.TEST_REPEAT)
90 | void setState_withConditionAndConsumer_shouldBlock() throws InterruptedException {
91 | final CountDownLatch latch = new CountDownLatch(10);
92 | final LockedBoolean lockedBoolean = new LockedBoolean(true);
93 |
94 | for (int i = 0; i < 10; i++) {
95 | final boolean odd = i % 2 == 0;
96 | lockedBoolean.set(odd, !odd, state -> latch.countDown());
97 | }
98 |
99 | Assertions.assertThat(TestConfig.await(latch)).isTrue();
100 | }
101 |
102 | @RepeatedTest(TestConfig.TEST_REPEAT)
103 | void toString_shouldBlock() throws InterruptedException {
104 | final CountDownLatch latch = new CountDownLatch(10);
105 | final LockedBoolean lockedBoolean = new LockedBoolean();
106 |
107 | IntStream.range(0, 10).parallel().forEach(i -> NanoThreadTest.TEST_EXECUTOR.submit(() -> {
108 | assertThat(lockedBoolean.toString()).contains(LockedBoolean.class.getSimpleName() + "{" + "state=false}");
109 | latch.countDown();
110 | }));
111 |
112 | Assertions.assertThat(TestConfig.await(latch)).isTrue();
113 | assertThat(lockedBoolean.get()).isFalse();
114 | }
115 |
116 | }
117 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/model/NanoThreadTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.model;
2 |
3 | import org.junit.jupiter.api.RepeatedTest;
4 | import org.junit.jupiter.api.parallel.Execution;
5 | import org.junit.jupiter.api.parallel.ExecutionMode;
6 |
7 | import java.util.Arrays;
8 | import java.util.concurrent.CountDownLatch;
9 | import java.util.concurrent.ExecutorService;
10 | import java.util.concurrent.TimeUnit;
11 | import java.util.concurrent.atomic.AtomicInteger;
12 | import java.util.stream.IntStream;
13 |
14 | import static org.assertj.core.api.Assertions.assertThat;
15 | import static org.nanonative.nano.core.config.TestConfig.TEST_REPEAT;
16 | import static org.nanonative.nano.core.model.NanoThread.GLOBAL_THREAD_POOL;
17 | import static org.nanonative.nano.core.model.NanoThread.activeCarrierThreads;
18 | import static org.nanonative.nano.core.model.NanoThread.activeNanoThreads;
19 |
20 | @Execution(ExecutionMode.CONCURRENT)
21 | class NanoThreadTest {
22 |
23 | public static final ExecutorService TEST_EXECUTOR = GLOBAL_THREAD_POOL;
24 |
25 | @RepeatedTest(TEST_REPEAT)
26 | void waitForAll_shouldBlockAndWait() {
27 | final AtomicInteger doneThreads = new AtomicInteger(0);
28 | final NanoThread[] threads = startConcurrentThreads(doneThreads);
29 |
30 | NanoThread.waitFor(threads);
31 | assertThat(doneThreads.get()).isEqualTo(TEST_REPEAT);
32 | }
33 |
34 | @RepeatedTest(TEST_REPEAT)
35 | void waitForAll_shouldNotBlock() throws InterruptedException {
36 | final CountDownLatch latch = new CountDownLatch(1);
37 | final AtomicInteger doneThreads = new AtomicInteger(0);
38 | final Runnable onComplete = latch::countDown;
39 |
40 | NanoThread.waitFor(onComplete, startConcurrentThreads(doneThreads));
41 | assertThat(latch.await(TEST_REPEAT, TimeUnit.SECONDS)).isTrue();
42 | assertThat(doneThreads.get()).isEqualTo(TEST_REPEAT);
43 | }
44 |
45 | @RepeatedTest(TEST_REPEAT)
46 | void waitFor_shouldBlockAndWait() {
47 | final AtomicInteger doneThreads = new AtomicInteger(0);
48 | final NanoThread[] threads = startConcurrentThreads(doneThreads);
49 |
50 | Arrays.stream(threads).forEach(NanoThread::await);
51 | assertThat(doneThreads.get()).isEqualTo(TEST_REPEAT);
52 | assertThat(Arrays.stream(threads).parallel().allMatch(NanoThread::isComplete)).isTrue();
53 | }
54 |
55 | @RepeatedTest(TEST_REPEAT)
56 | void waitFor_shouldNotBlockWait() throws InterruptedException {
57 | final CountDownLatch latch = new CountDownLatch(TEST_REPEAT);
58 | final AtomicInteger doneThreads = new AtomicInteger(0);
59 | final NanoThread[] threads = startConcurrentThreads(doneThreads);
60 |
61 | Arrays.stream(threads).forEach(thread -> thread.await(latch::countDown));
62 | assertThat(doneThreads.get()).isLessThan(TEST_REPEAT);
63 | assertThat(latch.await(TEST_REPEAT, TimeUnit.SECONDS)).isTrue();
64 | assertThat(doneThreads.get()).isEqualTo(TEST_REPEAT);
65 | Arrays.stream(threads).parallel().forEach(thread -> assertThat(thread.isComplete()).isTrue());
66 | Arrays.stream(threads).parallel().forEach(thread -> assertThat(thread.toString()).contains(NanoThread.class.getSimpleName() + "{onCompleteCallbacks=", ", isComplete=true}"));
67 | }
68 |
69 | @RepeatedTest(TEST_REPEAT)
70 | void activeNanoThreadCount() {
71 | new NanoThread().run(() -> null, () -> {
72 | assertThat(activeNanoThreads()).isPositive();
73 | assertThat(activeCarrierThreads()).isPositive();
74 | });
75 | }
76 |
77 | @SuppressWarnings("java:S2925")
78 | private static NanoThread[] startConcurrentThreads(final AtomicInteger doneThreads) {
79 | return IntStream.range(0, TEST_REPEAT).parallel().mapToObj(i -> {
80 | final NanoThread thread = new NanoThread();
81 | thread.run(null, () -> {
82 | try {
83 | Thread.sleep((long) (Math.random() * 100));
84 | doneThreads.incrementAndGet();
85 | } catch (final InterruptedException e) {
86 | Thread.currentThread().interrupt();
87 | }
88 | });
89 | return thread;
90 | }).toArray(NanoThread[]::new);
91 | }
92 | }
93 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/model/SchedulerTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.model;
2 |
3 | import org.junit.jupiter.api.RepeatedTest;
4 |
5 | import static org.nanonative.nano.core.config.TestConfig.TEST_REPEAT;
6 | import static org.assertj.core.api.Assertions.assertThat;
7 |
8 | class SchedulerTest {
9 |
10 | @RepeatedTest(TEST_REPEAT)
11 | void testNewScheduler() {
12 | final Scheduler scheduler = new Scheduler("test");
13 | assertThat(scheduler).isNotNull();
14 | assertThat(scheduler.id()).isEqualTo("test");
15 | assertThat(scheduler).hasToString("{\"id\":\"test\"}");
16 | }
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/model/ServiceTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.model;
2 |
3 | import org.junit.jupiter.api.RepeatedTest;
4 | import org.junit.jupiter.api.parallel.Execution;
5 | import org.junit.jupiter.api.parallel.ExecutionMode;
6 | import org.nanonative.nano.core.Nano;
7 | import org.nanonative.nano.core.config.TestConfig;
8 | import org.nanonative.nano.helper.event.model.Event;
9 | import org.nanonative.nano.model.TestService;
10 |
11 | import java.util.Map;
12 |
13 | import static org.assertj.core.api.Assertions.assertThat;
14 | import static org.nanonative.nano.core.config.TestConfig.TEST_REPEAT;
15 | import static org.nanonative.nano.core.config.TestConfig.TEST_TIMEOUT;
16 | import static org.nanonative.nano.core.model.Context.EVENT_APP_UNHANDLED;
17 | import static org.nanonative.nano.helper.NanoUtils.waitForCondition;
18 | import static org.nanonative.nano.helper.event.model.Event.eventOf;
19 | import static org.nanonative.nano.services.logging.LogService.CONFIG_LOG_LEVEL;
20 |
21 | @Execution(ExecutionMode.CONCURRENT)
22 | class ServiceTest {
23 |
24 | @RepeatedTest(TEST_REPEAT)
25 | void testService() {
26 | final long startTime = System.currentTimeMillis() - 10;
27 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TestConfig.TEST_LOG_LEVEL));
28 | final Context context = nano.context(this.getClass());
29 | final TestService service = new TestService();
30 | final Event error = eventOf(context, 999).payload(() -> "TEST ERROR_AA").error(new RuntimeException("TEST ERROR_BB"));
31 |
32 | assertThat(service).isNotNull();
33 | assertThat(service.createdAtMs()).isGreaterThan(startTime);
34 | assertThat(service.startCount()).isZero();
35 | assertThat(service.stopCount()).isZero();
36 | assertThat(service.events()).isEmpty();
37 | assertThat(service.failures()).isEmpty();
38 |
39 | service.start();
40 | assertThat(service.startCount()).isEqualTo(1);
41 |
42 | service.stop();
43 | assertThat(service.stopCount()).isEqualTo(1);
44 |
45 | service.onFailure(error);
46 | assertThat(service.failures()).hasSize(1).contains(error);
47 |
48 | final Event event = eventOf(context, EVENT_APP_UNHANDLED).payload(() -> error);
49 | service.onEvent(event);
50 | final Event receivedEvent = service.getEvent(EVENT_APP_UNHANDLED);
51 | assertThat(receivedEvent).isNotNull();
52 | assertThat(receivedEvent.payload(Event.class)).isEqualTo(error);
53 |
54 | assertThat(nano.services()).hasSize(1);
55 | service.nanoThread(context).run(() -> context, () -> {});
56 | assertThat(waitForCondition(() -> service.startCount() == 2, TEST_TIMEOUT)).isTrue();
57 | waitForCondition(() -> nano.services().size() == 2, TEST_TIMEOUT);
58 | assertThat(service.startCount()).isEqualTo(2);
59 | assertThat(service.failures()).hasSize(1);
60 | assertThat(nano.services()).size().isEqualTo(2);
61 |
62 | assertThat(nano.stop(this.getClass()).waitForStop().isReady()).isFalse();
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/core/model/UnhandledTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.core.model;
2 |
3 | import org.nanonative.nano.core.Nano;
4 | import org.junit.jupiter.api.RepeatedTest;
5 | import org.junit.jupiter.api.parallel.Execution;
6 | import org.junit.jupiter.api.parallel.ExecutionMode;
7 |
8 | import java.util.Map;
9 |
10 | import static org.nanonative.nano.core.config.TestConfig.*;
11 | import static org.assertj.core.api.Assertions.assertThat;
12 | import static org.nanonative.nano.services.logging.LogService.CONFIG_LOG_LEVEL;
13 |
14 | @Execution(ExecutionMode.CONCURRENT)
15 | class UnhandledTest {
16 |
17 | @RepeatedTest(TEST_REPEAT)
18 | void testConstructor() {
19 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TEST_LOG_LEVEL)).stop(this.getClass());
20 | final Context context = nano.context(this.getClass());
21 | final Unhandled error = new Unhandled(context, 111, null);
22 | assertThat(error).isNotNull();
23 | assertThat(error.nano()).isEqualTo(nano);
24 | assertThat(error.context()).isEqualTo(context);
25 | assertThat(error.payload()).isEqualTo(111);
26 | assertThat(error.payload(String.class)).isEqualTo("111");
27 | assertThat(error.payload(Integer.class)).isEqualTo(111);
28 | assertThat(error.exception()).isNull();
29 | assertThat(error).hasToString("Unhandled{payload=111, exception=null}");
30 | assertThat(nano.waitForStop().isReady()).isFalse();
31 | }
32 |
33 | @RepeatedTest(TEST_REPEAT)
34 | void testNullConstructor() {
35 | final Unhandled error = new Unhandled(null, null, null);
36 | assertThat(error).isNotNull();
37 | assertThat(error.nano()).isNull();
38 | assertThat(error.context()).isNull();
39 | assertThat(error.payload()).isNull();
40 | assertThat(error.payload(String.class)).isNull();
41 | assertThat(error.exception()).isNull();
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/examples/ErrorHandling.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.examples;
2 |
3 | import org.nanonative.nano.core.Nano;
4 | import org.nanonative.nano.core.model.Context;
5 | import org.junit.jupiter.api.Disabled;
6 |
7 | import static org.nanonative.nano.core.model.Context.EVENT_APP_UNHANDLED;
8 |
9 | @Disabled
10 | public class ErrorHandling {
11 |
12 | public static void main(final String[] args) {
13 | final Context context = new Nano(args).context(ErrorHandling.class);
14 |
15 | // Listen to exceptions
16 | context.subscribeEvent(EVENT_APP_UNHANDLED, event -> {
17 | // Print error message
18 | event.context().warn(() -> "Caught event [{}] with error [{}] ", event.nameOrg(), event.error().getMessage());
19 | event.acknowledge(); // Set exception as handled (prevent further processing)
20 | });
21 |
22 | // Throw an exception
23 | context.run(() -> {
24 | throw new RuntimeException("Test Exception");
25 | });
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/examples/HttpReceive.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.examples;
2 |
3 | import org.junit.jupiter.api.Disabled;
4 | import org.nanonative.nano.core.Nano;
5 | import org.nanonative.nano.helper.event.model.Event;
6 | import org.nanonative.nano.services.http.HttpServer;
7 | import org.nanonative.nano.services.http.model.HttpObject;
8 |
9 | import java.util.Map;
10 |
11 | import static org.nanonative.nano.core.model.Context.EVENT_APP_UNHANDLED;
12 | import static org.nanonative.nano.services.http.HttpServer.EVENT_HTTP_REQUEST;
13 |
14 | @Disabled
15 | public class HttpReceive {
16 |
17 | public static void main(final String[] args) {
18 | final Nano app = new Nano(args, new HttpServer());
19 |
20 | // Authorization
21 | app.subscribeEvent(EVENT_HTTP_REQUEST, HttpReceive::authorize);
22 |
23 | // Response
24 | app.subscribeEvent(EVENT_HTTP_REQUEST, HttpReceive::helloWorldController);
25 |
26 | // Error handling
27 | app.subscribeEvent(EVENT_APP_UNHANDLED, HttpReceive::controllerAdvice);
28 |
29 | // CORS
30 | app.subscribeEvent(EVENT_HTTP_REQUEST, HttpReceive::cors);
31 | }
32 |
33 | private static void cors(final Event event) {
34 | event.payloadOpt(HttpObject.class)
35 | .filter(HttpObject::isMethodOptions)
36 | .ifPresent(request -> request.corsResponse().respond(event));
37 | }
38 |
39 | private static void authorize(final Event event) {
40 | event.payloadOpt(HttpObject.class)
41 | .filter(request -> request.pathMatch("/hello/**"))
42 | .filter(request -> !"mySecretToken".equals(request.authToken()))
43 | .ifPresent(request -> request.response().body(Map.of("message", "You are unauthorized")).statusCode(401).respond(event));
44 | }
45 |
46 | private static void helloWorldController(final Event event) {
47 | event.payloadOpt(HttpObject.class)
48 | .filter(HttpObject::isMethodGet)
49 | .filter(request -> request.pathMatch("/hello"))
50 | .ifPresent(request -> request.response().body(Map.of("Hello", System.getProperty("user.name"))).respond(event));
51 | }
52 |
53 | private static void controllerAdvice(final Event event) {
54 | event.payloadOpt(HttpObject.class).ifPresent(request ->
55 | request.response().body("Internal Server Error [" + event.error().getMessage() + "]").statusCode(500).respond(event));
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/examples/HttpSend.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.examples;
2 |
3 | import org.junit.jupiter.api.Disabled;
4 | import org.nanonative.nano.core.Nano;
5 | import org.nanonative.nano.core.model.Context;
6 | import org.nanonative.nano.services.http.HttpClient;
7 | import org.nanonative.nano.services.http.HttpServer;
8 | import org.nanonative.nano.services.http.model.HttpObject;
9 |
10 | import static org.nanonative.nano.services.http.HttpClient.EVENT_SEND_HTTP;
11 | import static org.nanonative.nano.services.http.model.HttpMethod.GET;
12 |
13 | @Disabled
14 | @SuppressWarnings("java:S1854") // Suppress "dead code" warning
15 | public class HttpSend {
16 |
17 | public static void main(final String[] args) {
18 | final Context context = new Nano(args, new HttpServer()).context(HttpSend.class);
19 |
20 | // send request via event
21 | final HttpObject response1 = context.sendEventR(EVENT_SEND_HTTP, () -> new HttpObject()
22 | .methodType(GET)
23 | .path("http://localhost:8080/hello")
24 | .body("Hello World")
25 | ).response(HttpObject.class);
26 |
27 | // send request via context
28 | final HttpObject response2 = new HttpObject()
29 | .methodType(GET)
30 | .path("http://localhost:8080/hello")
31 | .body("Hello World")
32 | .send(context);
33 |
34 | // send request manually
35 | final HttpObject response3 = new HttpClient().send(new HttpObject()
36 | .methodType(GET)
37 | .path("http://localhost:8080/hello")
38 | .body("Hello World")
39 | );
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/examples/Kazim.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.examples;
2 |
3 | import org.junit.jupiter.api.Disabled;
4 | import org.nanonative.nano.core.Nano;
5 | import org.nanonative.nano.services.logging.model.LogLevel;
6 | import org.nanonative.nano.services.http.HttpServer;
7 | import org.nanonative.nano.services.metric.logic.MetricService;
8 |
9 | import java.util.Map;
10 |
11 | import static org.nanonative.nano.services.logging.LogService.CONFIG_LOG_FORMATTER;
12 | import static org.nanonative.nano.services.logging.LogService.CONFIG_LOG_LEVEL;
13 |
14 | @Disabled
15 | public class Kazim {
16 |
17 | public static void main(String[] args) {
18 | final Nano application = new Nano(Map.of(
19 | CONFIG_LOG_LEVEL, LogLevel.INFO,
20 | CONFIG_LOG_FORMATTER, "console"
21 | // CONFIG_METRIC_SERVICE_BASE_PATH, "/metrics",
22 | // CONFIG_METRIC_SERVICE_PROMETHEUS_PATH, "/influx"
23 | ), new MetricService(), new HttpServer());
24 |
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/examples/MetricCreation.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.examples;
2 |
3 | import org.nanonative.nano.core.Nano;
4 | import org.nanonative.nano.core.model.Context;
5 | import org.nanonative.nano.services.metric.logic.MetricService;
6 | import org.nanonative.nano.services.metric.model.MetricUpdate;
7 | import org.junit.jupiter.api.Disabled;
8 |
9 | import java.util.Map;
10 |
11 | import static org.nanonative.nano.services.metric.logic.MetricService.EVENT_METRIC_UPDATE;
12 | import static org.nanonative.nano.services.metric.model.MetricType.GAUGE;
13 | import static org.nanonative.nano.services.metric.model.MetricType.TIMER_END;
14 | import static org.nanonative.nano.services.metric.model.MetricType.TIMER_START;
15 |
16 | @Disabled
17 | @SuppressWarnings("java:S1854") // Suppress "dead code" warning
18 | public class MetricCreation {
19 |
20 | public static void main(final String[] args) {
21 | final Context context = new Nano(args, new MetricService()).context(MetricCreation.class);
22 | final Map metricTags = Map.of("tag_key", "tag_value");
23 |
24 | // create counter
25 | context.sendEvent(EVENT_METRIC_UPDATE, () -> new MetricUpdate(GAUGE, "my.counter.key", 130624, metricTags));
26 | // create gauge
27 | context.sendEvent(EVENT_METRIC_UPDATE, () -> new MetricUpdate(GAUGE, "my.gauge.key", 200888, metricTags));
28 | // start timer
29 | context.sendEvent(EVENT_METRIC_UPDATE, () -> new MetricUpdate(TIMER_START, "my.timer.key", null, metricTags));
30 | // end timer
31 | context.sendEvent(EVENT_METRIC_UPDATE, () -> new MetricUpdate(TIMER_END, "my.timer.key", null, metricTags));
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/examples/Yuna.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.examples;
2 |
3 | import org.junit.jupiter.api.Disabled;
4 | import org.nanonative.nano.core.Nano;
5 | import org.nanonative.nano.core.model.Context;
6 | import org.nanonative.nano.services.http.HttpServer;
7 | import org.nanonative.nano.services.http.model.HttpObject;
8 |
9 | import java.util.Date;
10 | import java.util.Map;
11 | import java.util.Optional;
12 | import java.util.logging.Level;
13 |
14 | import static org.nanonative.nano.core.model.Context.EVENT_CONFIG_CHANGE;
15 | import static org.nanonative.nano.services.http.HttpServer.EVENT_HTTP_REQUEST;
16 | import static org.nanonative.nano.services.logging.LogService.CONFIG_LOG_LEVEL;
17 |
18 | @Disabled
19 | public class Yuna {
20 |
21 | public static void main(final String[] args) {
22 | final Nano nano = new Nano(new HttpServer());
23 |
24 | final Date myConfigValue = nano.context().asDate("unix-timestamp");
25 | nano.context().info(() -> "Config value converted to date [{}]", myConfigValue);
26 |
27 | nano.subscribeEvent(EVENT_HTTP_REQUEST, event -> event.payloadOpt(HttpObject.class)
28 | .filter(HttpObject::isMethodGet)
29 | .filter(req -> req.pathMatch("/hello"))
30 | .ifPresent(req -> req.corsResponse()
31 | .statusCode(200)
32 | .body(Map.of("Nano", "World"))
33 | .respond(event))
34 | );
35 |
36 | final Context context = nano.context(Yuna.class);
37 | context.info(() -> "Hello World 1");
38 | context.sendEvent(EVENT_CONFIG_CHANGE, () -> Map.of(CONFIG_LOG_LEVEL, Level.OFF));
39 | context.info(() -> "Hello World 2");
40 | nano.stop(context);
41 | //
42 | // // Nano with configuration
43 | // final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, LogLevel.INFO));
44 | //
45 | // // Nano with startup services
46 | // final Nano nano = new Nano(new HttpServer());
47 | //
48 | // // Nano adding "Hello World" API
49 | // final Nano nano = new Nano(new HttpServer())
50 | // .subscribeEvent(EVENT_HTTP_REQUEST, event -> event.payloadOpt(HttpObject.class)
51 | // .filter(HttpObject::isMethodGet)
52 | // .filter(request -> request.pathMatch("/hello"))
53 | // .ifPresent(request -> request.response().body(System.getProperty("user.name")).send(event))
54 | // );
55 |
56 |
57 | //TODO: Dynamic Queues to Services
58 | //TODO: Dynamic Messages to Services
59 | //TODO: support internationalization (logRecord.setResourceBundle(javaLogger.getResourceBundle());, logRecord.setResourceBundleName(javaLogger.getResourceBundleName()))
60 | // final Nano application = new Nano(Map.of(
61 | // CONFIG_LOG_LEVEL, LogLevel.INFO,
62 | // CONFIG_LOG_FORMATTER, "console"
63 | // ), new LogQueue(), new MetricService(), new HttpServer());
64 |
65 |
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/model/EventChannelRegisterTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.model;
2 |
3 | import org.junit.jupiter.api.Test;
4 |
5 | import static org.nanonative.nano.helper.event.EventChannelRegister.*;
6 | import static org.assertj.core.api.Assertions.assertThat;
7 |
8 | class EventChannelRegisterTest {
9 |
10 | @Test
11 | void testChannelChannelIdRegistration() {
12 | final int channelId = registerChannelId(this.getClass().getSimpleName().toUpperCase());
13 | assertThat(isChannelIdAvailable(channelId)).isTrue();
14 | assertThat(eventNameOf(channelId)).isEqualTo(this.getClass().getSimpleName().toUpperCase());
15 |
16 | // duplicated registration should not be possible
17 | final int channelId2 = registerChannelId(this.getClass().getSimpleName().toUpperCase());
18 | assertThat(isChannelIdAvailable(channelId2)).isTrue();
19 | assertThat(channelId).isEqualTo(channelId2);
20 | assertThat(eventNameOf(channelId)).isEqualTo(this.getClass().getSimpleName().toUpperCase());
21 |
22 | // should not find non registered channelIds
23 | assertThat(isChannelIdAvailable(-99)).isFalse();
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/model/TestService.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.model;
2 |
3 | import berlin.yuna.typemap.model.TypeMapI;
4 | import org.nanonative.nano.core.model.Context;
5 | import org.nanonative.nano.core.model.Service;
6 | import org.nanonative.nano.helper.event.EventChannelRegister;
7 | import org.nanonative.nano.helper.event.model.Event;
8 |
9 | import java.util.List;
10 | import java.util.concurrent.CopyOnWriteArrayList;
11 | import java.util.concurrent.atomic.AtomicInteger;
12 | import java.util.concurrent.atomic.AtomicReference;
13 | import java.util.function.Consumer;
14 | import java.util.function.Function;
15 | import java.util.stream.Collectors;
16 |
17 | import static java.lang.System.lineSeparator;
18 | import static java.util.Optional.ofNullable;
19 | import static org.nanonative.nano.core.config.TestConfig.TEST_TIMEOUT;
20 | import static org.nanonative.nano.core.model.Context.EVENT_APP_HEARTBEAT;
21 | import static org.nanonative.nano.helper.NanoUtils.waitForCondition;
22 |
23 | public class TestService extends Service {
24 |
25 | private final AtomicInteger startCount = new AtomicInteger(0);
26 | private final AtomicInteger stopCount = new AtomicInteger(0);
27 | private final List failures = new CopyOnWriteArrayList<>();
28 | private final List events = new CopyOnWriteArrayList<>();
29 | private final AtomicReference> doOnEvent = new AtomicReference<>();
30 | private final AtomicReference> failureConsumer = new AtomicReference<>();
31 | private final AtomicReference> startConsumer = new AtomicReference<>();
32 | private final AtomicReference> stopConsumer = new AtomicReference<>();
33 | private long startTime = System.currentTimeMillis();
34 | public static int TEST_EVENT = EventChannelRegister.registerChannelId("TEST_EVENT");
35 |
36 | public TestService resetEvents() {
37 | events.clear();
38 | return this;
39 | }
40 |
41 | public List events(final int channelId) {
42 | getEvent(channelId);
43 | return events.stream().filter(event -> event.channelId() == channelId).toList();
44 | }
45 |
46 | public Event getEvent(final int channelId) {
47 | return getEvent(channelId, null, 2000);
48 | }
49 |
50 | public Event getEvent(final int channelId, final Function condition) {
51 | return getEvent(channelId, condition, TEST_TIMEOUT);
52 | }
53 |
54 | public Event getEvent(final int channelId, final long timeoutMs) {
55 | return getEvent(channelId, null, timeoutMs);
56 | }
57 |
58 | public Event getEvent(final int channelId, final Function condition, final long timeoutMs) {
59 | final AtomicReference result = new AtomicReference<>();
60 | waitForCondition(
61 | () -> {
62 | final Event event1 = events.stream()
63 | .filter(event -> event.channelId() == channelId)
64 | .filter(event -> condition != null ? condition.apply(event) : true)
65 | .findFirst()
66 | .orElse(null);
67 | if (event1 != null)
68 | result.set(event1);
69 | return event1 != null;
70 | }
71 | , timeoutMs
72 | );
73 | if (result.get() == null)
74 | throw new AssertionError("Event not found"
75 | + " channel [" + EventChannelRegister.eventNameOf(channelId) + "]"
76 | + " events [" + lineSeparator() + events.stream().filter(event -> event.channelId() != EVENT_APP_HEARTBEAT).map(Event::toString).collect(Collectors.joining(lineSeparator())) + lineSeparator() + "]"
77 | );
78 | return result.get();
79 | }
80 |
81 | public int startCount() {
82 | return startCount.get();
83 | }
84 |
85 | public int stopCount() {
86 | return stopCount.get();
87 | }
88 |
89 | public List failures() {
90 | return failures;
91 | }
92 |
93 | public List events() {
94 | return events;
95 | }
96 |
97 | public Consumer doOnEvent() {
98 | return doOnEvent.get();
99 | }
100 |
101 | public TestService doOnEvent(final Consumer onEvent) {
102 | this.doOnEvent.set(onEvent);
103 | return this;
104 | }
105 |
106 | public Consumer doOnFailure() {
107 | return failureConsumer.get();
108 | }
109 |
110 | public TestService doOnFailure(final Consumer onFailure) {
111 | this.failureConsumer.set(onFailure);
112 | return this;
113 | }
114 |
115 | public Consumer doOnStart() {
116 | return startConsumer.get();
117 | }
118 |
119 | public TestService doOnStart(final Consumer onStart) {
120 | this.startConsumer.set(onStart);
121 | return this;
122 | }
123 |
124 | public Consumer doOnStop() {
125 | return stopConsumer.get();
126 | }
127 |
128 | public TestService doOnStop(final Consumer onStop) {
129 | this.stopConsumer.set(onStop);
130 | return this;
131 | }
132 |
133 | public long getStartTime() {
134 | return startTime;
135 | }
136 |
137 | // ########## DEFAULT METHODS ##########
138 | @Override
139 | public void start() {
140 | startTime = System.currentTimeMillis();
141 | startCount.incrementAndGet();
142 | if (startConsumer.get() != null)
143 | startConsumer.get().accept(context);
144 | }
145 |
146 | @Override
147 | public void stop() {
148 | stopCount.incrementAndGet();
149 | if (stopConsumer.get() != null)
150 | stopConsumer.get().accept(context);
151 | }
152 |
153 | @Override
154 | public Object onFailure(final Event error) {
155 | failures.add(error);
156 | ofNullable(failureConsumer.get()).ifPresent(consumer -> consumer.accept(error));
157 | return null;
158 | }
159 |
160 | @Override
161 | public void onEvent(final Event event) {
162 | events.add(event);
163 | ofNullable(doOnEvent.get()).ifPresent(consumer -> consumer.accept(event));
164 | }
165 |
166 | @Override
167 | public void configure(final TypeMapI configs, final TypeMapI merged) {
168 |
169 | }
170 | }
171 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/services/metric/logic/MetricServiceTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.services.metric.logic;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import org.nanonative.nano.core.Nano;
5 | import org.nanonative.nano.services.http.HttpClient;
6 | import org.nanonative.nano.services.http.HttpServer;
7 | import org.nanonative.nano.services.http.model.HttpMethod;
8 | import org.nanonative.nano.services.http.model.HttpObject;
9 |
10 | import java.util.Map;
11 |
12 | import static org.assertj.core.api.Assertions.assertThat;
13 | import static org.nanonative.nano.core.config.TestConfig.TEST_LOG_LEVEL;
14 | import static org.nanonative.nano.services.http.HttpServer.CONFIG_SERVICE_HTTP_CLIENT;
15 | import static org.nanonative.nano.services.logging.LogService.CONFIG_LOG_LEVEL;
16 | import static org.nanonative.nano.services.metric.logic.MetricService.CONFIG_METRIC_SERVICE_BASE_PATH;
17 | import static org.nanonative.nano.services.metric.logic.MetricService.CONFIG_METRIC_SERVICE_PROMETHEUS_PATH;
18 |
19 | class MetricServiceTest {
20 |
21 | protected static String serverUrl = "http://localhost:";
22 |
23 | @Test
24 | void metricEndpointsWithoutBasePath() {
25 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TEST_LOG_LEVEL, CONFIG_SERVICE_HTTP_CLIENT, true), new MetricService(), new HttpServer());
26 |
27 | final HttpObject result = new HttpObject()
28 | .methodType(HttpMethod.GET)
29 | .path(serverUrl + nano.service(HttpServer.class).port() + "/metrics/prometheus")
30 | .send(nano.context(MetricServiceTest.class));
31 |
32 | assertThat(result).isNotNull();
33 | assertThat(result.bodyAsString()).contains("java_version ");
34 | assertThat(nano.stop(MetricServiceTest.class).waitForStop().isReady()).isFalse();
35 | }
36 |
37 | @Test
38 | void metricEndpointsWithCustomBasePath() {
39 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TEST_LOG_LEVEL, CONFIG_METRIC_SERVICE_BASE_PATH, "/custom-metrics"), new MetricService(), new HttpServer(), new HttpClient());
40 |
41 | final HttpObject result = new HttpObject()
42 | .methodType(HttpMethod.GET)
43 | .path(serverUrl + nano.service(HttpServer.class).port() + "/custom-metrics/prometheus")
44 | .send(nano.context(MetricServiceTest.class));
45 |
46 | assertThat(result).isNotNull();
47 | assertThat(result.bodyAsString()).contains("java_version ");
48 | assertThat(nano.stop(MetricServiceTest.class).waitForStop().isReady()).isFalse();
49 | }
50 |
51 |
52 | @Test
53 | void metricEndpointsWithPrometheus() {
54 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TEST_LOG_LEVEL, CONFIG_METRIC_SERVICE_PROMETHEUS_PATH, "/prometheus"), new MetricService(), new HttpServer(), new HttpClient());
55 |
56 | final HttpObject result = new HttpObject()
57 | .methodType(HttpMethod.GET)
58 | .path(serverUrl + nano.service(HttpServer.class).port() + "/prometheus")
59 | .send(nano.context(MetricServiceTest.class));
60 |
61 | assertThat(result).isNotNull();
62 | assertThat(result.statusCode()).isEqualTo(200);
63 | assertThat(nano.stop(MetricServiceTest.class).waitForStop().isReady()).isFalse();
64 | }
65 |
66 | @Test
67 | void metricEndpointsWithBasePath() {
68 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TEST_LOG_LEVEL, CONFIG_METRIC_SERVICE_BASE_PATH, "/stats"), new MetricService(), new HttpServer(), new HttpClient());
69 |
70 | final HttpObject result = new HttpObject()
71 | .methodType(HttpMethod.GET)
72 | .path(serverUrl + nano.service(HttpServer.class).port() + "/stats/prometheus")
73 | .send(nano.context(MetricServiceTest.class));
74 |
75 | assertThat(result).isNotNull();
76 | assertThat(result.statusCode()).isEqualTo(200);
77 | assertThat(nano.stop(MetricServiceTest.class).waitForStop().isReady()).isFalse();
78 |
79 | }
80 |
81 | @Test
82 | void withoutMetricService() {
83 | final Nano nano = new Nano(Map.of(CONFIG_LOG_LEVEL, TEST_LOG_LEVEL), new HttpServer(), new HttpClient());
84 |
85 | final HttpObject result = new HttpObject()
86 | .methodType(HttpMethod.GET)
87 | .path(serverUrl + nano.service(HttpServer.class).port() + "/metrics/prometheus")
88 | .send(nano.context(MetricServiceTest.class));
89 |
90 | assertThat(result).isNotNull();
91 | assertThat(result.statusCode()).isEqualTo(404);
92 | assertThat(nano.stop(MetricServiceTest.class).waitForStop().isReady()).isFalse();
93 |
94 | }
95 | }
96 |
--------------------------------------------------------------------------------
/src/test/java/org/nanonative/nano/services/metric/model/MetricCacheTest.java:
--------------------------------------------------------------------------------
1 | package org.nanonative.nano.services.metric.model;
2 |
3 | import org.junit.jupiter.api.RepeatedTest;
4 | import org.junit.jupiter.api.parallel.Execution;
5 | import org.junit.jupiter.api.parallel.ExecutionMode;
6 |
7 | import java.util.Map;
8 |
9 | import static org.nanonative.nano.core.config.TestConfig.TEST_REPEAT;
10 | import static org.assertj.core.api.Assertions.assertThat;
11 |
12 | @Execution(ExecutionMode.CONCURRENT)
13 | class MetricCacheTest {
14 |
15 |
16 | @RepeatedTest(TEST_REPEAT)
17 | void generateMetricFormats() throws InterruptedException {
18 | final MetricCache metricCache = new MetricCache()
19 | .counterIncrement("my_counter")
20 | .counterIncrement("my/counter")
21 | .gaugeSet("my_gauge", 100)
22 | .gaugeSet("my$gauge", 9.99)
23 | .timerStart("my^timer");
24 | Thread.sleep(15);
25 | metricCache.timerStop("my#timer");
26 |
27 | assertThat(metricCache.counters()).hasSize(1);
28 | assertThat(metricCache.gauges()).hasSize(1);
29 | assertThat(metricCache.timers()).hasSize(1);
30 |
31 | final long timer = metricCache.timer("my%timer");
32 | assertThat(metricCache.counter("my%counter")).isEqualTo(2);
33 | assertThat(metricCache.gauge("my%gauge")).isEqualTo(9.99);
34 | assertThat(timer).isBetween(15L, 60L);
35 | assertThat(metricCache.prometheus()).isEqualTo("my_counter 2\nmy_gauge 9.99\nmy_timer " + timer + "\n");
36 | assertThat(metricCache.influx()).isEqualTo("my.counter value=2\nmy.gauge value=9.99\nmy.timer value=" + timer + "\n");
37 | assertThat(metricCache.dynatrace()).isEqualTo("my.counter, 2\nmy.gauge, 9.99\nmy.timer, " + timer + "\n");
38 | assertThat(metricCache.wavefront()).isEqualTo("my.counter 2 source=nano \nmy.gauge 9.99 source=nano \nmy.timer " + timer + " source=nano \n");
39 | assertThat(metricCache).hasToString(MetricCache.class.getSimpleName() + "{counters=1, gauges=1, timers=1}");
40 | }
41 |
42 | @RepeatedTest(TEST_REPEAT)
43 | void generateMetricFormatsWithTags() throws InterruptedException {
44 | final Map tags = Map.of("aa", "bb", "cc", "dd");
45 | final MetricCache metricCache = new MetricCache()
46 | .counterIncrement("my_counter", tags)
47 | .counterIncrement("my/counter", tags)
48 | .gaugeSet("my_gauge", 100, tags)
49 | .gaugeSet("my$gauge", 9.99, tags)
50 | .timerStart("my^timer", tags);
51 | Thread.sleep(15);
52 | metricCache.timerStop("my#timer", tags);
53 |
54 | assertThat(metricCache.counters()).hasSize(1);
55 | assertThat(metricCache.gauges()).hasSize(1);
56 | assertThat(metricCache.timers()).hasSize(1);
57 |
58 | final long timer = metricCache.timer("my%timer", tags);
59 | assertThat(timer).isBetween(15L, 60L);
60 | assertThat(metricCache.counter("my%counter", tags)).isEqualTo(2);
61 | assertThat(metricCache.gauge("my%gauge", tags)).isEqualTo(9.99);
62 | assertThat(metricCache.prometheus()).isEqualTo("my_counter{aa=\"bb\",cc=\"dd\"} 2\nmy_gauge{aa=\"bb\",cc=\"dd\"} 9.99\nmy_timer{aa=\"bb\",cc=\"dd\"} " + timer + "\n");
63 | assertThat(metricCache.influx()).isEqualTo("my.counter,aa=bb,cc=dd value=2\nmy.gauge,aa=bb,cc=dd value=9.99\nmy.timer,aa=bb,cc=dd value=" + timer + "\n");
64 | assertThat(metricCache.dynatrace()).isEqualTo("my.counter,aa=bb,cc=dd 2\nmy.gauge,aa=bb,cc=dd 9.99\nmy.timer,aa=bb,cc=dd " + timer + "\n");
65 | assertThat(metricCache.wavefront()).isEqualTo("my.counter 2 source=nano aa=bb cc=dd\nmy.gauge 9.99 source=nano aa=bb cc=dd\nmy.timer " + timer + " source=nano aa=bb cc=dd\n");
66 | assertThat(metricCache).hasToString(MetricCache.class.getSimpleName() + "{counters=1, gauges=1, timers=1}");
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/src/test/resources/Nano.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoNative/nano/7888a9a36ecb671c11426816db1531030899895d/src/test/resources/Nano.png
--------------------------------------------------------------------------------
/src/test/resources/application-local.properties:
--------------------------------------------------------------------------------
1 | app.profiles=default, local, dev, prod
2 | resource.key2=CC
3 |
--------------------------------------------------------------------------------
/src/test/resources/application.properties:
--------------------------------------------------------------------------------
1 | resource.key1=AA
2 | resource.key2=BB
3 | app.profile=local
4 | test.placeholder.fallback=${invalid_key:fallback should be used 1}
5 | test.placeholder.fallback.empty=${invalid_key:}
6 | test.placeholder.value=${placeholder_value:fallback should not be used}
7 | test.placeholder.key_empty=${:fallback should be used 2}
8 | placeholder_value=used placeholder value
9 |
--------------------------------------------------------------------------------
/src/test/resources/junit-platform.properties:
--------------------------------------------------------------------------------
1 | junit.jupiter.execution.parallel.enabled = true
2 | junit.jupiter.execution.parallel.mode.default=concurrent
3 | junit.jupiter.execution.parallel.mode.classes.default=concurrent
4 |
--------------------------------------------------------------------------------
/src/test/resources/tiny_java.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NanoNative/nano/7888a9a36ecb671c11426816db1531030899895d/src/test/resources/tiny_java.png
--------------------------------------------------------------------------------