Heroku Deployments

@RestController
public class HelloController {
    @GetMapping(path="/api/hello",
            produces = {MediaType.TEXT_PLAIN_VALUE})
    public String hello(
            @RequestParam("name")String name,
            @AuthenticationPrincipal UserDetails user) {
        String username = user==null ? null : user.getUsername();
        String greeting = "hello, " + name;
        return username==null ? greeting : greeting + " (from " + username + ")";
    }
}

<plugin> <!-- builds a Spring Boot Executable JAR -->
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

$ mvn clean package
...
target/
|...
|-- [ 31M]  docker-hello-example-6.0.1-SNAPSHOT-bootexec.jar (2)
|-- [9.7K]  docker-hello-example-6.0.1-SNAPSHOT.jar (1)

<plugin>
    <groupId>com.heroku.sdk</groupId>
    <artifactId>heroku-maven-plugin</artifactId>
</plugin>

@SpringBootTest(classes=ClientTestConfiguration.class, (1)
    webEnvironment = SpringBootTest.WebEnvironment.NONE) (2)
@ActiveProfiles({"test","heroku"}) (3)
public class HelloHerokuIT { (4)

@Autowired
private RestTemplate anonymousUser;
@Autowired
private RestTemplate authnUser;
@Autowired
private String authnUsername;
private UriComponentsBuilder helloUrl;

@BeforeEach
void init(@Autowired URI baseUrl) {
    log.info("baseUrl={}", baseUrl);
    helloUrl = UriComponentsBuilder.fromUri(baseUrl).path("api/hello")
            .queryParam("name","{name}"); (1)
}

spring.security.user.name=user
spring.security.user.password=password

it.server.scheme=https (1)
it.server.host=${heroku.appName}.herokuapp.com (2)
it.server.port=${server.http.port} (3) (4)

<build> (1)
    <testResources> <!-- used to replace ${variables} in property files -->
        <testResource> (2)
            <directory>src/test/resources</directory>
            <includes> <!-- replace ${heroku.appName} -->
                <include>application-heroku.properties</include>
            </includes>
            <filtering>true</filtering>
        </testResource>
        <testResource> (3)
            <directory>src/test/resources</directory>
            <excludes>
                <exclude>application-heroku.properties</exclude>
            </excludes>
            <filtering>false</filtering>
        </testResource>
    </testResources>
    ....

<properties> (1)
    <heroku.appName>ejava-boot</heroku.appName>
    <server.http.port>443</server.http.port>
</properties>

$ mvn clean process-test-resources
[INFO] --- maven-clean-plugin:3.1.0:clean (default-clean) @ docker-hello-example ---
[INFO] --- maven-resources-plugin:3.1.0:resources (default-resources) @ docker-hello-example ---
[INFO] --- maven-compiler-plugin:3.8.1:compile (default-compile) @ docker-hello-example ---
[INFO] --- maven-resources-plugin:3.1.0:testResources (default-testResources) @ docker-hello-example ---

$ cat target/test-classes/application-heroku.properties
it.server.scheme=https
it.server.host=ejava-boot.herokuapp.com
it.server.port=443

$ mvn clean process-test-resources -Dheroku.appName=other-name (1)
$ cat target/test-classes/application-heroku.properties
it.server.scheme=https
it.server.host=other-name.herokuapp.com (2)
it.server.port=443

@Value("${spring.security.user.name}") (1)
private String username;
@Value("${spring.security.user.password}")
private String password;

@Bean
public String authnUsername() { return username; } (2)

@Bean
@ConfigurationProperties(prefix = "it.server")
public ServerConfig itServerConfig() {
    return new ServerConfig();
}

//use for IT tests
@Bean (1)
public URI baseUrl(ServerConfig serverConfig) {
    URI baseUrl = serverConfig.build().getBaseUrl();
    return baseUrl;
}

@Bean
public RestTemplate anonymousUser(RestTemplateBuilder builder,
                                  ClientHttpRequestFactory requestFactory) { (1)
    return builder.requestFactory(
                    //used to read the streams twice (3)
                    ()->new BufferingClientHttpRequestFactory(requestFactory))
            .interceptors(new RestTemplateLoggingFilter()) (2)
            .build();
}

@Bean
public RestTemplate authnUser(RestTemplateBuilder builder,
                              ClientHttpRequestFactory requestFactory) {
    return builder.requestFactory(
                    //used to read the streams twice
                    ()->new BufferingClientHttpRequestFactory(requestFactory))
            .interceptors(
                    new BasicAuthenticationInterceptor(username, password), (1)
                    new RestTemplateLoggingFilter())
            .build();
}

import org.apache.http.client.HttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import javax.net.ssl.SSLContext;
...
@Bean
public ClientHttpRequestFactory httpsRequestFactory(
        ServerConfig serverConfig, (1)
        SSLContext sslContext) { (2)
    HttpClient httpsClient = HttpClientBuilder.create()
            .setSSLContext(serverConfig.isHttps() ? sslContext : null)
            .build();
    return new HttpComponentsClientHttpRequestFactory(httpsClient);
}

import org.apache.http.ssl.SSLContextBuilder;
import javax.net.ssl.SSLContext;
...
@Bean
public SSLContext sslContext(ServerConfig serverConfig)  {
    try {
        URL trustStoreUrl = null;
        //using trusted certs, no need for customized truststore
        //...
        SSLContextBuilder builder = SSLContextBuilder.create()
                .setProtocol("TLSv1.2");
        if (trustStoreUrl!=null) {
            builder.loadTrustMaterial(trustStoreUrl, serverConfig.getTrustStorePassword());
        }
        return builder.build();
    } catch (Exception ex) {
        throw new IllegalStateException("unable to establish SSL context", ex);
    }
}

$ mvn verify -DitOnly -DskipITs=not_true (1) (2) (3)
...
GET https://ejava-boot.herokuapp.com:443/api/hello?name=jim, returned OK/200
hello, jim
...
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS

<profiles>
    <profile> <!-- deploys a Spring Boot Executable JAR -->
        <id>heroku-it-deploy</id>
        <activation>
            <property> (1)
                <name>skipITs</name>
                <value>false</value>
            </property>
        </activation>
        <properties> (2)
            <spring-boot.repackage.skip>false</spring-boot.repackage.skip>
        </properties>
        <build>
            <plugins>
                <plugin> (3)
                    <groupId>com.heroku.sdk</groupId>
                    <artifactId>heroku-maven-plugin</artifactId>
                    <executions>
                        <execution>
                            <id>deploy</id>
                            <phase>pre-integration-test</phase>
                            <goals>
                                <goal>deploy</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

$ mvn verify -DitOnly -DskipITs=false
...
[INFO] --- spring-boot-maven-plugin:2.4.2:repackage (package) @ docker-hello-example ---
[INFO] Replacing main artifact with repackaged archive
[INFO] <<< heroku-maven-plugin:3.0.3:deploy (deploy) < package @ docker-hello-example <<<
[INFO] --- heroku-maven-plugin:3.0.3:deploy (deploy) @ docker-hello-example ---
[INFO] jakarta.el-3.0.3.jar already exists in destination.
...
[INFO] -----> Done
[INFO] --- maven-failsafe-plugin:3.0.0-M5:integration-test (integration-test) @ docker-hello-example ---
...
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
[INFO] --- maven-failsafe-plugin:3.0.0-M5:verify (verify) @ docker-hello-example ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS