- remove autxmanager and clean up tests

- drop authenticatedconneciton

Author: atakavci

core/src/main/java/redis/clients/authentication/core/AuthXManager.java

@@ -72,6 +72,7 @@ protected Token renewToken() {
                 scheduledTask = scheduleNext(tokenManagerConfig.getRetryPolicy().getdelayInMs());
             } else {
                 listener.onError(e);
+                throw new AuthXException("Token request/renewal failed!", e);
             }
         }
         return null;

core/src/main/java/redis/clients/authentication/core/AuthXManagerFactory.java

@@ -4,7 +4,7 @@
 
 public class CoreAuthenticationIntegrationTests {
     @Test
-    public void testAuthXManager() {
+    public void testTokenManager() {
         // Test code
     }
 }

core/src/main/java/redis/clients/authentication/core/AuthenticatedConnection.java

@@ -7,11 +7,10 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockConstruction;
 import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
@@ -22,15 +21,10 @@
 import org.hamcrest.Matchers;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
-import org.mockito.MockedConstruction;
-import org.mockito.Mockito;
-import redis.clients.authentication.core.AuthXManager;
-import redis.clients.authentication.core.AuthXManagerFactory;
+
 import redis.clients.authentication.core.IdentityProvider;
-import redis.clients.authentication.core.IdentityProviderConfig;
 import redis.clients.authentication.core.SimpleToken;
 import redis.clients.authentication.core.Token;
-import redis.clients.authentication.core.TokenAuthConfig;
 import redis.clients.authentication.core.TokenListener;
 import redis.clients.authentication.core.TokenManager;
 import redis.clients.authentication.core.TokenManagerConfig;
@@ -39,33 +33,6 @@
 
 public class CoreAuthenticationUnitTests {
 
-  public static class CustomAuthXManager extends AuthXManager {
-
-    public CustomAuthXManager(TokenManager tokenManager) {
-      super(tokenManager);
-    }
-  }
-
-  @Test
-  public void testAuthXManagerFactory() {
-    TokenManagerConfig tokenManagerConfig = mock(TokenManagerConfig.class);
-    IdentityProviderConfig identityProviderConfig = mock(IdentityProviderConfig.class);
-    IdentityProvider identityProvider = mock(IdentityProvider.class);
-
-    when(identityProviderConfig.getProvider()).thenReturn(identityProvider);
-
-    try (MockedConstruction<TokenManager> mockedConstructor = mockConstruction(TokenManager.class,
-      (mock, context) -> {
-        assertEquals(identityProvider, context.arguments().get(0));
-        assertEquals(tokenManagerConfig, context.arguments().get(1));
-      })) {
-      AuthXManagerFactory.create(new TokenAuthConfig(tokenManagerConfig, identityProviderConfig));
-
-      AuthXManagerFactory.create(CustomAuthXManager.class,
-        new TokenAuthConfig(tokenManagerConfig, identityProviderConfig));
-    }
-  }
-
   public static class TokenManagerConfigWrapper extends TokenManagerConfig {
     int lower;
     float ratio;
@@ -159,7 +126,8 @@ public void testCalculateRenewalDelay() {
   }
 
   @Test
-  public void testAuthXManager() throws InterruptedException, ExecutionException, TimeoutException {
+  public void testTokenManagerStart()
+      throws InterruptedException, ExecutionException, TimeoutException {
 
     IdentityProvider identityProvider = () -> new SimpleToken("tokenVal",
         System.currentTimeMillis() + 5 * 1000, System.currentTimeMillis(),
@@ -168,16 +136,15 @@ public void testAuthXManager() throws InterruptedException, ExecutionException,
     TokenManager tokenManager = new TokenManager(identityProvider,
         new TokenManagerConfig(0.7F, 200, 2000, null));
 
-    AuthXManager manager = spy(new AuthXManager(tokenManager));
-
+    TokenListener listener = mock(TokenListener.class);
     final Token[] tokenHolder = new Token[1];
     doAnswer(invocation -> {
       Object[] args = invocation.getArguments();
       tokenHolder[0] = (Token) args[0];
       return null;
-    }).when(manager).authenticateConnections(any());
+    }).when(listener).onTokenRenewed(any());
 
-    manager.start(true);
+    tokenManager.start(listener, true);
     assertEquals(tokenHolder[0].getValue(), "tokenVal");
   }
 
@@ -190,8 +157,8 @@ public void testBlockForInitialToken() {
     TokenManager tokenManager = new TokenManager(identityProvider,
         new TokenManagerConfig(0.7F, 200, 2000, new TokenManagerConfig.RetryPolicy(5, 100)));
 
-    AuthXManager manager = new AuthXManager(tokenManager);
-    ExecutionException e = assertThrows(ExecutionException.class, () -> manager.start(true));
+    ExecutionException e = assertThrows(ExecutionException.class,
+      () -> tokenManager.start(mock(TokenListener.class), true));
 
     assertEquals("java.lang.RuntimeException: Test exception from identity provider!",
       e.getCause().getCause().getMessage());
@@ -210,12 +177,12 @@ public void testNoBlockForInitialToken()
     TokenManager tokenManager = new TokenManager(identityProvider, new TokenManagerConfig(0.7F, 200,
         2000, new TokenManagerConfig.RetryPolicy(numberOfRetries - 1, 100)));
 
-    AuthXManager manager = spy(new AuthXManager(tokenManager));
-    manager.start(false);
+    TokenListener listener = mock(TokenListener.class);
+    tokenManager.start(listener, false);
 
     requesLatch.await();
-    verify(manager, Mockito.atLeastOnce()).onError(Mockito.any());
-    verify(manager, Mockito.never()).authenticateConnections(Mockito.any());
+    verify(listener, atLeastOnce()).onError(any());
+    verify(listener, never()).onTokenRenewed(any());
   }
 
   @Test
@@ -273,12 +240,12 @@ public void testTokenManagerWithHangingTokenRequest()
     TokenManager tokenManager = new TokenManager(identityProvider, new TokenManagerConfig(0.7F, 200,
         executionTimeout, new TokenManagerConfig.RetryPolicy(numberOfRetries, 100)));
 
-    AuthXManager manager = spy(new AuthXManager(tokenManager));
-    manager.start(false);
+    TokenListener listener = mock(TokenListener.class);
+    tokenManager.start(listener, false);
     requesLatch.await();
-    verify(manager, never()).onError(any());
+    verify(listener, never()).onError(any());
     await().atMost(2, TimeUnit.SECONDS).untilAsserted(() -> {
-      verify(manager, times(1)).authenticateConnections(any());
+      verify(listener, times(1)).onTokenRenewed(any());
     });
   }
 }