TestBuildContextHolder.java

package ro.isdc.wro.maven.plugin.support;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.MockitoAnnotations.initMocks;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

import org.apache.commons.io.FileUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.sonatype.plexus.build.incremental.BuildContext;

import ro.isdc.wro.util.WroUtil;


/**
 * @author Alex Objelean
 */
public class TestBuildContextHolder {
  private static final String KEY = "key";
  private static final String VALUE = "value";
  private BuildContextHolder victim;

  @Mock
  private BuildContext buildContext;

  @Before
  public void setUp() {
    victim = new BuildContextHolder();
    initMocks(this);
  }

  @After
  public void tearDown() {
    victim.destroy();
  }

  private void initVictimWithBuildContext() {
    victim = new BuildContextHolder(buildContext, null);
  }

  @Test
  public void shouldUseBuildContextIncrementalFlag() {
    initVictimWithBuildContext();
    when(buildContext.isIncremental()).thenReturn(false);
    assertFalse(victim.isIncrementalBuild());
  }

  @Test
  public void shouldInvokeSetValueOnBuildContext() {
    initVictimWithBuildContext();
    victim.setValue(KEY, VALUE);
    verify(buildContext).setValue(KEY, VALUE);
  }

  @Test
  public void shouldInvokeGetValueOnBuildContext() {
    initVictimWithBuildContext();
    victim.getValue(KEY);
    verify(buildContext).getValue(KEY);
  }

  @Test
  public void shouldDisableIncrementalBuildByDefault() {
    assertFalse(victim.isIncrementalBuild());
  }

  @Test
  public void shouldEnableIncrementalBuildWhenConfigured() {
    victim.setIncrementalBuildEnabled(true);
    assertTrue(victim.isIncrementalBuild());
  }

  @Test
  public void shouldLoadExistingDefaultValue()
      throws IOException {
    final File tempFile = WroUtil.createTempFile();
    try {
      final Properties props = new Properties();
      props.setProperty(KEY, VALUE);
      props.store(new FileOutputStream(tempFile), null);

      victim = new BuildContextHolder() {
        @Override
        File newFallbackStorageFile(final File rootFolder) {
          return tempFile;
        }
      };

      assertEquals(VALUE, victim.getValue(KEY));
    } finally {
      FileUtils.deleteQuietly(tempFile);
    }
  }

  @Test
  public void shouldPersisteSavedValue()
      throws Exception {
    victim.setValue(KEY, VALUE);
    victim.persist();
    final File storage = victim.getFallbackStorageFile();

    final Properties props = new Properties();
    props.load(new FileInputStream(storage));

    assertEquals(VALUE, props.getProperty(KEY));
  }

  @Test
  public void shouldNotHaveAnyValueByDefault() {
    assertNull(victim.getValue(KEY));
  }

  @Test
  public void shouldFindPreviouslyPersistedValue() {
    victim.setValue(KEY, VALUE);
    assertEquals(VALUE, victim.getValue(KEY));
  }

  @Test
  public void shouldRemoveWhenNullValueProvided() {
    victim.setValue(KEY, null);
    assertNull(victim.getValue(KEY));
  }

  @Test
  public void shouldNotStoreValueAssociatedWithNullKey() {
    victim.setValue(null, VALUE);
    assertNull(victim.getValue(null));
  }

  @Test
  public void shouldRememberStoredValueAfterPersist() throws Exception {
    final File tempFile = WroUtil.createTempFile();
    try {
      victim = new BuildContextHolder();
      victim.setValue(KEY, VALUE);
      victim.persist();

      final BuildContextHolder secondVictim = new BuildContextHolder() {
        @Override
        File newFallbackStorageFile(final File rootFolder) {
          return victim.getFallbackStorageFile();
        };
      };

      assertEquals(VALUE, secondVictim.getValue(KEY));
    } finally {
      FileUtils.deleteQuietly(tempFile);
    }
  }

  @Test
  public void shouldForgetStoredValueIfPersistNotInvoked() {
    final File tempFile = WroUtil.createTempFile();
    try {
      victim = new BuildContextHolder();
      victim.setValue(KEY, VALUE);

      final BuildContextHolder secondVictim = new BuildContextHolder() {
        @Override
        File newFallbackStorageFile(final File rootFolder) {
          return victim.getFallbackStorageFile();
        };
      };

      assertEquals(null, secondVictim.getValue(KEY));
    } finally {
      FileUtils.deleteQuietly(tempFile);
    }
  }
}