// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.net;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import android.accounts.Account;
import android.accounts.AccountManager;
import android.accounts.AccountManagerCallback;
import android.accounts.AccountManagerFuture;
import android.accounts.AuthenticatorException;
import android.accounts.OperationCanceledException;
import android.app.Activity;
import android.app.Application;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.Robolectric;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
import org.robolectric.shadows.ShadowAccountManager;
import org.robolectric.shadows.ShadowApplication;
import org.chromium.base.ApplicationStatus;
import org.chromium.base.test.BaseRobolectricTestRunner;
import org.chromium.base.test.util.JniMocker;
import org.chromium.net.HttpNegotiateAuthenticator.GetAccountsCallback;
import org.chromium.net.HttpNegotiateAuthenticator.RequestData;
import java.io.IOException;
import java.util.List;
/** Robolectric tests for HttpNegotiateAuthenticator */
@RunWith(BaseRobolectricTestRunner.class)
@Config(
manifest = Config.NONE,
shadows = {HttpNegotiateAuthenticatorTest.ExtendedShadowAccountManager.class})
public class HttpNegotiateAuthenticatorTest {
/**
* User the AccountManager to inject a mock instance.
* Note: Shadow classes need to be public and static.
*/
@Implements(AccountManager.class)
public static class ExtendedShadowAccountManager extends ShadowAccountManager {
@Implementation
public static AccountManager get(Context context) {
return sMockAccountManager;
}
}
@Rule public JniMocker mocker = new JniMocker();
@Mock private static AccountManager sMockAccountManager;
@Mock private HttpNegotiateAuthenticator.Natives mAuthenticatorJniMock;
@Captor private ArgumentCaptor<AccountManagerCallback<Bundle>> mBundleCallbackCaptor;
@Captor private ArgumentCaptor<AccountManagerCallback<Account[]>> mAccountCallbackCaptor;
@Captor private ArgumentCaptor<Bundle> mBundleCaptor;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mocker.mock(HttpNegotiateAuthenticatorJni.TEST_HOOKS, mAuthenticatorJniMock);
}
/** Test of {@link HttpNegotiateAuthenticator#getNextAuthToken} */
@Test
public void testGetNextAuthToken() {
final String accountType = "Dummy_Account";
HttpNegotiateAuthenticator authenticator = createAuthenticator(accountType);
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
authenticator.getNextAuthToken(0, "test_principal", "", true);
verify(sMockAccountManager)
.getAuthTokenByFeatures(
eq(accountType),
eq("SPNEGO:HOSTBASED:test_principal"),
eq(new String[] {"SPNEGO"}),
any(Activity.class),
(Bundle) isNull(),
mBundleCaptor.capture(),
mBundleCallbackCaptor.capture(),
any(Handler.class));
assertThat(
"There is no existing context",
mBundleCaptor.getValue().get(HttpNegotiateConstants.KEY_SPNEGO_CONTEXT),
nullValue());
assertThat(
"The existing token is empty",
mBundleCaptor.getValue().getString(HttpNegotiateConstants.KEY_INCOMING_AUTH_TOKEN),
equalTo(""));
assertThat(
"Delegation is allowed",
mBundleCaptor.getValue().getBoolean(HttpNegotiateConstants.KEY_CAN_DELEGATE),
equalTo(true));
assertThat(
"getAuthTokenByFeatures was called with a callback",
mBundleCallbackCaptor.getValue(),
notNullValue());
}
/**
* Test of {@link HttpNegotiateAuthenticator#getNextAuthToken} without a visible activity.
* This emulates the behavior with WebView, where the application is a generic one and doesn't
* set up the ApplicationStatus the same way.
*/
@Test
@Config(application = Application.class)
public void testGetNextAuthTokenWithoutActivity() {
final String accountType = "Dummy_Account";
final Account[] returnedAccount = {new Account("name", accountType)};
HttpNegotiateAuthenticator authenticator = createAuthenticator(accountType);
authenticator.getNextAuthToken(1234, "test_principal", "", true);
Assert.assertNull(ApplicationStatus.getLastTrackedFocusedActivity());
verify(sMockAccountManager)
.getAccountsByTypeAndFeatures(
eq(accountType),
eq(new String[] {"SPNEGO"}),
mAccountCallbackCaptor.capture(),
any(Handler.class));
mAccountCallbackCaptor.getValue().run(makeFuture(returnedAccount));
verify(sMockAccountManager)
.getAuthToken(
any(Account.class),
eq("SPNEGO:HOSTBASED:test_principal"),
mBundleCaptor.capture(),
eq(true),
any(HttpNegotiateAuthenticator.GetTokenCallback.class),
any(Handler.class));
assertThat(
"There is no existing context",
mBundleCaptor.getValue().get(HttpNegotiateConstants.KEY_SPNEGO_CONTEXT),
nullValue());
assertThat(
"The existing token is empty",
mBundleCaptor.getValue().getString(HttpNegotiateConstants.KEY_INCOMING_AUTH_TOKEN),
equalTo(""));
assertThat(
"Delegation is allowed",
mBundleCaptor.getValue().getBoolean(HttpNegotiateConstants.KEY_CAN_DELEGATE),
equalTo(true));
}
/** Tests the behavior of {@link HttpNegotiateAuthenticator.GetAccountsCallback} */
@Test
public void testGetAccountCallback() {
String type = "Dummy_Account";
HttpNegotiateAuthenticator authenticator = createAuthenticator(type);
RequestData requestData = new RequestData();
requestData.nativeResultObject = 42;
requestData.accountManager = sMockAccountManager;
GetAccountsCallback callback = authenticator.new GetAccountsCallback(requestData);
// Should fail because there are no accounts
callback.run(makeFuture(new Account[] {}));
verify(mAuthenticatorJniMock)
.setResult(
eq(42L),
eq(authenticator),
eq(NetError.ERR_MISSING_AUTH_CREDENTIALS),
(String) isNull());
// Should succeed, for a single account we use it for the AccountManager#getAuthToken call.
Account testAccount = new Account("a", type);
callback.run(makeFuture(new Account[] {testAccount}));
verify(sMockAccountManager)
.getAuthToken(
eq(testAccount),
(String) isNull(),
(Bundle) isNull(),
eq(true),
any(HttpNegotiateAuthenticator.GetTokenCallback.class),
any(Handler.class));
// Should fail because there is more than one account
callback.run(makeFuture(new Account[] {new Account("a", type), new Account("b", type)}));
verify(mAuthenticatorJniMock, times(2))
.setResult(
eq(42L),
eq(authenticator),
eq(NetError.ERR_MISSING_AUTH_CREDENTIALS),
(String) isNull());
}
/**
* Tests the behavior of {@link HttpNegotiateAuthenticator.GetTokenCallback} when the result it
* receives contains an intent rather than a token directly.
*/
@Test
public void testGetTokenCallbackWithIntent() {
String type = "Dummy_Account";
HttpNegotiateAuthenticator authenticator = createAuthenticator(type);
RequestData requestData = new RequestData();
requestData.nativeResultObject = 42;
requestData.authTokenType = "foo";
requestData.account = new Account("a", type);
requestData.accountManager = sMockAccountManager;
Bundle b = new Bundle();
b.putParcelable(AccountManager.KEY_INTENT, new Intent());
authenticator.new GetTokenCallback(requestData).run(makeFuture(b));
verifyNoMoreInteractions(sMockAccountManager);
// Verify that the broadcast receiver is registered
Intent intent = new Intent(AccountManager.LOGIN_ACCOUNTS_CHANGED_ACTION);
ShadowApplication shadowApplication = ShadowApplication.getInstance();
List<BroadcastReceiver> receivers = shadowApplication.getReceiversForIntent(intent);
assertThat("There is one registered broadcast receiver", receivers.size(), equalTo(1));
// Send the intent to the receiver.
BroadcastReceiver receiver = receivers.get(0);
receiver.onReceive(RuntimeEnvironment.application.getApplicationContext(), intent);
// Verify that the auth token is properly requested from the account manager.
verify(sMockAccountManager)
.getAuthToken(
eq(new Account("a", type)),
eq("foo"),
(Bundle) isNull(),
eq(true),
any(HttpNegotiateAuthenticator.GetTokenCallback.class),
(Handler) isNull());
}
/** Test of callback called when getting the auth token completes. */
@Test
public void testAccountManagerCallbackRun() {
HttpNegotiateAuthenticator authenticator = createAuthenticator("Dummy_Account");
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
// Call getNextAuthToken to get the callback
authenticator.getNextAuthToken(1234, "test_principal", "", true);
verify(sMockAccountManager)
.getAuthTokenByFeatures(
any(String.class),
any(String.class),
any(String[].class),
any(Activity.class),
(Bundle) isNull(),
any(Bundle.class),
mBundleCallbackCaptor.capture(),
any(Handler.class));
Bundle resultBundle = new Bundle();
Bundle context = new Bundle();
context.putString("String", "test_context");
resultBundle.putInt(HttpNegotiateConstants.KEY_SPNEGO_RESULT, HttpNegotiateConstants.OK);
resultBundle.putBundle(HttpNegotiateConstants.KEY_SPNEGO_CONTEXT, context);
resultBundle.putString(AccountManager.KEY_AUTHTOKEN, "output_token");
mBundleCallbackCaptor.getValue().run(makeFuture(resultBundle));
verify(mAuthenticatorJniMock).setResult(1234, authenticator, 0, "output_token");
// Check that the next call to getNextAuthToken uses the correct context
authenticator.getNextAuthToken(5678, "test_principal", "", true);
verify(sMockAccountManager, times(2))
.getAuthTokenByFeatures(
any(String.class),
any(String.class),
any(String[].class),
any(Activity.class),
(Bundle) isNull(),
mBundleCaptor.capture(),
mBundleCallbackCaptor.capture(),
any(Handler.class));
assertThat(
"The spnego context is preserved between calls",
mBundleCaptor.getValue().getBundle(HttpNegotiateConstants.KEY_SPNEGO_CONTEXT),
equalTo(context));
// Test exception path
mBundleCallbackCaptor
.getValue()
.run(this.<Bundle>makeFuture(new OperationCanceledException()));
verify(mAuthenticatorJniMock).setResult(5678, authenticator, NetError.ERR_UNEXPECTED, null);
}
@Test
public void testPermissionDenied() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
HttpNegotiateAuthenticator authenticator = createAuthenticator("Dummy_Account", true);
authenticator.getNextAuthToken(1234, "test_principal", "", true);
verify(mAuthenticatorJniMock)
.setResult(
anyLong(),
eq(authenticator),
eq(NetError.ERR_MISCONFIGURED_AUTH_ENVIRONMENT),
(String) isNull());
}
@Test
public void testAccountManagerCallbackNullErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(null, NetError.ERR_UNEXPECTED);
}
@Test
public void testAccountManagerCallbackUnexpectedErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(HttpNegotiateConstants.ERR_UNEXPECTED, NetError.ERR_UNEXPECTED);
}
@Test
public void testAccountManagerCallbackAbortedErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(HttpNegotiateConstants.ERR_ABORTED, NetError.ERR_ABORTED);
}
@Test
public void testAccountManagerCallbackSecLibErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(
HttpNegotiateConstants.ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS,
NetError.ERR_UNEXPECTED_SECURITY_LIBRARY_STATUS);
}
@Test
public void testAccountManagerCallbackInvalidResponseErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(
HttpNegotiateConstants.ERR_INVALID_RESPONSE, NetError.ERR_INVALID_RESPONSE);
}
@Test
public void testAccountManagerCallbackInvalidAuthCredsErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(
HttpNegotiateConstants.ERR_INVALID_AUTH_CREDENTIALS,
NetError.ERR_INVALID_AUTH_CREDENTIALS);
}
@Test
public void testAccountManagerCallbackUnsuppAutchSchemeErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(
HttpNegotiateConstants.ERR_UNSUPPORTED_AUTH_SCHEME,
NetError.ERR_UNSUPPORTED_AUTH_SCHEME);
}
@Test
public void testAccountManagerCallbackMissingAuthCredsErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(
HttpNegotiateConstants.ERR_MISSING_AUTH_CREDENTIALS,
NetError.ERR_MISSING_AUTH_CREDENTIALS);
}
@Test
public void testAccountManagerCallbackUndocSecLibErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(
HttpNegotiateConstants.ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS,
NetError.ERR_UNDOCUMENTED_SECURITY_LIBRARY_STATUS);
}
@Test
public void testAccountManagerCallbackMalformedIdentityErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
checkErrorReturn(
HttpNegotiateConstants.ERR_MALFORMED_IDENTITY, NetError.ERR_MALFORMED_IDENTITY);
}
@Test
public void testAccountManagerCallbackInvalidErrorReturns() {
Robolectric.buildActivity(Activity.class).create().start().resume().visible();
// 9999 is not a valid return value
checkErrorReturn(9999, NetError.ERR_UNEXPECTED);
}
private void checkErrorReturn(Integer spnegoError, int expectedError) {
HttpNegotiateAuthenticator authenticator = createAuthenticator("Dummy_Account");
// Call getNextAuthToken to get the callback
authenticator.getNextAuthToken(1234, "test_principal", "", true);
verify(sMockAccountManager)
.getAuthTokenByFeatures(
any(String.class),
any(String.class),
any(String[].class),
any(Activity.class),
(Bundle) isNull(),
any(Bundle.class),
mBundleCallbackCaptor.capture(),
any(Handler.class));
Bundle resultBundle = new Bundle();
if (spnegoError != null) {
resultBundle.putInt(HttpNegotiateConstants.KEY_SPNEGO_RESULT, spnegoError);
}
mBundleCallbackCaptor.getValue().run(makeFuture(resultBundle));
verify(mAuthenticatorJniMock)
.setResult(anyLong(), eq(authenticator), eq(expectedError), (String) isNull());
}
/**
* Returns a future that successfully returns the provided result.
* Hides mocking related annoyances: compiler warnings and irrelevant catch clauses.
*/
private <T> AccountManagerFuture<T> makeFuture(T result) {
// Avoid warning when creating mock accountManagerFuture, can't take .class of an
// instantiated generic type, yet compiler complains if I leave it uninstantiated.
@SuppressWarnings("unchecked")
AccountManagerFuture<T> accountManagerFuture = mock(AccountManagerFuture.class);
try {
when(accountManagerFuture.getResult()).thenReturn(result);
} catch (OperationCanceledException | AuthenticatorException | IOException e) {
// Can never happen - artifact of Mockito.
fail();
}
return accountManagerFuture;
}
/**
* Returns a future that fails with the provided exception when trying to get its result.
* Hides mocking related annoyances: compiler warnings and irrelevant catch clauses.
*/
private <T> AccountManagerFuture<T> makeFuture(Exception ex) {
// Avoid warning when creating mock accountManagerFuture, can't take .class of an
// instantiated generic type, yet compiler complains if I leave it uninstantiated.
@SuppressWarnings("unchecked")
AccountManagerFuture<T> accountManagerFuture = mock(AccountManagerFuture.class);
try {
when(accountManagerFuture.getResult()).thenThrow(ex);
} catch (OperationCanceledException | AuthenticatorException | IOException e) {
// Can never happen - artifact of Mockito.
fail();
}
return accountManagerFuture;
}
/** Returns a new authenticator with an overridden lacksPermission method. */
private HttpNegotiateAuthenticator createAuthenticator(
String accountType, boolean lacksPermission) {
return new HttpNegotiateAuthenticator(accountType) {
@Override
boolean lacksPermission(Context context, String permission, boolean onlyPreM) {
return lacksPermission;
}
};
}
private HttpNegotiateAuthenticator createAuthenticator(String accountType) {
return createAuthenticator(accountType, false);
}
}
Codebase Browser
chromium