CacheUtilsEditTest.java

package com.beijunyi.parallelgit.utils;

import java.io.IOException;
import javax.annotation.Nonnull;

import com.beijunyi.parallelgit.AbstractParallelGitTest;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuilder;
import org.eclipse.jgit.dircache.DirCacheEditor;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.junit.Before;
import org.junit.Test;

import static org.eclipse.jgit.lib.FileMode.*;
import static org.eclipse.jgit.lib.ObjectId.zeroId;
import static org.junit.Assert.*;

public class CacheUtilsEditTest extends AbstractParallelGitTest {

  @Nonnull
  private static DirCache setupCache(String... files) {
    DirCache cache = DirCache.newInCore();
    DirCacheBuilder builder = cache.builder();
    for(String file : files)
      CacheUtils.addFile(file, REGULAR_FILE, zeroId(), builder);
    builder.finish();
    return cache;
  }

  @Before
  public void setUp() throws IOException {
    initRepository();
  }

  @Test
  public void keepEverything_ExistingEntriesShouldBeKept() throws IOException {
    writeMultipleToCache("/file1.txt", "/file2.txt");
    DirCacheBuilder builder = CacheUtils.keepEverything(cache);
    builder.finish();
    assertNotNull(CacheUtils.getEntry("/file1.txt", cache));
    assertNotNull(CacheUtils.getEntry("/file2.txt", cache));
  }

  @Test
  public void addFile_theFileShouldExistInTheCacheAfterTheOperation() {
    CacheUtils.addFile("/test_file.txt", someObjectId(), cache);
    assertNotNull(CacheUtils.getEntry("/test_file.txt", cache));
  }

  @Test
  public void addFile_theAddedFileShouldHaveTheSpecifiedObjectId() {
    AnyObjectId expected = someObjectId();
    CacheUtils.addFile("/test_file.txt", expected, cache);
    assertEquals(expected, CacheUtils.getBlob("/test_file.txt", cache));
  }

  @Test
  public void addFile_theAddedFileShouldHaveTheSpecifiedFileMode() {
    FileMode expected = EXECUTABLE_FILE;
    CacheUtils.addFile("/test_file.txt", expected, someObjectId(), cache);
    assertEquals(expected, CacheUtils.getFileMode("/test_file.txt", cache));
  }

  @Test
  public void addFilesWithDirCacheBuilderTest() {
    DirCache cache = DirCache.newInCore();

    DirCacheBuilder builder = cache.builder();
    String[] files = new String[] {"a/b/c1.txt",
                                    "a/c2.txt",
                                    "a/c3.txt",
                                    "a/b/c4.txt"};
    for(String file : files)
      CacheUtils.addFile(file, REGULAR_FILE, zeroId(), builder);builder.finish();

    int entryCount = cache.getEntryCount();
    assertEquals(4, entryCount);
  }

  @Test
  public void deleteFileTest() {
    DirCache cache = setupCache("a/b/c1.txt",
                                 "a/c2.txt",
                                 "a/c3.txt");

    CacheUtils.deleteFile("non_existent_file", cache);
    assertEquals(3, cache.getEntryCount());

    CacheUtils.deleteFile("a/b/c1.txt", cache);
    assertEquals(2, cache.getEntryCount());

    CacheUtils.deleteFile("a/c2.txt", cache);
    assertEquals(1, cache.getEntryCount());
  }

  @Test
  public void deleteFilesWithDirCacheEditorTest() {
    DirCache cache = setupCache("a/b/c1.txt",
                                 "a/b/c2.txt",
                                 "a/c3.txt",
                                 "a/c4.txt",
                                 "a/c5.txt",
                                 "a/c6.txt");

    DirCacheEditor editor = cache.editor();
    CacheUtils.deleteFile("a/b/c1.txt", editor);
    CacheUtils.deleteFile("a/c3.txt", editor);
    CacheUtils.deleteFile("a/c4.txt", editor);
    CacheUtils.deleteFile("a/c6.txt", editor);
    editor.finish();

    assertEquals(2, cache.getEntryCount());
    assertNull(cache.getEntry("a/b/c1.txt"));
    assertNotNull(cache.getEntry("a/b/c2.txt"));
    assertNotNull(cache.getEntry("a/c5.txt"));
  }

  @Test
  public void deleteTreeTest() {
    DirCache cache = setupCache("a/b/c1.txt",
                                 "a/b/c2.txt",
                                 "a/c3.txt",
                                 "a/c4.txt",
                                 "a/c5.txt",
                                 "a/c6.txt");

    CacheUtils.deleteDirectory("a/b", cache);

    assertEquals(4, cache.getEntryCount());
    assertNull(cache.getEntry("a/b/c1.txt"));
    assertNull(cache.getEntry("a/b/c2.txt"));
    assertNotNull(cache.getEntry("a/c3.txt"));
    assertNotNull(cache.getEntry("a/c4.txt"));
    assertNotNull(cache.getEntry("a/c5.txt"));
    assertNotNull(cache.getEntry("a/c6.txt"));
  }

  @Test
  public void deleteMultipleTreesTest() {
    DirCache cache = setupCache("a/b/c1.txt",
                                 "a/b/c2.txt",
                                 "a/d/c3.txt",
                                 "a/d/c4.txt",
                                 "a/c5.txt",
                                 "a/c6.txt");

    DirCacheEditor editor = cache.editor();
    CacheUtils.deleteDirectory("a/b", editor);
    CacheUtils.deleteDirectory("a/d", editor);
    editor.finish();

    assertEquals(2, cache.getEntryCount());
    assertNotNull(cache.getEntry("a/c5.txt"));
    assertNotNull(cache.getEntry("a/c6.txt"));
  }

  @Test
  public void updateFileBlob_theEntryBlobShouldEqualToTheInputBlobAfterTheOperation() throws IOException {
    writeToCache("/test_file.txt");

    ObjectId expected = someObjectId();
    CacheUtils.updateFileBlob("/test_file.txt", expected, cache);
    assertEquals(expected, CacheUtils.getBlob("/test_file.txt", cache));
  }

  @Test
  public void updateFileMode_theEntryFileModeShouldEqualToTheInputFileModeAfterTheOperation() throws IOException {
    writeToCache("/test_file.txt");

    CacheUtils.updateFileMode("/test_file.txt", EXECUTABLE_FILE, cache);
    assertEquals(EXECUTABLE_FILE, CacheUtils.getFileMode("/test_file.txt", cache));
  }

}