@Override
public Collection<T> loadConfig() {
    Collection<T> configData = new ArrayList<>();
    final File configDirectory = new File(configuration.getDataDirectory(),dataDirectory);
    final File[] dataFiles = configDirectory.listFiles((FilenameFilter) new WildcardFileFilter("*.yml"));
    if (dataFiles == null) {
        throw ConfigValidationException.createFileReadError(configDirectory.getAbsolutePath());
    }

    for (File dataFile : dataFiles) {
        T data;
        try {
            data = configurationFactory.build(dataFile);
        } catch (IOException | ConfigurationException e) {
            throw Throwables.propagate(e);
        }
        configData.add(data);

    }
    return configData;
}

@Test
public void nodeClientShouldBeCreatedFromConfig() throws URISyntaxException,IOException,ConfigurationException {
    URL configFileUrl = this.getClass().getResource("/node_client.yml");
    File configFile = new File(configFileUrl.toURI());
    EsConfiguration config = configFactory.build(configFile);

    ManagedEsClient managedEsClient = new ManagedEsClient(config);
    Client client = managedEsClient.getClient();

    assertNotNull(client);
    assertTrue(client instanceof NodeClient);

    NodeClient nodeClient = (NodeClient) client;
    assertEquals(config.getClusterName(),nodeClient.settings().get("cluster.name"));
    assertEquals("true",nodeClient.settings().get("node.client"));
    assertEquals("false",nodeClient.settings().get("node.data"));
}

@Test
public void transportClientShouldBeCreatedFromConfig() throws URISyntaxException,ConfigurationException {
    URL configFileUrl = this.getClass().getResource("/transport_client.yml");
    File configFile = new File(configFileUrl.toURI());
    EsConfiguration config = configFactory.build(configFile);

    ManagedEsClient managedEsClient = new ManagedEsClient(config);
    Client client = managedEsClient.getClient();

    assertNotNull(client);
    assertTrue(client instanceof TransportClient);

    final TransportClient transportClient = (TransportClient) client;
    assertEquals(3,transportClient.transportAddresses().size());
    assertEquals(
            TransportAddressHelper.fromHostAndPort(HostAndPort.fromParts("127.0.0.1",9300)),transportClient.transportAddresses().get(0));
    assertEquals(
            TransportAddressHelper.fromHostAndPort(HostAndPort.fromParts("127.0.0.1",9301)),transportClient.transportAddresses().get(1));
    assertEquals(
            TransportAddressHelper.fromHostAndPort(HostAndPort.fromParts("127.0.0.1",9302)),transportClient.transportAddresses().get(2));
}

@Test
public void managedClientShouldUseCustomElasticsearchConfig() throws URISyntaxException,ConfigurationException {
    URL configFileUrl = this.getClass().getResource("/custom_settings_file.yml");
    File configFile = new File(configFileUrl.toURI());
    EsConfiguration config = configFactory.build(configFile);

    ManagedEsClient managedEsClient = new ManagedEsClient(config);
    Client client = managedEsClient.getClient();

    assertNotNull(client);
    assertTrue(client instanceof NodeClient);

    NodeClient nodeClient = (NodeClient) client;
    assertEquals(config.getClusterName(),nodeClient.settings().get("cluster.name"));
    assertEquals("19300-19400",nodeClient.settings().get("transport.tcp.port"));
}

@Test
public void managedClientObeysPrecedenceOfSettings() throws URISyntaxException,ConfigurationException {
    URL configFileUrl = this.getClass().getResource("/custom_settings_precedence.yml");
    File configFile = new File(configFileUrl.toURI());
    EsConfiguration config = configFactory.build(configFile);

    ManagedEsClient managedEsClient = new ManagedEsClient(config);
    Client client = managedEsClient.getClient();

    assertNotNull(client);
    assertTrue(client instanceof NodeClient);

    NodeClient nodeClient = (NodeClient) client;
    assertEquals(config.getClusterName(),nodeClient.settings().get("cluster.name"));
    assertEquals("29300-29400",nodeClient.settings().get("transport.tcp.port"));
    assertEquals("target/data/yaml",nodeClient.settings().get("path.home"));
}

