PropertiesWriterTest

//2012-11-30 johnpfeiffer

package net.kittyandbear;

import static org.junit.Assert.assertEquals;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;

public class PropertiesWriterTest {

    private PropertiesWriter testerDefault;
    private File testerDefaultFile;
    private final String DEFAULTKEY = "defaultKey";
    private final String DEFAULTVALUE = "defaultValue";

    @Rule
    public TemporaryFolder folder = new TemporaryFolder();

    @Before
    public void setUp() throws Exception {

        final String TESTFILENAME = "test.properties";
        testerDefaultFile = folder.newFile( TESTFILENAME );

        testerDefault = new PropertiesWriter( testerDefaultFile.getAbsolutePath() );
        testerDefault.setPropertyValue( DEFAULTKEY, DEFAULTVALUE );
    }

    // Happy Path tests to verify most important functionality first
    @Test
    public void testSetPropertyAndWriteTo() throws IllegalArgumentException, IOException {
        // Given
        // When
        testerDefault.setPropertyValue( "setPropertyTestKey", "setPropertyTestValue" );
        testerDefault.write( testerDefaultFile.getAbsolutePath() );

        // Then
        PropertiesReader reader = new PropertiesReader( testerDefaultFile.getAbsolutePath() );
        assertEquals( "setPropertyTestValue", reader.getPropertyValue( "setPropertyTestKey" ) );
    }

    @Test
    public void testWriteSorted() throws IllegalArgumentException, IOException {

        // Given
        final String TESTKEYA = "APropertyKeyA";
        final String TESTVALUEA = "APropertyValueA";
        final String TESTKEYB = "BPropertyKeyB";
        final String TESTVALUEB = "BPropertyValueB";

        // When
        testerDefault.setPropertyValue( TESTKEYB, TESTVALUEB );
        testerDefault.setPropertyValue( TESTKEYA, TESTVALUEA );
        testerDefault.writeSorted( testerDefaultFile.getAbsolutePath() );

        // Then
        BufferedReader br = new BufferedReader( new FileReader( testerDefaultFile ) );
        StringBuffer strb = new StringBuffer();
        String line;
        while( ( line = br.readLine() ) != null ) {
            strb.append( line + PropertiesWriter.NEWLINE );
        }
        String expectedSortedOrder = TESTKEYA + "=" + TESTVALUEA + PropertiesWriter.NEWLINE + TESTKEYB + "=" + TESTVALUEB
                + PropertiesWriter.NEWLINE + DEFAULTKEY + "=" + DEFAULTVALUE + PropertiesWriter.NEWLINE;

        assertEquals( expectedSortedOrder, strb.toString() );
    }

    @Test
    public void testSetPropertyBlankAndWriteTo() throws IllegalArgumentException, IOException {

        // Given
        // When
        testerDefault.setPropertyValue( "blankvaluetestKey", "" );
        testerDefault.write( testerDefaultFile.getAbsolutePath() );

        // Then
        PropertiesReader reader = new PropertiesReader( testerDefaultFile.getAbsolutePath() );
        assertEquals( "", reader.getPropertyValue( "blankvaluetestKey" ) );
    }

    @Test
    public void testGetVersion() {

        assertEquals( "0.30", PropertiesWriter.CLASSVERSION );
    }

    @Test( expected = IllegalArgumentException.class )
    public void testSetPropertyValueKeyNull() {

        testerDefault.setPropertyValue( null, "novalue" );
    }

    @Test( expected = IllegalArgumentException.class )
    public void testSetPropertyValueKeyEmpty() {

        testerDefault.setPropertyValue( "", "novalue" );
    }

    @Test( expected = IllegalArgumentException.class )
    public void testSetPropertyValueValueNull() {

        testerDefault.setPropertyValue( "nokey", null );
    }

    @Test( expected = IllegalArgumentException.class )
    public void testWritePathFileNull() throws IOException {

        testerDefault.write( null );
    }

    @Test( expected = IllegalArgumentException.class )
    public void testWritePathFileEmpty() throws IOException {

        testerDefault.write( "" );
    }


    @Test( expected = IllegalArgumentException.class )
    public void testWriteSortedPathFileNull() throws IOException {

        testerDefault.writeSorted( null );
    }

    @Test( expected = IllegalArgumentException.class )
    public void testWriteSortedPathFileEmpty() throws IOException {

        testerDefault.writeSorted( "" );
    }


} // end class