src/test/java/net/pterodactylus/util/envopt/ParserTest.java

   1 package net.pterodactylus.util.envopt;
   2
   3 import java.util.Optional;
   4
   5 import net.pterodactylus.util.envopt.Parser.RequiredOptionIsMissing;
   6
   7 import org.hamcrest.MatcherAssert;
   8 import org.hamcrest.Matchers;
   9 import org.junit.Test;
  10 import org.mockito.Mockito;
  11
  12 /**
  13  * Unit test for {@link Parser}.
  14  *
  15  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  16  */
  17 public class ParserTest {
  18
  19         private final Environment environment = Mockito.mock(Environment.class);
  20         private final Parser parser = new Parser(environment);
  21
  22         @Test
  23         public void parserCanParseEnvironmentIntoOptions() {
  24                 Mockito.when(environment.getValue("foo")).thenReturn(Optional.of("test"));
  25                 TestOptions testOptions = parser.parseEnvironment(TestOptions::new);
  26                 MatcherAssert.assertThat(testOptions.getOptionOne(), Matchers.is("test"));
  27         }
  28
  29         @Test
  30         public void parserIgnoresOptionsWithoutAnnotations() {
  31                 MoreTestOptions moreTestOptions = parser.parseEnvironment(MoreTestOptions::new);
  32                 MatcherAssert.assertThat(moreTestOptions.getOptionOne(), Matchers.nullValue());
  33         }
  34
  35         @Test
  36         public void parserCanAssignToFinalValues() {
  37                 Mockito.when(environment.getValue("foo")).thenReturn(Optional.of("test"));
  38             FinalTestOptions finalTestOptions = parser.parseEnvironment(FinalTestOptions::new);
  39                 MatcherAssert.assertThat(finalTestOptions.getOptionOne(), Matchers.is("test"));
  40         }
  41
  42         @Test(expected = RequiredOptionIsMissing.class)
  43         public void parserThrowsIfRequiredOptionIsMissing() {
  44                 Mockito.when(environment.getValue("foo")).thenReturn(Optional.empty());
  45             RequiredTestOptions requiredTestOptions = parser.parseEnvironment(RequiredTestOptions::new);
  46                 requiredTestOptions.getOptionOne();
  47         }
  48
  49         @Test
  50         public void parserSetsDefaultValueIfValueIsMissing() {
  51             Mockito.when(environment.getValue("foo")).thenReturn(Optional.empty());
  52                 DefaultTestOptions options = parser.parseEnvironment(DefaultTestOptions::new);
  53                 MatcherAssert.assertThat(options.optionOne, Matchers.is("something"));
  54         }
  55
  56         /**
  57          * Test class with options used by {@link Parser}.
  58          *
  59          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  60          */
  61         private static class TestOptions {
  62
  63                 @Option(name = "foo")
  64                 private String optionOne;
  65
  66                 public String getOptionOne() {
  67                         return optionOne;
  68                 }
  69
  70         }
  71
  72         /**
  73          * Test class with options used by {@link Parser}.
  74          *
  75          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  76          */
  77         private static class MoreTestOptions {
  78
  79                 private String optionOne;
  80
  81                 public String getOptionOne() {
  82                         return optionOne;
  83                 }
  84
  85         }
  86
  87         /**
  88          * Test class with options used by {@link Parser}.
  89          *
  90          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
  91          */
  92         private static class FinalTestOptions {
  93
  94                 @Option(name = "foo")
  95                 private final String optionOne = null;
  96
  97                 public String getOptionOne() {
  98                         return optionOne;
  99                 }
 100
 101         }
 102
 103         /**
 104          * Test class with options used by {@link Parser}.
 105          *
 106          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 107          */
 108         private static class RequiredTestOptions {
 109
 110                 @Option(name = "foo", required = true)
 111                 private final String optionOne = null;
 112
 113                 public String getOptionOne() {
 114                         return optionOne;
 115                 }
 116
 117         }
 118
 119         /**
 120          * Test class with options used by {@link Parser}.
 121          *
 122          * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
 123          */
 124         private static class DefaultTestOptions {
 125
 126                 @Option(name = "foo", defaultValue = "something")
 127                 public final String optionOne = null;
 128
 129         }
 130
 131 }