private List<String> mapServersToEndpoint(List<Server> servers) {
    List<String> endpoints = new ArrayList<>();
    for (Server server : servers) {
        ServerVariables serverVariables = server.getVariables();
        String serverUrl = server.getUrl();
        if (CollectionUtils.isEmpty(serverVariables)) {
            endpoints.add(serverUrl);
        } else {
            List<String> evaluatedUrls = Collections.singletonList(serverUrl);
            for (Map.Entry<String, ServerVariable> serverVar : serverVariables.entrySet()) {
                evaluatedUrls = evaluateServerUrlsForOneVar(serverVar.getKey(), serverVar.getValue(),
                        evaluatedUrls);
            }
            endpoints.addAll(evaluatedUrls);
        }
    }
    return endpoints;
}
 

private void appendServersSection(StructuralNode node, List<Server> servers) {
    if (null == servers || servers.isEmpty()) return;

    Section serversSection = new SectionImpl(node);
    serversSection.setTitle(labels.getLabel(SECTION_TITLE_SERVERS));

    servers.forEach(server -> {
        Section serverSection = new SectionImpl(serversSection);
        serverSection.setTitle(italicUnconstrained(labels.getLabel(LABEL_SERVER)) + ": " + server.getUrl());

        appendDescription(serverSection, server.getDescription());
        ServerVariables variables = server.getVariables();
        appendVariables(serverSection, variables);
        serversSection.append(serverSection);
    });
    node.append(serversSection);
}
 

private void appendVariables(Section serverSection, ServerVariables variables) {
    if (null == variables || variables.isEmpty()) return;

    TableImpl serverVariables = new TableImpl(serverSection, new HashMap<String, Object>() {{
        put("header-option", "");
        put("cols", ".^2a,.^9a,.^3a,.^4a");
    }}, new ArrayList<>());
    serverVariables.setTitle(labels.getLabel(TABLE_TITLE_SERVER_VARIABLES));

    serverVariables.setHeaderRow(labels.getLabel(TABLE_HEADER_VARIABLE), labels.getLabel(TABLE_HEADER_DESCRIPTION),
            labels.getLabel(TABLE_HEADER_POSSIBLE_VALUES), labels.getLabel(TABLE_HEADER_DEFAULT)
    );

    variables.forEach((name, variable) -> {
        String possibleValues = String.join(", ", Optional.ofNullable(variable.getEnum()).orElse(Collections.singletonList("Any")));
        serverVariables.addRow(name, Optional.ofNullable(variable.getDescription()).orElse(""), possibleValues, variable.getDefault());

    });
    serverSection.append(serverVariables);
}
 

public ServerVariables getServerVariables(ObjectNode obj, String location, ParseResult result){
    ServerVariables serverVariables = new ServerVariables();
    if (obj == null) {
        return null;
    }

    Set<String> serverKeys = getKeys(obj);
    for (String serverName : serverKeys) {
        JsonNode serverValue = obj.get(serverName);
        ObjectNode server = (ObjectNode) serverValue;
        ServerVariable serverVariable = getServerVariable(server, String.format("%s.%s", location, serverName), result);
        serverVariables.addServerVariable(serverName,serverVariable);
    }

    return serverVariables;
}
 

private static String extractUrl(Server server, String url, ServerVariables variables, Map<String, String> userVariables) {
    Set<String> replacedVariables = new HashSet<>();
    Matcher matcher = VARIABLE_PATTERN.matcher(url);
    while (matcher.find()) {
        if (!replacedVariables.contains(matcher.group())) {
            String variableName = matcher.group(1);
            ServerVariable variable = variables.get(variableName);
            String replacement;
            if (variable != null) {
                String defaultValue = variable.getDefault();
                List<String> enumValues = variable.getEnum() == null ? new ArrayList<>() : variable.getEnum();
                if (defaultValue == null && !enumValues.isEmpty()) {
                   defaultValue = enumValues.get(0);
                } else if (defaultValue == null) {
                    defaultValue = "";
                }

                replacement = userVariables.getOrDefault(variableName, defaultValue);

                if (!enumValues.isEmpty() && !enumValues.contains(replacement)) {
                    LOGGER.warn("Variable override of '{}' is not listed in the enum of allowed values ({}).", replacement, StringUtils.join(enumValues, ","));
                }
            } else {
                replacement = userVariables.getOrDefault(variableName, "");
            }

            if (StringUtils.isEmpty(replacement)) {
                replacement = "";
                LOGGER.warn("No value found for variable '{}' in server definition '{}' and no user override specified, default to empty string.", variableName, server.getUrl());
            }

            url = url.replace(matcher.group(), replacement);
            replacedVariables.add(matcher.group());
            matcher = VARIABLE_PATTERN.matcher(url);
        }
    }
    return url;
}
 

@Test
public void testGetServerURLWithVariables() {
    Server s1 = new Server().url("http://localhost:{port}/").variables(new ServerVariables().addServerVariable("port", new ServerVariable()._default("8080").description("the server port")));
    Assert.assertEquals(URLPathUtils.getServerURL(s1, null).toString(), "http://localhost:8080/");

    Server s2 = new Server().url("http://{version}.test.me/{version}").variables(new ServerVariables().addServerVariable("version", new ServerVariable()._default("v1")));
    Assert.assertEquals(URLPathUtils.getServerURL(s2, null).toString(), "http://v1.test.me/v1");

    Server s3 = new Server().url("http://localhost:{port}/{version}").variables(
                new ServerVariables().addServerVariable("version", new ServerVariable()._default("v4"))
                    .addServerVariable("port", new ServerVariable()._default("8080"))
                    .addServerVariable("other", new ServerVariable()._default("something"))
            );
    Assert.assertEquals(URLPathUtils.getServerURL(s3, null).toString(), "http://localhost:8080/v4");

    Server s4 = new Server().url("http://91.161.147.64/{targetEnv}").variables(new ServerVariables().addServerVariable("targetEnv", new ServerVariable().description("target environment")._enum(Arrays.asList("dev", "int", "prd"))._default("prd")));
    Assert.assertEquals(URLPathUtils.getServerURL(s4, null).toString(), "http://91.161.147.64/prd");

    Server s5 = new Server().url("https://api.stats.com/{country1}").variables(new ServerVariables().addServerVariable("country1", new ServerVariable()._enum(Arrays.asList("france", "germany", "italy"))));
    Assert.assertEquals(URLPathUtils.getServerURL(s5, null).toString(), "https://api.stats.com/france");

    Server s6 = new Server().url("https://api.example.com/{wrong}");
    Assert.assertEquals(URLPathUtils.getServerURL(s6, null).toString(), "https://api.example.com/");

    Server s7 = new Server().url("https://api.example.com/{wrong}").variables(new ServerVariables());
    Assert.assertEquals(URLPathUtils.getServerURL(s7, null).toString(), "https://api.example.com/");

    Server s8 = new Server().url("https://api.example.com/{wrong}").variables(new ServerVariables().addServerVariable("other", new ServerVariable()._default("something")));
    Assert.assertEquals(URLPathUtils.getServerURL(s8, null).toString(), "https://api.example.com/");

    Server s9 = new Server().url("https://{user}.example.com/{version}").variables(
                new ServerVariables().addServerVariable("version", new ServerVariable()._default("v1"))
                    .addServerVariable("user", new ServerVariable()._default("{user}")));
    Assert.assertEquals(URLPathUtils.getServerURL(s9, null).toString(), "https://{user}.example.com/v1");
}
 

private ServerVariables serverVariables(String... entries) {
    ServerVariables variables = new ServerVariables();
    for (int i = 0; i < entries.length; i+=2) {
        String key = entries[i];
        String value = "";
        if (i+1 < entries.length) {
            value = entries[i+1];
        }
        variables.addServerVariable(key, new ServerVariable()._default(value).description("variable for: " + key));
    }
    return variables;
}
 

@Test
public void shouldCreateUriBuildersFromServerWithVariables() {
    // Given
    Server server = server("{scheme}://example.com/");
    ServerVariables variables = new ServerVariables();
    variables.put("scheme", new ServerVariable()._default("http"));
    server.setVariables(variables);
    List<Server> servers = asList(server);
    // When
    List<UriBuilder> uriBuilders =
            SwaggerConverter.createUriBuilders(servers, EMPTY_URI_BUILDER);
    // Then
    assertThat(uriBuilders, hasSize(1));
    assertUriBuilder(uriBuilders.get(0), "http", "example.com", "/");
}
 

@Test
public void testGetServerURLWithVariablesAndUserOverrides() {
    Server s1 = new Server().url("http://localhost:{port}/").variables(
            serverVariables("port", "8080")
    );
    Assert.assertEquals(URLPathUtils.getServerURL(s1, new HashMap<String, String>() {{ put("port", "1234"); }}).toString(), "http://localhost:1234/");

    Server s2 = new Server().url("http://{version}.test.me/{version}").variables(
            serverVariables("version", "v1")
    );
    Assert.assertEquals(URLPathUtils.getServerURL(s2, new HashMap<String, String>() {{ put("version", "v2" ); }}).toString(), "http://v2.test.me/v2");

    Server s3 = new Server().url("http://localhost:{port}/{version}").variables(
            serverVariables(
                    "version", "v4",
                    "port", "8080",
                    "other", "something"
            )
    );
    Assert.assertEquals(URLPathUtils.getServerURL(s3, new HashMap<String, String>() {{ put("port", "5678"); }}).toString(), "http://localhost:5678/v4");

    Server s4 = new Server().url("http://91.161.147.64/{targetEnv}").variables(
            new ServerVariables().addServerVariable("targetEnv", new ServerVariable().description("target environment")._enum(Arrays.asList("dev", "int", "prd"))._default("prd")));
    Assert.assertEquals(URLPathUtils.getServerURL(s4, new HashMap<String, String>() {{ put("targetEnv", "int" ); }}).toString(), "http://91.161.147.64/int");

    Server s5 = new Server().url("https://api.stats.com/{country1}").variables(
            new ServerVariables().addServerVariable("country1", new ServerVariable()._enum(Arrays.asList("france", "germany", "italy")))
    );
    Assert.assertEquals(URLPathUtils.getServerURL(s5, new HashMap<String, String>() {{ put("country1", "italy" ); }}).toString(), "https://api.stats.com/italy");

    Server s6 = new Server().url("https://api.example.com/{wrong}");
    Assert.assertEquals(URLPathUtils.getServerURL(s6, new HashMap<String, String>() {{ put("port", "8080" ); }}).toString(), "https://api.example.com/");

    Server s7 = new Server().url("https://api.example.com/{wrong}").variables(new ServerVariables());
    Assert.assertEquals(URLPathUtils.getServerURL(s7, new HashMap<String, String>() {{ put("", "8080" ); }}).toString(), "https://api.example.com/");

    Server s8 = new Server().url("https://api.example.com/{wrong}").variables(
            serverVariables("other", "something")
    );
    Assert.assertEquals(URLPathUtils.getServerURL(s8, new HashMap<String, String>() {{ put("something", "other" ); }}).toString(), "https://api.example.com/");

    Server s9 = new Server().url("https://{user}.example.com/{version}").variables(
            serverVariables(
                    "version", "v1",
                    "user", "{user}"
            )
    );
    Assert.assertEquals(URLPathUtils.getServerURL(s9, new HashMap<String, String>() {{
        put("version", "v2" );
        put("user", "jim");
    }}).toString(), "https://jim.example.com/v2");
}
 

protected ServerVariables getServerVariables() {
    ServerVariables serverVariables = new ServerVariables();
    return serverVariables;
}
 

public Server getServer(ObjectNode obj, String location, ParseResult result, String path) {
     if (obj == null) {
         return null;
     }

     Server server = new Server();

     String value = getString("url", obj, true, location, result);
     if(StringUtils.isNotBlank(value)) {
if(!isValidURL(value) && path != null){
	try {
		final URI absURI = new URI(path);
		if("http".equals(absURI.getScheme()) || "https".equals(absURI.getScheme())){
			value = absURI.resolve(new URI(value)).toString();
		}
	} catch (URISyntaxException e) {
                 result.warning(location,"invalid url : "+value);
	}

}
         server.setUrl(value);
     }

     value = getString("description", obj, false, location, result);
     if(StringUtils.isNotBlank(value)) {
         server.setDescription(value);
     }
     if (obj.get("variables") != null) {
         ObjectNode variables = getObject("variables", obj, false, location, result);
         ServerVariables serverVariables = getServerVariables(variables, String.format("%s.%s", location, "variables"), result);
         if (serverVariables != null && serverVariables.size() > 0) {
             server.setVariables(serverVariables);
         }
     }


     Map <String,Object> extensions = getExtensions(obj);
     if(extensions != null && extensions.size() > 0) {
         server.setExtensions(extensions);
     }

     Set<String> keys = getKeys(obj);
     for(String key : keys) {
         if(!SERVER_KEYS.contains(key) && !key.startsWith("x-")) {
             result.extra(location, key, obj.get(key));
         }
     }


     return server;
 }