private void connect() throws URISyntaxException,ConfigurationException {
    final File yml = new File(Resources.getResource(serializer).toURI());
    final YamlConfigurationFactory<TinkerPopFactory> factory =
            new YamlConfigurationFactory<>(TinkerPopFactory.class,validator,objectMapper,"dw");
    final Cluster cluster = factory.build(yml).build();
    final Graph graph = EmptyGraph.instance();
    client = cluster.connect();
    g = graph.traversal().withRemote(DriverRemoteConnection.using(cluster,"g"));
}

@Test
public void testReadWriteClient() throws ConfigurationException,URISyntaxException {
    final Long expected = client.submit("g.addV('Person').id()").one().getLong();
    final Long person = client.submit("g.V().hasLabel('Person').id()").one().getLong();
    assertEquals(expected,person);

    if(testBytecode) {
        client.submit("g.V().drop()");
        final Long remoteExpected = (Long) g.addV("Person").id().next();
        final Long remotePerson = (Long) g.V().hasLabel("Person").id().next();
        assertEquals(remoteExpected,remotePerson);
    }
}

public SupportedMsaVersions loadSupportedMsaVersions(final URL url) {
    final ConfigurationFactory<SupportedMsaVersions> factory = supportedMsaVersionsFactoryFactory.create(
            SupportedMsaVersions.class,buildDefaultValidatorFactory().getValidator(),"");
    try {
        SupportedMsaVersions supportedMsaVersions = factory.build(
                configurationSourceProvider,url.toString());
        return supportedMsaVersions;
    } catch (IOException | ConfigurationException e) {
        throw propagate(e);
    }
}

@Test
public void canDeserializeCorrectly() throws IOException,ConfigurationException {
    final HikariDataSourceFactory factory = new YamlConfigurationFactory<>(HikariDataSourceFactory.class,BaseValidator.newValidator(),Jackson.newObjectMapper(),"dw")
            .build(new ResourceConfigurationSourceProvider(),"config.yaml");

    assertthat(factory.getUser()).isEqualTo("nick");
    assertthat(factory.getpassword()).isEqualTo("nickss");
    assertthat(factory.getDatasourceClassName()).isEqualTo("org.postgresql.ds.PGSimpleDataSource");
    assertthat(factory.getProperties()).containsExactly(entry("databaseName","postgres"));
    assertthat(factory.getMinSize()).isEqualTo(OptionalInt.empty());
    assertthat(factory.getMaxSize()).isEqualTo(12);
    assertthat(factory.isAutoCommit()).isTrue();
}

private EmoConfiguration loadConfigFile(File configFile)
        throws IOException,ConfigurationException {
    Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    ObjectMapper mapper = CustomJsonObjectMapperFactory.build(new YAMLFactory());
    ConfigurationFactory<EmoConfiguration> configurationFactory = new ConfigurationFactory(EmoConfiguration.class,mapper,"dw");
    return configurationFactory.build(configFile);
}

public static DdlConfiguration parseDdlConfiguration(File file) throws IOException,ConfigurationException {
    // Similar to Dropwizard's ConfigurationFactory but ignores System property overrides.
    ObjectMapper mapper = CustomJsonObjectMapperFactory.build(new YAMLFactory());
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNowN_PROPERTIES,true);
    DdlConfiguration ddlConfiguration = mapper.readValue(file,DdlConfiguration.class);

    Set<ConstraintViolation<DdlConfiguration>> errors = _validator.validate(ddlConfiguration);
    if (!errors.isEmpty()) {
        throw new ConfigurationValidationException(file.toString(),errors);
    }

    return ddlConfiguration;
}

@Test
public void ensureSdkDefaultConfigDeserialization()
        throws IOException,URISyntaxException,ConfigurationException {
    // This test makes sure that we haven't forgotten to update the emodb sdk default config file when we add/remove properties
    Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    ObjectMapper mapper = CustomJsonObjectMapperFactory.build(new YAMLFactory());
    ConfigurationFactory configurationFactory = new ConfigurationFactory(EmoConfiguration.class,"dw");
    // Make sure that our config files are up to date
    configurationFactory.build(
    new File(EmoStartMojo.class.getResource("/emodb-default-config.yaml").toURI()));
}

/**
 * Parses the given configuration file and returns a configuration object.
 *
 * @param configurationFileName The name of the configuration file.
 * @return A configuration object.
 * @throws IOException The IO error that contains detail information.
 * @throws ConfigurationException The configuration error that contains detail information.
 */
