/src/test/java/com/aragost/javahg/test/AbstractTestCase.java

/*
 * #%L
 * JavaHg
 * %%
 * Copyright (C) 2011 aragost Trifork ag
 * %%
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 * #L%
 */
package com.aragost.javahg.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Collection;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.junit.After;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.runner.RunWith;

import com.aragost.javahg.BaseRepository;
import com.aragost.javahg.Changeset;
import com.aragost.javahg.HgVersion;
import com.aragost.javahg.Repository;
import com.aragost.javahg.RepositoryConfiguration;
import com.aragost.javahg.RepositoryConfiguration.CachePolicy;
import com.aragost.javahg.commands.AddCommand;
import com.aragost.javahg.commands.CommitCommand;
import com.aragost.javahg.commands.UpdateCommand;
import com.aragost.javahg.commands.VersionCommand;
import com.aragost.javahg.internals.AbstractCommand;
import com.aragost.javahg.internals.GenericCommand;
import com.aragost.javahg.internals.HgInputStream;
import com.aragost.javahg.internals.RuntimeIOException;
import com.aragost.javahg.internals.Server;
import com.aragost.javahg.internals.Utils;
import com.google.common.collect.ObjectArrays;
import com.google.common.io.Files;

/**
 * Base class for test cases.
 */
@RunWith(org.junit.runners.BlockJUnit4ClassRunner.class)
public abstract class AbstractTestCase {

    // The jul root logger is changed in the initialization of this
    // class. A strong reference must be maintained to the logger. See
    // LG_LOST_LOGGER_DUE_TO_WEAK_REFERENCE on
    // http://findbugs.sourceforge.net/bugDescriptions.html
    private static final Logger JUL_ROOT_LOGGER = Logger.getLogger("");

    private static int count = 0;

    private BaseRepository testRepository;

    private BaseRepository testRepository2;

    protected static final RepositoryConfiguration REPO_CONF;

    static {
        REPO_CONF = makeRepoConf();

        JUL_ROOT_LOGGER.setLevel(Level.WARNING);

        File dir = Files.createTempDir();
        BaseRepository repo = Repository.create(REPO_CONF, dir);
        HgVersion version = VersionCommand.on(repo).execute();
        repo.close();
        try {
            deleteTempDir(dir);
        } catch (IOException e) {
            System.err.println("JavaHg: Failed to remove temp dir: " + dir.getAbsolutePath());
        }

        System.err.println("JavaHg test using Mercurial version: " + version + ", binary: " + REPO_CONF.getHgBin());
    }

    public File createMercurialRepository() {
        File dir = Files.createTempDir();
        Server server = new Server(RepositoryConfiguration.DEFAULT.getHgBin(),
                                   RepositoryConfiguration.DEFAULT.getEncoding());
        server.initMecurialRepository(dir);
        return dir;
    }

    protected static RepositoryConfiguration makeRepoConf() {
        RepositoryConfiguration conf = new RepositoryConfiguration();
        conf.setCachePolicy(CachePolicy.WEAK);
        conf.addExtension(JavaHgTestExtension.class);

        return conf;
    }

    public Charset utf8() {
        return Charset.forName("UTF-8");
    }

    public BaseRepository getTestRepository() {
        if (this.testRepository == null) {
            File dir = Files.createTempDir();
            this.testRepository = Repository.create(REPO_CONF, dir);
        }
        return this.testRepository;
    }

    public BaseRepository getTestRepository2() {
        if (this.testRepository2 == null) {
            File dir = Files.createTempDir();
            this.testRepository2 = Repository.create(REPO_CONF, dir);
        }
        return this.testRepository2;
    }

    /**
     * Write to a file in the test repository
     * 
     * @param name
     * @param content
     * @throws IOException
     */
    public void writeFile(String name, String content) throws IOException {
        writeFile(getTestRepository(), name, content);
    }

