Skip to content

Commit

Permalink
Add test for skip functionality
Browse files Browse the repository at this point in the history
  • Loading branch information
@msavy
msavy committed Aug 17, 2015
1 parent 2c20a0d commit b28977a
Showing 1 changed file with 97 additions and 51 deletions.
148 changes: 97 additions & 51 deletions gateway/engine/core/src/test/java/io/apiman/gateway/engine/impl/PolicyChainTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,30 +18,35 @@
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import java.util.ArrayList;
import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;

import io.apiman.gateway.engine.async.IAsyncHandler;
import io.apiman.gateway.engine.beans.PolicyFailure;
import io.apiman.gateway.engine.beans.ServiceRequest;
import io.apiman.gateway.engine.beans.ServiceResponse;
import io.apiman.gateway.engine.beans.exceptions.ConfigurationParseException;
import io.apiman.gateway.engine.io.IApimanBuffer;
import io.apiman.gateway.engine.policy.IPolicy;
import io.apiman.gateway.engine.policy.IPolicyChain;
import io.apiman.gateway.engine.policy.IPolicyContext;
import io.apiman.gateway.engine.policy.PolicyWithConfiguration;
import io.apiman.gateway.engine.policy.RequestChain;
import io.apiman.gateway.engine.policy.ResponseChain;
import io.apiman.gateway.engine.util.PassthroughPolicy;

import java.util.ArrayList;
import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;

