docs(springboot cloudconfig): A fix of example docs.

Fix the example doc to make cloud config demo works both local and kubernetes, and pass the mm doc validate

Signed-off-by: lony2003 <[email protected]>

Author: lony2003

spring-boot-examples/README.md

@@ -76,7 +76,7 @@ name: Run Demo Producer Service
 match_order: none
 output_match_mode: substring
 expected_stdout_lines:
-- 'Started ProducerApplication'
+- 'Started CloudConfigApplication'
 background: true
 expected_return_code: 143
 sleep: 30
@@ -91,6 +91,8 @@ cd cloud-config-demo/
 
 <!-- END_STEP -->
 
+The `cloud-config-demo` starts in port `8082` by default.
+
 It will work and gain secrets from secret store. you can also uncomment the lines in application.yaml to enable more configuration imports.
 
 ## Interacting with the applications
@@ -196,6 +198,28 @@ Customer: salaboy follow-up done.
 Congratulations the customer: salaboy is happy!
 ```
 
+You can check the config in CloudConfig app, just run:
+
+<!-- STEP
+name: Send GET request to CloudConfig App
+match_order: none
+output_match_mode: substring
+expected_stdout_lines:
+- 'testvalue'
+background: true
+sleep: 1
+timeout_seconds: 2
+-->
+<!-- Timeout for above service must be more than sleep + timeout for the client-->
+
+```sh
+curl -X GET localhost:8082/config
+```
+
+<!-- END_STEP -->
+
+You will get `testvalue` in terminal stdout.
+
 ## Running on Kubernetes
 
 You can run the same example on a Kubernetes cluster. [Check the Kubernetes tutorial here](kubernetes/README.md).

spring-boot-examples/cloud-config-demo/src/main/resources/application.yaml

@@ -17,3 +17,6 @@ spring:
 # so to maintain the compatibility of Kubernetes, following lines are commented.
 #      - dapr:config:democonfigconf/dapr.spring.demo-config-config.singlevalue?type=value
 #      - dapr:config:democonfigconf/multivalue-yaml?type=doc&doc-type=yaml
+server:
+  port: 8082
+

spring-boot-examples/cloud-config-demo/src/test/java/io/dapr/springboot/examples/cloudconfig/CloudConfigTests.java

@@ -15,13 +15,14 @@
 
 import com.github.dockerjava.api.command.InspectContainerResponse;
 import com.redis.testcontainers.RedisContainer;
-import io.dapr.spring.boot.cloudconfig.autoconfigure.DaprCloudConfigAutoConfiguration;
-import io.dapr.springboot.DaprAutoConfiguration;
 import io.dapr.springboot.examples.cloudconfig.config.MultipleConfig;
 import io.dapr.springboot.examples.cloudconfig.config.SingleConfig;
 import io.dapr.testcontainers.Component;
 import io.dapr.testcontainers.DaprContainer;
 import io.dapr.testcontainers.DaprLogLevel;
+import io.restassured.RestAssured;
+import io.restassured.http.ContentType;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
@@ -32,6 +33,7 @@
 import org.springframework.test.context.DynamicPropertyRegistry;
 import org.springframework.test.context.DynamicPropertySource;
 import org.testcontainers.containers.Network;
+import org.testcontainers.containers.wait.strategy.Wait;
 import org.testcontainers.images.builder.Transferable;
 import org.testcontainers.junit.jupiter.Container;
 import org.testcontainers.junit.jupiter.Testcontainers;
@@ -46,8 +48,7 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-@SpringBootTest(classes = {TestCloudConfigApplication.class, DaprTestContainersConfig.class,
-        DaprAutoConfiguration.class, DaprCloudConfigAutoConfiguration.class},
+@SpringBootTest(classes = {TestCloudConfigApplication.class, DaprTestContainersConfig.class,},
         webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
 @Testcontainers
 @Tag("testcontainers")
@@ -128,23 +129,39 @@ private static Map<String, String> generateMultiValueProperty() {
         "multiValued", "true");
   }
 
+  @BeforeEach
+  void setUp() {
+    RestAssured.baseURI = "http://localhost:" + 8082;
+    org.testcontainers.Testcontainers.exposeHostPorts(8082);
+  }
+
   @Autowired
   MultipleConfig multipleConfig;
 
   @Autowired
   SingleConfig singleConfig;
 
-  @DynamicPropertySource
-  static void dynamicProperties(DynamicPropertyRegistry registry) {
-    registry.add("dapr.client.http-port", DAPR_CONTAINER::getHttpPort);
-    registry.add("dapr.client.grpc-port", DAPR_CONTAINER::getGrpcPort);
-  }
-
   @Test
   void testCloudConfig() {
     assertEquals("testvalue", singleConfig.getSingleValueSecret());
     assertEquals("spring", multipleConfig.getMultipleSecretConfigV1());
     assertEquals("dapr", multipleConfig.getMultipleSecretConfigV2());
   }
 
+  @Test
+  void testController() {
+    given().contentType(ContentType.JSON)
+        .when()
+        .get("/config")
+        .then()
+        .statusCode(200).body(is("testvalue"));
+  }
+
+  @Test
+  void fillCoverage() {
+    new SingleConfig().setSingleValueSecret("testvalue");
+    new MultipleConfig().setMultipleSecretConfigV1("spring");
+    new MultipleConfig().setMultipleSecretConfigV2("dapr");
+  }
+
 }

spring-boot-examples/cloud-config-demo/src/test/java/io/dapr/springboot/examples/cloudconfig/DaprTestContainersConfig.java

@@ -17,22 +17,128 @@
 import com.redis.testcontainers.RedisContainer;
 import io.dapr.testcontainers.Component;
 import io.dapr.testcontainers.DaprContainer;
+import io.dapr.testcontainers.DaprLogLevel;
 import org.junit.runner.Description;
 import org.junit.runners.model.Statement;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.test.context.TestConfiguration;
 import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
 import org.springframework.context.annotation.Bean;
+import org.springframework.core.env.Environment;
 import org.testcontainers.DockerClientFactory;
 import org.testcontainers.containers.Network;
 import org.testcontainers.images.builder.Transferable;
+import org.testcontainers.junit.jupiter.Container;
 import redis.clients.jedis.Jedis;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 @TestConfiguration(proxyBeanMethods = false)
 public class DaprTestContainersConfig {
+  public static final String CONFIG_STORE_NAME = "democonfigconf";
+  public static final String CONFIG_MULTI_NAME = "multivalue-yaml";
+  public static final String CONFIG_SINGLE_NAME = "dapr.spring.demo-config-config.singlevalue";
 
+  public static final String SECRET_STORE_NAME = "democonfig";
+  public static final String SECRET_MULTI_NAME = "multivalue-properties";
+  public static final String SECRET_SINGLE_NAME = "dapr.spring.demo-config-secret.singlevalue";
+
+  public static final String SECRET_STORE_NAME_MULTI = "democonfigMultivalued";
+
+  private static final Map<String, String> SINGLE_VALUE_PROPERTY = generateSingleValueProperty();
+  private static final Map<String, String> MULTI_VALUE_PROPERTY = generateMultiValueProperty();
+
+
+  private static final Map<String, String> STORE_PROPERTY = generateStoreProperty();
+
+  private static final Network DAPR_NETWORK = getDaprNetwork();
+
+  private static Map<String, String> generateStoreProperty() {
+    return Map.of("redisHost", "redis:6379",
+        "redisPassword", "");
+  }
+
+  private static Map<String, String> generateSingleValueProperty() {
+    return Map.of("secretsFile", "/dapr-secrets/singlevalued.json",
+        "multiValued", "false");
+  }
+
+  private static Map<String, String> generateMultiValueProperty() {
+    return Map.of("secretsFile", "/dapr-secrets/multivalued.json",
+        "nestedSeparator", ".",
+        "multiValued", "true");
+  }
+
+  public static Network getDaprNetwork() {
+      Network defaultDaprNetwork = new Network() {
+        @Override
+        public String getId() {
+          return "dapr-network";
+        }
+
+        @Override
+        public void close() {
+
+        }
+
+        @Override
+        public Statement apply(Statement base, Description description) {
+          return null;
+        }
+      };
+
+      List<com.github.dockerjava.api.model.Network> networks = DockerClientFactory.instance().client().listNetworksCmd()
+          .withNameFilter("dapr-network").exec();
+      if (networks.isEmpty()) {
+        Network.builder().createNetworkCmdModifier(cmd -> cmd.withName("dapr-network")).build().getId();
+        return defaultDaprNetwork;
+      } else {
+        return defaultDaprNetwork;
+      }
+
+  }
+
+  @Container
+  private static final RedisContainer REDIS_CONTAINER = new RedisContainer(
+      RedisContainer.DEFAULT_IMAGE_NAME.withTag(RedisContainer.DEFAULT_TAG)) {
+    @Override
+    protected void containerIsStarted(InspectContainerResponse containerInfo) {
+      super.containerIsStarted(containerInfo);
+
+      String address = getHost();
+      Integer port = getMappedPort(6379);
+
+      Logger logger = LoggerFactory.getLogger(CloudConfigTests.class);
+      // Put values using Jedis
+      try (Jedis jedis = new Jedis(address, port)) {
+        logger.info("Putting Dapr Cloud config to {}:{}", address, port);
+        jedis.set(CloudConfigTests.CONFIG_MULTI_NAME, DaprConfigurationStores.YAML_CONFIG);
+        jedis.set(CloudConfigTests.CONFIG_SINGLE_NAME, "testvalue");
+      }
+    }
+  }
+      .withNetworkAliases("redis")
+      .withCommand()
+      .withNetwork(DAPR_NETWORK);
+
+  @Container
+  @ServiceConnection
+  public static final DaprContainer DAPR_CONTAINER = new DaprContainer("daprio/daprd:1.14.4")
+      .withAppName("configuration-dapr-app")
+      .withNetwork(DAPR_NETWORK)
+      .withComponent(new Component(CONFIG_STORE_NAME, "configuration.redis", "v1", STORE_PROPERTY))
+      .withComponent(new Component(SECRET_STORE_NAME, "secretstores.local.file", "v1", SINGLE_VALUE_PROPERTY))
+      .withComponent(new Component(SECRET_STORE_NAME_MULTI, "secretstores.local.file", "v1", MULTI_VALUE_PROPERTY))
+      .withDaprLogLevel(DaprLogLevel.DEBUG)
+      .withLogConsumer(outputFrame -> System.out.println(outputFrame.getUtf8String()))
+      .dependsOn(REDIS_CONTAINER)
+      .withCopyToContainer(Transferable.of(DaprSecretStores.SINGLE_VALUED_SECRET), "/dapr-secrets/singlevalued.json")
+      .withCopyToContainer(Transferable.of(DaprSecretStores.MULTI_VALUED_SECRET), "/dapr-secrets/multivalued.json");
+
+  static {
+    DAPR_CONTAINER.setPortBindings(List.of("3500:3500", "50001:50001"));
+  }
 }

spring-boot-examples/cloud-config-demo/src/test/java/io/dapr/springboot/examples/cloudconfig/TestCloudConfigApplication.java

@@ -20,12 +20,16 @@
 @SpringBootApplication
 public class TestCloudConfigApplication {
 
+  static {
+    DaprTestContainersConfig.DAPR_CONTAINER.start();
+  }
+
   public static void main(String[] args) {
 
     SpringApplication.from(CloudConfigApplication::main)
             .with(DaprTestContainersConfig.class)
             .run(args);
-    org.testcontainers.Testcontainers.exposeHostPorts(8080);
+    org.testcontainers.Testcontainers.exposeHostPorts(8082);
   }
 
 }

spring-boot-examples/kubernetes/README.md

@@ -1,10 +1,10 @@
 # Running this example on Kubernetes
 
 To run this example on Kubernetes, you can use any Kubernetes distribution. 
-We install Dapr on a Kubernetes cluster and then we will deploy both the `producer-app` and `consumer-app`.
-
-You can also deploy `cloud-config-demo` if you like, but actually it doesn't have any feature.
+We install Dapr on a Kubernetes cluster and then we will deploy the `producer-app`, `consumer-app` and `cloud-config-demo`.
 
+> ___A Note for `cloud-config-demo`:___
+> 
 > Remind that only Kubernetes Secret works on dapr secret, Kubernetes ConfigMap doesn't support in dapr runtime, and there is no easy way to fill data to redis running in cluster before container started automatically, so configuration schema are commented by default.
 
 ## Creating a cluster and installing Dapr
@@ -157,7 +157,7 @@ Next you need to use `kubectl port-forward` to be able to send requests to the a
 kubectl port-forward svc/producer-app 8080:8080
 ```
 
