src/test/java/de/todesbaum/jsite/application/FileOptionTest.java

   1 package de.todesbaum.jsite.application;
   2
   3 import static org.hamcrest.MatcherAssert.assertThat;
   4 import static org.hamcrest.Matchers.is;
   5
   6 import java.util.Optional;
   7
   8 import org.junit.Test;
   9
  10 /**
  11  * Unit test for {@link FileOption}.
  12  *
  13  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  14  */
  15 public class FileOptionTest {
  16
  17         private static final String DEFAULT_MIME_TYPE = "application/octet-stream";
  18         private static final String DEFAULT_CUSTOM_KEY = "CHK@";
  19         private static final String CUSTOM_KEY = "KSK@custom-key";
  20         private static final String EMPTY_CUSTOM_KEY = "";
  21         private static final boolean DEFAULT_INSERT = true;
  22         private static final boolean CUSTOM_INSERT = false;
  23         private static final boolean DEFAULT_FORCE_INSERT = false;
  24         private static final boolean CUSTOM_FORCE_INSERT = true;
  25         private static final boolean DEFAULT_INSERT_REDIRECT = true;
  26         private static final boolean CUSTOM_INSERT_REDIRECT = false;
  27         private static final String DEFAULT_LAST_INSERT_HASH = null;
  28         private static final String CUSTOM_LAST_INSERT_HASH = "last-insert-hash";
  29         private static final int DEFAULT_LAST_INSERT_EDITION = 0;
  30         private static final int CUSTOM_LAST_INSERT_EDITION = 12345;
  31         private static final String DEFAULT_LAST_INSERT_FILENAME = null;
  32         private static final String CUSTOM_LAST_INSERT_FILENAME = "filename.dat";
  33         private static final String DEFAULT_CURRENT_HASH = null;
  34         private static final String CUSTOM_CURRENT_HASH = "current-hash";
  35         private static final Optional<?> DEFAULT_CHANGED_NAME = Optional.empty();
  36         private static final String CUSTOM_CHANGED_NAME = "changed-name";
  37         private static final String NULL_CHANGED_NAME = null;
  38         private static final String ZERO_LENGTH_CHANGED_NAME = "";
  39         private static final String CUSTOM_MIME_TYPE = "custom/mime-type";
  40         private static final String NULL_MIME_TYPE = null;
  41         private final FileOption fileOption = new FileOption(DEFAULT_MIME_TYPE);
  42
  43         @Test
  44         public void defaultCustomKeyIsCHK() {
  45                 assertThat(fileOption.getCustomKey(), is(DEFAULT_CUSTOM_KEY));
  46         }
  47
  48         @Test
  49         public void customKeyIsRetainedCorrectly() {
  50                 fileOption.setCustomKey(CUSTOM_KEY);
  51                 assertThat(fileOption.getCustomKey(), is(CUSTOM_KEY));
  52         }
  53
  54         @Test
  55         public void nullCustomKeyIsTurnedIntoEmptyCustomKey() {
  56                 fileOption.setCustomKey(null);
  57                 assertThat(fileOption.getCustomKey(), is(EMPTY_CUSTOM_KEY));
  58         }
  59
  60         @Test
  61         public void defaultInsertIsTrue() {
  62                 assertThat(fileOption.isInsert(), is(DEFAULT_INSERT));
  63         }
  64
  65         @Test
  66         public void insertIsRetainedCorrectly() {
  67                 fileOption.setInsert(CUSTOM_INSERT);
  68                 assertThat(fileOption.isInsert(), is(CUSTOM_INSERT));
  69         }
  70
  71         @Test
  72         public void defaultForceInsertIsFalse() {
  73                 assertThat(fileOption.isForceInsert(), is(DEFAULT_FORCE_INSERT));
  74         }
  75
  76         @Test
  77         public void customForceInsertIsRetainedCorrectly() {
  78                 fileOption.setForceInsert(CUSTOM_FORCE_INSERT);
  79                 assertThat(fileOption.isForceInsert(), is(CUSTOM_FORCE_INSERT));
  80         }
  81
  82         @Test
  83         public void defaultInsertRedirectIsTrue() {
  84                 assertThat(fileOption.isInsertRedirect(), is(DEFAULT_INSERT_REDIRECT));
  85         }
  86
  87         @Test
  88         public void customInsertRedirectIsRetainedCorrectly() {
  89                 fileOption.setInsertRedirect(CUSTOM_INSERT_REDIRECT);
  90                 assertThat(fileOption.isInsertRedirect(), is(CUSTOM_INSERT_REDIRECT));
  91         }
  92
  93         @Test
  94         public void defaultLastInsertHashIsNull() {
  95                 assertThat(fileOption.getLastInsertHash(), is(DEFAULT_LAST_INSERT_HASH));
  96         }
  97
  98         @Test
  99         public void lastInsertHashIsRetainedCorrectly() {
 100                 fileOption.setLastInsertHash(CUSTOM_LAST_INSERT_HASH);
 101                 assertThat(fileOption.getLastInsertHash(), is(CUSTOM_LAST_INSERT_HASH));
 102         }
 103
 104         @Test
 105         public void defaultLastInsertEditionIsZero() {
 106                 assertThat(fileOption.getLastInsertEdition(), is(DEFAULT_LAST_INSERT_EDITION));
 107         }
 108
 109         @Test
 110         public void lastInsertEditionIsRetainedCorrectly() {
 111                 fileOption.setLastInsertEdition(CUSTOM_LAST_INSERT_EDITION);
 112                 assertThat(fileOption.getLastInsertEdition(), is(CUSTOM_LAST_INSERT_EDITION));
 113         }
 114
 115         @Test
 116         public void defaultLastInsertFilenameIsNull() {
 117                 assertThat(fileOption.getLastInsertFilename(), is(DEFAULT_LAST_INSERT_FILENAME));
 118         }
 119
 120         @Test
 121         public void lastInsertFilenameIsRetainedCorrectly() {
 122                 fileOption.setLastInsertFilename(CUSTOM_LAST_INSERT_FILENAME);
 123                 assertThat(fileOption.getLastInsertFilename(), is(CUSTOM_LAST_INSERT_FILENAME));
 124         }
 125
 126         @Test
 127         public void defaultCurrentHashIsNull() {
 128                 assertThat(fileOption.getCurrentHash(), is(DEFAULT_CURRENT_HASH));
 129         }
 130
 131         @Test
 132         public void currentHashIsRetainedCorrectly() {
 133                 fileOption.setCurrentHash(CUSTOM_CURRENT_HASH);
 134                 assertThat(fileOption.getCurrentHash(), is(CUSTOM_CURRENT_HASH));
 135         }
 136
 137         @Test
 138         public void defaultChangedNameIsEmpty() {
 139                 assertThat(fileOption.getChangedName(), is(DEFAULT_CHANGED_NAME));
 140         }
 141
 142         @Test
 143         public void changedNameIsRetainedCorrectly() {
 144                 fileOption.setChangedName(CUSTOM_CHANGED_NAME);
 145                 assertThat(fileOption.getChangedName().get(), is(CUSTOM_CHANGED_NAME));
 146         }
 147
 148         @Test
 149         public void nullSetsChangedNameToEmpty() {
 150                 fileOption.setChangedName(NULL_CHANGED_NAME);
 151                 assertThat(fileOption.getChangedName(), is(DEFAULT_CHANGED_NAME));
 152         }
 153
 154         @Test
 155         public void zeroLengthStringSetsChangedNameToEmpty() {
 156                 fileOption.setChangedName(ZERO_LENGTH_CHANGED_NAME);
 157                 assertThat(fileOption.getChangedName(), is(DEFAULT_CHANGED_NAME));
 158         }
 159
 160         @Test
 161         public void defaultMimeTypeIsTheOneGivenInTheConstructor() {
 162                 assertThat(fileOption.getMimeType(), is(DEFAULT_MIME_TYPE));
 163         }
 164
 165         @Test
 166         public void mimeTypeIsRetainedCorrectly() {
 167                 fileOption.setMimeType(CUSTOM_MIME_TYPE);
 168                 assertThat(fileOption.getMimeType(), is(CUSTOM_MIME_TYPE));
 169         }
 170
 171         @Test
 172         public void nullSetsMimeTypeBackToTheOneGivenInConstructor() {
 173                 fileOption.setMimeType(NULL_MIME_TYPE);
 174                 assertThat(fileOption.getMimeType(), is(DEFAULT_MIME_TYPE));
 175         }
 176
 177         @Test
 178         public void fileWithCustomInsertIsCustom() {
 179                 fileOption.setInsert(CUSTOM_INSERT);
 180                 assertThat(fileOption.isCustom(), is(true));
 181         }
 182
 183         @Test
 184         public void fileWithCustomKeyIsCustom() {
 185                 fileOption.setCustomKey(CUSTOM_KEY);
 186                 assertThat(fileOption.isCustom(), is(true));
 187         }
 188
 189         @Test
 190         public void fileWithChangedNameIsCustom() {
 191                 fileOption.setChangedName(CUSTOM_CHANGED_NAME);
 192                 assertThat(fileOption.isCustom(), is(true));
 193         }
 194
 195         @Test
 196         public void fileWithCustomMimeTypeIsCustom() {
 197                 fileOption.setMimeType(CUSTOM_MIME_TYPE);
 198                 assertThat(fileOption.isCustom(), is(true));
 199         }
 200
 201         @Test
 202         public void fileWithCustomInsertRedirectIsCustom() {
 203                 fileOption.setInsertRedirect(CUSTOM_INSERT_REDIRECT);
 204                 assertThat(fileOption.isCustom(), is(true));
 205         }
 206
 207         @Test
 208         public void unchangedFileIsNotCustom() {
 209                 assertThat(fileOption.isCustom(), is(false));
 210         }
 211
 212         @Test
 213         public void copyConstructorCopiesAllProperties() {
 214                 fileOption.setChangedName(CUSTOM_CHANGED_NAME);
 215                 fileOption.setInsertRedirect(CUSTOM_INSERT_REDIRECT);
 216                 fileOption.setInsert(CUSTOM_INSERT);
 217                 fileOption.setMimeType(CUSTOM_MIME_TYPE);
 218                 fileOption.setCurrentHash(CUSTOM_CURRENT_HASH);
 219                 fileOption.setCustomKey(CUSTOM_KEY);
 220                 fileOption.setForceInsert(CUSTOM_FORCE_INSERT);
 221                 fileOption.setLastInsertEdition(CUSTOM_LAST_INSERT_EDITION);
 222                 fileOption.setLastInsertFilename(CUSTOM_LAST_INSERT_FILENAME);
 223                 fileOption.setLastInsertHash(CUSTOM_LAST_INSERT_HASH);
 224                 fileOption.setCurrentHash(CUSTOM_CURRENT_HASH);
 225                 FileOption copiedFileOption = new FileOption(fileOption);
 226                 assertThat(copiedFileOption.getChangedName().get(), is(CUSTOM_CHANGED_NAME));
 227                 assertThat(copiedFileOption.isInsertRedirect(), is(CUSTOM_INSERT_REDIRECT));
 228                 assertThat(copiedFileOption.isInsert(), is(CUSTOM_INSERT));
 229                 assertThat(copiedFileOption.getMimeType(), is(CUSTOM_MIME_TYPE));
 230                 assertThat(copiedFileOption.getCurrentHash(), is(CUSTOM_CURRENT_HASH));
 231                 assertThat(copiedFileOption.getCustomKey(), is(CUSTOM_KEY));
 232                 assertThat(copiedFileOption.isForceInsert(), is(CUSTOM_FORCE_INSERT));
 233                 assertThat(copiedFileOption.getLastInsertEdition(), is(CUSTOM_LAST_INSERT_EDITION));
 234                 assertThat(copiedFileOption.getLastInsertFilename(), is(CUSTOM_LAST_INSERT_FILENAME));
 235                 assertThat(copiedFileOption.getLastInsertHash(), is(CUSTOM_LAST_INSERT_HASH));
 236                 assertThat(copiedFileOption.getCurrentHash(), is(CUSTOM_CURRENT_HASH));
 237         }
 238
 239 }