| /* |
| * Copyright 2000-2012 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.jetbrains.idea.svn16; |
| |
| import com.intellij.openapi.application.ApplicationManager; |
| import com.intellij.openapi.util.Pair; |
| import com.intellij.openapi.util.SystemInfo; |
| import com.intellij.openapi.util.Trinity; |
| import com.intellij.openapi.util.io.FileUtil; |
| import com.intellij.testFramework.PlatformTestCase; |
| import com.intellij.util.concurrency.Semaphore; |
| import com.intellij.util.ui.UIUtil; |
| import junit.framework.Assert; |
| import org.jetbrains.idea.svn.auth.SvnAuthenticationManager; |
| import org.jetbrains.idea.svn.auth.SvnAuthenticationNotifier; |
| import org.jetbrains.idea.svn.SvnConfiguration; |
| import org.jetbrains.idea.svn.SvnVcs; |
| import org.jetbrains.idea.svn.auth.ProviderType; |
| import org.jetbrains.idea.svn.auth.SvnAuthenticationInteraction; |
| import org.jetbrains.idea.svn.auth.SvnAuthenticationListener; |
| import org.jetbrains.idea.svn.auth.SvnAuthenticationProvider; |
| import org.tmatesoft.svn.core.SVNErrorMessage; |
| import org.tmatesoft.svn.core.SVNException; |
| import org.tmatesoft.svn.core.SVNURL; |
| import org.tmatesoft.svn.core.auth.*; |
| import org.tmatesoft.svn.core.internal.util.jna.SVNJNAUtil; |
| import org.tmatesoft.svn.core.internal.wc.SVNConfigFile; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| public class SvnAuthenticationTest extends PlatformTestCase { |
| private SvnAuthenticationManager myAuthenticationManager; |
| private TestInteraction myTestInteraction; |
| private final Object mySynchObject = new Object(); |
| private SvnTestInteractiveAuthentication myInteractiveProvider; |
| private SvnConfiguration myConfiguration; |
| |
| @Override |
| protected void runBareRunnable(Runnable runnable) throws Throwable { |
| runnable.run(); |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| UIUtil.invokeAndWaitIfNeeded(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| SvnAuthenticationTest.super.setUp(); |
| } |
| catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| } |
| }); |
| |
| |
| myConfiguration = SvnConfiguration.getInstance(myProject); |
| final String configPath = myProject.getBaseDir().getPath() + File.separator + "Subversion"; |
| myConfiguration.setConfigurationDirParameters(false, configPath); |
| |
| final File configFile = new File(configPath); |
| myFilesToDelete.add(configFile); |
| |
| SvnVcs vcs = SvnVcs.getInstance(myProject); |
| |
| myAuthenticationManager = new SvnAuthenticationManager(myProject, configFile); |
| |
| myInteractiveProvider = new SvnTestInteractiveAuthentication(myAuthenticationManager); |
| myAuthenticationManager.setAuthenticationProvider(new SvnAuthenticationProvider(vcs, myInteractiveProvider, myAuthenticationManager)); |
| myAuthenticationManager.setRuntimeStorage(SvnConfiguration.RUNTIME_AUTH_CACHE); |
| |
| myTestInteraction = new TestInteraction(); |
| myAuthenticationManager.setInteraction(myTestInteraction); |
| |
| SVNConfigFile.createDefaultConfiguration(configFile); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| UIUtil.invokeAndWaitIfNeeded(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| SvnAuthenticationTest.super.tearDown(); |
| } |
| catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| } |
| }); |
| |
| FileUtil.delete(new File(myConfiguration.getConfigurationDirectory())); |
| } |
| |
| public void testSavedAndRead() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final boolean[] result = {false}; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| if (SystemInfo.isWindows) { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.save)); |
| } else { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| } |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(3, listener.getCnt()); |
| //long start = System.currentTimeMillis(); |
| //waitListenerStep(start, listener, 3); |
| |
| listener.reset(); |
| if (!SystemInfo.isWindows) savedOnceListener.reset(); |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| if (! SystemInfo.isWindows) { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| } |
| commonScheme(url, false, null); |
| //start = System.currentTimeMillis(); |
| //waitListenerStep(start, listener, 4); |
| Assert.assertEquals(SystemInfo.isWindows ? 1 : 3, listener.getCnt()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(SystemInfo.isWindows ? 0 : 2, myTestInteraction.getNumPlaintextPrompt()); |
| Assert.assertEquals(0, myTestInteraction.getNumAuthWarn()); |
| Assert.assertEquals(0, myTestInteraction.getNumPasswordsWarn()); |
| Assert.assertEquals(0, myTestInteraction.getNumSSLPlaintextPrompt()); |
| Assert.assertEquals(0, myTestInteraction.getNumSSLWarn()); |
| Assert.assertEquals(SystemInfo.isWindows ? 1 : 3, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } |
| |
| public void testSavedAndReadUnix() throws Exception { |
| if (SystemInfo.isWindows) return; |
| |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| |
| final File servers = new File(myConfiguration.getConfigurationDirectory(), "servers"); |
| final File oldServers = new File(myConfiguration.getConfigurationDirectory(), "config_old"); |
| FileUtil.copy(servers, oldServers); |
| try { |
| FileUtil.appendToFile(servers, "\nstore-plaintext-passwords=yes\n"); |
| |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.save)); |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(3, listener.getCnt()); |
| //long start = System.currentTimeMillis(); |
| //waitListenerStep(start, listener, 3); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| commonScheme(url, false, null); |
| //start = System.currentTimeMillis(); |
| //waitListenerStep(start, listener, 4); |
| Assert.assertEquals(4, listener.getCnt()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| } finally { |
| FileUtil.delete(servers); |
| FileUtil.rename(oldServers, servers); |
| } |
| |
| Assert.assertTrue(result[0]); |
| myTestInteraction.assertNothing(); |
| Assert.assertEquals(4, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } |
| |
| private void waitListenerStep(long start, TestListener listener, final int stepNoNext) { |
| while (listener.getCnt() < stepNoNext && System.currentTimeMillis() - start < 10000) { |
| synchronized (mySynchObject) { |
| try { |
| mySynchObject.wait(50); |
| } |
| catch (InterruptedException e) { |
| // |
| } |
| } |
| } |
| Assert.assertEquals(stepNoNext, listener.getCnt()); |
| } |
| |
| public void testWhenNotSaved() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| myInteractiveProvider.setSaveData(false); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| |
| commonScheme(url, false, null); |
| //long start = System.currentTimeMillis(); |
| //waitListenerStep(start, listener, 2); |
| Assert.assertEquals(2, listener.getCnt()); |
| |
| savedOnceListener.assertNotSaved(url, ISVNAuthenticationManager.PASSWORD); |
| // cause is not cleared though |
| savedOnceListener.reset(); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| commonScheme(url, false, null); |
| Assert.assertEquals(4, listener.getCnt()); |
| //start = System.currentTimeMillis(); |
| //waitListenerStep(start, listener, 4); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| myTestInteraction.assertNothing(); |
| Assert.assertEquals(4, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertNotSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } |
| |
| public void testWhenAuthCredsNoInConfig() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final File config = new File(myConfiguration.getConfigurationDirectory(), "config"); |
| final String contents = FileUtil.loadFile(config); |
| final String auth = "[auth]"; |
| final int idx = contents.indexOf(auth); |
| Assert.assertTrue(idx != -1); |
| final String newContents = contents.substring(0, idx + auth.length()) + "\nstore-auth-creds=no\n" + contents.substring(idx + auth.length()); |
| |
| final File oldConfig = new File(myConfiguration.getConfigurationDirectory(), "config_old"); |
| FileUtil.rename(config, oldConfig); |
| try { |
| config.createNewFile(); |
| FileUtil.appendToFile(config, newContents); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(2, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumAuthWarn()); |
| myTestInteraction.reset(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.reset(); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| commonScheme(url, false, null); |
| Assert.assertEquals(4, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumAuthWarn()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumAuthWarn()); |
| Assert.assertEquals(4, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertNotSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } finally { |
| FileUtil.delete(config); |
| FileUtil.rename(oldConfig, config); |
| } |
| } |
| |
| public void testWhenAuthCredsNoInServers() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final File servers = new File(myConfiguration.getConfigurationDirectory(), "servers"); |
| |
| final File oldServers = new File(myConfiguration.getConfigurationDirectory(), "config_old"); |
| FileUtil.copy(servers, oldServers); |
| try { |
| FileUtil.appendToFile(servers, "\nstore-auth-creds=no\n"); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(2, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumAuthWarn()); |
| myTestInteraction.reset(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.reset(); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| commonScheme(url, false, null); |
| Assert.assertEquals(4, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumAuthWarn()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumAuthWarn()); |
| Assert.assertEquals(4, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertNotSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } finally { |
| FileUtil.delete(servers); |
| FileUtil.rename(oldServers, servers); |
| } |
| } |
| |
| public void testWhenPassSaveNoInConfig() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final File config = new File(myConfiguration.getConfigurationDirectory(), "config"); |
| final String contents = FileUtil.loadFile(config); |
| final String auth = "[auth]"; |
| final int idx = contents.indexOf(auth); |
| Assert.assertTrue(idx != -1); |
| final String newContents = contents.substring(0, idx + auth.length()) + "\nstore-passwords=no\n" + contents.substring(idx + auth.length()); |
| |
| final File oldConfig = new File(myConfiguration.getConfigurationDirectory(), "config_old"); |
| FileUtil.rename(config, oldConfig); |
| try { |
| config.createNewFile(); |
| FileUtil.appendToFile(config, newContents); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(3, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| myTestInteraction.reset(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.reset(); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| Assert.assertEquals(6, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| Assert.assertEquals(6, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } finally { |
| FileUtil.delete(config); |
| FileUtil.rename(oldConfig, config); |
| } |
| } |
| |
| public void testWhenPassSaveNoInServers() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final File servers = new File(myConfiguration.getConfigurationDirectory(), "servers"); |
| |
| final File oldServers = new File(myConfiguration.getConfigurationDirectory(), "config_old"); |
| FileUtil.copy(servers, oldServers); |
| try { |
| FileUtil.appendToFile(servers, "\nstore-passwords=no\n"); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(3, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| myTestInteraction.reset(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.reset(); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| Assert.assertEquals(6, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| Assert.assertEquals(6, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } finally { |
| FileUtil.delete(servers); |
| FileUtil.rename(oldServers, servers); |
| } |
| } |
| |
| public void testWhenPassSaveNoForGroup() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final File servers = new File(myConfiguration.getConfigurationDirectory(), "servers"); |
| final String contents = FileUtil.loadFile(servers); |
| final String groups = "[groups]"; |
| final int idx = contents.indexOf(groups); |
| Assert.assertTrue(idx != -1); |
| final String newContents = contents.substring(0, idx + groups.length()) + "\nsomegroup=some*\n" + contents.substring(idx + groups.length()) + |
| "\n[somegroup]\nstore-passwords=no\n"; |
| |
| final File oldServers = new File(myConfiguration.getConfigurationDirectory(), "config_old"); |
| FileUtil.rename(servers, oldServers); |
| try { |
| servers.createNewFile(); |
| FileUtil.appendToFile(servers, newContents); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(3, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| myTestInteraction.reset(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.reset(); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| Assert.assertEquals(6, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumPasswordsWarn()); |
| Assert.assertEquals(6, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } finally { |
| FileUtil.delete(servers); |
| FileUtil.rename(oldServers, servers); |
| } |
| } |
| |
| public void testWhenPassPhraseSaveNo() throws Exception { |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| |
| final File servers = new File(myConfiguration.getConfigurationDirectory(), "servers"); |
| |
| final File oldServers = new File(myConfiguration.getConfigurationDirectory(), "config_old"); |
| FileUtil.copy(servers, oldServers); |
| try { |
| FileUtil.appendToFile(servers, "\nstore-ssl-client-cert-pp=no\n"); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("https://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| |
| commonScheme(url, false, null); |
| Assert.assertEquals(3, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumSSLWarn()); |
| myTestInteraction.reset(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.reset(); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| Assert.assertEquals(6, listener.getCnt()); |
| Assert.assertEquals(1, myTestInteraction.getNumSSLWarn()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumSSLWarn()); |
| Assert.assertEquals(6, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.SSL); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| } finally { |
| FileUtil.delete(servers); |
| FileUtil.rename(oldServers, servers); |
| } |
| } |
| |
| public void testPlaintextPrompt() throws Exception { |
| SVNJNAUtil.setJNAEnabled(false); |
| |
| // yes, no |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| myTestInteraction.setPlaintextAnswer(true); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.save)); |
| |
| commonScheme(url, false, null); |
| long start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 3); |
| Assert.assertEquals(1, myTestInteraction.getNumPlaintextPrompt()); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| savedOnceListener.reset(); |
| myTestInteraction.reset(); |
| |
| UIUtil.invokeAndWaitIfNeeded(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| clearAuthCache(); |
| } |
| catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| } |
| }); |
| |
| myTestInteraction.setPlaintextAnswer(false); |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 6); |
| Assert.assertEquals(1, myTestInteraction.getNumPlaintextPrompt()); |
| |
| savedOnceListener.reset(); |
| myTestInteraction.reset(); |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 9); |
| Assert.assertEquals(1, myTestInteraction.getNumPlaintextPrompt()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumPlaintextPrompt()); |
| Assert.assertEquals(9, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| SVNJNAUtil.setJNAEnabled(true); |
| } |
| |
| private void clearAuthCache() { |
| SvnAuthenticationNotifier.clearAuthenticationDirectory(myConfiguration); |
| } |
| |
| public void testPlaintextPromptAndSecondPrompt() throws Exception { |
| SVNJNAUtil.setJNAEnabled(false); |
| |
| // yes, no |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| myTestInteraction.setPlaintextAnswer(false); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("http://some.host.com/repo"); |
| final SVNURL url2 = SVNURL.parseURIEncoded("http://some.other.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| |
| commonScheme(url, false, null); |
| long start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 3); |
| Assert.assertEquals(1, myTestInteraction.getNumPlaintextPrompt()); |
| // actually password not saved, but save was called |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.PASSWORD); |
| savedOnceListener.reset(); |
| myTestInteraction.reset(); |
| |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url2, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url2, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url2, Type.without_pasword_save)); |
| commonScheme(url2, false, "anotherRealm"); |
| start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 6); |
| Assert.assertEquals(1, myTestInteraction.getNumPlaintextPrompt()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumPlaintextPrompt()); |
| Assert.assertEquals(6, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| // didn't called to save for 2nd time |
| savedOnceListener.assertNotSaved(url, ISVNAuthenticationManager.PASSWORD); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| SVNJNAUtil.setJNAEnabled(true); |
| } |
| |
| public void testPlaintextSSLPrompt() throws Exception { |
| SVNJNAUtil.setJNAEnabled(false); |
| |
| // yes, no |
| final TestListener listener = new TestListener(mySynchObject); |
| myAuthenticationManager.addListener(listener); |
| final SavedOnceListener savedOnceListener = new SavedOnceListener(); |
| myAuthenticationManager.addListener(savedOnceListener); |
| myTestInteraction.setSSLPlaintextAnswer(true); |
| |
| final SVNURL url = SVNURL.parseURIEncoded("https://some.host.com/repo"); |
| |
| final SVNException[] exception = new SVNException[1]; |
| final Boolean[] result = new Boolean[1]; |
| synchronousBackground(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.save)); |
| |
| commonScheme(url, false, null); |
| long start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 3); |
| Assert.assertEquals(1, myTestInteraction.getNumSSLPlaintextPrompt()); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.SSL); |
| savedOnceListener.reset(); |
| myTestInteraction.reset(); |
| |
| UIUtil.invokeAndWaitIfNeeded(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| clearAuthCache(); |
| } |
| catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| } |
| }); |
| |
| myTestInteraction.setSSLPlaintextAnswer(false); |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 6); |
| Assert.assertEquals(1, myTestInteraction.getNumSSLPlaintextPrompt()); |
| |
| SvnConfiguration.RUNTIME_AUTH_CACHE.clear(); |
| myTestInteraction.reset(); |
| savedOnceListener.reset(); |
| |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.interactive, url, Type.request)); |
| listener.addStep(new Trinity<ProviderType, SVNURL, Type>(ProviderType.persistent, url, Type.without_pasword_save)); |
| commonScheme(url, false, null); |
| start = System.currentTimeMillis(); |
| waitListenerStep(start, listener, 9); |
| Assert.assertEquals(1, myTestInteraction.getNumSSLPlaintextPrompt()); |
| } |
| catch (SVNException e) { |
| exception[0] = e; |
| } |
| result[0] = true; |
| } |
| }); |
| |
| Assert.assertTrue(result[0]); |
| Assert.assertEquals(1, myTestInteraction.getNumSSLPlaintextPrompt()); |
| Assert.assertEquals(9, listener.getCnt()); |
| listener.assertForAwt(); |
| savedOnceListener.assertForAwt(); |
| savedOnceListener.assertSaved(url, ISVNAuthenticationManager.SSL); |
| |
| if (exception[0] != null) { |
| throw exception[0]; |
| } |
| SVNJNAUtil.setJNAEnabled(true); |
| } |
| |
| private static void synchronousBackground(final Runnable runnable) throws InterruptedException { |
| final Semaphore semaphore = new Semaphore(); |
| semaphore.down(); |
| ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { |
| @Override |
| public void run() { |
| try { |
| runnable.run(); |
| } finally { |
| semaphore.up(); |
| } |
| } |
| }); |
| semaphore.waitFor(); |
| } |
| |
| private void commonScheme(final SVNURL url, final boolean username, final String realm) throws SVNException { |
| String kind = null; |
| |
| final String actualRealm = realm == null ? "realm" : realm; |
| final String protocol = url.getProtocol(); |
| if (username) { |
| kind = ISVNAuthenticationManager.USERNAME; |
| } else if ("svn+ssh".equals(protocol)) { |
| kind = ISVNAuthenticationManager.SSH; |
| } else if ("http".equals(protocol)) { |
| kind = ISVNAuthenticationManager.PASSWORD; |
| } else if ("https".equals(protocol)) { |
| kind = ISVNAuthenticationManager.SSL; |
| } else if ("file".equals(protocol)) { |
| kind = ISVNAuthenticationManager.USERNAME; |
| } |
| SVNAuthentication authentication = null; |
| try { |
| authentication = myAuthenticationManager.getFirstAuthentication(kind, actualRealm, url); |
| while (! passwordSpecified(authentication)) { |
| authentication = myAuthenticationManager.getNextAuthentication(kind, actualRealm, url); |
| } |
| } finally { |
| myAuthenticationManager.acknowledgeAuthentication(authentication != null, kind, actualRealm, null, authentication, url); |
| } |
| } |
| |
| private static class SvnTestInteractiveAuthentication implements ISVNAuthenticationProvider { |
| private final SvnAuthenticationManager myManager; |
| private boolean mySaveData; |
| |
| public SvnTestInteractiveAuthentication(SvnAuthenticationManager manager) { |
| myManager = manager; |
| mySaveData = true; |
| } |
| |
| public void setSaveData(boolean saveData) { |
| mySaveData = saveData; |
| } |
| |
| @Override |
| public int acceptServerAuthentication(SVNURL url, String realm, Object certificate, boolean resultMayBeStored) { |
| return ISVNAuthenticationProvider.REJECTED; |
| } |
| |
| @Override |
| public SVNAuthentication requestClientAuthentication(String kind, |
| SVNURL url, |
| String realm, |
| SVNErrorMessage errorMessage, |
| SVNAuthentication previousAuth, |
| boolean authMayBeStored) { |
| authMayBeStored = authMayBeStored && mySaveData; |
| SVNAuthentication result = null; |
| if (ISVNAuthenticationManager.USERNAME.equals(kind)) { |
| result = new SVNUserNameAuthentication("username", authMayBeStored); |
| } else if (ISVNAuthenticationManager.PASSWORD.equals(kind)) { |
| result = new SVNPasswordAuthentication("username", "abc", authMayBeStored, url, false); |
| } else if (ISVNAuthenticationManager.SSH.equals(kind)) { |
| result = new SVNSSHAuthentication("username", "abc", -1, authMayBeStored, url, false); |
| } else if (ISVNAuthenticationManager.SSL.equals(kind)) { |
| result = new SVNSSLAuthentication(new File("aaa"), "abc", authMayBeStored, url, false); |
| } |
| if (! ISVNAuthenticationManager.USERNAME.equals(kind)) { |
| myManager.requested(ProviderType.interactive, url, realm, kind, result == null); |
| } |
| return result; |
| } |
| } |
| |
| private static boolean passwordSpecified(final SVNAuthentication authentication) { |
| final String kind = authentication.getKind(); |
| if (ISVNAuthenticationManager.SSH.equals(kind)) { |
| if (((SVNSSHAuthentication) authentication).hasPrivateKey()) { |
| return ((SVNSSHAuthentication) authentication).getPassphrase() != null && |
| (((SVNSSHAuthentication) authentication).getPrivateKey() != null || |
| ((SVNSSHAuthentication) authentication).getPrivateKeyFile() != null); |
| } else { |
| return ((SVNSSHAuthentication) authentication).getPassword() != null; |
| } |
| } else if (ISVNAuthenticationManager.PASSWORD.equals(kind)) { |
| return ((SVNPasswordAuthentication) authentication).getPassword() != null; |
| } else if (ISVNAuthenticationManager.SSL.equals(kind)) { |
| return ((SVNSSLAuthentication) authentication).getPassword() != null; |
| } else if (ISVNAuthenticationManager.USERNAME.equals(kind)) { |
| return true; |
| } |
| return true; |
| } |
| |
| private static class TestListener implements SvnAuthenticationListener { |
| private final List<Trinity<ProviderType, SVNURL, Type>> myExpectedSequence; |
| private int myCnt; |
| private final Object mySynchObject; |
| private boolean mySuccess; |
| private boolean mySaved; |
| |
| private TestListener(final Object synchObject) { |
| mySynchObject = synchObject; |
| myExpectedSequence = new ArrayList<Trinity<ProviderType, SVNURL, Type>>(); |
| myCnt = 0; |
| mySuccess = true; |
| } |
| |
| public void addStep(Trinity<ProviderType, SVNURL, Type> step) { |
| myExpectedSequence.add(step); |
| } |
| |
| public int getCnt() { |
| return myCnt; |
| } |
| |
| @Override |
| public void acknowledge(boolean accepted, String kind, String realm, SVNErrorMessage message, SVNAuthentication authentication) { |
| } |
| |
| @Override |
| public void saveAttemptStarted(ProviderType type, SVNURL url, String realm, String kind) { |
| mySaved = false; |
| } |
| |
| @Override |
| public void saveAttemptFinished(ProviderType type, SVNURL url, String realm, String kind) { |
| if (! mySuccess) return; |
| if (! mySaved) { |
| saveRegistration(type, url, false); |
| } |
| } |
| |
| @Override |
| public void actualSaveWillBeTried(ProviderType type, SVNURL url, String realm, String kind) { |
| if (! mySuccess) return; |
| mySaved = true; |
| saveRegistration(type, url, true); |
| } |
| |
| private void saveRegistration(ProviderType type, SVNURL url, boolean withCredentials) { |
| mySuccess = myExpectedSequence.get(myCnt).equals(new Trinity<ProviderType, SVNURL, Type>(type, url, withCredentials ? Type.save : Type.without_pasword_save)); |
| if (mySuccess) { |
| ++ myCnt; |
| } |
| synchronized (mySynchObject) { |
| mySynchObject.notifyAll(); |
| } |
| } |
| |
| public void reset() { |
| myExpectedSequence.clear(); |
| myCnt = 0; |
| mySuccess = true; |
| } |
| |
| @Override |
| public void requested(ProviderType type, SVNURL url, String realm, String kind, boolean canceled) { |
| if (! mySuccess) return; |
| |
| mySuccess = myExpectedSequence.get(myCnt).equals(new Trinity<ProviderType, SVNURL, Type>(type, url, Type.request)); |
| if (mySuccess) { |
| ++ myCnt; |
| } |
| synchronized (mySynchObject) { |
| mySynchObject.notifyAll(); |
| } |
| } |
| |
| public void assertForAwt() { |
| Assert.assertTrue("last cnt = " + myCnt, mySuccess); |
| } |
| } |
| |
| private static class SavedOnceListener implements SvnAuthenticationListener { |
| private final Set<Pair<SVNURL, String>> myClientRequested; |
| private final Set<Pair<SVNURL, String>> mySaved; |
| private String myCause; |
| private boolean mySaveCalled; |
| |
| private SavedOnceListener() { |
| myClientRequested = new HashSet<Pair<SVNURL, String>>(); |
| mySaved = new HashSet<Pair<SVNURL, String>>(); |
| } |
| |
| @Override |
| public void acknowledge(boolean accepted, String kind, String realm, SVNErrorMessage message, SVNAuthentication authentication) { |
| } |
| |
| public void reset() { |
| mySaved.clear(); |
| myClientRequested.clear(); |
| } |
| |
| @Override |
| public void saveAttemptStarted(ProviderType type, SVNURL url, String realm, String kind) { |
| mySaveCalled = false; |
| } |
| |
| @Override |
| public void saveAttemptFinished(ProviderType type, SVNURL url, String realm, String kind) { |
| if (! mySaveCalled) { |
| saveRegistration(url, kind); |
| } |
| } |
| |
| @Override |
| public void actualSaveWillBeTried(ProviderType type, SVNURL url, String realm, String kind) { |
| mySaveCalled = true; |
| saveRegistration(url, kind); |
| } |
| |
| private void saveRegistration(SVNURL url, String kind) { |
| final Pair<SVNURL, String> pair = new Pair<SVNURL, String>(url, kind); |
| if (mySaved.contains(pair)) { |
| myCause = "saved twice"; |
| } |
| mySaved.add(pair); |
| } |
| |
| public boolean isSaved(final SVNURL url, final String kind) { |
| return mySaved.contains(new Pair<SVNURL, String>(url, kind)); |
| } |
| |
| @Override |
| public void requested(ProviderType type, SVNURL url, String realm, String kind, boolean canceled) { |
| if (ProviderType.interactive.equals(type)) { |
| final Pair<SVNURL, String> pair = new Pair<SVNURL, String>(url, kind); |
| if (myClientRequested.contains(pair)) { |
| myCause = "client requested twice"; |
| } |
| myClientRequested.add(pair); |
| } |
| } |
| |
| public void assertForAwt() { |
| assertNull(myCause, myCause); |
| } |
| |
| public void assertSaved(final SVNURL url, final String kind) { |
| Assert.assertTrue("not saved", mySaved.contains(new Pair<SVNURL, String>(url, kind))); |
| } |
| |
| public void assertNotSaved(final SVNURL url, final String kind) { |
| Assert.assertTrue("saved", ! mySaved.contains(new Pair<SVNURL, String>(url, kind))); |
| } |
| } |
| |
| private static enum Type { |
| request, |
| save, |
| without_pasword_save |
| } |
| |
| private static class TestInteraction implements SvnAuthenticationInteraction { |
| private int myNumAuthWarn; |
| private int myNumPasswordsWarn; |
| private int myNumSSLWarn; |
| private int myNumPlaintextPrompt; |
| private int myNumSSLPlaintextPrompt; |
| |
| private boolean myPlaintextAnswer; |
| private boolean mySSLPlaintextAnswer; |
| |
| public void setPlaintextAnswer(boolean plaintextAnswer) { |
| myPlaintextAnswer = plaintextAnswer; |
| } |
| |
| public void setSSLPlaintextAnswer(boolean SSLPlaintextAnswer) { |
| mySSLPlaintextAnswer = SSLPlaintextAnswer; |
| } |
| |
| public void assertNothing() { |
| Assert.assertEquals("myNumAuthWarn", myNumAuthWarn, 0); |
| Assert.assertEquals("myNumPasswordsWarn", myNumPasswordsWarn, 0); |
| Assert.assertEquals("myNumSSLWarn", myNumSSLWarn, 0); |
| Assert.assertEquals("myNumPlaintextPrompt", myNumPlaintextPrompt, 0); |
| Assert.assertEquals("myNumSSLPlaintextPrompt", myNumSSLPlaintextPrompt, 0); |
| } |
| |
| public void reset() { |
| myNumAuthWarn = 0; |
| myNumPasswordsWarn = 0; |
| myNumSSLWarn = 0; |
| myNumPlaintextPrompt = 0; |
| myNumSSLPlaintextPrompt = 0; |
| } |
| |
| @Override |
| public boolean promptForPlaintextPasswordSaving(SVNURL url, String realm) { |
| ++ myNumPlaintextPrompt; |
| return myPlaintextAnswer; |
| } |
| |
| @Override |
| public boolean promptInAwt() { |
| return false; |
| } |
| |
| @Override |
| public void warnOnAuthStorageDisabled(SVNURL url) { |
| ++ myNumAuthWarn; |
| } |
| |
| @Override |
| public void warnOnPasswordStorageDisabled(SVNURL url) { |
| ++ myNumPasswordsWarn; |
| } |
| |
| @Override |
| public void warnOnSSLPassphraseStorageDisabled(SVNURL url) { |
| ++ myNumSSLWarn; |
| } |
| |
| @Override |
| public boolean promptForSSLPlaintextPassphraseSaving(SVNURL url, String realm, File certificateFile, String certificateName) { |
| ++ myNumSSLPlaintextPrompt; |
| return mySSLPlaintextAnswer; |
| } |
| |
| public int getNumAuthWarn() { |
| return myNumAuthWarn; |
| } |
| |
| public int getNumPasswordsWarn() { |
| return myNumPasswordsWarn; |
| } |
| |
| public int getNumPlaintextPrompt() { |
| return myNumPlaintextPrompt; |
| } |
| |
| public int getNumSSLPlaintextPrompt() { |
| return myNumSSLPlaintextPrompt; |
| } |
| |
| public int getNumSSLWarn() { |
| return myNumSSLWarn; |
| } |
| |
| @Override |
| public void dispose() { |
| } |
| } |
| } |