-In a different terminals you can check the logs of the `producer-app` and `consumer-app`:
+In a different terminals you can check the logs of the `producer-app`, `consumer-app` and `cloud-config-demo`:
 
 ```bash
 kubectl logs -f producer-app-<POD_ID>
@@ -167,5 +167,9 @@ and
 ```bash
 kubectl logs -f consumer-app-<POD_ID>
 ```
+and
 
+```bash
+kubectl logs -f cloud-config-demo-<POD_ID>
+```
 

spring-boot-examples/kubernetes/cloud-config-demo.yaml

@@ -8,8 +8,8 @@ spec:
   type: NodePort
   ports:
     - name: "cloud-config-demo"
-      port: 8080
-      targetPort: 8080
+      port: 8082
+      targetPort: 8082
       nodePort: 31002
   selector:
     app: cloud-config-demo
@@ -31,7 +31,7 @@ spec:
     metadata:
       annotations:
         dapr.io/app-id: cloud-config-demo
-        dapr.io/app-port: "8080"
+        dapr.io/app-port: "8082"
         dapr.io/enabled: "true"
       labels:
         app: cloud-config-demo
@@ -41,5 +41,5 @@ spec:
           name: cloud-config-demo
           imagePullPolicy: Always
           ports:
-            - containerPort: 8080
+            - containerPort: 8082
               name: cloud-config