@Test public void shouldUseDifferentBucketsWhenUsingValidPartitionKey() throws Exception { FakeTimeService time = new FakeTimeService(0); Expression<String> expr = Expression.valueOf("${matches(exchange.foo, 'bar-00') ?'bucket-00' :''}", String.class); ThrottlingFilter filter = new ThrottlingFilter(time, 1, duration("3 seconds"), expr); Handler handler = new ResponseHandler(Status.OK); // The time does not need to advance Exchange exchange = new Exchange(); Promise<Response, NeverThrowsException> promise; exchange.put("foo", "bar-00"); promise = filter.filter(exchange, new Request(), handler); assertThat(promise.get().getStatus()).isEqualTo(Status.OK); exchange.put("foo", "bar-00"); promise = filter.filter(exchange, new Request(), handler); assertThat(promise.get().getStatus()).isEqualTo(Status.TOO_MANY_REQUESTS); exchange.put("foo", "bar-01"); promise = filter.filter(exchange, new Request(), handler); assertThat(promise.get().getStatus()).isEqualTo(Status.OK); }
@Test public void shouldThrottleRequests() throws Exception { FakeTimeService time = new FakeTimeService(0); ThrottlingFilter filter = new ThrottlingFilter(time, 1, duration("3 seconds"), DEFAULT_PARTITION_EXPR); // This one has to call the handler as there are enough tokens in the bucket. Handler handler1 = mock(Handler.class, "handler1"); filter.filter(mock(Context.class), new Request(), handler1); verify(handler1).handle(any(Context.class), any(Request.class)); time.advance(duration("2 seconds")); // This one does not have to be called as there is no token anymore in the bucket. Handler handler2 = mock(Handler.class, "handler2"); Promise<Response, NeverThrowsException> promise2 = filter.filter(mock(Context.class), new Request(), handler2); verifyZeroInteractions(handler2); assertThat(promise2.get().getStatus()).isEqualTo(Status.TOO_MANY_REQUESTS); time.advance(duration("4 seconds")); // This one has to call the handler as the bucket has been refilled. Handler handler3 = mock(Handler.class, "handler3"); filter.filter(mock(Context.class), new Request(), handler3); verify(handler3).handle(any(Context.class), any(Request.class)); }
@Test(description = "OPENDJ-1197") public void testClientSideConnectTimeout() throws Exception { // Use an non-local unreachable network address. final ConnectionFactory factory = new LDAPConnectionFactory( "10.20.30.40", 1389, new LDAPOptions().setConnectTimeout(1, TimeUnit.MILLISECONDS)); try { for (int i = 0; i < ITERATIONS; i++) { final PromiseImpl<LdapException, NeverThrowsException> promise = PromiseImpl.create(); final Promise<? extends Connection, LdapException> connectionPromise = factory.getConnectionAsync(); connectionPromise.onFailure(getFailureHandler(promise)); ConnectionException e = (ConnectionException) promise.getOrThrow(TEST_TIMEOUT, TimeUnit.SECONDS); assertThat(e.getResult().getResultCode()).isEqualTo(ResultCode.CLIENT_SIDE_CONNECT_ERROR); // Wait for the connect to timeout. try { connectionPromise.getOrThrow(TEST_TIMEOUT, TimeUnit.SECONDS); fail("The connect request succeeded unexpectedly"); } catch (ConnectionException ce) { assertThat(ce.getResult().getResultCode()) .isEqualTo(ResultCode.CLIENT_SIDE_CONNECT_ERROR); } } } finally { factory.close(); } }
@Test public void testReadSchedule() throws Exception { // given final ReadRequest readRequest = Requests.newReadRequest("test1"); // when Promise<ResourceResponse, ResourceException> promise = schedulerService.handleRead(new RootContext(), readRequest); // then AssertJPromiseAssert.assertThat(promise).isNotNull().succeeded(); ResourceResponse resourceResponse = promise.getOrThrow(); assertThat(resourceResponse.getContent().asMap()).isEqualTo(testScheduleConfig.asMap()); }
@Test public void shouldUseDefaultValueWithExpressionEvaluatingNull() throws Exception { FakeTimeService time = new FakeTimeService(0); Expression<String> expr = Expression.valueOf("${exchange.bar}", String.class); ThrottlingFilter filter = new ThrottlingFilter(time, 1, duration("3 seconds"), expr); Handler handler = new ResponseHandler(Status.OK); // The time does not need to advance Exchange exchange = new Exchange(); Promise<Response, NeverThrowsException> promise; promise = filter.filter(exchange, new Request(), handler); assertThat(promise.get().getStatus()).isEqualTo(Status.INTERNAL_SERVER_ERROR); }
@Test public void testListCurrentlyExecutingJobsAction() throws Exception { // given final ActionRequest readRequest = Requests.newActionRequest("", SchedulerAction.listCurrentlyExecutingJobs.toString()); // when Promise<ActionResponse, ResourceException> promise = schedulerService.handleAction(new RootContext(), readRequest); // then AssertJPromiseAssert.assertThat(promise).isNotNull().succeeded(); ActionResponse resourceResponse = promise.getOrThrow(); assertThat(resourceResponse.getJsonContent().asList().size()).isEqualTo(0); }
@Test public void testResumeJobsAction() throws Exception { // given final ActionRequest readRequest = Requests.newActionRequest("", SchedulerAction.resumeJobs.toString()); // when Promise<ActionResponse, ResourceException> promise = schedulerService.handleAction(new RootContext(), readRequest); // then AssertJPromiseAssert.assertThat(promise).isNotNull().succeeded(); ActionResponse resourceResponse = promise.getOrThrow(); assertThat(resourceResponse.getJsonContent().get("success").getObject()) .isEqualTo(new Boolean(true)); }
@Test public void shouldThrottleConcurrentRequests() throws Exception { CountDownLatch latch1 = new CountDownLatch(1); CountDownLatch latch2 = new CountDownLatch(1); FakeTimeService time = new FakeTimeService(0); final ThrottlingFilter filter = new ThrottlingFilter(time, 1, duration("3 seconds"), DEFAULT_PARTITION_EXPR); // This one has to be called as there are enough tokens in the bucket. final Handler handler1 = new LatchHandler(latch1, latch2); Runnable r = new Runnable() { @Override public void run() { filter.filter(mock(Context.class), new Request(), handler1); } }; Thread t1 = new Thread(r); t1.setName("Filter for request #1"); t1.start(); latch2.await(); time.advance(duration("2 seconds")); try { // This one does not have to be called as there no token anymore in the bucket. Handler handler2 = mock(Handler.class, "handler2"); Promise<Response, NeverThrowsException> promise2 = filter.filter(mock(Context.class), new Request(), handler2); verifyZeroInteractions(handler2); Response response = promise2.get(20, TimeUnit.SECONDS); assertThat(response.getStatus()).isEqualTo(Status.TOO_MANY_REQUESTS); assertThat(response.getHeaders().getFirst("Retry-After")).isEqualTo("1"); } finally { latch1.countDown(); t1.join(); } }
@Test(dataProvider = "annotatedRequestHandlerData") public void testQueryCollectionAnnotatedRequestHandler( Class<?> requestHandler, boolean collection, boolean create, boolean read, boolean update, boolean delete, boolean patch, boolean resourceAction, boolean collectionAction, boolean query) throws Exception { // Given Object provider = requestHandler.newInstance(); Connection connection = Resources.newInternalConnection(createHandler(collection, provider)); QueryRequest req = Requests.newQueryRequest("/test"); // When Promise<QueryResult, ResourceException> promise = connection.queryAsync(new RootContext(), req, mock(QueryResourceHandler.class)); // Then if (query && collection) { AssertJPromiseAssert.assertThat(promise).succeeded(); QueryResult result = promise.get(); Assertions.assertThat(result.getPagedResultsCookie()).isEqualTo("query"); } else if (collection) { AssertJPromiseAssert.assertThat(promise) .failedWithException() .isInstanceOf(NotSupportedException.class); } else { AssertJPromiseAssert.assertThat(promise) .failedWithException() .isInstanceOf(BadRequestException.class); } }
protected static void assertQueryPromiseFailedWithCodes( Promise<QueryResponse, ResourceException> promise, int resourceErrorCode, int entitlementErrorCode) { try { promise.getOrThrowUninterruptibly(); fail("Should throw ResourceException"); } catch (ResourceException e) { Assertions.assertThat(e.getCode()).isEqualTo(resourceErrorCode); Assertions.assertThat(e.getCause()).isInstanceOf(EntitlementException.class); Assertions.assertThat(((EntitlementException) e.getCause()).getErrorCode()) .isEqualTo(entitlementErrorCode); } }
@Test public void crestQueryIsAllowed() throws SSOException, DelegationException, ResourceException { // Given... final Set<String> actions = new HashSet<>(Arrays.asList("READ")); final DelegationPermission permission = new DelegationPermission( "/abc", "rest", "1.0", "policies", "read", actions, EXTENSIONS, DUMB_FUNC); given(factory.newInstance("/abc", "rest", "1.0", "policies", "read", actions, EXTENSIONS)) .willReturn(permission); given(subjectContext.getCallerSSOToken()).willReturn(token); given(evaluator.isAllowed(eq(token), eq(permission), eq(ENVIRONMENT))).willReturn(true); QueryResourceHandler handler = mock(QueryResourceHandler.class); Promise<QueryResponse, ResourceException> promise = Promises.newResultPromise(Responses.newQueryResponse("abc-def")); given( provider.queryCollection( isA(Context.class), isA(QueryRequest.class), isA(QueryResourceHandler.class))) .willReturn(promise); // When... final FilterChain chain = AuthorizationFilters.createAuthorizationFilter(provider, module); final Router router = new Router(); router.addRoute(RoutingMode.STARTS_WITH, Router.uriTemplate("/policies"), chain); final RealmContext context = new RealmContext(subjectContext); context.setSubRealm("abc", "abc"); final QueryRequest request = Requests.newQueryRequest("/policies"); Promise<QueryResponse, ResourceException> result = router.handleQuery(context, request, handler); // Then... QueryResponse response = result.getOrThrowUninterruptibly(); assertThat(response.getPagedResultsCookie()).isEqualTo("abc-def"); }
private <T extends Response> Promise<T, ResourceException> auditResponse( Promise<T, ResourceException> promise, final AuditingResultHandler auditingHandler) { return promise .thenOnResult( new ResultHandler<Response>() { @Override public void handleResult(Response response) { auditingHandler.auditAccessSuccess(); } }) .thenOnException( new ExceptionHandler<ResourceException>() { @Override public void handleException(ResourceException exception) { auditingHandler.auditAccessFailure(exception.getCode(), exception.getMessage()); } }); }