public static ApiConfiguration parse(String configurationFileName)
  throws IOException,ConfigurationException {
  if (StringUtils.isBlank(configurationFileName)) {
    throw new IllegalArgumentException("Configuration file cannot be blank");
  }

  ObjectMapper objectMapper = null;
  if (configurationFileName.endsWith("yml") || configurationFileName.endsWith("yaml")) {
    objectMapper = Jackson.newObjectMapper(new YAMLFactory());
  } else if (configurationFileName.endsWith("json")) {
    objectMapper = Jackson.newObjectMapper(new JsonFactory());
  } else {
    throw new IllegalArgumentException("Unrecognized configuration file type");
  }

  ValidatorFactory validatorFactory = Validation
      .byProvider(HibernateValidator.class)
      .configure()
      .addValidatedValueHandler(new OptionalValidatedValueUnwrapper())
      .buildValidatorFactory();

  final ConfigurationFactory<ApiConfiguration> configurationFactory =
      new DefaultConfigurationFactoryFactory<ApiConfiguration>()
        .create(ApiConfiguration.class,validatorFactory.getValidator(),"dw");

  final File file = new File(configurationFileName);
  if (!file.exists()) {
    throw new FileNotFoundException("Configuration file " + configurationFileName + " not found");
  }

  return configurationFactory.build(file);
}

static Injector createInjector() {
  KeywhizService service = new KeywhizService();
  Bootstrap<KeywhizConfig> bootstrap = new Bootstrap<>(service);
  service.initialize(bootstrap);

  File yamlFile = new File(Resources.getResource("keywhiz-test.yaml").getFile());
  Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
  ObjectMapper objectMapper = bootstrap.getobjectMapper().copy();
  KeywhizConfig config;
  try {
    config = new ConfigurationFactory<>(KeywhizConfig.class,"dw")
        .build(yamlFile);
  } catch (IOException | ConfigurationException e) {
    throw Throwables.propagate(e);
  }

  Environment environment = new Environment(service.getName(),bootstrap.getMetricRegistry(),bootstrap.getClassLoader());

  Injector injector = Guice.createInjector(new ServiceModule(config,environment));

  service.setInjector(injector);
  return injector;
}

public static BackupConfiguration loadConfiguration() throws IOException,ConfigurationException {
    if (!CONfigURATION_FILE.isPresent()) {
        throw new FileNotFoundException(String.format("Unable to find %s",CONfigURATION_FILENAME));
    }

    return CONfigURATION_FACTORY.build(CONfigURATION_FILE.get());
}

@Test
public void testTemplateConfigurationIsValid() throws IOException,ConfigurationException {
    final BackupConfiguration config = ConfigurationTestUtil.loadConfiguration();
    assertNotNull(config);

    final Validator validator = Validation.buildDefaultValidatorFactory().getValidator();
    assertTrue(validator.validate(config).isEmpty());
}

@Test
public void hasValidDefaults() throws IOException,ConfigurationException {
  final RavenAppenderFactory factory = new RavenAppenderFactory();

  assertNull("default dsn is unset",factory.getDsn());
  assertFalse("default environment is empty",factory.getEnvironment().isPresent());
  assertFalse("default extraTags is empty",factory.getEnvironment().isPresent());
  assertFalse("default ravenFactory is empty",factory.getRavenFactory().isPresent());
  assertFalse("default release is empty",factory.getRelease().isPresent());
  assertFalse("default serverName is empty",factory.getServerName().isPresent());
  assertFalse("default tags are empty",factory.getTags().isPresent());
}

