| /******************************************************************************* |
| * Copyright (c) 2004, 2014 Tasktop Technologies and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Tasktop Technologies - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.mylyn.tasks.tests; |
| |
| import java.net.URL; |
| import java.util.Collections; |
| import java.util.Date; |
| |
| import junit.framework.TestCase; |
| |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.mylyn.commons.net.AuthenticationCredentials; |
| import org.eclipse.mylyn.commons.net.AuthenticationType; |
| import org.eclipse.mylyn.commons.repositories.core.ILocationService; |
| import org.eclipse.mylyn.commons.repositories.core.auth.ICredentialsStore; |
| import org.eclipse.mylyn.internal.commons.repositories.core.LocationService; |
| import org.eclipse.mylyn.internal.tasks.core.IRepositoryConstants; |
| import org.eclipse.mylyn.tasks.core.TaskRepository; |
| import org.eclipse.mylyn.tasks.tests.util.TestUtils; |
| |
| /** |
| * @author Mik Kersten |
| */ |
| public class TaskRepositoryCredentialsTest extends TestCase { |
| |
| private static final String AUTH_REPOSITORY = "org.eclipse.mylyn.tasklist.repositories"; |
| |
| private static final String AUTH_HTTP = "org.eclipse.mylyn.tasklist.repositories.httpauth"; |
| |
| private static final String AUTH_CERT = "org.eclipse.mylyn.tasklist.repositories.certauth"; |
| |
| private static final String AUTH_PROXY = "org.eclipse.mylyn.tasklist.repositories.proxy"; |
| |
| private static final String PASSWORD = ".password"; |
| |
| private static String getKeyPrefix(AuthenticationType type) { |
| switch (type) { |
| case HTTP: |
| return AUTH_HTTP; |
| case CERTIFICATE: |
| return AUTH_CERT; |
| case PROXY: |
| return AUTH_PROXY; |
| case REPOSITORY: |
| return AUTH_REPOSITORY; |
| } |
| throw new IllegalArgumentException("Unknown authentication type: " + type); //$NON-NLS-1$ |
| } |
| |
| private String getPassword(AuthenticationType authType) { |
| ICredentialsStore store = service.getCredentialsStore(taskRepository.getRepositoryUrl()); |
| String password = store.get(getKeyPrefix(authType) + PASSWORD, null); |
| return password; |
| } |
| |
| private TaskRepository taskRepository; |
| |
| private ILocationService service; |
| |
| @Override |
| protected void setUp() throws Exception { |
| service = LocationService.getDefault(); |
| taskRepository = new TaskRepository("kind", "http://url"); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| taskRepository.flushAuthenticationCredentials(); |
| } |
| |
| @SuppressWarnings("deprecation") |
| public void testPlatformAuthHandlerAvailable() throws Exception { |
| if (!TestUtils.isCompatibilityAuthInstalled()) { |
| System.err.println("Skipping TaskRepositoryCredentialsTest.testPlatformAuthHandlerAvailable()"); |
| return; |
| } |
| URL url = new URL("http://mylyn"); |
| Platform.addAuthorizationInfo(url, "", "", Collections.EMPTY_MAP); |
| assertNotNull("Tests require org.eclipse.core.runtime.compatibility.auth", |
| Platform.getAuthorizationInfo(url, "", "")); |
| } |
| |
| public void testLabel() { |
| TaskRepository repository = new TaskRepository("kind", "http://foo.bar"); |
| assertTrue(repository.getRepositoryLabel().equals(repository.getRepositoryUrl())); |
| |
| repository.setProperty(IRepositoryConstants.PROPERTY_LABEL, "label"); |
| assertTrue(repository.getRepositoryLabel().equals("label")); |
| } |
| |
| @SuppressWarnings("deprecation") |
| public void testPassword() throws Exception { |
| assertCredentials(AuthenticationType.REPOSITORY); |
| |
| // test old API |
| taskRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("user", "pwd"), true); |
| assertEquals("user", taskRepository.getUserName()); |
| assertEquals("pwd", taskRepository.getPassword()); |
| |
| assertEquals(null, taskRepository.getHttpUser()); |
| assertEquals(null, taskRepository.getHttpPassword()); |
| } |
| |
| @SuppressWarnings("deprecation") |
| public void testHttpPassword() throws Exception { |
| assertCredentials(AuthenticationType.HTTP); |
| |
| TaskRepository taskRepository = new TaskRepository("kind", "url"); |
| taskRepository.setCredentials(AuthenticationType.HTTP, new AuthenticationCredentials("user", "pwd"), true); |
| assertEquals("user", taskRepository.getHttpUser()); |
| assertEquals("pwd", taskRepository.getHttpPassword()); |
| } |
| |
| @SuppressWarnings("deprecation") |
| public void testProxyPassword() throws Exception { |
| assertCredentials(AuthenticationType.PROXY); |
| |
| TaskRepository taskRepository = new TaskRepository("kind", "url"); |
| taskRepository.setCredentials(AuthenticationType.PROXY, new AuthenticationCredentials("user", "pwd"), false); |
| assertEquals("user", taskRepository.getProxyUsername()); |
| assertEquals("pwd", taskRepository.getProxyPassword()); |
| } |
| |
| @SuppressWarnings("deprecation") |
| public void testFlushCredentials() throws Exception { |
| TaskRepository taskRepository = new TaskRepository("kind", "url"); |
| taskRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("user", "pwd"), |
| false); |
| taskRepository.setCredentials(AuthenticationType.HTTP, new AuthenticationCredentials("user", "pwd"), true); |
| taskRepository.setCredentials(AuthenticationType.PROXY, new AuthenticationCredentials("user", "pwd"), true); |
| |
| assertNotNull(taskRepository.getCredentials(AuthenticationType.REPOSITORY)); |
| assertNotNull(taskRepository.getCredentials(AuthenticationType.HTTP)); |
| assertNotNull(taskRepository.getCredentials(AuthenticationType.PROXY)); |
| |
| taskRepository.flushAuthenticationCredentials(); |
| |
| assertNotNull(taskRepository.getUserName());// username is not flushed |
| assertNull(taskRepository.getPassword()); |
| assertNull(taskRepository.getHttpUser()); |
| assertNull(taskRepository.getHttpPassword()); |
| assertNull(taskRepository.getProxyUsername()); |
| assertNull(taskRepository.getProxyPassword()); |
| |
| assertNull(taskRepository.getCredentials(AuthenticationType.REPOSITORY)); |
| assertNull(taskRepository.getCredentials(AuthenticationType.HTTP)); |
| assertNull(taskRepository.getCredentials(AuthenticationType.PROXY)); |
| } |
| |
| public void testPlatformIsRunning() { |
| assertTrue(Platform.isRunning()); |
| } |
| |
| public void assertCredentials(AuthenticationType authType) throws Exception { |
| assertNull(getPassword(authType)); |
| try { |
| taskRepository.flushAuthenticationCredentials(); |
| |
| assertNull(taskRepository.getCredentials(authType)); |
| assertTrue(taskRepository.getSavePassword(authType)); |
| |
| taskRepository.setCredentials(authType, new AuthenticationCredentials("user", "pwd"), true); |
| AuthenticationCredentials credentials = taskRepository.getCredentials(authType); |
| assertNotNull(credentials); |
| assertEquals("user", credentials.getUserName()); |
| assertEquals("pwd", credentials.getPassword()); |
| |
| assertEquals("pwd", getPassword(authType)); |
| |
| // test not saving password |
| taskRepository.setCredentials(authType, new AuthenticationCredentials("user1", "pwd1"), false); |
| assertFalse(taskRepository.getSavePassword(authType)); |
| credentials = taskRepository.getCredentials(authType); |
| assertNotNull(credentials); |
| assertEquals("user1", credentials.getUserName()); |
| assertEquals("pwd1", credentials.getPassword()); |
| |
| // make sure old passwords are not stored |
| assertNull(getPassword(authType)); |
| |
| taskRepository.setCredentials(authType, new AuthenticationCredentials("user2", "pwd2"), true); |
| assertTrue(taskRepository.getSavePassword(authType)); |
| credentials = taskRepository.getCredentials(authType); |
| assertNotNull(credentials); |
| assertEquals("user2", credentials.getUserName()); |
| assertEquals("pwd2", credentials.getPassword()); |
| } finally { |
| taskRepository.flushAuthenticationCredentials(); |
| } |
| } |
| |
| public void testConfigUpdateStoring() throws Exception { |
| Date stamp = taskRepository.getConfigurationDate(); |
| assertNull("unset configuration date returns null", stamp); |
| stamp = new Date(); |
| stamp.setTime(stamp.getTime() - 35000L); |
| |
| taskRepository.setConfigurationDate(stamp); |
| assertEquals("Time stamp set", stamp.getTime(), taskRepository.getConfigurationDate().getTime()); |
| } |
| |
| public void testDoNotPersistCredentials() throws Exception { |
| taskRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("user", "pwd"), true); |
| assertEquals("pwd", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| |
| taskRepository.setShouldPersistCredentials(false); |
| taskRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("user", "newpwd"), |
| true); |
| assertEquals("newpwd", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| |
| taskRepository.setShouldPersistCredentials(true); |
| assertEquals("pwd", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| } |
| |
| public void testSetCredentialsDoesNotAffectExistingRepositoryWhenShouldNotPersistIsSetToTrue() throws Exception { |
| taskRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("user", "pwd"), true); |
| assertEquals("pwd", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| |
| TaskRepository newRepository = new TaskRepository("kind", "http://url"); |
| newRepository.setShouldPersistCredentials(false); |
| newRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("newuser", "newpwd"), |
| true); |
| assertEquals("pwd", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| assertEquals("newpwd", newRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| |
| taskRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("user", "pwd2"), |
| true); |
| assertEquals("pwd2", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| assertEquals("newpwd", newRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| } |
| |
| public void testSetCredentialsAffectExistingRepository() throws Exception { |
| taskRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("user", "pwd"), true); |
| assertEquals("pwd", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| |
| TaskRepository newRepository = new TaskRepository("kind", "http://url"); |
| newRepository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("newuser", "newpwd"), |
| true); |
| assertEquals("newpwd", taskRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| assertEquals("newpwd", newRepository.getCredentials(AuthenticationType.REPOSITORY).getPassword()); |
| } |
| |
| } |