    public void writeFile(BaseRepository repo, String name, String content) throws IOException {
        File file = new File(repo.getDirectory(), name);
        Files.write(content, file, utf8());
    }
    
    /**
     * Write something to the file in the test repository.
     * <p>
     * Each call to this method will write different content
     * 
     * @param name
     * @throws IOException
     */
    public void writeFile(String name) throws IOException {
        writeFile(name, String.valueOf(count++) + "\n");
    }

    public void appendFile(String name) throws IOException {
        File file = new File(getTestRepository().getDirectory(), name);
        Files.append(String.valueOf(count++) + "\n", file, utf8());
    }

    /**
     * Read first line of the file
     * 
     * @param name
     * @return
     * @throws IOException
     */
    public String readFile(String name) throws IOException {
        File file = new File(getTestRepository().getDirectory(), name);
        return Files.readFirstLine(file, utf8());
    }

    /**
     * Delete the specified file from the working copy of the test
     * repository.
     * 
     * @param name
     */
    public void deleteFile(String name) {
        File file = new File(getTestRepository().getDirectory(), name);
        boolean deleted = file.delete();
        if (!deleted) {
            throw new RuntimeException("Could not delete: " + file);
        }
    }

    /**
     * Commit the changes in the test repository
     * 
     * @throws IOException
     */
    public Changeset commit() throws IOException {
        Repository repo = getTestRepository();
        AddCommand.on(repo).execute();
        CommitCommand cmd = CommitCommand.on(repo).user("testcase").message("testcase: " + getClass().getName());
        return cmd.execute();
    }

    /**
     * Create a new changeset in the test repository.
     * 
     * @return the changeset Created
     * @throws IOException
     */
    public Changeset createChangeset() throws IOException {
        writeFile("dummyFileForCreatingChangesets", String.valueOf(count++));
        return commit();
    }

    /**
     * Update the test repository to the specified changeset
     * 
     * @param cs
     * @throws IOException
     */
    public void update(Changeset cs) throws IOException {
        UpdateCommand.on(getTestRepository()).clean().rev(cs.getNode()).execute();
    }

    @After
    public void closeTestRepository() throws IOException {
        if (this.testRepository != null) {
            this.testRepository.close();
            deleteTempDir(this.testRepository.getDirectory());
            this.testRepository = null;
        }
        if (this.testRepository2 != null) {
            this.testRepository2.close();
            deleteTempDir(this.testRepository2.getDirectory());
            this.testRepository2 = null;
        }
    }

    /**
     * Return an absolute File object referencing a file in the
     * specified repository.
     * 
     * @param repo
     * @param parts
     * @return
     */
    public static File repoFile(Repository repo, String... parts) {
        File result = repo.getDirectory();
        for (String part : parts) {
            result = new File(result, part);
        }
        return result;
    }

    /**
     * The error text for missing files is different on Windows
     * compared to Linux/Mac
     * 
     * @return
     */
    public static String getMissingFileErrorText() {
        String error = "No such file or directory";
        String osName = System.getProperty("os.name");
        if (osName.startsWith("Windows")) {
            error = "The system cannot find the file specified";
        }
        return error;
    }

    /**
     * Create a temp directory, and return the canonical file object
     * (i.e. no symlinks).
     * 
     * @return
     * @throws IOException
     */
    protected static File createTempDir() throws IOException {
        return Files.createTempDir().getCanonicalFile();
    }

    /**
     * Delete a directory in the system temporary directory
     * (java.io.tmpdir).
     * 
     * @throws IOException
     */
    public static void deleteTempDir(File file) throws IOException {
        Utils.deleteTempDir(file);
    }

    protected void assertSingleton(Object obj, Collection<?> coll) {
        Assert.assertEquals(obj, Utils.single(coll));
    }

    protected void assertFailedExecution(AbstractCommand cmd) {
        assertFailedExecution(cmd, "");
    }