@Test
public void can_set_variable_with_default_in_array() throws IOException,ConfigurationException {
    environmentProvider.put("ARRAY_2","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.array.get(2),is(equalTo("5")));
}

@Test
public void can_set_variable_with_default_in_object() throws IOException,ConfigurationException {
    environmentProvider.put("OBJECT_C","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.object.get("c"),is(equalTo("5")));
}

@Test
public void can_set_variable_without_default_in_array() throws IOException,ConfigurationException {
    environmentProvider.put("ARRAY_1","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.array.get(1),is(equalTo("5")));
}

@Test
public void can_set_variable_without_default_in_object() throws IOException,ConfigurationException {
    environmentProvider.put("OBJECT_B","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.object.get("b"),is(equalTo("5")));
}

@Test
public void uses_default_value_in_array() throws IOException,ConfigurationException {
    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.array.get(2),is(equalTo("default")));
}

@Test
public void uses_default_value_in_object() throws IOException,ConfigurationException {
    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.object.get("c"),is(equalTo("default")));
}

@Test
public void can_set_variable_with_default_in_array() throws IOException,ConfigurationException {
    environmentProvider.put("SUB_ARRAY_2","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.subTestConfiguration.array.get(2),is(equalTo("5")));
}

@Test
public void can_set_variable_with_default_in_object() throws IOException,ConfigurationException {
    environmentProvider.put("SUB_OBJECT_C","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.subTestConfiguration.object.get("c"),is(equalTo("5")));
}

@Test
public void can_set_variable_without_default_in_array() throws IOException,ConfigurationException {
    environmentProvider.put("SUB_ARRAY_1","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.subTestConfiguration.array.get(1),is(equalTo("5")));
}

@Test
public void can_set_variable_without_default_in_object() throws IOException,ConfigurationException {
    environmentProvider.put("SUB_OBJECT_B","5");

    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.subTestConfiguration.object.get("b"),is(equalTo("5")));
}

@Test
public void uses_default_value_in_array() throws IOException,ConfigurationException {
    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.subTestConfiguration.array.get(2),is(equalTo("default")));
}

@Test
public void uses_default_value_in_object() throws IOException,ConfigurationException {
    TestConfiguration testConfiguration = environmentConfigurationFactory.build(new File(
            "src/test/resources/config.yaml"));

    assertthat(testConfiguration.subTestConfiguration.object.get("c"),is(equalTo("default")));
}

@Before
public void setUp() throws URISyntaxException,ConfigurationException {
    connect();
}

public String getUrl() throws ConfigurationException {
    return url;
}

@Singleton
@Provides
@Named("openDataUrl")
public String provideOpenDataClient(final OpenDataClientConfiguration configuration) throws ConfigurationException {
    return configuration.getUrl();
}

@Override
protected AzureTableMetadataStorage<BackupMetadata> getMetadataStorage() throws IOException,ConfigurationException {
    return new AzureTableMetadataStorage<>(BackupMetadata.class,configuration,azureNamespace,new MetricRegistry());
}

@Override
protected AzureTablelikeMetadataStorage<BackupMetadata> getMetadataStorage() throws IOException,ConfigurationException {
    return new AzureTablelikeMetadataStorage<>(BackupMetadata.class);
}

@Before
public void setUp() throws InvalidKeySpecException,NoSuchAlgorithmException,ConfigurationException {
    final TokenConfiguration config = ConfigurationTestUtil.loadConfiguration().getTokenConfiguration();
    generator = new TemporaryTokenGenerator(config);
}

@Override
protected MetadataStorage<BackupMetadata> getMetadataStorage() throws IOException,ConfigurationException {
    final BackupConfiguration configuration = ConfigurationTestUtil.loadConfiguration();
    return new AzureTableMetadataStorage<>(BackupMetadata.class,configuration.getoffsiteConfiguration().getStorageConfiguration(),new MetricRegistry());
}

@Override
protected AzureFileStorage getFileStorage() throws IOException,ConfigurationException,StorageException,InvalidKeyException,URISyntaxException {
    final BackupConfiguration configuration = ConfigurationTestUtil.loadConfiguration();
    return new AzureFileStorage(configuration.getoffsiteConfiguration().getStorageConfiguration(),azureNamespace);
}

@Test
public void defaultConfigShouldBeValid() throws IOException,ConfigurationException {
    configFactory.build();
}

@Test(expected = ConfigurationException.class)
public void eitherNodeClientOrServerListMustBeSet() throws IOException,URISyntaxException {
    URL configFileUrl = this.getClass().getResource("/invalid.yml");
    File configFile = new File(configFileUrl.toURI());
    configFactory.build(configFile);
}

/**
 * Loads,parses,binds,and validates a configuration object.
 *
 * @param provider the provider to to use for reading configuration files
 * @param path     the path of the configuration file
 * @return a validated configuration object
 * @throws IOException            if there is an error reading the file
 * @throws ConfigurationException if there is an error parsing or validating the file
 */
public T build(ConfigurationSourceProvider provider,String path)
    throws IOException,ConfigurationException
{
    return build(loadConfiguration(provider,path),path);
}