Unit testing overhaul.

James Moger

2011-12-07 7e8873a14ccc2cb25213489d7d7ba97f09673831

Unit testing overhaul.

Migrated to JUnit4-style tests.
Replaced assertTrue with assertEquals where appropriate.
Start Gitblit instance with dedicated unit testing settings file and
user service.
Integrated RPC, Federation, and Git servlet unit tests into suite.

 src/com/gitblit/GitBlitServer.java

@@ -130,6 +130,11 @@
     */

    private static void start(Params params) {

        FileSettings settings = Params.FILESETTINGS;

        if (!StringUtils.isEmpty(params.settingsfile)) {

            if (new File(params.settingsfile).exists()) {

                settings = new FileSettings(params.settingsfile);				
            }

        }



        logger = LoggerFactory.getLogger(GitBlitServer.class);

        logger.info(Constants.BORDER);

@@ -462,5 +467,11 @@
        @Parameter(names = "--shutdownPort", description = "Port for Shutdown Monitor to listen on. (port <= 0 will disable this monitor)")

        public Integer shutdownPort = FILESETTINGS.getInteger(Keys.server.shutdownPort, 8081);



        /*

         * Setting overrides

         */

        @Parameter(names = { "--settings" }, description = "Path to alternative settings")

        public String settingsfile;



    }

}

 test-gitblit.properties

New file
@@ -0,0 +1,84 @@
#
# Gitblit Unit Testing properties
#

git.repositoriesFolder = git
git.searchRepositoriesSubfolders = true
git.enableGitServlet = true
web.authenticateViewPages = false
web.authenticateAdminPages = true
web.allowCookieAuthentication = true
realm.userService = test-users.conf
realm.passwordStorage = md5
realm.minPasswordLength = 5
web.siteName =
web.allowAdministration = true
web.enableRpcServlet = true
web.enableRpcManagement = true
web.enableRpcAdministration = true
web.allowGravatar = true
web.allowZipDownloads = true
web.syndicationEntries = 25
web.showRepositorySizes = true
web.showFederationRegistrations = false
web.loginMessage = gitblit
web.repositoriesMessage = gitblit
web.useClientTimezone = false
web.timeFormat = HH:mm
web.datestampShortFormat = yyyy-MM-dd
web.datestampLongFormat = EEEE, MMMM d, yyyy
web.datetimestampLongFormat = EEEE, MMMM d, yyyy h:mm a z
web.mountParameters = true
web.forwardSlashCharacter = /
web.otherUrls = 
web.repositoryListType = grouped
web.repositoryRootGroupName = main
web.repositoryListSwatches = true
web.diffStyle = gitblit
web.showEmailAddresses = true
web.showSearchTypeSelection = false
web.generateActivityGraph = true
web.activityDuration = 14
web.summaryCommitCount = 16
web.summaryRefsCount = 5
web.itemsPerPage = 50
web.prettyPrintExtensions = c cpp cs css htm html java js php pl prefs properties py rb sh sql xml vb
web.markdownExtensions = md mkd markdown MD MKD
web.imageExtensions = bmp jpg gif png 
web.binaryExtensions = jar pdf tar.gz zip
web.aggressiveHeapManagement = false
web.debugMode = false
regex.global = true
regex.global.bug = \\b(Bug:)(\\s*[#]?|-){0,1}(\\d+)\\b!!!<a href="http://somehost/bug/$3">Bug-Id: $3</a>
regex.global.changeid = \\b(Change-Id:\\s*)([A-Za-z0-9]*)\\b!!!<a href="http://somehost/changeid/$2">Change-Id: $2</a>
regex.myrepository.bug = \\b(Bug:)(\\s*[#]?|-){0,1}(\\d+)\\b!!!<a href="http://elsewhere/bug/$3">Bug-Id: $3</a>
mail.server =
mail.port = 25
mail.debug = false
mail.username =
mail.password =
mail.fromAddress = 
mail.adminAddresses = 
federation.name = Unit Test
federation.passphrase = Unit Testing
federation.allowProposals = false
federation.proposalsFolder = proposals
federation.defaultFrequency = 60 mins
federation.sets = animal mineral vegetable
federation.example1.url = https://go.gitblit.com
federation.example1.token = 6f3b8a24bf970f17289b234284c94f43eb42f0e4
federation.example1.frequency = 120 mins
federation.example1.folder =
federation.example1.bare = true 
federation.example1.mirror = true 
federation.example1.mergeAccounts = true

server.tempFolder = temp
server.useNio = true
server.contextPath = /
server.httpPort = 0
server.httpsPort = 8443
server.httpBindInterface = localhost
server.httpsBindInterface = localhost
server.storePassword = gitblit
server.shutdownPort = 8081

 test-users.conf

New file
@@ -0,0 +1,6 @@
[user "admin"]
    password = admin
    role = "#admin"
    role = "#notfederated"
[team "admins"]
    user = admin

 tests/com/gitblit/tests/ActivityTest.java

@@ -15,15 +15,18 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;



import java.io.IOException;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.models.GravatarProfile;

import com.gitblit.utils.ActivityUtils;



public class ActivityTest extends TestCase {

public class ActivityTest {



    @Test

    public void testGravatarProfile() throws IOException {        

        GravatarProfile profile = ActivityUtils.getGravatarProfile("beau@dentedreality.com.au");

        assertEquals("beau", profile.preferredUsername);


 tests/com/gitblit/tests/Base64Test.java

@@ -15,14 +15,17 @@
 */

package com.gitblit.tests;



import junit.framework.TestCase;

import static org.junit.Assert.assertEquals;



import org.junit.Test;



import com.gitblit.utils.Base64;



public class Base64Test extends TestCase {

public class Base64Test {



    @Test

    public void testBase64() {

        String source = "this is a test";		
        String source = "this is a test";

        String base64 = Base64.encodeBytes(source.getBytes());

        assertEquals("dGhpcyBpcyBhIHRlc3Q=", base64);

        String decoded = new String(Base64.decode(base64));


 tests/com/gitblit/tests/ByteFormatTest.java

@@ -15,19 +15,22 @@
 */

package com.gitblit.tests;



import junit.framework.TestCase;

import static org.junit.Assert.assertEquals;



import org.junit.Test;



import com.gitblit.utils.ByteFormat;



public class ByteFormatTest extends TestCase {

public class ByteFormatTest {



    @Test

    public void testByteFormat() throws Exception {

        ByteFormat format = new ByteFormat();

        assertTrue(format.format(10).equals("10 b"));

        assertTrue(format.format(1024 * 10).equals("10 KB"));

        assertTrue(format.format(1024 * 1000).equals("1,000 KB"));

        assertTrue(format.format(2 * 1024 * 1000).equals("2.0 MB"));

        assertTrue(format.format(1024 * 1024 * 1000).equals("1,000.0 MB"));

        assertTrue(format.format(2 * 1024 * 1024 * 1000).equals("2.0 GB"));

        assertEquals("10 b", format.format(10));

        assertEquals("10 KB", format.format(1024 * 10));

        assertEquals("1,000 KB", format.format(1024 * 1000));

        assertEquals("2.0 MB", format.format(2 * 1024 * 1000));

        assertEquals("1,000.0 MB", format.format(1024 * 1024 * 1000));

        assertEquals("2.0 GB", format.format(2 * 1024 * 1024 * 1000));

    }

}


 tests/com/gitblit/tests/DiffUtilsTest.java

@@ -15,27 +15,31 @@
 */

package com.gitblit.tests;



import java.util.List;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;



import junit.framework.TestCase;

import java.util.List;



import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.revwalk.RevCommit;

import org.junit.Test;



import com.gitblit.models.AnnotatedLine;

import com.gitblit.utils.DiffUtils;

import com.gitblit.utils.DiffUtils.DiffOutputType;

import com.gitblit.utils.JGitUtils;



public class DiffUtilsTest extends TestCase {

public class DiffUtilsTest {



    @Test

    public void testDiffOutputTypes() throws Exception {

        assertTrue(DiffOutputType.forName("plain").equals(DiffOutputType.PLAIN));

        assertTrue(DiffOutputType.forName("gitweb").equals(DiffOutputType.GITWEB));

        assertTrue(DiffOutputType.forName("gitblit").equals(DiffOutputType.GITBLIT));

        assertTrue(DiffOutputType.forName(null) == null);

        assertEquals(DiffOutputType.PLAIN, DiffOutputType.forName("plain"));

        assertEquals(DiffOutputType.GITWEB, DiffOutputType.forName("gitweb"));

        assertEquals(DiffOutputType.GITBLIT, DiffOutputType.forName("gitblit"));

        assertEquals(null, DiffOutputType.forName(null));

    }



    @Test

    public void testParentCommitDiff() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit commit = JGitUtils.getCommit(repository,

@@ -47,6 +51,7 @@
        assertTrue(diff.indexOf(expected) > -1);

    }



    @Test

    public void testArbitraryCommitDiff() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit baseCommit = JGitUtils.getCommit(repository,

@@ -60,6 +65,7 @@
        assertTrue(diff.indexOf(expected) > -1);

    }



    @Test

    public void testPlainFileDiff() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit commit = JGitUtils.getCommit(repository,

@@ -71,6 +77,7 @@
        assertTrue(diff.indexOf(expected) > -1);

    }



    @Test

    public void testFilePatch() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit commit = JGitUtils.getCommit(repository,

@@ -82,6 +89,7 @@
        assertTrue(patch.indexOf(expected) > -1);

    }



    @Test

    public void testArbitraryFilePatch() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit baseCommit = JGitUtils.getCommit(repository,

@@ -95,6 +103,7 @@
        assertTrue(patch.indexOf(expected) > -1);

    }



    @Test

    public void testArbitraryCommitPatch() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit baseCommit = JGitUtils.getCommit(repository,

@@ -108,12 +117,13 @@
        assertTrue(patch.indexOf(expected) > -1);

    }



    @Test

    public void testBlame() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        List<AnnotatedLine> lines = DiffUtils.blame(repository, "java.java",

                "1d0c2933a4ae69c362f76797d42d6bd182d05176");

        repository.close();

        assertTrue(lines.size() > 0);

        assertTrue(lines.get(0).commitId.equals("c6d31dccf5cc75e8e46299fc62d38f60ec6d41e0"));

        assertEquals("c6d31dccf5cc75e8e46299fc62d38f60ec6d41e0", lines.get(0).commitId);

    }

}


 tests/com/gitblit/tests/FederationTests.java

@@ -15,55 +15,48 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;



import java.io.IOException;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicBoolean;



import junit.framework.TestCase;

import org.junit.AfterClass;

import org.junit.BeforeClass;

import org.junit.Test;



import com.gitblit.Constants.AccessRestrictionType;

import com.gitblit.Constants.FederationProposalResult;

import com.gitblit.Constants.FederationRequest;

import com.gitblit.Constants.FederationToken;

import com.gitblit.GitBlitServer;

import com.gitblit.models.FederationProposal;

import com.gitblit.models.RepositoryModel;

import com.gitblit.utils.FederationUtils;

import com.gitblit.utils.JsonUtils;



public class FederationTests extends TestCase {

public class FederationTests {



    int port = 8180;

    String url = GitBlitSuite.url;

    String account = GitBlitSuite.account;

    String password = GitBlitSuite.password;



    int shutdownPort = 8181;

    private static final AtomicBoolean started = new AtomicBoolean(false);



    @Override

    protected void setUp() throws Exception {

        // Start a Gitblit instance

        Executors.newSingleThreadExecutor().execute(new Runnable() {

            public void run() {

                GitBlitServer.main("--httpPort", "" + port, "--httpsPort", "0", "--shutdownPort",

                        "" + shutdownPort, "--repositoriesFolder",

                        "\"" + GitBlitSuite.REPOSITORIES.getAbsolutePath() + "\"", "--userService",

                        "distrib/users.conf");

            }

        });



        // Wait a few seconds for it to be running

        Thread.sleep(2500);

    @BeforeClass

    public static void startGitblit() throws Exception {

        started.set(GitBlitSuite.startGitblit());

    }



    @Override

    protected void tearDown() throws Exception {

        // Stop Gitblit

        GitBlitServer.main("--stop", "--shutdownPort", "" + shutdownPort);



        // Wait a few seconds for it to be running

        Thread.sleep(2500);

    @AfterClass

    public static void stopGitblit() throws Exception {

        if (started.get()) {

            GitBlitSuite.stopGitblit();

        }

    }



    @Test

    public void testProposal() throws Exception {

        // create dummy repository data

        Map<String, RepositoryModel> repositories = new HashMap<String, RepositoryModel>();

@@ -83,16 +76,16 @@
                "testtoken", repositories);



        // propose federation

        assertEquals("proposal refused",

                FederationUtils.propose("http://localhost:" + port, proposal),

        assertEquals("proposal refused", FederationUtils.propose(url, proposal),

                FederationProposalResult.NO_PROPOSALS);

    }



    @Test

    public void testPullRepositories() throws Exception {

        try {

            String url = FederationUtils.asLink("http://localhost:" + port, "testtoken",

            String requrl = FederationUtils.asLink(url, "d7cc58921a80b37e0329a4dae2f9af38bf61ef5c",

                    FederationRequest.PULL_REPOSITORIES);

            String json = JsonUtils.retrieveJsonString(url, null, null);

            String json = JsonUtils.retrieveJsonString(requrl, null, null);

        } catch (IOException e) {

            if (!e.getMessage().contains("403")) {

                throw e;


 tests/com/gitblit/tests/FileUtilsTest.java

@@ -15,20 +15,25 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;



import java.io.File;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.utils.FileUtils;



public class FileUtilsTest extends TestCase {

public class FileUtilsTest {



    @Test

    public void testReadContent() throws Exception {

        File dir = new File(System.getProperty("user.dir"));

        String rawContent = FileUtils.readContent(new File(dir, "LICENSE"), "\n");

        assertTrue(rawContent.trim().startsWith("Apache License"));

    }

	


    @Test

    public void testWriteContent() throws Exception {

        String contentA = "this is a test";

        File tmp = File.createTempFile("gitblit-", ".test");

@@ -37,6 +42,7 @@
        assertEquals(contentA, contentB);

    }



    @Test

    public void testFolderSize() throws Exception {

        assertEquals(-1, FileUtils.folderSize(null));

        assertEquals(-1, FileUtils.folderSize(new File(System.getProperty("user.dir"), "pretend")));

@@ -47,7 +53,6 @@


        File file = new File(System.getProperty("user.dir"), "LICENSE");

        size = FileUtils.folderSize(file);

        assertTrue("size is actually " + size, size == 11556L);



        assertEquals("size is actually " + size, 11556L, size);

    }

}

 tests/com/gitblit/tests/GitBlitSuite.java

@@ -17,23 +17,42 @@


import java.io.File;

import java.util.concurrent.Executors;



import junit.extensions.TestSetup;

import junit.framework.Test;

import junit.framework.TestSuite;

import java.util.concurrent.atomic.AtomicBoolean;



import org.eclipse.jgit.lib.Repository;

import org.eclipse.jgit.storage.file.FileRepository;

import org.junit.AfterClass;

import org.junit.BeforeClass;

import org.junit.runner.RunWith;

import org.junit.runners.Suite;

import org.junit.runners.Suite.SuiteClasses;



import com.gitblit.ConfigUserService;

import com.gitblit.FileSettings;

import com.gitblit.GitBlit;

import com.gitblit.GitBlitException;

import com.gitblit.GitBlitServer;

import com.gitblit.models.RepositoryModel;

import com.gitblit.utils.JGitUtils;



public class GitBlitSuite extends TestSetup {

/**

 * The GitBlitSuite uses test-gitblit.properties and test-users.conf. The suite

 * is fairly comprehensive for all lower-level functionality. Wicket pages are

 * currently not unit-tested.

 * 
 * This suite starts a Gitblit server instance within the same JVM instance as

 * the unit tests. This allows the unit tests to access the GitBlit static

 * singleton while also being able to communicate with the instance via tcp/ip

 * for testing rpc requests, federation requests, and git servlet operations.

 * 
 * @author James Moger

 * 
 */

@RunWith(Suite.class)

@SuiteClasses({ FileUtilsTest.class, TimeUtilsTest.class, StringUtilsTest.class, Base64Test.class,

        JsonUtilsTest.class, ByteFormatTest.class, ObjectCacheTest.class, UserServiceTest.class,

        MarkdownUtilsTest.class, JGitUtilsTest.class, SyndicationUtilsTest.class,

        DiffUtilsTest.class, MetricUtilsTest.class, TicgitUtilsTest.class, GitBlitTest.class,

        FederationTests.class, RpcTests.class, GitServletTest.class })

public class GitBlitSuite {



    public static final File REPOSITORIES = new File("git");



@@ -44,30 +63,7 @@
    public static String account = "admin";

    public static String password = "admin";



    private GitBlitSuite(TestSuite suite) {

        super(suite);

    }



    public static Test suite() {

        TestSuite suite = new TestSuite();

        suite.addTestSuite(FileUtilsTest.class);

        suite.addTestSuite(TimeUtilsTest.class);

        suite.addTestSuite(StringUtilsTest.class);

        suite.addTestSuite(Base64Test.class);

        suite.addTestSuite(JsonUtilsTest.class);

        suite.addTestSuite(ByteFormatTest.class);

        suite.addTestSuite(ObjectCacheTest.class);

        suite.addTestSuite(UserServiceTest.class);

        suite.addTestSuite(MarkdownUtilsTest.class);

        suite.addTestSuite(JGitUtilsTest.class);

        suite.addTestSuite(SyndicationUtilsTest.class);

        suite.addTestSuite(DiffUtilsTest.class);

        suite.addTestSuite(MetricUtilsTest.class);

        suite.addTestSuite(TicgitUtilsTest.class);

        suite.addTestSuite(GitBlitTest.class);

        suite.addTestSuite(RpcTests.class);

        return new GitBlitSuite(suite);

    }

    private static AtomicBoolean started = new AtomicBoolean(false);



    public static Repository getHelloworldRepository() throws Exception {

        return new FileRepository(new File(REPOSITORIES, "helloworld.git"));

@@ -85,19 +81,26 @@
        return new FileRepository(new File(REPOSITORIES, "test/bluez-gnome.git"));

    }



    public static void startGitblit() throws Exception {

    public static boolean startGitblit() throws Exception {

        if (started.get()) {

            // already started

            return false;

        }

        // Start a Gitblit instance

        Executors.newSingleThreadExecutor().execute(new Runnable() {

            public void run() {

                GitBlitServer.main("--httpPort", "" + port, "--httpsPort", "0", "--shutdownPort",

                        "" + shutdownPort, "--repositoriesFolder",

                        "\"" + GitBlitSuite.REPOSITORIES.getAbsolutePath() + "\"", "--userService",

                        "distrib/users.conf");

                        "test-users.conf", "--settings", "test-gitblit.properties");

            }

        });



        // Wait a few seconds for it to be running

        Thread.sleep(2500);



        started.set(true);

        return true;

    }



    public static void stopGitblit() throws Exception {

@@ -108,12 +111,9 @@
        Thread.sleep(2500);

    }



    @Override

    protected void setUp() throws Exception {

        FileSettings settings = new FileSettings("distrib/gitblit.properties");

        GitBlit.self().configureContext(settings, true);

        ConfigUserService loginService = new ConfigUserService(new File("distrib/users.conf"));

        GitBlit.self().setUserService(loginService);

    @BeforeClass

    public static void setUp() throws Exception {

        startGitblit();



        if (REPOSITORIES.exists() || REPOSITORIES.mkdirs()) {

            cloneOrFetch("helloworld.git", "https://github.com/git/hello-world.git");

@@ -128,22 +128,20 @@
            showRemoteBranches("ticgit.git");

            showRemoteBranches("test/jgit.git");

        }



        startGitblit();

    }



    @Override

    protected void tearDown() throws Exception {

    @AfterClass

    public static void tearDown() throws Exception {

        stopGitblit();

    }



    private void cloneOrFetch(String name, String fromUrl) throws Exception {

    private static void cloneOrFetch(String name, String fromUrl) throws Exception {

        System.out.print("Fetching " + name + "... ");

        JGitUtils.cloneRepository(REPOSITORIES, name, fromUrl);

        System.out.println("done.");

    }



    private void enableTickets(String repositoryName) {

    private static void enableTickets(String repositoryName) {

        try {

            RepositoryModel model = GitBlit.self().getRepositoryModel(repositoryName);

            model.useTickets = true;

@@ -153,7 +151,7 @@
        }

    }



    private void enableDocs(String repositoryName) {

    private static void enableDocs(String repositoryName) {

        try {

            RepositoryModel model = GitBlit.self().getRepositoryModel(repositoryName);

            model.useDocs = true;

@@ -163,7 +161,7 @@
        }

    }



    private void showRemoteBranches(String repositoryName) {

    private static void showRemoteBranches(String repositoryName) {

        try {

            RepositoryModel model = GitBlit.self().getRepositoryModel(repositoryName);

            model.showRemoteBranches = true;


 tests/com/gitblit/tests/GitBlitTest.java

@@ -15,9 +15,14 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import static org.junit.Assert.assertNotNull;



import java.util.List;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.Constants.AccessRestrictionType;

import com.gitblit.FileSettings;

@@ -25,8 +30,9 @@
import com.gitblit.models.RepositoryModel;

import com.gitblit.models.UserModel;



public class GitBlitTest extends TestCase {

public class GitBlitTest {



    @Test

    public void testRepositoryModel() throws Exception {

        List<String> repositories = GitBlit.self().getRepositoryList();

        assertTrue("Repository list is empty!", repositories.size() > 0);

@@ -37,23 +43,24 @@
        RepositoryModel model = GitBlit.self().getRepositoryModel(

                GitBlitSuite.getHelloworldRepository().getDirectory().getName());

        assertTrue("Helloworld model is null!", model != null);

        assertTrue(model.toString().equals(

                GitBlitSuite.getHelloworldRepository().getDirectory().getName()));

        assertEquals(GitBlitSuite.getHelloworldRepository().getDirectory().getName(), model.toString());

        assertTrue(GitBlit.self().calculateSize(model) > 22000L);

    }



    @Test

    public void testUserModel() throws Exception {

        List<String> users = GitBlit.self().getAllUsernames();

        assertTrue("No users found!", users.size() > 0);

        assertTrue("Admin not found", users.contains("admin"));

        UserModel model = GitBlit.self().getUserModel("admin");

        assertTrue(model.toString().equals("admin"));

        assertEquals("admin", model.toString());

        assertTrue("Admin missing #admin role!", model.canAdmin);

        model.canAdmin = false;

        assertFalse("Admin should not have #admin!", model.canAdmin);

        String repository = GitBlitSuite.getHelloworldRepository().getDirectory().getName();

        RepositoryModel repositoryModel = GitBlit.self().getRepositoryModel(model, repository);

        assertFalse("Admin can still access repository!", model.canAccessRepository(repositoryModel));

        RepositoryModel repositoryModel = GitBlit.self().getRepositoryModel(repository);

        assertFalse("Admin can still access repository!",

                model.canAccessRepository(repositoryModel));

        model.addRepository(repository);

        assertTrue("Admin can't access repository!", model.canAccessRepository(repositoryModel));

        assertEquals(GitBlit.self().getRepositoryModel(model, "pretend"), null);

@@ -61,6 +68,7 @@
        assertTrue(GitBlit.self().getRepositoryModels(model).size() > 0);

    }



    @Test

    public void testAccessRestrictionTypes() throws Exception {

        assertTrue(AccessRestrictionType.PUSH.exceeds(AccessRestrictionType.NONE));

        assertTrue(AccessRestrictionType.CLONE.exceeds(AccessRestrictionType.PUSH));

@@ -82,22 +90,23 @@
        assertTrue(AccessRestrictionType.CLONE.toString().equals("CLONE"));

        assertTrue(AccessRestrictionType.VIEW.toString().equals("VIEW"));



        assertTrue(AccessRestrictionType.fromName("none").equals(AccessRestrictionType.NONE));

        assertTrue(AccessRestrictionType.fromName("push").equals(AccessRestrictionType.PUSH));

        assertTrue(AccessRestrictionType.fromName("clone").equals(AccessRestrictionType.CLONE));

        assertTrue(AccessRestrictionType.fromName("view").equals(AccessRestrictionType.VIEW));

        assertEquals(AccessRestrictionType.NONE, AccessRestrictionType.fromName("none"));

        assertEquals(AccessRestrictionType.PUSH, AccessRestrictionType.fromName("push"));

        assertEquals(AccessRestrictionType.CLONE, AccessRestrictionType.fromName("clone"));

        assertEquals(AccessRestrictionType.VIEW, AccessRestrictionType.fromName("view"));

    }



    @Test

    public void testFileSettings() throws Exception {

        FileSettings settings = new FileSettings("distrib/gitblit.properties");

        assertTrue(settings.getBoolean("missing", true));

        assertTrue(settings.getString("missing", "default").equals("default"));

        assertTrue(settings.getInteger("missing", 10) == 10);

        assertTrue(settings.getInteger("realm.realmFile", 5) == 5);

        assertEquals(true, settings.getBoolean("missing", true));

        assertEquals("default", settings.getString("missing", "default"));

        assertEquals(10, settings.getInteger("missing", 10));

        assertEquals(5, settings.getInteger("realm.realmFile", 5));



        assertTrue(settings.getBoolean("git.enableGitServlet", false));

        assertTrue(settings.getString("realm.userService", null).equals("users.conf"));

        assertTrue(settings.getInteger("realm.minPasswordLength", 0) == 5);

        assertEquals("users.conf", settings.getString("realm.userService", null));

        assertEquals(5, settings.getInteger("realm.minPasswordLength", 0));

        List<String> mdExtensions = settings.getStrings("web.markdownExtensions");

        assertTrue(mdExtensions.size() > 0);

        assertTrue(mdExtensions.contains("md"));

@@ -109,6 +118,7 @@
        assertTrue(settings.getChar("web.forwardSlashCharacter", ' ') == '/');

    }



    @Test

    public void testGitblitSettings() throws Exception {

        // These are already tested by above test method.

        assertTrue(GitBlit.getBoolean("missing", true));

@@ -117,7 +127,7 @@
        assertEquals(5, GitBlit.getInteger("realm.userService", 5));



        assertTrue(GitBlit.getBoolean("git.enableGitServlet", false));

        assertEquals("distrib/users.conf", GitBlit.getString("realm.userService", null));

        assertEquals("test-users.conf", GitBlit.getString("realm.userService", null));

        assertEquals(5, GitBlit.getInteger("realm.minPasswordLength", 0));

        List<String> mdExtensions = GitBlit.getStrings("web.markdownExtensions");

        assertTrue(mdExtensions.size() > 0);

@@ -131,10 +141,12 @@
        assertFalse(GitBlit.isDebugMode());

    }



    @Test

    public void testAuthentication() throws Exception {

        assertTrue(GitBlit.self().authenticate("admin", "admin".toCharArray()) != null);

    }



    @Test

    public void testRepositories() throws Exception {

        assertTrue(GitBlit.self().getRepository("missing") == null);

        assertTrue(GitBlit.self().getRepositoryModel("missing") == null);


 tests/com/gitblit/tests/GitServletTest.java

@@ -1,12 +1,15 @@
package com.gitblit.tests;



import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;



import java.io.BufferedWriter;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStreamWriter;

import java.text.MessageFormat;

import java.util.Date;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicBoolean;



import org.eclipse.jgit.api.CloneCommand;

import org.eclipse.jgit.api.Git;

@@ -16,39 +19,30 @@
import org.junit.BeforeClass;

import org.junit.Test;



import com.gitblit.GitBlitServer;

import com.gitblit.Constants.AccessRestrictionType;

import com.gitblit.GitBlit;

import com.gitblit.models.RepositoryModel;



public class GitServletTest {



    File folder = new File(GitBlitSuite.REPOSITORIES, "working/ticgit");



    static int port = 8180;

    String url = GitBlitSuite.url;

    String account = GitBlitSuite.account;

    String password = GitBlitSuite.password;



    static int shutdownPort = 8181;

    private static final AtomicBoolean started = new AtomicBoolean(false);



    @BeforeClass

    public static void startGitblit() throws Exception {

        // Start a Gitblit instance

        Executors.newSingleThreadExecutor().execute(new Runnable() {

            public void run() {

                GitBlitServer.main("--httpPort", "" + port, "--httpsPort", "0", "--shutdownPort",

                        "" + shutdownPort, "--repositoriesFolder",

                        "\"" + GitBlitSuite.REPOSITORIES.getAbsolutePath() + "\"", "--userService",

                        "distrib/users.conf");

            }

        });



        // Wait a few seconds for it to be running

        Thread.sleep(2500);

        started.set(GitBlitSuite.startGitblit());

    }



    @AfterClass

    public static void stopGitblit() throws Exception {

        // Stop Gitblit

        GitBlitServer.main("--stop", "--shutdownPort", "" + shutdownPort);



        // Wait a few seconds for it to be running

        Thread.sleep(2500);

        if (started.get()) {

            GitBlitSuite.stopGitblit();

        }

    }



    @Test

@@ -57,11 +51,46 @@
            FileUtils.delete(folder, FileUtils.RECURSIVE);

        }

        CloneCommand clone = Git.cloneRepository();

        clone.setURI(MessageFormat.format("http://localhost:{0,number,#}/git/ticgit.git", port));

        clone.setURI(MessageFormat.format("{0}/git/ticgit.git", url));

        clone.setDirectory(folder);

        clone.setBare(false);

        clone.setCloneAllBranches(true);

        clone.setCredentialsProvider(new UsernamePasswordCredentialsProvider(account, password));

        clone.call();

        assertTrue(true);

    }



    @Test

    public void testBogusLoginClone() throws Exception {

        // restrict repository access

        RepositoryModel model = GitBlit.self().getRepositoryModel("ticgit.git");

        model.accessRestriction = AccessRestrictionType.CLONE;

        GitBlit.self().updateRepositoryModel(model.name, model, false);



        // delete any existing working folder

        File folder = new File(GitBlitSuite.REPOSITORIES, "working/gitblit");

        if (folder.exists()) {

            FileUtils.delete(folder, FileUtils.RECURSIVE);

        }

        boolean cloned = false;

        try {

            CloneCommand clone = Git.cloneRepository();

            clone.setURI(MessageFormat.format("{0}/git/ticgit.git", url));

            clone.setDirectory(folder);

            clone.setBare(false);

            clone.setCloneAllBranches(true);

            clone.setCredentialsProvider(new UsernamePasswordCredentialsProvider("bogus", "bogus"));

            clone.call();

            cloned = true;

        } catch (Exception e) {

            e.printStackTrace();

        }



        // restore anonymous repository access

        model.accessRestriction = AccessRestrictionType.NONE;

        GitBlit.self().updateRepositoryModel(model.name, model, false);



        assertFalse("Bogus login cloned a repository?!", cloned);

    }



    @Test

@@ -76,20 +105,5 @@
        git.commit().setMessage("test commit").call();

        git.push().setPushAll().call();

        git.getRepository().close();

    }



    @Test

    public void testBogusLoginClone() throws Exception {

        File folder = new File(GitBlitSuite.REPOSITORIES, "working/gitblit");

        if (folder.exists()) {

            FileUtils.delete(folder, FileUtils.RECURSIVE);

        }

        CloneCommand clone = Git.cloneRepository();

        clone.setURI(MessageFormat.format("http://localhost:{0,number,#}/git/gitblit.git", port));

        clone.setDirectory(folder);

        clone.setBare(false);

        clone.setCloneAllBranches(true);

        clone.setCredentialsProvider(new UsernamePasswordCredentialsProvider("bogus", "bogus"));

        clone.call();

    }

}


 tests/com/gitblit/tests/JGitUtilsTest.java

@@ -15,6 +15,12 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;



import java.io.File;

import java.io.FileOutputStream;

import java.text.SimpleDateFormat;

@@ -22,8 +28,6 @@
import java.util.Date;

import java.util.List;

import java.util.Map;



import junit.framework.TestCase;



import org.eclipse.jgit.diff.DiffEntry.ChangeType;

import org.eclipse.jgit.lib.Constants;

@@ -35,7 +39,9 @@
import org.eclipse.jgit.revwalk.RevCommit;

import org.eclipse.jgit.util.FS;

import org.eclipse.jgit.util.FileUtils;

import org.junit.Test;



import com.gitblit.Constants.SearchType;

import com.gitblit.GitBlit;

import com.gitblit.Keys;

import com.gitblit.models.GitNote;

@@ -45,56 +51,62 @@
import com.gitblit.utils.JGitUtils;

import com.gitblit.utils.StringUtils;



public class JGitUtilsTest extends TestCase {

public class JGitUtilsTest {



    @Test

    public void testDisplayName() throws Exception {

        assertTrue(JGitUtils.getDisplayName(new PersonIdent("Napoleon Bonaparte", "")).equals(

                "Napoleon Bonaparte"));

        assertTrue(JGitUtils.getDisplayName(new PersonIdent("", "someone@somewhere.com")).equals(

                "<someone@somewhere.com>"));

        assertTrue(JGitUtils.getDisplayName(

                new PersonIdent("Napoleon Bonaparte", "someone@somewhere.com")).equals(

                "Napoleon Bonaparte <someone@somewhere.com>"));

        assertEquals("Napoleon Bonaparte",

                JGitUtils.getDisplayName(new PersonIdent("Napoleon Bonaparte", "")));

        assertEquals("<someone@somewhere.com>",

                JGitUtils.getDisplayName(new PersonIdent("", "someone@somewhere.com")));

        assertEquals("Napoleon Bonaparte <someone@somewhere.com>",

                JGitUtils.getDisplayName(new PersonIdent("Napoleon Bonaparte",

                        "someone@somewhere.com")));

    }



    @Test

    public void testFindRepositories() {

        List<String> list = JGitUtils.getRepositoryList(null, true, true);

        assertTrue(list.size() == 0);

        assertEquals(0, list.size());

        list.addAll(JGitUtils.getRepositoryList(new File("DoesNotExist"), true, true));

        assertTrue(list.size() == 0);

        assertEquals(0, list.size());

        list.addAll(JGitUtils.getRepositoryList(GitBlitSuite.REPOSITORIES, true, true));

        assertTrue("No repositories found in " + GitBlitSuite.REPOSITORIES, list.size() > 0);

    }



    @Test

    public void testOpenRepository() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        repository.close();

        assertTrue("Could not find repository!", repository != null);

        assertNotNull("Could not find repository!", repository);

    }



    @Test

    public void testFirstCommit() throws Exception {

        assertTrue(JGitUtils.getFirstChange(null, null).equals(new Date(0)));

        assertEquals(new Date(0), JGitUtils.getFirstChange(null, null));



        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit commit = JGitUtils.getFirstCommit(repository, null);

        Date firstChange = JGitUtils.getFirstChange(repository, null);

        repository.close();

        assertTrue("Could not get first commit!", commit != null);

        assertTrue("Incorrect first commit!",

                commit.getName().equals("f554664a346629dc2b839f7292d06bad2db4aece"));

        assertNotNull("Could not get first commit!", commit);

        assertEquals("Incorrect first commit!", "f554664a346629dc2b839f7292d06bad2db4aece",

                commit.getName());

        assertTrue(firstChange.equals(new Date(commit.getCommitTime() * 1000L)));

    }



    @Test

    public void testLastCommit() throws Exception {

        assertTrue(JGitUtils.getLastChange(null, null).equals(new Date(0)));

        assertEquals(new Date(0), JGitUtils.getLastChange(null, null));



        Repository repository = GitBlitSuite.getHelloworldRepository();

        assertTrue(JGitUtils.getCommit(repository, null) != null);

        Date date = JGitUtils.getLastChange(repository, null);

        repository.close();

        assertTrue("Could not get last repository change date!", date != null);

        assertNotNull("Could not get last repository change date!", date);

    }



    @Test

    public void testCreateRepository() throws Exception {

        String[] repositories = { "NewTestRepository.git", "NewTestRepository" };

        for (String repositoryName : repositories) {

@@ -102,18 +114,19 @@
                    repositoryName);

            File folder = FileKey.resolve(new File(GitBlitSuite.REPOSITORIES, repositoryName),

                    FS.DETECTED);

            assertTrue(repository != null);

            assertNotNull(repository);

            assertFalse(JGitUtils.hasCommits(repository));

            assertTrue(JGitUtils.getFirstCommit(repository, null) == null);

            assertTrue(JGitUtils.getFirstChange(repository, null).getTime() == folder

                    .lastModified());

            assertTrue(JGitUtils.getLastChange(repository, null).getTime() == folder.lastModified());

            assertTrue(JGitUtils.getCommit(repository, null) == null);

            assertNull(JGitUtils.getFirstCommit(repository, null));

            assertEquals(folder.lastModified(), JGitUtils.getFirstChange(repository, null)

                    .getTime());

            assertEquals(folder.lastModified(), JGitUtils.getLastChange(repository, null).getTime());

            assertNull(JGitUtils.getCommit(repository, null));

            repository.close();

            assertTrue(GitBlit.self().deleteRepository(repositoryName));

        }

    }



    @Test

    public void testRefs() throws Exception {

        Repository repository = GitBlitSuite.getJGitRepository();

        Map<ObjectId, List<RefModel>> map = JGitUtils.getAllRefs(repository);

@@ -123,13 +136,13 @@
            List<RefModel> list = entry.getValue();

            for (RefModel ref : list) {

                if (ref.displayName.equals("refs/tags/spearce-gpg-pub")) {

                    assertTrue(ref.toString().equals("refs/tags/spearce-gpg-pub"));

                    assertTrue(ref.getObjectId().getName()

                            .equals("8bbde7aacf771a9afb6992434f1ae413e010c6d8"));

                    assertTrue(ref.getAuthorIdent().getEmailAddress().equals("spearce@spearce.org"));

                    assertEquals("refs/tags/spearce-gpg-pub", ref.toString());

                    assertEquals("8bbde7aacf771a9afb6992434f1ae413e010c6d8", ref.getObjectId()

                            .getName());

                    assertEquals("spearce@spearce.org", ref.getAuthorIdent().getEmailAddress());

                    assertTrue(ref.getShortMessage().startsWith("GPG key"));

                    assertTrue(ref.getFullMessage().startsWith("GPG key"));

                    assertTrue(ref.getReferencedObjectType() == Constants.OBJ_BLOB);

                    assertEquals(Constants.OBJ_BLOB, ref.getReferencedObjectType());

                } else if (ref.displayName.equals("refs/tags/v0.12.1")) {

                    assertTrue(ref.isAnnotatedTag());

                }

@@ -137,6 +150,7 @@
        }

    }



    @Test

    public void testBranches() throws Exception {

        Repository repository = GitBlitSuite.getJGitRepository();

        assertTrue(JGitUtils.getLocalBranches(repository, true, 0).size() == 0);

@@ -160,6 +174,7 @@
        repository.close();

    }



    @Test

    public void testTags() throws Exception {

        Repository repository = GitBlitSuite.getJGitRepository();

        assertTrue(JGitUtils.getTags(repository, true, 5).size() == 5);

@@ -180,13 +195,13 @@
            if (model.getObjectId().getName().equals("728643ec0c438c77e182898c2f2967dbfdc231c8")) {

                assertFalse(model.isAnnotatedTag());

                assertTrue(model.getAuthorIdent().getEmailAddress().equals("marcel@holtmann.org"));

                assertTrue(model.getFullMessage().equals(

                        "Update changelog and bump version number\n"));

                assertEquals("Update changelog and bump version number\n", model.getFullMessage());

            }

        }

        repository.close();

    }



    @Test

    public void testCommitNotes() throws Exception {

        Repository repository = GitBlitSuite.getJGitRepository();

        RevCommit commit = JGitUtils.getCommit(repository,

@@ -194,10 +209,11 @@
        List<GitNote> list = JGitUtils.getNotesOnCommit(repository, commit);

        repository.close();

        assertTrue(list.size() > 0);

        assertTrue(list.get(0).notesRef.getReferencedObjectId().getName()

                .equals("183474d554e6f68478a02d9d7888b67a9338cdff"));

        assertEquals("183474d554e6f68478a02d9d7888b67a9338cdff", list.get(0).notesRef

                .getReferencedObjectId().getName());

    }



    @Test

    public void testCreateOrphanedBranch() throws Exception {

        Repository repository = JGitUtils.createRepository(GitBlitSuite.REPOSITORIES, "orphantest");

        assertTrue(JGitUtils.createOrphanBranch(repository,

@@ -205,6 +221,7 @@
        FileUtils.delete(repository.getDirectory(), FileUtils.RECURSIVE);

    }



    @Test

    public void testStringContent() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        String contentA = JGitUtils.getStringContent(repository, null, "java.java");

@@ -222,10 +239,11 @@
        assertTrue("ContentA is null!", contentA != null && contentA.length() > 0);

        assertTrue("ContentB is null!", contentB != null && contentB.length() > 0);

        assertTrue(contentA.equals(contentB));

        assertTrue(contentC == null);

        assertNull(contentC);

        assertTrue(contentA.equals(contentD));

    }



    @Test

    public void testFilesInCommit() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        RevCommit commit = JGitUtils.getCommit(repository,

@@ -248,19 +266,21 @@
            assertTrue("PathChangeModel equals itself failed!", path.equals(path));

            assertFalse("PathChangeModel equals string failed!", path.equals(""));

        }

        assertTrue(deletions.get(0).changeType.equals(ChangeType.DELETE));

        assertTrue(additions.get(0).changeType.equals(ChangeType.ADD));

        assertEquals(ChangeType.DELETE, deletions.get(0).changeType);

        assertEquals(ChangeType.ADD, additions.get(0).changeType);

        assertTrue(latestChanges.size() > 0);

    }



    @Test

    public void testFilesInPath() throws Exception {

        assertTrue(JGitUtils.getFilesInPath(null, null, null).size() == 0);

        assertEquals(0, JGitUtils.getFilesInPath(null, null, null).size());

        Repository repository = GitBlitSuite.getHelloworldRepository();

        List<PathModel> files = JGitUtils.getFilesInPath(repository, null, null);

        repository.close();

        assertTrue(files.size() > 10);

    }



    @Test

    public void testDocuments() throws Exception {

        Repository repository = GitBlitSuite.getTicgitRepository();

        List<String> extensions = GitBlit.getStrings(Keys.web.markdownExtensions);

@@ -274,17 +294,19 @@
        assertTrue(allFiles.size() > markdownDocs.size());

    }



    @Test

    public void testFileModes() throws Exception {

        assertTrue(JGitUtils.getPermissionsFromMode(FileMode.TREE.getBits()).equals("drwxr-xr-x"));

        assertTrue(JGitUtils.getPermissionsFromMode(FileMode.REGULAR_FILE.getBits()).equals(

                "-rw-r--r--"));

        assertTrue(JGitUtils.getPermissionsFromMode(FileMode.EXECUTABLE_FILE.getBits()).equals(

                "-rwxr-xr-x"));

        assertTrue(JGitUtils.getPermissionsFromMode(FileMode.SYMLINK.getBits()).equals("symlink"));

        assertTrue(JGitUtils.getPermissionsFromMode(FileMode.GITLINK.getBits()).equals("gitlink"));

        assertTrue(JGitUtils.getPermissionsFromMode(FileMode.MISSING.getBits()).equals("missing"));

        assertEquals("drwxr-xr-x", JGitUtils.getPermissionsFromMode(FileMode.TREE.getBits()));

        assertEquals("-rw-r--r--",

                JGitUtils.getPermissionsFromMode(FileMode.REGULAR_FILE.getBits()));

        assertEquals("-rwxr-xr-x",

                JGitUtils.getPermissionsFromMode(FileMode.EXECUTABLE_FILE.getBits()));

        assertEquals("symlink", JGitUtils.getPermissionsFromMode(FileMode.SYMLINK.getBits()));

        assertEquals("gitlink", JGitUtils.getPermissionsFromMode(FileMode.GITLINK.getBits()));

        assertEquals("missing", JGitUtils.getPermissionsFromMode(FileMode.MISSING.getBits()));

    }



    @Test

    public void testRevlog() throws Exception {

        assertTrue(JGitUtils.getRevLog(null, 0).size() == 0);

        List<RevCommit> commits = JGitUtils.getRevLog(null, 10);

@@ -302,51 +324,55 @@
        // grab the two most recent commits to java.java

        commits = JGitUtils.getRevLog(repository, null, "java.java", 0, 2);

        assertEquals(2, commits.size());

		


        // grab the commits since 2008-07-15

        commits = JGitUtils.getRevLog(repository, null, new SimpleDateFormat("yyyy-MM-dd").parse("2008-07-15"));

        commits = JGitUtils.getRevLog(repository, null,

                new SimpleDateFormat("yyyy-MM-dd").parse("2008-07-15"));

        assertEquals(12, commits.size());

        repository.close();

    }



    @Test

    public void testSearchTypes() throws Exception {

        assertTrue(com.gitblit.Constants.SearchType.forName("commit").equals(com.gitblit.Constants.SearchType.COMMIT));

        assertTrue(com.gitblit.Constants.SearchType.forName("committer").equals(com.gitblit.Constants.SearchType.COMMITTER));

        assertTrue(com.gitblit.Constants.SearchType.forName("author").equals(com.gitblit.Constants.SearchType.AUTHOR));

        assertTrue(com.gitblit.Constants.SearchType.forName("unknown").equals(com.gitblit.Constants.SearchType.COMMIT));

        assertEquals(SearchType.COMMIT, SearchType.forName("commit"));

        assertEquals(SearchType.COMMITTER, SearchType.forName("committer"));

        assertEquals(SearchType.AUTHOR, SearchType.forName("author"));

        assertEquals(SearchType.COMMIT, SearchType.forName("unknown"));



        assertTrue(com.gitblit.Constants.SearchType.COMMIT.toString().equals("commit"));

        assertTrue(com.gitblit.Constants.SearchType.COMMITTER.toString().equals("committer"));

        assertTrue(com.gitblit.Constants.SearchType.AUTHOR.toString().equals("author"));

        assertEquals("commit", SearchType.COMMIT.toString());

        assertEquals("committer", SearchType.COMMITTER.toString());

        assertEquals("author", SearchType.AUTHOR.toString());

    }



    @Test

    public void testSearchRevlogs() throws Exception {

        assertTrue(JGitUtils.searchRevlogs(null, null, "java", com.gitblit.Constants.SearchType.COMMIT, 0, 0).size() == 0);

        List<RevCommit> results = JGitUtils.searchRevlogs(null, null, "java", com.gitblit.Constants.SearchType.COMMIT, 0,

        assertEquals(0, JGitUtils.searchRevlogs(null, null, "java", SearchType.COMMIT, 0, 0).size());

        List<RevCommit> results = JGitUtils.searchRevlogs(null, null, "java", SearchType.COMMIT, 0,

                3);

        assertTrue(results.size() == 0);

        assertEquals(0, results.size());



        // test commit message search

        Repository repository = GitBlitSuite.getHelloworldRepository();

        results = JGitUtils.searchRevlogs(repository, null, "java", com.gitblit.Constants.SearchType.COMMIT, 0, 3);

        assertTrue(results.size() == 3);

        results = JGitUtils.searchRevlogs(repository, null, "java", SearchType.COMMIT, 0, 3);

        assertEquals(3, results.size());



        // test author search

        results = JGitUtils.searchRevlogs(repository, null, "timothy", com.gitblit.Constants.SearchType.AUTHOR, 0, -1);

        assertTrue(results.size() == 1);

        results = JGitUtils.searchRevlogs(repository, null, "timothy", SearchType.AUTHOR, 0, -1);

        assertEquals(1, results.size());



        // test committer search

        results = JGitUtils.searchRevlogs(repository, null, "mike", com.gitblit.Constants.SearchType.COMMITTER, 0, 10);

        assertTrue(results.size() == 10);

        results = JGitUtils.searchRevlogs(repository, null, "mike", SearchType.COMMITTER, 0, 10);

        assertEquals(10, results.size());



        // test paging and offset

        RevCommit commit = JGitUtils.searchRevlogs(repository, null, "mike", com.gitblit.Constants.SearchType.COMMITTER,

        RevCommit commit = JGitUtils.searchRevlogs(repository, null, "mike", SearchType.COMMITTER,

                9, 1).get(0);

        assertTrue(results.get(9).equals(commit));

        assertEquals(results.get(9), commit);



        repository.close();

    }



    @Test

    public void testZip() throws Exception {

        assertFalse(JGitUtils.zip(null, null, null, null));

        Repository repository = GitBlitSuite.getHelloworldRepository();


 tests/com/gitblit/tests/JsonUtilsTest.java

@@ -15,18 +15,21 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;



import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.utils.JsonUtils;

import com.google.gson.reflect.TypeToken;



public class JsonUtilsTest extends TestCase {

public class JsonUtilsTest {



    @Test

    public void testSerialization() {

        Map<String, String> map = new HashMap<String, String>();

        map.put("a", "alligator");


 tests/com/gitblit/tests/MailTest.java

@@ -15,15 +15,18 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertTrue;



import javax.mail.Message;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.FileSettings;

import com.gitblit.MailExecutor;



public class MailTest extends TestCase {

public class MailTest {



    @Test

    public void testSendMail() throws Exception {

        FileSettings settings = new FileSettings("mailtest.properties");

        MailExecutor mail = new MailExecutor(settings);

@@ -31,7 +34,7 @@
        message.setSubject("Test");

        message.setText("this is a test");

        mail.queue(message);

        mail.run();		
        mail.run();



        assertTrue("mail queue is not empty!", mail.hasEmptyQueue());

    }


 tests/com/gitblit/tests/MarkdownUtilsTest.java

@@ -15,14 +15,18 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;



import java.text.ParseException;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.utils.MarkdownUtils;



public class MarkdownUtilsTest extends TestCase {

public class MarkdownUtilsTest {



    @Test

    public void testMarkdown() throws Exception {

        assertEquals("<h1> H1</h1>", MarkdownUtils.transformMarkdown("# H1"));

        assertEquals("<h2> H2</h2>", MarkdownUtils.transformMarkdown("## H2"));

@@ -34,8 +38,9 @@
                MarkdownUtils.transformMarkdown("**THIS ** is a test"));

        assertEquals("<p>** THIS** is a test</p>",

                MarkdownUtils.transformMarkdown("** THIS** is a test"));

		
        assertEquals("<table><tr><td>test</td></tr></table>", MarkdownUtils.transformMarkdown("<table><tr><td>test</td></tr></table>"));



        assertEquals("<table><tr><td>test</td></tr></table>",

                MarkdownUtils.transformMarkdown("<table><tr><td>test</td></tr></table>"));

        assertEquals("<table><tr><td>&lt;test&gt;</td></tr></table>",

                MarkdownUtils.transformMarkdown("<table><tr><td>&lt;test&gt;</td></tr></table>"));




 tests/com/gitblit/tests/MetricUtilsTest.java

@@ -15,17 +15,20 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;



import java.util.List;



import junit.framework.TestCase;



import org.eclipse.jgit.lib.Repository;

import org.junit.Test;



import com.gitblit.models.Metric;

import com.gitblit.utils.MetricUtils;



public class MetricUtilsTest extends TestCase {

public class MetricUtilsTest {



    @Test

    public void testMetrics() throws Exception {

        testMetrics(GitBlitSuite.getHelloworldRepository());

        testMetrics(GitBlitSuite.getBluezGnomeRepository());

@@ -37,12 +40,13 @@
        assertTrue("No date metrics found!", metrics.size() > 0);

    }



    @Test

    public void testAuthorMetrics() throws Exception {

        Repository repository = GitBlitSuite.getHelloworldRepository();

        List<Metric> byEmail = MetricUtils.getAuthorMetrics(repository, null, true);

        List<Metric> byName = MetricUtils.getAuthorMetrics(repository, null, false);

        repository.close();

        assertTrue("No author metrics found!", byEmail.size() == 9);

        assertTrue("No author metrics found!", byName.size() == 8);

        assertEquals("No author metrics found!", 9, byEmail.size());

        assertEquals("No author metrics found!", 8, byName.size());

    }

}

 tests/com/gitblit/tests/ObjectCacheTest.java

@@ -15,14 +15,19 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;



import java.util.Date;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.utils.ObjectCache;



public class ObjectCacheTest extends TestCase {

public class ObjectCacheTest {



    @Test

    public void testCache() throws Exception {

        ObjectCache<String> cache = new ObjectCache<String>();

        cache.updateObject("test", "alpha");


 tests/com/gitblit/tests/RpcTests.java

@@ -15,13 +15,17 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;



import java.io.IOException;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;



import junit.framework.TestCase;

import java.util.concurrent.atomic.AtomicBoolean;



import org.junit.AfterClass;

import org.junit.BeforeClass;

@@ -45,27 +49,30 @@
 * @author James Moger

 * 

 */

public class RpcTests extends TestCase {

	
public class RpcTests {



    String url = GitBlitSuite.url;

    String account = GitBlitSuite.account;

    String password = GitBlitSuite.password;

	


    private static final AtomicBoolean started = new AtomicBoolean(false);



    @BeforeClass

    public static void startGitblit() throws Exception {

        GitBlitSuite.startGitblit();

        started.set(GitBlitSuite.startGitblit());

    }



    @AfterClass

    public static void stopGitblit() throws Exception {

        GitBlitSuite.stopGitblit();

        if (started.get()) {

            GitBlitSuite.stopGitblit();

        }

    }



    @Test

    public void testListRepositories() throws IOException {

        Map<String, RepositoryModel> map = RpcUtils.getRepositories(url, null, null);

        assertTrue("Repository list is null!", map != null);

        assertNotNull("Repository list is null!", map);

        assertTrue("Repository list is empty!", map.size() > 0);

    }



@@ -76,7 +83,7 @@
            list = RpcUtils.getUsers(url, null, null);

        } catch (UnauthorizedException e) {

        }

        assertTrue("Server allows anyone to admin!", list == null);

        assertNull("Server allows anyone to admin!", list);



        list = RpcUtils.getUsers(url, "admin", "admin".toCharArray());

        assertTrue("User list is empty!", list.size() > 0);

@@ -93,7 +100,7 @@
                RpcUtils.createUser(user, url, account, password.toCharArray()));



        UserModel retrievedUser = findUser(user.username);

        assertTrue("Failed to find " + user.username, retrievedUser != null);

        assertNotNull("Failed to find " + user.username, retrievedUser);

        assertTrue("Retrieved user can not administer Gitblit", retrievedUser.canAdmin);



        // rename and toggle admin permission

@@ -104,7 +111,7 @@
                RpcUtils.updateUser(originalName, user, url, account, password.toCharArray()));



        retrievedUser = findUser(user.username);

        assertTrue("Failed to find " + user.username, retrievedUser != null);

        assertNotNull("Failed to find " + user.username, retrievedUser);

        assertTrue("Retrieved user did not update", !retrievedUser.canAdmin);



        // delete

@@ -112,7 +119,7 @@
                RpcUtils.deleteUser(retrievedUser, url, account, password.toCharArray()));



        retrievedUser = findUser(user.username);

        assertTrue("Failed to delete " + user.username, retrievedUser == null);

        assertNull("Failed to delete " + user.username, retrievedUser);

    }



    private UserModel findUser(String name) throws IOException {

@@ -140,9 +147,8 @@
                RpcUtils.createRepository(model, url, account, password.toCharArray()));



        RepositoryModel retrievedRepository = findRepository(model.name);

        assertTrue("Failed to find " + model.name, retrievedRepository != null);

        assertTrue("Access retriction type is wrong",

                AccessRestrictionType.VIEW.equals(retrievedRepository.accessRestriction));

        assertNotNull("Failed to find " + model.name, retrievedRepository);

        assertEquals(AccessRestrictionType.VIEW, retrievedRepository.accessRestriction);



        // rename and change access restriciton

        String originalName = model.name;

@@ -152,16 +158,18 @@
                url, account, password.toCharArray()));



        retrievedRepository = findRepository(model.name);

        assertTrue("Failed to find " + model.name, retrievedRepository != null);

        assertNotNull("Failed to find " + model.name, retrievedRepository);

        assertTrue("Access retriction type is wrong",

                AccessRestrictionType.PUSH.equals(retrievedRepository.accessRestriction));



        // memberships

        String testMember = "justadded";

        UserModel testMember = new UserModel("justadded");

        assertTrue(RpcUtils.createUser(testMember, url, account, password.toCharArray()));



        List<String> members = RpcUtils.getRepositoryMembers(retrievedRepository, url, account,

                password.toCharArray());

        assertTrue("Membership roster is not empty!", members.size() == 0);

        members.add(testMember);

        assertEquals("Membership roster is not empty!", 0, members.size());

        members.add(testMember.username);

        assertTrue(

                "Failed to set memberships!",

                RpcUtils.setRepositoryMembers(retrievedRepository, members, url, account,

@@ -170,7 +178,7 @@
                password.toCharArray());

        boolean foundMember = false;

        for (String member : members) {

            if (member.equalsIgnoreCase(testMember)) {

            if (member.equalsIgnoreCase(testMember.username)) {

                foundMember = true;

                break;

            }

@@ -182,11 +190,11 @@
                url, account, password.toCharArray()));



        retrievedRepository = findRepository(model.name);

        assertTrue("Failed to delete " + model.name, retrievedRepository == null);

        assertNull("Failed to delete " + model.name, retrievedRepository);



        for (UserModel u : RpcUtils.getUsers(url, account, password.toCharArray())) {

            if (u.username.equals(testMember)) {

                RpcUtils.deleteUser(u, url, account, password.toCharArray());

            if (u.username.equals(testMember.username)) {

                assertTrue(RpcUtils.deleteUser(u, url, account, password.toCharArray()));

                break;

            }

        }

@@ -235,13 +243,13 @@
    @Test

    public void testSettings() throws Exception {

        ServerSettings settings = RpcUtils.getSettings(url, account, password.toCharArray());

        assertTrue("No settings were retrieved!", settings != null);

        assertNotNull("No settings were retrieved!", settings);

    }



    @Test

    public void testServerStatus() throws Exception {

        ServerStatus status = RpcUtils.getStatus(url, account, password.toCharArray());

        assertTrue("No status was retrieved!", status != null);

        assertNotNull("No status was retrieved!", status);

    }



    @Test

@@ -272,7 +280,7 @@
    public void testBranches() throws Exception {

        Map<String, Collection<String>> branches = RpcUtils.getBranches(url, account,

                password.toCharArray());

        assertTrue(branches != null);

        assertNotNull(branches);

        assertTrue(branches.size() > 0);

    }

}


 tests/com/gitblit/tests/StringUtilsTest.java

@@ -15,15 +15,20 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;



import java.util.Arrays;

import java.util.List;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.utils.StringUtils;



public class StringUtilsTest extends TestCase {

public class StringUtilsTest {



    @Test

    public void testIsEmpty() throws Exception {

        assertTrue(StringUtils.isEmpty(null));

        assertTrue(StringUtils.isEmpty(""));

@@ -31,86 +36,99 @@
        assertFalse(StringUtils.isEmpty("A"));

    }



    @Test

    public void testBreakLinesForHtml() throws Exception {

        String input = "this\nis\r\na\rtest\r\n\r\nof\n\nline\r\rbreaking";

        String output = "this<br/>is<br/>a<br/>test<br/><br/>of<br/><br/>line<br/><br/>breaking";

        assertTrue(StringUtils.breakLinesForHtml(input).equals(output));

        assertEquals(output, StringUtils.breakLinesForHtml(input));

    }



    @Test

    public void testEncodeUrl() throws Exception {

        String input = "test /";

        String output = "test%20%2F";

        assertTrue(StringUtils.encodeURL(input).equals(output));

        assertEquals(output, StringUtils.encodeURL(input));

    }



    @Test

    public void testEscapeForHtml() throws Exception {

        String input = "& < > \" \t";

        String outputNoChange = "&amp; &lt; &gt; &quot; \t";

        String outputChange = "&amp;&nbsp;&lt;&nbsp;&gt;&nbsp;&quot;&nbsp; &nbsp; &nbsp;";

        assertTrue(StringUtils.escapeForHtml(input, false).equals(outputNoChange));

        assertTrue(StringUtils.escapeForHtml(input, true).equals(outputChange));

        assertEquals(outputNoChange, StringUtils.escapeForHtml(input, false));

        assertEquals(outputChange, StringUtils.escapeForHtml(input, true));

    }



    @Test

    public void testDecodeForHtml() throws Exception {

        String input = "&amp; &lt; &gt; &quot;";

        String output = "& < > \"";

        assertTrue(StringUtils.decodeFromHtml(input).equals(output));

        assertEquals(output, StringUtils.decodeFromHtml(input));

    }



    @Test

    public void testFlattenStrings() throws Exception {

        String[] strings = { "A", "B", "C", "D" };

        assertTrue(StringUtils.flattenStrings(Arrays.asList(strings)).equals("A B C D"));

        assertEquals("A B C D", StringUtils.flattenStrings(Arrays.asList(strings)));

    }



    @Test

    public void testTrim() throws Exception {

        String input = "123456789 123456789 123456789 123456789 123456789 123456789 123456789 ";

        String output = "123456789 123456789 123456789 123456789 123456789 1234567...";

        assertTrue(StringUtils.trimShortLog(input).equals(output));

        assertTrue(StringUtils.trimString(input, input.length()).equals(input));

        assertEquals(output, StringUtils.trimShortLog(input));

        assertEquals(input, StringUtils.trimString(input, input.length()));

    }



    @Test

    public void testPadding() throws Exception {

        String input = "test";

        assertTrue(StringUtils.leftPad(input, 6 + input.length(), ' ').equals("      test"));

        assertTrue(StringUtils.rightPad(input, 6 + input.length(), ' ').equals("test      "));

        assertEquals("      test", StringUtils.leftPad(input, 6 + input.length(), ' '));

        assertEquals("test      ", StringUtils.rightPad(input, 6 + input.length(), ' '));



        assertTrue(StringUtils.leftPad(input, input.length(), ' ').equals(input));

        assertTrue(StringUtils.rightPad(input, input.length(), ' ').equals(input));

        assertEquals(input, StringUtils.leftPad(input, input.length(), ' '));

        assertEquals(input, StringUtils.rightPad(input, input.length(), ' '));

    }



    @Test

    public void testSHA1() throws Exception {

        assertTrue(StringUtils.getSHA1("blob 16\000what is up, doc?").equals(

                "bd9dbf5aae1a3862dd1526723246b20206e5fc37"));

        assertEquals("bd9dbf5aae1a3862dd1526723246b20206e5fc37",

                StringUtils.getSHA1("blob 16\000what is up, doc?"));

    }



    @Test

    public void testMD5() throws Exception {

        assertTrue(StringUtils.getMD5("blob 16\000what is up, doc?").equals(

                "77fb8d95331f0d557472f6776d3aedf6"));

        assertEquals("77fb8d95331f0d557472f6776d3aedf6",

                StringUtils.getMD5("blob 16\000what is up, doc?"));

    }



    @Test

    public void testRootPath() throws Exception {

        String input = "/nested/path/to/repository";

        String output = "/nested/path/to";

        assertTrue(StringUtils.getRootPath(input).equals(output));

        assertTrue(StringUtils.getRootPath("repository").equals(""));

        assertEquals(output, StringUtils.getRootPath(input));

        assertEquals("", StringUtils.getRootPath("repository"));

    }



    @Test

    public void testStringsFromValue() throws Exception {

        List<String> strings = StringUtils.getStringsFromValue("A B C D");

        assertTrue(strings.size() == 4);

        assertTrue(strings.get(0).equals("A"));

        assertTrue(strings.get(1).equals("B"));

        assertTrue(strings.get(2).equals("C"));

        assertTrue(strings.get(3).equals("D"));

        assertEquals(4, strings.size());

        assertEquals("A", strings.get(0));

        assertEquals("B", strings.get(1));

        assertEquals("C", strings.get(2));

        assertEquals("D", strings.get(3));

    }



    @Test

    public void testStringsFromValue2() throws Exception {

        List<String> strings = StringUtils.getStringsFromValue("common/* libraries/*");

        assertTrue(strings.size() == 2);

        assertTrue(strings.get(0).equals("common/*"));

        assertTrue(strings.get(1).equals("libraries/*"));

        assertEquals(2, strings.size());

        assertEquals("common/*", strings.get(0));

        assertEquals("libraries/*", strings.get(1));

    }



    @Test

    public void testFuzzyMatching() throws Exception {

        assertTrue(StringUtils.fuzzyMatch("12345", "12345"));

        assertTrue(StringUtils.fuzzyMatch("AbCdEf", "abcdef"));


 tests/com/gitblit/tests/SyndicationUtilsTest.java

@@ -15,6 +15,9 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;



import java.io.ByteArrayOutputStream;

import java.util.ArrayList;

import java.util.Date;

@@ -22,14 +25,15 @@
import java.util.List;

import java.util.Set;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.Constants.SearchType;

import com.gitblit.models.FeedEntryModel;

import com.gitblit.utils.SyndicationUtils;



public class SyndicationUtilsTest extends TestCase {

public class SyndicationUtilsTest {



    @Test

    public void testSyndication() throws Exception {

        List<FeedEntryModel> entries = new ArrayList<FeedEntryModel>();

        for (int i = 0; i < 10; i++) {

@@ -58,12 +62,12 @@
        assertTrue(feed.indexOf("<description>Description</description>") > -1);

    }



    @Test

    public void testFeedRead() throws Exception {

        Set<String> links = new HashSet<String>();

        for (int i = 0; i < 2; i++) {

            List<FeedEntryModel> feed = SyndicationUtils.readFeed(GitBlitSuite.url,

                    "ticgit.git", "deving", 5, i, GitBlitSuite.account,

                    GitBlitSuite.password.toCharArray());

            List<FeedEntryModel> feed = SyndicationUtils.readFeed(GitBlitSuite.url, "ticgit.git",

                    "deving", 5, i, GitBlitSuite.account, GitBlitSuite.password.toCharArray());

            assertTrue(feed != null);

            assertTrue(feed.size() > 0);

            assertEquals(5, feed.size());

@@ -75,10 +79,11 @@
        assertEquals("Feed pagination failed", 10, links.size());

    }



    @Test

    public void testSearchFeedRead() throws Exception {

        List<FeedEntryModel> feed = SyndicationUtils.readSearchFeed(GitBlitSuite.url,

                "ticgit.git", null, "test", null, 5, 0, GitBlitSuite.account,

                GitBlitSuite.password.toCharArray());

        List<FeedEntryModel> feed = SyndicationUtils

                .readSearchFeed(GitBlitSuite.url, "ticgit.git", null, "test", null, 5, 0,

                        GitBlitSuite.account, GitBlitSuite.password.toCharArray());

        assertTrue(feed != null);

        assertTrue(feed.size() > 0);

        assertEquals(5, feed.size());


 tests/com/gitblit/tests/TicgitUtilsTest.java

@@ -15,31 +15,38 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertNull;

import static org.junit.Assert.assertTrue;



import java.util.List;



import junit.framework.TestCase;



import org.eclipse.jgit.lib.Repository;

import org.junit.Test;



import com.gitblit.models.RefModel;

import com.gitblit.models.TicketModel;

import com.gitblit.models.TicketModel.Comment;

import com.gitblit.utils.TicgitUtils;



public class TicgitUtilsTest extends TestCase {

public class TicgitUtilsTest {



    @Test

    public void testTicgitBranch() throws Exception {

        Repository repository = GitBlitSuite.getTicgitRepository();

        RefModel branch = TicgitUtils.getTicketsBranch(repository);

        repository.close();

        assertTrue("Ticgit branch does not exist!", branch != null);

        assertNotNull("Ticgit branch does not exist!", branch);



        repository = GitBlitSuite.getHelloworldRepository();

        branch = TicgitUtils.getTicketsBranch(repository);

        repository.close();

        assertTrue("Ticgit branch exists!", branch == null);

        assertNull("Ticgit branch exists!", branch);

    }



    @Test

    public void testRetrieveTickets() throws Exception {

        Repository repository = GitBlitSuite.getTicgitRepository();

        List<TicketModel> ticketsA = TicgitUtils.getTickets(repository);

@@ -57,24 +64,26 @@
                Comment commentB = ticketB.comments.get(j);

                assertTrue("Comments are not equal!", commentA.equals(commentB));

                assertFalse(commentA.equals(""));

                assertTrue(commentA.hashCode() == commentA.text.hashCode());

                assertEquals(commentA.hashCode(), commentA.text.hashCode());

            }

        }



        repository = GitBlitSuite.getHelloworldRepository();

        List<TicketModel> ticketsC = TicgitUtils.getTickets(repository);

        repository.close();

        assertTrue(ticketsC == null);

        assertNull(ticketsC);

    }



    @Test

    public void testReadTicket() throws Exception {

        Repository repository = GitBlitSuite.getTicgitRepository();

        List<TicketModel> tickets = TicgitUtils.getTickets(repository);

        TicketModel ticket = TicgitUtils

                .getTicket(repository, tickets.get(tickets.size() - 1).name);

        repository.close();

        assertTrue(ticket != null);

        assertTrue(ticket.name

                .equals("1254123752_comments-on-ticgits-longer-than-5-lines-can-t-be-viewed-entirely_266"));

        assertNotNull(ticket);

        assertEquals(

                "1254123752_comments-on-ticgits-longer-than-5-lines-can-t-be-viewed-entirely_266",

                ticket.name);

    }

}

 tests/com/gitblit/tests/TimeUtilsTest.java

@@ -15,18 +15,22 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;



import java.util.Date;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.utils.TimeUtils;



public class TimeUtilsTest extends TestCase {

public class TimeUtilsTest {



    private Date offset(long subtract) {

        return new Date(System.currentTimeMillis() - subtract);

    }



    @Test

    public void testBasicTimeFunctions() throws Exception {

        assertEquals(2, TimeUtils.minutesAgo(offset(2 * TimeUtils.MIN), false));

        assertEquals(3, TimeUtils.minutesAgo(offset((2 * TimeUtils.MIN) + (35 * 1000L)), true));

@@ -37,14 +41,17 @@
        assertEquals(4, TimeUtils.daysAgo(offset(4 * TimeUtils.ONEDAY)));

    }



    @Test

    public void testToday() throws Exception {

        assertTrue(TimeUtils.isToday(new Date()));

    }



    @Test

    public void testYesterday() throws Exception {

        assertTrue(TimeUtils.isYesterday(offset(TimeUtils.ONEDAY)));

    }



    @Test

    public void testDurations() throws Exception {

        assertEquals("1 day", TimeUtils.duration(1));

        assertEquals("5 days", TimeUtils.duration(5));

@@ -67,6 +74,7 @@
        assertEquals("2 years, 2 months", TimeUtils.duration(2 * 365 + 60));

    }



    @Test

    public void testTimeAgo() throws Exception {

        // standard time ago tests

        assertEquals("1 min ago", TimeUtils.timeAgo(offset(1 * TimeUtils.MIN)));

@@ -91,6 +99,7 @@
        assertEquals("age2", TimeUtils.timeAgoCss(offset(2 * TimeUtils.ONEDAY)));

    }



    @Test

    public void testFrequency() {

        assertEquals(5, TimeUtils.convertFrequencyToMinutes("2 mins"));

        assertEquals(10, TimeUtils.convertFrequencyToMinutes("10 mins"));


 tests/com/gitblit/tests/UserServiceTest.java

@@ -15,33 +15,42 @@
 */

package com.gitblit.tests;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;



import java.io.File;

import java.io.IOException;



import junit.framework.TestCase;

import org.junit.Test;



import com.gitblit.ConfigUserService;

import com.gitblit.FileUserService;

import com.gitblit.IUserService;

import com.gitblit.models.TeamModel;

import com.gitblit.models.UserModel;



public class UserServiceTest extends TestCase {

public class UserServiceTest {



    @Test

    public void testFileUserService() throws IOException {

        File file = new File("us-test.properties");

        file.delete();

        test(new FileUserService(file));

        IUserService service = new FileUserService(file);

        testUsers(service);

        file.delete();

    }



    @Test

    public void testConfigUserService() throws IOException {

        File file = new File("us-test.conf");

        file.delete();

        test(new ConfigUserService(file));

        IUserService service = new ConfigUserService(file);

        testUsers(service);

        file.delete();

    }



    protected void test(IUserService service) {

    protected void testUsers(IUserService service) {



        UserModel admin = service.getUserModel("admin");

        assertTrue(admin == null);