    protected void assertFailedExecution(AbstractCommand cmd, String msg) {
        if (msg.length() > 0) {
            msg = " Message: " + msg;
        }
        Assert.fail("Exception expected! Return code: " + cmd.getReturnCode() + "." + msg);
    }

    /**
     * Execute a Mercurial command direcotry for a repository, with
     * out using the server
     * 
     * @param repo
     * @param hgrcPath
     * @param args
     */
    protected void execHgCommand(BaseRepository repo, String... args) {
        try {
            String[] arr = Utils.arrayConcat(new String[] { REPO_CONF.getHgBin(), "--repo",
                    repo.getDirectory().getAbsolutePath() }, args);

            Process process = Runtime.getRuntime().exec(arr);
            String stderr = Utils.readStream(process.getErrorStream(), repo.newDecoder());
            Utils.consumeAll(process.getInputStream());

            if (process.waitFor() != 0) {
                throw new RuntimeException(stderr);
            }
        } catch (IOException e) {
            throw new RuntimeIOException(e);
        } catch (InterruptedException e) {
            throw Utils.asRuntime(e);
        }
    }

    /**
     * Warning: invoking commands on this server may put it in an invalid state.
     * Use AbstractCommand.launchStream(String...) instead.
     * 
     * @param repo The repo
     * @return A Server from the repo
     */
    protected Server getFirstServer(Repository repo) {
        return repo.getServerPool().getServers().get(0);
    }

    protected static ServeState startServing(Repository repo,
            String... additionalConfig) {

        // On windows hg serve --port 0 doesn't print the port it's listening on
        Assume.assumeTrue(!Utils.isWindows());

        final File pidFile;

        try {
            pidFile = File.createTempFile("javahg", ".pid");

            final Process process = Runtime.getRuntime().exec(
                    ObjectArrays.concat(
                            new String[] {
                                    RepositoryConfiguration.DEFAULT.getHgBin(),
                                    "serve", "--port", "0", "-d", "--pid-file",
                                    pidFile.toString(), "-R",
                                    repo.getDirectory().toString() },
                            additionalConfig, String.class));

            HgInputStream in = new HgInputStream(process.getInputStream(),
                    repo.newDecoder());

            Assert.assertTrue(in.find("(bound to *:".getBytes()));
            final int port = in.readDecimal().intValue();
            in.close();

            return new ServeState() {

                public int getPort() {
                    return port;
                }

                public void stop() {
                    BufferedReader in = null;;
                    try {
                        // probably already dead:
                        process.destroy();

                        in = new BufferedReader(new InputStreamReader(new FileInputStream(pidFile)));
                        killProcess(Integer.parseInt(in.readLine()));

                    } catch (Exception e) {
                        throw Utils.asRuntime(e);
                    } finally {
                        try {
                            in.close();
                        } catch (IOException e) {
                            throw Utils.asRuntime(e);
                        }
                    }
                }};
        } catch (IOException e) {
            throw Utils.asRuntime(e);
        }
    }
    
    /**
     * Kill a process
     * 
     * @param pid The process id
     */
    protected static void killProcess(int pid) {
        try {
            Runtime rt = Runtime.getRuntime();
            if (System.getProperty("os.name").toLowerCase().indexOf("windows") > -1) {
                rt.exec("taskkill " + pid).waitFor();
            } else {
                rt.exec(new String[] { "kill", "-9", "" + pid }).waitFor();
            }
        } catch (IOException e) {
            throw Utils.asRuntime(e);
        } catch (InterruptedException e) {
            throw Utils.asRuntime(e);
        }
    }

    protected static class TestableCommand extends GenericCommand {

        public TestableCommand(Repository repository, String commandName) {
            super(repository, commandName);
        }

        public HgInputStream executeToStream(String... args) {
             return launchStream(args);
        }
    }

    protected interface ServeState
    {
        public int getPort();
        public void stop();
    }
}