From 9cb3eb42cb8482e2f8e48e1bc12ed0c1dc8ea59d Mon Sep 17 00:00:00 2001 From: linwaiwai Date: Tue, 12 Jan 2021 18:59:34 +0800 Subject: [PATCH] add dubbo input unit test. --- pom.xml | 20 +++-- src/main/java/we/fizz/Step.java | 4 + src/main/java/we/fizz/input/InputConfig.java | 2 +- .../input/extension/dubbo/DubboInput.java | 14 ++- .../java/we/fizz/input/DubboInputTests.java | 87 +++++++++++++++++++ .../dubbo/ApacheDubboGenericProxyTests.java | 55 ++++++++++++ 6 files changed, 173 insertions(+), 9 deletions(-) create mode 100644 src/test/java/we/fizz/input/DubboInputTests.java create mode 100644 src/test/java/we/fizz/input/proxy/dubbo/ApacheDubboGenericProxyTests.java diff --git a/pom.xml b/pom.xml index 9398ef2..56e131f 100644 --- a/pom.xml +++ b/pom.xml @@ -222,10 +222,14 @@ org.mockito mockito-core + ${mockito.version} + test org.mockito mockito-inline + ${mockito.version} + test @@ -233,12 +237,18 @@ dubbo ${apache.dubbo.version} + + junit + junit + ${junit.version} + test + - + diff --git a/src/main/java/we/fizz/Step.java b/src/main/java/we/fizz/Step.java index 55bd5e1..06ad674 100644 --- a/src/main/java/we/fizz/Step.java +++ b/src/main/java/we/fizz/Step.java @@ -69,6 +69,10 @@ public class Step { return this.getWeakPipeline() != null ? this.getWeakPipeline().get().getApplicationContext(): null; } + public ConfigurableApplicationContext getCurrentApplicationContext() { + return this.getWeakPipeline() != null ? this.getWeakPipeline().get().getApplicationContext(): null; + } + public static class Builder { public Step read(Map config, SoftReference weakPipeline) { Step step = new Step(); diff --git a/src/main/java/we/fizz/input/InputConfig.java b/src/main/java/we/fizz/input/InputConfig.java index 60eee68..5df57fb 100644 --- a/src/main/java/we/fizz/input/InputConfig.java +++ b/src/main/java/we/fizz/input/InputConfig.java @@ -59,7 +59,7 @@ public class InputConfig { public void setFallback(Map fallback) { this.fallback = fallback; } - + public void parse(){ } diff --git a/src/main/java/we/fizz/input/extension/dubbo/DubboInput.java b/src/main/java/we/fizz/input/extension/dubbo/DubboInput.java index c295e57..fb0b491 100644 --- a/src/main/java/we/fizz/input/extension/dubbo/DubboInput.java +++ b/src/main/java/we/fizz/input/extension/dubbo/DubboInput.java @@ -35,10 +35,18 @@ public class DubboInput extends RPCInput { declaration.setMethod(config.getMethod()); declaration.setParameterTypes(config.getParameterTypes()); declaration.setTimeout(timeout); + HashMap contextAttachment = null; + if (attachments == null){ + contextAttachment = new HashMap(); + } else { + contextAttachment = new HashMap(attachments); + } + if (inputContext.getStepContext() != null && inputContext.getStepContext().getTraceId() != null){ + contextAttachment.put(CommonConstants.HEADER_TRACE_ID, inputContext.getStepContext().getTraceId()); + } - HashMap contextAttachment = new HashMap(attachments); - contextAttachment.put(CommonConstants.HEADER_TRACE_ID, inputContext.getStepContext().getTraceId()); - return proxy.send(body, declaration, contextAttachment).flatMap(cr->{ + Mono proxyResponse = proxy.send(body, declaration, contextAttachment); + return proxyResponse.flatMap(cr->{ DubboRPCResponse response = new DubboRPCResponse(); String responseStr = JSON.toJSONString(cr); response.setBodyMono(Mono.just(responseStr)); diff --git a/src/test/java/we/fizz/input/DubboInputTests.java b/src/test/java/we/fizz/input/DubboInputTests.java new file mode 100644 index 0000000..c555417 --- /dev/null +++ b/src/test/java/we/fizz/input/DubboInputTests.java @@ -0,0 +1,87 @@ +package we.fizz.input; + +import org.apache.dubbo.config.ReferenceConfig; +import org.apache.dubbo.rpc.service.GenericService; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.context.ConfigurableApplicationContext; +import reactor.core.publisher.Mono; +import we.fizz.Step; +import we.fizz.StepContext; +import we.fizz.StepResponse; +import we.fizz.input.extension.dubbo.DubboInput; +import we.fizz.input.extension.dubbo.DubboInputConfig; +import we.fizz.input.proxy.dubbo.ApacheDubboGenericProxyTests; +import we.proxy.dubbo.ApacheDubboGenericProxy; +import we.proxy.dubbo.DubboInterfaceDeclaration; + +import java.lang.ref.SoftReference; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@RunWith(MockitoJUnitRunner.class) +public class DubboInputTests { + private static final String SERVICE_NAME = "com.fizzgate.test"; + private static final String METHOD_NAME = "method"; + private static final String[] LEFT = new String[]{}; + + private static final Object[] RIGHT = new Object[]{}; + + private ApacheDubboGenericProxy proxy; +// @Before +// public void setup(){ +// ApacheDubboGenericProxyTests test = new ApacheDubboGenericProxyTests(); +// proxy = test.getMockApachDubbo(); +// } + + @Test + public void test() { + DubboInterfaceDeclaration declaration = mock(DubboInterfaceDeclaration.class); + declaration.setServiceName(SERVICE_NAME); + declaration.setMethod(METHOD_NAME); + declaration.setParameterTypes("java.lang.String, java.lang.String"); + declaration.setTimeout(3000); + + ReferenceConfig referenceConfig = mock(ReferenceConfig.class); + GenericService genericService = mock(GenericService.class); + when(referenceConfig.get()).thenReturn(genericService); + when(referenceConfig.getInterface()).thenReturn(SERVICE_NAME); + CompletableFuture future = new CompletableFuture<>(); + when(genericService.$invokeAsync(any(), any(), any())).thenReturn(future); + ApacheDubboGenericProxy apacheDubboProxyService = new ApacheDubboGenericProxy(); + ApacheDubboGenericProxy proxy = spy(apacheDubboProxyService); + when(proxy.createReferenceConfig(SERVICE_NAME)).thenReturn(referenceConfig); + + ConfigurableApplicationContext applicationContext = mock(ConfigurableApplicationContext.class); + when(applicationContext.getBean(ApacheDubboGenericProxy.class)).thenReturn(proxy); + + Step step = mock(Step.class); + when(step.getCurrentApplicationContext()).thenReturn(applicationContext); + + StepResponse stepResponse = new StepResponse(step, null, new HashMap>()); + DubboInputConfig config = mock(DubboInputConfig.class); + when(config.getServiceName()).thenReturn(SERVICE_NAME); + InputFactory.registerInput(InputType.DUBBO, DubboInput.class); + DubboInput dubboInput = (DubboInput)InputFactory.createInput(InputType.DUBBO.toString()); + + dubboInput.setName("hello"); + dubboInput.setWeakStep(new SoftReference<>(step)); + dubboInput.setStepResponse(stepResponse); + dubboInput.setConfig(config); + StepContext stepContext = mock(StepContext.class); + stepContext.put("step1", stepResponse); + InputContext context = new InputContext(stepContext, null); + dubboInput.beforeRun(context); + + dubboInput.run(); + + future.complete("success"); + + } +} diff --git a/src/test/java/we/fizz/input/proxy/dubbo/ApacheDubboGenericProxyTests.java b/src/test/java/we/fizz/input/proxy/dubbo/ApacheDubboGenericProxyTests.java new file mode 100644 index 0000000..ef346a1 --- /dev/null +++ b/src/test/java/we/fizz/input/proxy/dubbo/ApacheDubboGenericProxyTests.java @@ -0,0 +1,55 @@ +package we.fizz.input.proxy.dubbo; + +import org.apache.dubbo.config.ReferenceConfig; +import org.apache.dubbo.rpc.service.GenericService; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; +import we.proxy.dubbo.ApacheDubboGenericProxy; +import we.proxy.dubbo.DubboInterfaceDeclaration; + +import java.util.HashMap; +import java.util.concurrent.CompletableFuture; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +@RunWith(MockitoJUnitRunner.class) +public class ApacheDubboGenericProxyTests { + private static final String SERVICE_NAME = "com.fizzgate.test"; + private static final String METHOD_NAME = "method"; + private static final String[] LEFT = new String[]{}; + + private static final Object[] RIGHT = new Object[]{}; + @Before + public void setup(){ + + } + + public ApacheDubboGenericProxy getMockApachDubbo(){ + ReferenceConfig referenceConfig = mock(ReferenceConfig.class); + GenericService genericService = mock(GenericService.class); + when(referenceConfig.get()).thenReturn(genericService); + when(referenceConfig.getInterface()).thenReturn(SERVICE_NAME); + ApacheDubboGenericProxy apacheDubboProxyService = mock(ApacheDubboGenericProxy.class); + when(apacheDubboProxyService.createReferenceConfig(SERVICE_NAME)).thenReturn(referenceConfig); + CompletableFuture future = new CompletableFuture<>(); + when(genericService.$invokeAsync(METHOD_NAME, LEFT, RIGHT)).thenReturn(future); + future.complete("success"); + return apacheDubboProxyService; + } + @Test + public void test() { + HashMap attachments = mock(HashMap.class); + DubboInterfaceDeclaration declaration = mock(DubboInterfaceDeclaration.class); + declaration.setServiceName(SERVICE_NAME); + declaration.setMethod(METHOD_NAME); + declaration.setParameterTypes("java.lang.String, java.lang.String"); + declaration.setTimeout(3000); + ApacheDubboGenericProxyTests test = new ApacheDubboGenericProxyTests(); + ApacheDubboGenericProxy apacheDubboProxyService = test.getMockApachDubbo(); + apacheDubboProxyService.send("", declaration, attachments); + } + +}