org.tigris.subversion.javahl.tests.SVNTests Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of javasvn Show documentation
Show all versions of javasvn Show documentation
The only pure Java Subversion library in the world
/**
* @copyright
* ====================================================================
* Copyright (c) 2003-2005 CollabNet. All rights reserved.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at http://subversion.tigris.org/license-1.html.
* If newer versions of this license are posted there, you may use a
* newer version instead, at your option.
*
* This software consists of voluntary contributions made by many
* individuals. For exact contribution history, see the revision
* history and logs, available at http://subversion.tigris.org/.
* ====================================================================
* @endcopyright
*/
package org.tigris.subversion.javahl.tests;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.tigris.subversion.javahl.*;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* common base class for the javahl binding tests
*/
public class SVNTests extends TestCase
{
/**
* our admin object, mostly used for creating,dumping and loading
* repositories
*/
protected SVNAdmin admin;
/**
* the subversion client, what we want to test.
*/
protected SVNClientInterface client;
/**
* the root directory. All other files and directories will created in
* here
*/
protected File rootDir;
/**
* the base name of the test. Together with the testCounter this will make
* up the directory name of the test.
*/
protected String testBaseName;
/**
* this counter will be incremented for every test in one suite (test class)
*/
protected static int testCounter;
/**
* the file in which the sample repository has been dumped.
*/
protected File greekDump;
/**
* the directory of the sample repository.
*/
protected File greekRepos;
/**
* the initial working copy of the sample repository.
*/
protected WC greekWC;
/**
* the directory "svn-test-work/local_tmp" in the rootDir. This
* will be used for the sample repository and its dumpfile and for
* the config directory
*/
protected File localTmp;
/**
* the directory "repositories" in the rootDir. All test repositories will
* be created here.
*/
protected File repositories;
/**
* the directory "working_copies" in the rootDir. All test working copies
* will be created here.
*/
protected File workingCopies;
/**
* the directory "config" in the localTmp. It will be used as the
* configuration directory for all the tests.
*/
protected File conf;
/**
* standard log message. Used for all commits.
*/
protected String logMessage = "Log Message";
/**
* the map of all items expected to be received by the callback for the
* log message. After each commit, this will be cleared
*/
protected Map expectedCommitItems;
/**
* common root directory for all tests. Can be set by the command line or
* by the system property "test.rootdir". If not set, the current directory
* of this process is used
*/
protected static String rootDirectoryName;
/**
* common root URL for all tests. Can be set by the command line or by the
* system property "test.rooturl". If not set, the file url of the
* rootDirectoryName is used.
*/
protected static String rootUrl;
/**
* retrieve the root directory and the root url from the command line
* arguments
* @param args command line arguments
*/
protected static void processArgs(String[] args)
{
if(args == null)
return;
for (int i = 0; i < args.length; i++)
{
String arg = args[i];
if("-d".equals(arg))
if(i + 1 < args.length)
{
rootDirectoryName = args[++i];
}
if("-u".equals(arg))
if(i + 1 < args.length)
{
rootUrl = args[++i];
}
}
}
/**
* Main method, will call all tests of all test classes
* @param args command line arguments
*/
public static void main(String[] args)
{
processArgs(args);
junit.textui.TestRunner.run(suite());
}
/**
* build a test suite with all test of all test classes known
* @return complete test suite
*/
public static TestSuite suite()
{
TestSuite suite = new TestSuite();
suite.addTestSuite(BasicTests.class);
suite.addTestSuite(SVNAdminTests.class);
return suite;
}
/**
* Initialize one test object
*/
protected SVNTests()
{
// if not already set, get a usefull value for rootDir
if(rootDirectoryName == null)
rootDirectoryName = System.getProperty("test.rootdir");
if(rootDirectoryName == null)
rootDirectoryName = System.getProperty("user.dir");
rootDir = new File(rootDirectoryName);
// if not alread set, get a usefull value for root url
if(rootUrl == null)
rootUrl = System.getProperty("test.rooturl");
if(rootUrl == null)
{
// if no root url, set build a file url
rootUrl = rootDir.toURI().toString();
// java may have a different view about the number of '/' to follow
// "file:" than subversion. We convert to the subversion view.
if(rootUrl.startsWith("file:///"))
; // this is the form subversion needs
else if(rootUrl.startsWith("file://"))
rootUrl = rootUrl.replaceFirst("file://", "file:///");
else if(rootUrl.startsWith("file:/"))
rootUrl = rootUrl.replaceFirst("file:/", "file:///");
}
}
/**
* Standard initialization of one test
* @throws Exception
*/
protected void setUp() throws Exception
{
super.setUp();
// create a clean directory for the config files and the sample
// repository
//
// ### The path is now "svn-test-work/local_tmp", however, I'm
// ### not sure how to update this code for that.
localTmp = new File(rootDir, "local_tmp");
if(localTmp.exists())
removeDirectoryWithContent(localTmp);
localTmp.mkdir();
conf = new File(localTmp, "config");
conf.mkdir();
// create and configure the needed subversion objects
admin = new SVNAdmin();
client = new SVNClient();
client.notification2(new MyNotifier());
client.commitMessageHandler(new MyCommitMessage());
client.username("jrandom");
client.password("rayjandom");
client.setConfigDirectory(conf.getAbsolutePath());
expectedCommitItems = new HashMap();
// build and dump the sample repository
File greekFiles = buildGreekFiles();
greekRepos = new File(localTmp, "repos");
greekDump = new File(localTmp, "greek_dump");
admin.create(greekRepos.getAbsolutePath(), true,false, null,
SVNAdmin.BDB);
addExpectedCommitItem(greekFiles.getAbsolutePath(), null, null,
NodeKind.none, CommitItemStateFlags.Add);
client.doImport(greekFiles.getAbsolutePath(), makeReposUrl(greekRepos),
null, true );
admin.dump(greekRepos.getAbsolutePath(), new FileOutputer(greekDump),
new IgnoreOutputer(), null, null, false);
// create the directory for the repositories and the working copies
//
// ### The paths are now "svn-test-work/repositories" and
// ### "svn-test-work/repositories". However, I'm not sure
// ### how to update this code for that.
repositories = new File(rootDir, "repositories");
repositories.mkdirs();
workingCopies = new File(rootDir, "working_copies");
workingCopies.mkdirs();
}
/**
* build a sample directory with test files to be used as import for
* the sample repository. Create also the master working copy test set.
* @return the sample repository
* @throws IOException
*/
private File buildGreekFiles() throws IOException
{
File greekFiles = new File(localTmp, "greek_files");
greekFiles.mkdir();
greekWC = new WC();
greekWC.addItem("",null);
greekWC.addItem("iota", "This is the file 'iota'.");
greekWC.addItem("A", null);
greekWC.addItem("A/mu", "This is the file 'mu'.");
greekWC.addItem("A/B", null);
greekWC.addItem("A/B/lambda", "This is the file 'lambda'.");
greekWC.addItem("A/B/E", null);
greekWC.addItem("A/B/E/alpha", "This is the file 'alpha'.");
greekWC.addItem("A/B/E/beta", "This is the file 'beta'.");
greekWC.addItem("A/B/F", null);
greekWC.addItem("A/C", null);
greekWC.addItem("A/D", null);
greekWC.addItem("A/D/gamma", "This is the file 'gamma'.");
greekWC.addItem("A/D/H", null);
greekWC.addItem("A/D/H/chi", "This is the file 'chi'.");
greekWC.addItem("A/D/H/psi", "This is the file 'psi'.");
greekWC.addItem("A/D/H/omega", "This is the file 'omega'.");
greekWC.addItem("A/D/G", null);
greekWC.addItem("A/D/G/pi", "This is the file 'pi'.");
greekWC.addItem("A/D/G/rho", "This is the file 'rho'.");
greekWC.addItem("A/D/G/tau", "This is the file 'tau'.");
greekWC.materialize(greekFiles);
return greekFiles;
}
/**
* Remove a directory with all files and directories it may contain.
* @param localTmp
*/
protected void removeDirectoryWithContent(File localTmp)
{
if(localTmp.isDirectory())
{
File[] content = localTmp.listFiles();
for(int i = 0; i < content.length; i++)
removeDirectoryWithContent(content[i]);
}
localTmp.delete();
}
/**
* cleanup after one test
* @throws Exception
*/
protected void tearDown() throws Exception
{
// take care of our subversion objects.
admin.dispose();
client.dispose();
// remove the temporary directory
removeDirectoryWithContent(localTmp);
super.tearDown();
}
/**
* Create the url for the repository to be used for the tests.
* @param file the directory of the repository
* @return the URL for the repository
*/
protected String makeReposUrl(File file)
{
// split the common part of the root directory
String path = file.getAbsolutePath().
substring(rootDirectoryName.length()+1);
// append to the root url
return rootUrl + path.replace(File.separatorChar, '/');
}
/**
* add another commit item expected during the callback for the log message.
* @param workingCopyPath the path of the of the working
* @param baseUrl the url for the repository
* @param itemPath the path of the item relative the working copy
* @param nodeKind expected node kind (dir or file or none)
* @param stateFlags expected commit state flags
* (see CommitItemStateFlags)
*/
protected void addExpectedCommitItem(String workingCopyPath, String baseUrl,
String itemPath, int nodeKind,
int stateFlags)
{
//determine the full working copy path and the full url of the item.
String path = null;
if(workingCopyPath != null)
if(itemPath != null)
path = workingCopyPath.replace(File.separatorChar, '/') +
'/' + itemPath;
else
path = workingCopyPath.replace(File.separatorChar, '/');
String url = null;
if(baseUrl != null)
if(itemPath != null)
url = baseUrl + '/' + itemPath;
else
url = baseUrl;
// the key of the item is either the url or the path (if no url)
String key;
if(url != null)
key = url;
else
key = path;
expectedCommitItems.put(key, new MyCommitItem(path, nodeKind,
stateFlags, url));
}
/**
* Intended to be called as part of test method execution
* (post-{@link #setUp()}). Calls fail() if the
* directory name cannot be determined.
*
* @return The name of the working copy administrative directory.
* @since 1.3
*/
protected String getAdminDirectoryName() {
String admDirName = null;
if (this.client != null) {
admDirName = client.getAdminDirectoryName();
}
if (admDirName == null) {
fail("Unable to determine the WC admin directory name");
}
return admDirName;
}
/**
* internal class which implements the OutputInterface to write the data
* to a file.
*/
public class FileOutputer implements OutputInterface
{
/**
* the output file stream
*/
FileOutputStream myStream;
/**
* create new object
* @param outputName the file to write the data to
* @throws IOException
*/
public FileOutputer(File outputName) throws IOException
{
myStream = new FileOutputStream(outputName);
}
/**
* write the bytes in data to java
* @param data the data to be writtem
* @throws IOException throw in case of problems.
*/
public int write(byte[] data) throws IOException
{
myStream.write(data);
return data.length;
}
/**
* close the output
* @throws IOException throw in case of problems.
*/
public void close() throws IOException
{
myStream.close();
}
}
/**
* internal class implements the OutputInterface, but ignores the data
*/
public class IgnoreOutputer implements OutputInterface
{
/**
* write the bytes in data to java
* @param data the data to be writtem
* @throws IOException throw in case of problems.
*/
public int write(byte[] data) throws IOException
{
return data.length;
}
/**
* close the output
* @throws IOException throw in case of problems.
*/
public void close() throws IOException
{
}
}
/**
* internal class which implements the InputInterface to read the data
* from a file.
*/
public class FileInputer implements InputInterface
{
/**
* input file stream
*/
FileInputStream myStream;
/**
* create a new object
* @param inputName the file from which the data is read
* @throws IOException
*/
public FileInputer(File inputName) throws IOException
{
myStream = new FileInputStream(inputName);
}
/**
* read the number of data.length bytes from input.
* @param data array to store the read bytes.
* @throws IOException throw in case of problems.
*/
public int read(byte[] data) throws IOException
{
return myStream.read(data);
}
/**
* close the input
* @throws IOException throw in case of problems.
*/
public void close() throws IOException
{
myStream.close();
}
}
/**
* this internal class represent the repository and the working copy for
* one test.
*/
protected class OneTest
{
/**
* the file name of repository (used by SVNAdmin)
*/
protected File repository;
/**
* the file name of the working copy directory
*/
protected File workingCopy;
/**
* the url of the repository (used by SVNClient)
*/
protected String url;
/**
* the expected layout of the working copy after the next subversion
* command
*/
protected WC wc;
/**
* build a new test setup with a new repository, a new working and a
* new expected working layout
* @throws Exception
*/
protected OneTest() throws Exception
{
String testName = testBaseName + ++testCounter;
wc = greekWC.copy();
repository = createStartRepository(testName);
url = makeReposUrl(repository);
workingCopy = createStartWorkingCopy(repository, testName);
}
/**
* Copy the working copy and the expected working copy layout for tests
* which need multiple working copy
* @param append append to the working copy name of the original
* @return second test object.
* @throws Exception
*/
protected OneTest copy(String append) throws Exception
{
return new OneTest(this, append);
}
/**
* constructor for create a copy
* @param orig original test
* @param append append this to the directory name of the original
* test
* @throws Exception
*/
private OneTest(OneTest orig, String append) throws Exception
{
String testName = testBaseName + testCounter +append;
repository = orig.getRepository();
url = orig.getUrl();
wc = orig.wc.copy();
workingCopy = createStartWorkingCopy(repository, testName);
}
/**
* Return the directory of the repository
* @return the repository directory name
*/
public File getRepository()
{
return repository;
}
/**
* Return the name of the directory of the repository
* @return the name of repository directory
*/
public String getRepositoryPath()
{
return repository.getAbsolutePath();
}
/**
* Return the working copy directory
* @return the working copy directory
*/
public File getWorkingCopy()
{
return workingCopy;
}
/**
* Return the working copy directory name
* @return the name of the working copy directory
*/
public String getWCPath()
{
return workingCopy.getAbsolutePath();
}
/**
* Returns the url of repository
* @return the url
*/
public String getUrl()
{
return url;
}
/**
* Returns the expected working copy content
* @return the expected working copy content
*/
public WC getWc()
{
return wc;
}
/**
* Create the repository for the beginning of the test
* @param testName the name of the test
* @return the repository directory
* @throws Exception
*/
protected File createStartRepository(String testName) throws Exception
{
// build a clean repository directory
File repos = new File(repositories, testName);
removeDirectoryWithContent(repos);
// create and load the repository from the default repository dump
admin.create(repos.getAbsolutePath(), true, false,
conf.getAbsolutePath(), SVNAdmin.BDB);
admin.load(repos.getAbsolutePath(), new FileInputer(greekDump),
new IgnoreOutputer(), false, false, null);
return repos;
}
/**
* Create the working copy for the beginning of the test
* @param repos the repository directory
* @param testName the name of the test
* @return the directory of the working copy
* @throws Exception
*/
protected File createStartWorkingCopy(File repos, String testName)
throws Exception
{
// build a clean working directory
String uri = makeReposUrl(repos);
workingCopy = new File(workingCopies, testName);
removeDirectoryWithContent(workingCopy);
// checkout the repository
client.checkout(uri, workingCopy.getAbsolutePath(), null, true);
// sanity check the working with its expected status
checkStatus();
return workingCopy;
}
/**
* Check if the working copy has the expected status
* @throws Exception
*/
public void checkStatus() throws Exception
{
Status[] states = client.status(workingCopy.getAbsolutePath(), true,
false, true, true);
wc.check(states, workingCopy.getAbsolutePath());
}
}
/**
* internal class to receive the request for the log messages to check if
* the expected commit items are presented
*/
class MyCommitMessage implements CommitMessage
{
/**
* Retrieve a commit message from the user based on the items to be commited
* @param elementsToBeCommited Array of elements to be commited
* @return the log message of the commit.
*/
public String getLogMessage(CommitItem[] elementsToBeCommited)
{
// check all received CommitItems are expected as received
for (int i = 0; i < elementsToBeCommited.length; i++)
{
CommitItem commitItem = elementsToBeCommited[i];
// since imports do not provide a url, the key is either url or
// path
String key;
if(commitItem.getUrl() != null)
key = commitItem.getUrl();
else
key = commitItem.getPath();
MyCommitItem myItem = (MyCommitItem) expectedCommitItems.get(
key);
// check commit item is expected and has the expected data
assertNotNull("commit item for "+key+ " not expected", myItem);
myItem.test(commitItem, key);
}
// all remaining expected commit items are missing
for (Iterator iterator = expectedCommitItems.keySet().iterator();
iterator.hasNext();)
{
String str = (String) iterator.next();
fail("commit item for "+str+" not found");
}
return logMessage;
}
}
/**
* internal class to describe an expected commit item
*/
class MyCommitItem
{
/**
* the path of the item
*/
String myPath;
/**
* the kind of node (file, diretory or none, see NodeKind)
*/
int myNodeKind;
/**
* the reason why this item is commited (see CommitItemStateFlag)
*/
int myStateFlags;
/**
* the url of the item
*/
String myUrl;
/**
* build one expected commit item
* @param path the expected path
* @param nodeKind the expected node kind
* @param stateFlags the expected state flags
* @param url the expected url
*/
private MyCommitItem(String path, int nodeKind, int stateFlags,
String url)
{
myPath = path;
myNodeKind = nodeKind;
myStateFlags = stateFlags;
myUrl = url;
}
/**
* Check if the commit item has the expected data
* @param ci the commit item to check
* @param key the key of the item
*/
private void test(CommitItem ci, String key)
{
assertEquals("commit item path", ci.getPath(), myPath);
assertEquals("commit item node kind", ci.getNodeKind(), myNodeKind);
assertEquals("commit item state flags", ci.getStateFlags(),
myStateFlags);
assertEquals("commit item url", ci.getUrl(), myUrl);
// after the test, remove the item from the expected map
expectedCommitItems.remove(key);
}
}
class MyNotifier implements Notify2
{
/**
* Handler for Subversion notifications.
*
* Override this function to allow Subversion to send notifications
*
* @param info everything to know about this event
*/
public void onNotify(NotifyInformation info)
{
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy