/*
 * 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.knox.gateway.topology.simple;

import org.junit.Test;

import java.io.File;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

public class SimpleDescriptorFactoryTest {

    private enum FileType {
        JSON,
        YAML,
        YML
    }

    @Test
    public void testParseJSONSimpleDescriptor() throws Exception {
        testParseSimpleDescriptor(FileType.JSON);
    }

    @Test
    public void testParseYAMLSimpleDescriptor() throws Exception {
        testParseSimpleDescriptor(FileType.YML);
        testParseSimpleDescriptor(FileType.YAML);
    }

    @Test
    public void testParseJSONSimpleDescriptorWithServiceVersions() throws Exception {
        testParseSimpleDescriptorWithServiceVersions(FileType.JSON);
    }

    @Test
    public void testParseYAMLSimpleDescriptorWithServiceVersions() throws Exception {
        testParseSimpleDescriptorWithServiceVersions(FileType.YML);
        testParseSimpleDescriptorWithServiceVersions(FileType.YAML);
    }

    @Test
    public void testParseJSONSimpleDescriptorWithServiceParams() throws Exception {
        testParseSimpleDescriptorWithServiceParams(FileType.JSON);
    }

    @Test
    public void testParseYAMLSimpleDescriptorWithServiceParams() throws Exception {
        testParseSimpleDescriptorWithServiceParams(FileType.YML);
        testParseSimpleDescriptorWithServiceParams(FileType.YAML);
    }

    @Test
    public void testParseJSONSimpleDescriptorWithApplications() throws Exception {
        testParseSimpleDescriptorWithApplications(FileType.JSON);
    }

    @Test
    public void testParseYAMLSimpleDescriptorApplications() throws Exception {
        testParseSimpleDescriptorWithApplications(FileType.YML);
        testParseSimpleDescriptorWithApplications(FileType.YAML);
    }


    @Test
    public void testParseJSONSimpleDescriptorWithServicesAndApplications() throws Exception {
        testParseSimpleDescriptorWithServicesAndApplications(FileType.JSON);
    }

    @Test
    public void testParseYAMLSimpleDescriptorWithServicesAndApplications() throws Exception {
        testParseSimpleDescriptorWithServicesAndApplications(FileType.YML);
        testParseSimpleDescriptorWithServicesAndApplications(FileType.YAML);
    }


    private void testParseSimpleDescriptor(FileType type) throws Exception {
        final String   discoveryType    = "AMBARI";
        final String   discoveryAddress = "http://c6401.ambari.apache.org:8080";
        final String   discoveryUser    = "joeblow";
        final String   providerConfig   = "ambari-cluster-policy.xml";
        final String   clusterName      = "myCluster";

        final Map<String, List<String>> services = new HashMap<>();
        services.put("NODEMANAGER", null);
        services.put("JOBTRACKER", null);
        services.put("RESOURCEMANAGER", null);
        services.put("HIVE", Arrays.asList("http://c6401.ambari.apache.org",
                                           "http://c6402.ambari.apache.org",
                                           "http://c6403.ambari.apache.org"));
        services.put("AMBARIUI", Collections.singletonList("http://c6401.ambari.apache.org:8080"));

        String fileName = "test-topology." + getFileExtensionForType(type);
        File testFile = null;
        try {
            testFile = writeDescriptorFile(type,
                                           fileName,
                                           discoveryType,
                                           discoveryAddress,
                                           discoveryUser,
                                           providerConfig,
                                           clusterName,
                                           services);
            SimpleDescriptor sd = SimpleDescriptorFactory.parse(testFile.getAbsolutePath());
            validateSimpleDescriptor(sd, discoveryType, discoveryAddress, providerConfig, clusterName, services);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (testFile != null) {
                try {
                    testFile.delete();
                } catch (Exception e) {
                    // Ignore
                }
            }
        }
    }

    private void testParseSimpleDescriptorWithServiceVersions(FileType type) throws Exception {
        final String   discoveryType    = "AMBARI";
        final String   discoveryAddress = "http://c6401.ambari.apache.org:8080";
        final String   discoveryUser    = "joeblow";
        final String   providerConfig   = "ambari-cluster-policy.xml";
        final String   clusterName      = "myCluster";

        final Map<String, List<String>> services = new HashMap<>();
        services.put("NODEMANAGER", null);
        services.put("JOBTRACKER", null);
        services.put("RESOURCEMANAGER", null);
        services.put("WEBHDFS", null);
        services.put("HIVE", Arrays.asList("http://c6401.ambari.apache.org",
                                           "http://c6402.ambari.apache.org",
                                           "http://c6403.ambari.apache.org"));
        services.put("AMBARIUI", Collections.singletonList("http://c6401.ambari.apache.org:8080"));

        Map<String, String> serviceVersions = new HashMap<>();
        serviceVersions.put("HIVE", "0.13.0");
        serviceVersions.put("WEBHDFS", "2.4.0");

        String fileName = "test-topology." + getFileExtensionForType(type);
        File testFile = null;
        try {
            testFile = writeDescriptorFile(type,
                                           fileName,
                                           discoveryType,
                                           discoveryAddress,
                                           discoveryUser,
                                           providerConfig,
                                           clusterName,
                                           services,
                                           serviceVersions);
            SimpleDescriptor sd = SimpleDescriptorFactory.parse(testFile.getAbsolutePath());
            validateSimpleDescriptor(sd, discoveryType, discoveryAddress, providerConfig, clusterName, services, serviceVersions);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (testFile != null) {
                try {
                    testFile.delete();
                } catch (Exception e) {
                    // Ignore
                }
            }
        }
    }


    private void testParseSimpleDescriptorWithServiceParams(FileType type) throws Exception {

        final String   discoveryType    = "AMBARI";
        final String   discoveryAddress = "http://c6401.ambari.apache.org:8080";
        final String   discoveryUser    = "admin";
        final String   providerConfig   = "ambari-cluster-policy.xml";
        final String   clusterName      = "myCluster";

        final Map<String, List<String>> services = new HashMap<>();
        services.put("NODEMANAGER", null);
        services.put("JOBTRACKER", null);
        services.put("RESOURCEMANAGER", null);
        services.put("HIVE", Arrays.asList("http://c6401.ambari.apache.org", "http://c6402.ambari.apache.org", "http://c6403.ambari.apache.org"));
        services.put("AMBARIUI", Collections.singletonList("http://c6401.ambari.apache.org:8080"));
        services.put("KNOXSSO", null);
        services.put("KNOXTOKEN", null);
        services.put("CustomRole", Collections.singletonList("http://c6402.ambari.apache.org:1234"));

        final Map<String, Map<String, String>> serviceParams = new HashMap<>();
        Map<String, String> knoxSSOParams = new HashMap<>();
        knoxSSOParams.put("knoxsso.cookie.secure.only", "true");
        knoxSSOParams.put("knoxsso.token.ttl", "100000");
        serviceParams.put("KNOXSSO", knoxSSOParams);

        Map<String, String> knoxTokenParams = new HashMap<>();
        knoxTokenParams.put("knox.token.ttl", "36000000");
        knoxTokenParams.put("knox.token.audiences", "tokenbased");
        knoxTokenParams.put("knox.token.target.url", "https://localhost:8443/gateway/tokenbased");
        serviceParams.put("KNOXTOKEN", knoxTokenParams);

        Map<String, String> customRoleParams = new HashMap<>();
        customRoleParams.put("custom.param.1", "value1");
        customRoleParams.put("custom.param.2", "value2");
        serviceParams.put("CustomRole", customRoleParams);

        String fileName = "test-topology." + getFileExtensionForType(type);
        File testFile = null;
        try {
            testFile = writeDescriptorFile(type,
                                           fileName,
                                           discoveryType,
                                           discoveryAddress,
                                           discoveryUser,
                                           providerConfig,
                                           clusterName,
                                           services,
                                           null,
                                           serviceParams);
            SimpleDescriptor sd = SimpleDescriptorFactory.parse(testFile.getAbsolutePath());
            validateSimpleDescriptor(sd, discoveryType, discoveryAddress, providerConfig, clusterName, services, null, serviceParams);
        } finally {
            if (testFile != null) {
                try {
                    testFile.delete();
                } catch (Exception e) {
                    // Ignore
                }
            }
        }
    }

    private void testParseSimpleDescriptorWithApplications(FileType type) throws Exception {

        final String   discoveryType    = "AMBARI";
        final String   discoveryAddress = "http://c6401.ambari.apache.org:8080";
        final String   discoveryUser    = "admin";
        final String   providerConfig   = "ambari-cluster-policy.xml";
        final String   clusterName      = "myCluster";

        final Map<String, List<String>> apps = new HashMap<>();
        apps.put("app-one", null);
        apps.put("appTwo", null);
        apps.put("thirdApps", null);
        apps.put("appfour", Arrays.asList("http://host1:1234", "http://host2:5678", "http://host1:1357"));
        apps.put("AppFive", Collections.singletonList("http://host5:8080"));

        final Map<String, Map<String, String>> appParams = new HashMap<>();
        Map<String, String> oneParams = new HashMap<>();
        oneParams.put("appone.cookie.secure.only", "true");
        oneParams.put("appone.token.ttl", "100000");
        appParams.put("app-one", oneParams);
        Map<String, String> fiveParams = new HashMap<>();
        fiveParams.put("myproperty", "true");
        fiveParams.put("anotherparam", "100000");
        appParams.put("AppFive", fiveParams);

        String fileName = "test-topology." + getFileExtensionForType(type);
        File testFile = null;
        try {
            testFile = writeDescriptorFile(type,
                                           fileName,
                                           discoveryType,
                                           discoveryAddress,
                                           discoveryUser,
                                           providerConfig,
                                           clusterName,
                                           null,
                                           null,
                                           null,
                                           apps,
                                           appParams);
            SimpleDescriptor sd = SimpleDescriptorFactory.parse(testFile.getAbsolutePath());
            validateSimpleDescriptor(sd,
                                     discoveryType,
                                     discoveryAddress,
                                     providerConfig,
                                     clusterName,
                                     null,
                                     null,
                                     null,
                                     apps,
                                     appParams);
        } finally {
            if (testFile != null) {
                try {
                    testFile.delete();
                } catch (Exception e) {
                    // Ignore
                }
            }
        }
    }

    private void testParseSimpleDescriptorWithServicesAndApplications(FileType type) throws Exception {

        final String   discoveryType    = "AMBARI";
        final String   discoveryAddress = "http://c6401.ambari.apache.org:8080";
        final String   discoveryUser    = "admin";
        final String   providerConfig   = "ambari-cluster-policy.xml";
        final String   clusterName      = "myCluster";

        final Map<String, List<String>> services = new HashMap<>();
        services.put("NODEMANAGER", null);
        services.put("JOBTRACKER", null);
        services.put("RESOURCEMANAGER", null);
        services.put("HIVE", Arrays.asList("http://c6401.ambari.apache.org", "http://c6402.ambari.apache.org", "http://c6403.ambari.apache.org"));
        services.put("AMBARIUI", Collections.singletonList("http://c6401.ambari.apache.org:8080"));
        services.put("KNOXSSO", null);
        services.put("KNOXTOKEN", null);
        services.put("CustomRole", Collections.singletonList("http://c6402.ambari.apache.org:1234"));

        final Map<String, Map<String, String>> serviceParams = new HashMap<>();
        Map<String, String> knoxSSOParams = new HashMap<>();
        knoxSSOParams.put("knoxsso.cookie.secure.only", "true");
        knoxSSOParams.put("knoxsso.token.ttl", "100000");
        serviceParams.put("KNOXSSO", knoxSSOParams);

        Map<String, String> knoxTokenParams = new HashMap<>();
        knoxTokenParams.put("knox.token.ttl", "36000000");
        knoxTokenParams.put("knox.token.audiences", "tokenbased");
        knoxTokenParams.put("knox.token.target.url", "https://localhost:8443/gateway/tokenbased");
        serviceParams.put("KNOXTOKEN", knoxTokenParams);

        Map<String, String> customRoleParams = new HashMap<>();
        customRoleParams.put("custom.param.1", "value1");
        customRoleParams.put("custom.param.2", "value2");
        serviceParams.put("CustomRole", customRoleParams);

        final Map<String, List<String>> apps = new HashMap<>();
        apps.put("app-one", null);
        apps.put("appTwo", null);
        apps.put("thirdApps", null);
        apps.put("appfour", Arrays.asList("http://host1:1234", "http://host2:5678", "http://host1:1357"));
        apps.put("AppFive", Collections.singletonList("http://host5:8080"));

        final Map<String, Map<String, String>> appParams = new HashMap<>();
        Map<String, String> oneParams = new HashMap<>();
        oneParams.put("appone.cookie.secure.only", "true");
        oneParams.put("appone.token.ttl", "100000");
        appParams.put("app-one", oneParams);
        Map<String, String> fiveParams = new HashMap<>();
        fiveParams.put("myproperty", "true");
        fiveParams.put("anotherparam", "100000");
        appParams.put("AppFive", fiveParams);

        String fileName = "test-topology." + getFileExtensionForType(type);
        File testFile = null;
        try {
            testFile = writeDescriptorFile(type,
                                           fileName,
                                           discoveryType,
                                           discoveryAddress,
                                           discoveryUser,
                                           providerConfig,
                                           clusterName,
                                           services,
                                           null,
                                           serviceParams,
                                           apps,
                                           appParams);
            SimpleDescriptor sd = SimpleDescriptorFactory.parse(testFile.getAbsolutePath());
            validateSimpleDescriptor(sd,
                                     discoveryType,
                                     discoveryAddress,
                                     providerConfig,
                                     clusterName,
                                     services,
                                     null,
                                     serviceParams,
                                     apps,
                                     appParams);
        } finally {
            if (testFile != null) {
                try {
                    testFile.delete();
                } catch (Exception e) {
                    // Ignore
                }
            }
        }
    }

    private String getFileExtensionForType(FileType type) {
        String extension = null;
        switch (type) {
            case JSON:
                extension = "json";
                break;
            case YML:
                extension = "yml";
                break;
            case YAML:
                extension = "yaml";
                break;
        }
        return extension;
    }

    private File writeDescriptorFile(FileType                  type,
                                     String                    path,
                                     String                    discoveryType,
                                     String                    discoveryAddress,
                                     String                    discoveryUser,
                                     String                    providerConfig,
                                     String                    clusterName,
                                     Map<String, List<String>> services) throws Exception {
        return writeDescriptorFile(type,
                                   path,
                                   discoveryType,
                                   discoveryAddress,
                                   discoveryUser,
                                   providerConfig,
                                   clusterName,
                                   services,
                                   null);
    }

    private File writeDescriptorFile(FileType                  type,
                                     String                    path,
                                     String                    discoveryType,
                                     String                    discoveryAddress,
                                     String                    discoveryUser,
                                     String                    providerConfig,
                                     String                    clusterName,
                                     Map<String, List<String>> services,
                                     Map<String, String>       serviceVersions) throws Exception {
        return writeDescriptorFile(type,
                                   path,
                                   discoveryType,
                                   discoveryAddress,
                                   discoveryUser,
                                   providerConfig,
                                   clusterName,
                                   services,
                                   serviceVersions,
                                   null);
    }

    private File writeDescriptorFile(FileType                         type,
                                     String                           path,
                                     String                           discoveryType,
                                     String                           discoveryAddress,
                                     String                           discoveryUser,
                                     String                           providerConfig,
                                     String                           clusterName,
                                     Map<String, List<String>>        services,
                                     Map<String, String>              serviceVersions,
                                     Map<String, Map<String, String>> serviceParams) throws Exception {
        return writeDescriptorFile(type,
                                   path,
                                   discoveryType,
                                   discoveryAddress,
                                   discoveryUser,
                                   providerConfig,
                                   clusterName,
                                   services,
                                   serviceVersions,
                                   serviceParams,
                                   null,
                                   null);
    }


    private File writeDescriptorFile(FileType                         type,
                                     String                           path,
                                     String                           discoveryType,
                                     String                           discoveryAddress,
                                     String                           discoveryUser,
                                     String                           providerConfig,
                                     String                           clusterName,
                                     Map<String, List<String>>        services,
                                     Map<String, String>              serviceVersions,
                                     Map<String, Map<String, String>> serviceParams,
                                     Map<String, List<String>>        apps,
                                     Map<String, Map<String, String>> appParams) throws Exception {
        File result = null;
        switch (type) {
            case JSON:
                result = writeJSON(path,
                                   discoveryType,
                                   discoveryAddress,
                                   discoveryUser,
                                   providerConfig,
                                   clusterName,
                                   services,
                                   serviceVersions,
                                   serviceParams,
                                   apps,
                                   appParams);
                break;
            case YAML:
            case YML:
                result = writeYAML(path,
                                   discoveryType,
                                   discoveryAddress,
                                   discoveryUser,
                                   providerConfig,
                                   clusterName,
                                   services,
                                   serviceVersions,
                                   serviceParams,
                                   apps,
                                   appParams);
                break;
        }
        return result;
    }


    private File writeJSON(String                           path,
                           String                           discoveryType,
                           String                           discoveryAddress,
                           String                           discoveryUser,
                           String                           providerConfig,
                           String                           clusterName,
                           Map<String, List<String>>        services,
                           Map<String, String>              serviceVersions,
                           Map<String, Map<String, String>> serviceParams,
                           Map<String, List<String>>        apps,
                           Map<String, Map<String, String>> appParams) throws Exception {
      Path pathObject = Paths.get(path);
      try (OutputStream outputStream = Files.newOutputStream(pathObject);
           Writer fw = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8)) {
        fw.write("{" + "\n");
        fw.write("\"discovery-type\":\"" + discoveryType + "\",\n");
        fw.write("\"discovery-address\":\"" + discoveryAddress + "\",\n");
        fw.write("\"discovery-user\":\"" + discoveryUser + "\",\n");
        fw.write("\"provider-config-ref\":\"" + providerConfig + "\",\n");
        fw.write("\"cluster\":\"" + clusterName + "\"");

        if (services != null && !services.isEmpty()) {
          fw.write(",\n\"services\":[\n");
          writeServiceOrApplicationJSON(fw, services, serviceParams, serviceVersions);
          fw.write("]\n");
        }

        if (apps != null && !apps.isEmpty()) {
          fw.write(",\n\"applications\":[\n");
          writeServiceOrApplicationJSON(fw, apps, appParams, null);
          fw.write("]\n");
        }

        fw.write("}\n");
        fw.flush();
      }
      return pathObject.toFile();
    }

    private void writeServiceOrApplicationJSON(Writer fw,
                                               Map<String, List<String>>        elementURLs,
                                               Map<String, Map<String, String>> elementParams,
                                               Map<String, String>              serviceVersions) throws Exception {
        if (elementURLs != null) {
            int i = 0;
            for (String name : elementURLs.keySet()) {
                fw.write("{\"name\":\"" + name + "\"");

                if (serviceVersions != null) {
                    String ver = serviceVersions.get(name);
                    if (ver != null) {
                        fw.write(",\n\"version\":\"" + ver + "\"");
                    }
                }

                // Service params
                if (elementParams != null && !elementParams.isEmpty()) {
                    Map<String, String> params = elementParams.get(name);
                    if (params != null && !params.isEmpty()) {
                        fw.write(",\n\"params\":{\n");
                        Iterator<String> paramNames = params.keySet().iterator();
                        while (paramNames.hasNext()) {
                            String paramName = paramNames.next();
                            String paramValue = params.get(paramName);
                            fw.write("\"" + paramName + "\":\"" + paramValue + "\"");
                            fw.write(paramNames.hasNext() ? ",\n" : "");
                        }
                        fw.write("\n}");
                    }
                }

                // Service URLs
                List<String> urls = elementURLs.get(name);
                if (urls != null) {
                    fw.write(",\n\"urls\":[");
                    Iterator<String> urlIter = urls.iterator();
                    while (urlIter.hasNext()) {
                        fw.write("\"" + urlIter.next() + "\"");
                        if (urlIter.hasNext()) {
                            fw.write(", ");
                        }
                    }
                    fw.write("]\n");
                }

                fw.write("}");
                if (i++ < elementURLs.size() - 1) {
                    fw.write(",");
                }
                fw.write("\n");
            }
        }
    }

    private File writeYAML(String                           path,
                           String                           discoveryType,
                           String                           discoveryAddress,
                           String                           discoveryUser,
                           String                           providerConfig,
                           String                           clusterName,
                           Map<String, List<String>>        services,
                           Map<String, String>              serviceVersions,
                           Map<String, Map<String, String>> serviceParams,
                           Map<String, List<String>>        apps,
                           Map<String, Map<String, String>> appParams) throws Exception {

      Path pathObject = Paths.get(path);
      try (OutputStream outputStream = Files.newOutputStream(pathObject);
           Writer fw = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8)) {
        fw.write("---" + "\n");
        fw.write("discovery-type: " + discoveryType + "\n");
        fw.write("discovery-address: " + discoveryAddress + "\n");
        fw.write("discovery-user: " + discoveryUser + "\n");
        fw.write("provider-config-ref: " + providerConfig + "\n");
        fw.write("cluster: " + clusterName + "\n");

        if (services != null && !services.isEmpty()) {
          fw.write("services:\n");
          writeServiceOrApplicationYAML(fw, services, serviceParams, serviceVersions);
        }

        if (apps != null && !apps.isEmpty()) {
          fw.write("applications:\n");
          writeServiceOrApplicationYAML(fw, apps, appParams, null);
        }

        fw.flush();
      }
      return pathObject.toFile();
    }

    private void writeServiceOrApplicationYAML(Writer                           fw,
                                               Map<String, List<String>>        elementURLs,
                                               Map<String, Map<String, String>> elementParams,
                                               Map<String, String>              serviceVersions) throws Exception {
        for (String name : elementURLs.keySet()) {
            fw.write("    - name: " + name + "\n");

            if (serviceVersions != null) {
                String ver = serviceVersions.get(name);
                if (ver != null) {
                    fw.write("      version: " + ver + "\n");
                }
            }

            // Service params
            if (elementParams != null && !elementParams.isEmpty()) {
                if (elementParams.containsKey(name)) {
                    Map<String, String> params = elementParams.get(name);
                    fw.write("      params:\n");
                    for (String paramName : params.keySet()) {
                        fw.write("            " + paramName + ": " + params.get(paramName) + "\n");
                    }
                }
            }

            // Service URLs
            List<String> urls = elementURLs.get(name);
            if (urls != null) {
                fw.write("      urls:\n");
                for (String url : urls) {
                    fw.write("          - " + url + "\n");
                }
            }
        }
    }


    private void validateSimpleDescriptor(SimpleDescriptor          sd,
                                          String                    discoveryType,
                                          String                    discoveryAddress,
                                          String                    providerConfig,
                                          String                    clusterName,
                                          Map<String, List<String>> expectedServices) {
        validateSimpleDescriptor(sd, discoveryType, discoveryAddress, providerConfig, clusterName, expectedServices, null);
    }


    private void validateSimpleDescriptor(SimpleDescriptor          sd,
                                          String                    discoveryType,
                                          String                    discoveryAddress,
                                          String                    providerConfig,
                                          String                    clusterName,
                                          Map<String, List<String>> expectedServices,
                                          Map<String, String>       expectedServiceVersions) {
        validateSimpleDescriptor(sd, discoveryType, discoveryAddress, providerConfig, clusterName, expectedServices, expectedServiceVersions, null);
    }


    private void validateSimpleDescriptor(SimpleDescriptor                 sd,
                                          String                           discoveryType,
                                          String                           discoveryAddress,
                                          String                           providerConfig,
                                          String                           clusterName,
                                          Map<String, List<String>>        expectedServices,
                                          Map<String, String>              expectedServiceVersions,
                                          Map<String, Map<String, String>> expectedServiceParameters) {
        validateSimpleDescriptor(sd,
                                 discoveryType,
                                 discoveryAddress,
                                 providerConfig,
                                 clusterName,
                                 expectedServices,
                                 expectedServiceVersions,
                                 expectedServiceParameters,
                                 null,
                                 null);
    }

    private void validateSimpleDescriptor(SimpleDescriptor                 sd,
                                          String                           discoveryType,
                                          String                           discoveryAddress,
                                          String                           providerConfig,
                                          String                           clusterName,
                                          Map<String, List<String>>        expectedServices,
                                          Map<String, String>              expectedServiceVersions,
                                          Map<String, Map<String, String>> expectedServiceParameters,
                                          Map<String, List<String>>        expectedApps,
                                          Map<String, Map<String, String>> expectedAppParameters) {
        assertNotNull(sd);
        assertEquals(discoveryType, sd.getDiscoveryType());
        assertEquals(discoveryAddress, sd.getDiscoveryAddress());
        assertEquals(providerConfig, sd.getProviderConfig());
        assertEquals(clusterName, sd.getCluster());

        List<SimpleDescriptor.Service> actualServices = sd.getServices();

        if (expectedServices == null) {
            assertTrue(actualServices.isEmpty());
        } else {
            assertEquals(expectedServices.size(), actualServices.size());

            for (SimpleDescriptor.Service actualService : actualServices) {
                assertTrue(expectedServices.containsKey(actualService.getName()));
                assertEquals(expectedServices.get(actualService.getName()), actualService.getURLs());

                if (expectedServiceVersions != null) {
                    String expectedVersion = expectedServiceVersions.get(actualService.getName());
                    if (expectedVersion != null) {
                        String actualVersion = actualService.getVersion();
                        assertNotNull(actualVersion);
                        assertEquals("Unexpected version for " + actualService.getName(),
                                     expectedVersion,
                                     actualVersion);
                    }
                }

                // Validate service parameters
                if (expectedServiceParameters != null) {
                    if (expectedServiceParameters.containsKey(actualService.getName())) {
                        Map<String, String> expectedParams = expectedServiceParameters.get(actualService.getName());

                        Map<String, String> actualServiceParams = actualService.getParams();
                        assertNotNull(actualServiceParams);

                        // Validate the size of the service parameter set
                        assertEquals(expectedParams.size(), actualServiceParams.size());

                        // Validate the parameter contents
                        for (String paramName : actualServiceParams.keySet()) {
                            assertTrue(expectedParams.containsKey(paramName));
                            assertEquals(expectedParams.get(paramName), actualServiceParams.get(paramName));
                        }
                    }
                }
            }
        }

        List<SimpleDescriptor.Application> actualApps = sd.getApplications();

        if (expectedApps == null) {
            assertTrue(actualApps.isEmpty());
        } else {
            assertEquals(expectedApps.size(), actualApps.size());

            for (SimpleDescriptor.Application actualApp : actualApps) {
                assertTrue(expectedApps.containsKey(actualApp.getName()));
                assertEquals(expectedApps.get(actualApp.getName()), actualApp.getURLs());

                // Validate service parameters
                if (expectedServiceParameters != null) {
                    if (expectedAppParameters.containsKey(actualApp.getName())) {
                        Map<String, String> expectedParams = expectedAppParameters.get(actualApp.getName());

                        Map<String, String> actualAppParams = actualApp.getParams();
                        assertNotNull(actualAppParams);

                        // Validate the size of the service parameter set
                        assertEquals(expectedParams.size(), actualAppParams.size());

                        // Validate the parameter contents
                        for (String paramName : actualAppParams.keySet()) {
                            assertTrue(expectedParams.containsKey(paramName));
                            assertEquals(expectedParams.get(paramName), actualAppParams.get(paramName));
                        }
                    }
                }
            }
        }
    }

}
