/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.ambari.server.state.kerberos;

import junit.framework.Assert;
import org.apache.ambari.server.AmbariException;
import org.junit.Test;

import java.util.HashMap;
import java.util.Map;

public class VariableReplacementHelperTest {
  VariableReplacementHelper helper = new VariableReplacementHelper();

  @Test
  public void testReplaceVariables() throws AmbariException {
    Map<String, Map<String, String>> configurations = new HashMap<String, Map<String, String>>() {
      {
        put("", new HashMap<String, String>() {{
          put("global_variable", "Hello World");
          put("variable-name", "dash");
          put("variable_name", "underscore");
          put("variable.name", "dot");
        }});

        put("config_type", new HashMap<String, String>() {{
          put("variable-name", "config_type_dash");
          put("variable_name", "config_type_underscore");
          put("variable.name", "config_type_dot");
        }});

        put("config.type", new HashMap<String, String>() {{
          put("variable-name", "config.type_dash");
          put("variable_name", "config.type_underscore");
          put("variable.name", "config.type_dot");
        }});

        put("config-type", new HashMap<String, String>() {{
          put("variable.name", "Replacement1");
          put("variable.name1", "${config-type2/variable.name}");
          put("variable.name2", "");
        }});

        put("config-type2", new HashMap<String, String>() {{
          put("variable.name", "Replacement2");
          put("self_reference", "${config-type2/self_reference}");  // This essentially references itself.
          put("${config-type/variable.name}_reference", "Replacement in the key");
        }});
      }
    };

    Assert.assertEquals("concrete",
        helper.replaceVariables("concrete", configurations));

    Assert.assertEquals("Hello World",
        helper.replaceVariables("${global_variable}", configurations));

    Assert.assertEquals("Replacement1",
        helper.replaceVariables("${config-type/variable.name}", configurations));

    Assert.assertEquals("Replacement1|Replacement2",
        helper.replaceVariables("${config-type/variable.name}|${config-type2/variable.name}", configurations));

    Assert.assertEquals("Replacement1|Replacement2|${config-type3/variable.name}",
        helper.replaceVariables("${config-type/variable.name}|${config-type2/variable.name}|${config-type3/variable.name}", configurations));

    Assert.assertEquals("Replacement2|Replacement2",
        helper.replaceVariables("${config-type/variable.name1}|${config-type2/variable.name}", configurations));

    Assert.assertEquals("Replacement1_reference",
        helper.replaceVariables("${config-type/variable.name}_reference", configurations));

    Assert.assertEquals("dash",
        helper.replaceVariables("${variable-name}", configurations));

    Assert.assertEquals("underscore",
        helper.replaceVariables("${variable_name}", configurations));

    Assert.assertEquals("config_type_dot",
        helper.replaceVariables("${config_type/variable.name}", configurations));

    Assert.assertEquals("config_type_dash",
        helper.replaceVariables("${config_type/variable-name}", configurations));

    Assert.assertEquals("config_type_underscore",
        helper.replaceVariables("${config_type/variable_name}", configurations));

    Assert.assertEquals("config.type_dot",
        helper.replaceVariables("${config.type/variable.name}", configurations));

    Assert.assertEquals("config.type_dash",
        helper.replaceVariables("${config.type/variable-name}", configurations));

    Assert.assertEquals("config.type_underscore",
        helper.replaceVariables("${config.type/variable_name}", configurations));

    Assert.assertEquals("dot",
        helper.replaceVariables("${variable.name}", configurations));

    // Replacement yields an empty string
    Assert.assertEquals("",
        helper.replaceVariables("${config-type/variable.name2}", configurations));


    // This might cause an infinite loop... we assume protection is in place...
    try {
      Assert.assertEquals("${config-type2/self_reference}",
          helper.replaceVariables("${config-type2/self_reference}", configurations));
      Assert.fail(String.format("%s expected to be thrown", AmbariException.class.getName()));
    } catch (AmbariException e) {
      // This is expected...
    }
  }

  @Test
  public void testReplaceComplicatedVariables() throws AmbariException {
    Map<String, Map<String, String>> configurations = new HashMap<String, Map<String, String>>() {
      {
        put("", new HashMap<String, String>() {{
          put("host", "c6401.ambari.apache.org");
          put("realm", "EXAMPLE.COM");
        }});
      }
    };

    Assert.assertEquals("hive.metastore.local=false,hive.metastore.uris=thrift://c6401.ambari.apache.org:9083,hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@EXAMPLE.COM",
        helper.replaceVariables("hive.metastore.local=false,hive.metastore.uris=thrift://${host}:9083,hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@${realm}", configurations));

    Assert.assertEquals("Hello my realm is {EXAMPLE.COM}",
        helper.replaceVariables("Hello my realm is {${realm}}", configurations));

    Assert.assertEquals("$c6401.ambari.apache.org",
        helper.replaceVariables("$${host}", configurations));
  }

  @Test
  public void testReplaceVariablesWithFunctions() throws AmbariException {
    Map<String, Map<String, String>> configurations = new HashMap<String, Map<String, String>>() {
      {
        put("", new HashMap<String, String>() {{
          put("delimited.data", "one,two,three,four");
          put("realm", "UNIT.TEST");
        }});

        put("clusterHostInfo", new HashMap<String, String>() {{
          put("hive_metastore_host", "host1.unit.test, host2.unit.test , host3.unit.test"); // spaces are there on purpose.
        }});
      }
    };

    Assert.assertEquals("test=thrift://one:9083\\,thrift://two:9083\\,thrift://three:9083\\,thrift://four:9083",
        helper.replaceVariables("test=${delimited.data|each(thrift://%s:9083, \\\\,, \\s*\\,\\s*)}", configurations));

    Assert.assertEquals("hive.metastore.local=false,hive.metastore.uris=thrift://host1.unit.test:9083\\,thrift://host2.unit.test:9083\\,thrift://host3.unit.test:9083,hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@UNIT.TEST",
        helper.replaceVariables("hive.metastore.local=false,hive.metastore.uris=${clusterHostInfo/hive_metastore_host | each(thrift://%s:9083, \\\\,, \\s*\\,\\s*)},hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@${realm}", configurations));

    Assert.assertEquals("test=unit.test", helper.replaceVariables("test=${realm|toLower()}", configurations));
  }

}