/**
* Test {@link RequestChain} and {@link ResponseChain} functionality.
*
*
* @author Marc Savy <msavy@redhat.com>
*/
@SuppressWarnings({ "nls" })
Expand All @@ -52,7 +57,7 @@ public class PolicyChainTest {

private ServiceRequest mockRequest;
private ServiceResponse mockResponse;

private IApimanBuffer mockBuffer;
private IAsyncHandler<IApimanBuffer> mockBodyHandler;
private IAsyncHandler<Void> mockEndHandler;
Expand All @@ -64,152 +69,193 @@ public class PolicyChainTest {
private List<PolicyWithConfiguration> policies;

@Before
public void setup() {
public void setup() {
policies = new ArrayList<>();
policyOne = spy(new PassthroughPolicy("1"));
policyTwo = spy(new PassthroughPolicy("2"));
pwcOne = new PolicyWithConfiguration(policyOne, new Object());
pwcTwo = new PolicyWithConfiguration(policyTwo, new Object());

//mockChain = mock(IPolicyChain.class);
mockContext = mock(IPolicyContext.class);

mockRequest = mock(ServiceRequest.class);
given(mockRequest.getApiKey()).willReturn("bacon");
given(mockRequest.getDestination()).willReturn("mars");
given(mockRequest.getType()).willReturn("request");

mockResponse = mock(ServiceResponse.class);
given(mockRequest.getApiKey()).willReturn("bacon");
given(mockRequest.getDestination()).willReturn("mars");
given(mockRequest.getType()).willReturn("response");

mockBuffer = mock(IApimanBuffer.class);
given(mockBuffer.toString()).willReturn("bananas");
mockBodyHandler = (IAsyncHandler<IApimanBuffer>) mock(IAsyncHandler.class);
mockEndHandler = (IAsyncHandler<Void>) mock(IAsyncHandler.class);
given(mockBuffer.toString()).willReturn("bananas");

mockBodyHandler = mock(IAsyncHandler.class);
mockEndHandler = mock(IAsyncHandler.class);
}

@Test
public void shouldExecuteRequestChainTwice() {
policies.add(pwcOne);
policies.add(pwcTwo);

requestChain = new RequestChain(policies, mockContext);

requestChain.bodyHandler(mockBodyHandler);
requestChain.endHandler(mockEndHandler);

requestChain.doApply(mockRequest);
requestChain.write(mockBuffer);
requestChain.write(mockBuffer);
requestChain.end();

verify(mockBodyHandler, times(2)).handle(mockBuffer);
verify(mockEndHandler, times(1)).handle((Void) null);

InOrder order = inOrder(policyOne, policyTwo);
order.verify(policyOne).apply(mockRequest, mockContext, pwcOne.getConfiguration(), requestChain);
order.verify(policyTwo).apply(mockRequest, mockContext, pwcTwo.getConfiguration(), requestChain);
}

@Test
public void shouldExecuteResponseChainTwice() {
policies.add(pwcOne);
policies.add(pwcTwo);

responseChain = new ResponseChain(policies, mockContext);

responseChain.bodyHandler(mockBodyHandler);
responseChain.endHandler(mockEndHandler);

responseChain.doApply(mockResponse);
responseChain.write(mockBuffer);
responseChain.write(mockBuffer);
responseChain.end();

verify(mockBodyHandler, times(2)).handle(mockBuffer);
verify(mockEndHandler, times(1)).handle((Void) null);
verify(mockEndHandler, times(1)).handle((Void) null);

InOrder order = inOrder(policyTwo, policyOne);
order.verify(policyTwo).apply(mockResponse, mockContext, pwcTwo.getConfiguration(), responseChain);
order.verify(policyOne).apply(mockResponse, mockContext, pwcOne.getConfiguration(), responseChain);
}

@Test
public void shouldExecuteWithoutHandlers() {
policies.add(pwcOne);
requestChain = new RequestChain(policies, mockContext);
requestChain.doApply(mockRequest);
requestChain.end();
}

@Test
public void shouldPreserveBufferOrder() {
policies.add(pwcOne);
requestChain = new RequestChain(policies, mockContext);
requestChain.bodyHandler(mockBodyHandler);
requestChain.endHandler(mockEndHandler);

requestChain.doApply(mockRequest);
IApimanBuffer buffer1 = (IApimanBuffer) mock(IApimanBuffer.class);
IApimanBuffer buffer2 = (IApimanBuffer) mock(IApimanBuffer.class);
IApimanBuffer buffer3 = (IApimanBuffer) mock(IApimanBuffer.class);

IApimanBuffer buffer1 = mock(IApimanBuffer.class);
IApimanBuffer buffer2 = mock(IApimanBuffer.class);
IApimanBuffer buffer3 = mock(IApimanBuffer.class);

requestChain.write(buffer1);
requestChain.write(buffer2);
requestChain.write(buffer3);

requestChain.end();

InOrder order = inOrder(mockBodyHandler, mockEndHandler);
order.verify(mockBodyHandler).handle(buffer1);
order.verify(mockBodyHandler).handle(buffer2);
order.verify(mockBodyHandler).handle(buffer3);
order.verify(mockEndHandler).handle((Void) null);
}

@Test
public void shouldCallFailureHandlerOnDoFail() {
policies.add(pwcOne);
policies.add(pwcTwo);

requestChain = new RequestChain(policies, mockContext);

IAsyncHandler<PolicyFailure> mPolicyFailureHandler = mock(IAsyncHandler.class);

PolicyFailure mPolicyFailure = mock(PolicyFailure.class);

requestChain.policyFailureHandler(mPolicyFailureHandler);
requestChain.bodyHandler(mockBodyHandler);
requestChain.endHandler(mockEndHandler);

requestChain.doApply(mockRequest);
requestChain.doFailure(mPolicyFailure);

verify(mPolicyFailureHandler).handle(mPolicyFailure);
}

@Test
public void shouldCallErrorHandlerOnThrowError() {
policies.add(pwcOne);
policies.add(pwcTwo);

requestChain = new RequestChain(policies, mockContext);

IAsyncHandler<Throwable> mThrowableFailureHandler = mock(IAsyncHandler.class);

Throwable mThrowable = mock(Throwable.class);

requestChain.policyErrorHandler(mThrowableFailureHandler);
requestChain.bodyHandler(mockBodyHandler);
requestChain.endHandler(mockEndHandler);

requestChain.doApply(mockRequest);
requestChain.throwError(mThrowable);

verify(mThrowableFailureHandler).handle(mThrowable);
}

@Test
public void shouldEndChainImmediatelyWhenSkipCalled() {
IPolicy skipPolicy = spy(new IPolicy() {

@Override
public Object parseConfiguration(String jsonConfiguration) throws ConfigurationParseException {
return null;
}

@Override
public void apply(ServiceRequest request, IPolicyContext context, Object config,
IPolicyChain<ServiceRequest> chain) {
chain.doSkip(request);
}

@Override
public void apply(ServiceResponse response, IPolicyContext context, Object config,
IPolicyChain<ServiceResponse> chain) {
chain.doSkip(response);
}
});

PolicyWithConfiguration pwcSkip = new PolicyWithConfiguration(skipPolicy, null);
policies.add(pwcSkip);
policies.add(pwcTwo);

requestChain = new RequestChain(policies, mockContext);

requestChain.bodyHandler(mockBodyHandler);
requestChain.endHandler(mockEndHandler);

requestChain.doApply(mockRequest);
requestChain.end();

verify(mockEndHandler, times(1)).handle((Void) null);

// Should only be called once, as the second is skipped
verify(skipPolicy, times(1)).apply(mockRequest, mockContext, null, requestChain);
verify(policyOne, never()).apply(mockRequest, mockContext, null, requestChain);
}
}

0 comments on commit b28977a

Please sign in to comment.