From 0a9745189c0201c3acfc9471c42aa521432aaf17 Mon Sep 17 00:00:00 2001 From: spencergibb Date: Thu, 9 Mar 2023 16:10:01 -0500 Subject: [PATCH] Adds test to verify token sent on agentCheckPass. See gh-770 --- .../cloud/consul/test/TestConsulClient.java | 716 ++++++++++++++++++ .../cloud/consul/discovery/TtlScheduler.java | 3 +- .../consul/discovery/TtlSchedulerTests.java | 29 +- 3 files changed, 746 insertions(+), 2 deletions(-) create mode 100644 spring-cloud-consul-core/src/test/java/org/springframework/cloud/consul/test/TestConsulClient.java diff --git a/spring-cloud-consul-core/src/test/java/org/springframework/cloud/consul/test/TestConsulClient.java b/spring-cloud-consul-core/src/test/java/org/springframework/cloud/consul/test/TestConsulClient.java new file mode 100644 index 00000000..1b0dac5d --- /dev/null +++ b/spring-cloud-consul-core/src/test/java/org/springframework/cloud/consul/test/TestConsulClient.java @@ -0,0 +1,716 @@ +/* + * Copyright 2013-2023 the original author or authors. + * + * Licensed 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 + * + * https://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.springframework.cloud.consul.test; + +import java.util.List; +import java.util.Map; + +import com.ecwid.consul.v1.ConsulClient; +import com.ecwid.consul.v1.QueryParams; +import com.ecwid.consul.v1.Response; +import com.ecwid.consul.v1.acl.model.Acl; +import com.ecwid.consul.v1.acl.model.NewAcl; +import com.ecwid.consul.v1.acl.model.UpdateAcl; +import com.ecwid.consul.v1.agent.model.Check; +import com.ecwid.consul.v1.agent.model.Member; +import com.ecwid.consul.v1.agent.model.NewCheck; +import com.ecwid.consul.v1.agent.model.NewService; +import com.ecwid.consul.v1.agent.model.Self; +import com.ecwid.consul.v1.agent.model.Service; +import com.ecwid.consul.v1.catalog.CatalogNodesRequest; +import com.ecwid.consul.v1.catalog.CatalogServiceRequest; +import com.ecwid.consul.v1.catalog.CatalogServicesRequest; +import com.ecwid.consul.v1.catalog.model.CatalogDeregistration; +import com.ecwid.consul.v1.catalog.model.CatalogNode; +import com.ecwid.consul.v1.catalog.model.CatalogRegistration; +import com.ecwid.consul.v1.catalog.model.CatalogService; +import com.ecwid.consul.v1.catalog.model.Node; +import com.ecwid.consul.v1.coordinate.model.Datacenter; +import com.ecwid.consul.v1.event.EventListRequest; +import com.ecwid.consul.v1.event.model.Event; +import com.ecwid.consul.v1.event.model.EventParams; +import com.ecwid.consul.v1.health.HealthChecksForServiceRequest; +import com.ecwid.consul.v1.health.HealthServicesRequest; +import com.ecwid.consul.v1.health.model.HealthService; +import com.ecwid.consul.v1.kv.model.GetBinaryValue; +import com.ecwid.consul.v1.kv.model.GetValue; +import com.ecwid.consul.v1.kv.model.PutParams; +import com.ecwid.consul.v1.query.model.QueryExecution; +import com.ecwid.consul.v1.session.model.NewSession; +import com.ecwid.consul.v1.session.model.Session; + +public class TestConsulClient extends ConsulClient { + + private ConsulClient consulClient; + + public TestConsulClient(ConsulClient consulClient) { + this.consulClient = consulClient; + } + + @Override + public Response aclCreate(NewAcl newAcl, String token) { + return consulClient.aclCreate(newAcl, token); + } + + @Override + public Response aclUpdate(UpdateAcl updateAcl, String token) { + return consulClient.aclUpdate(updateAcl, token); + } + + @Override + public Response aclDestroy(String aclId, String token) { + return consulClient.aclDestroy(aclId, token); + } + + @Override + public Response getAcl(String id) { + return consulClient.getAcl(id); + } + + @Override + public Response aclClone(String aclId, String token) { + return consulClient.aclClone(aclId, token); + } + + @Override + public Response> getAclList(String token) { + return consulClient.getAclList(token); + } + + @Override + public Response> getAgentChecks() { + return consulClient.getAgentChecks(); + } + + @Override + public Response> getAgentServices() { + return consulClient.getAgentServices(); + } + + @Override + public Response> getAgentMembers() { + return consulClient.getAgentMembers(); + } + + @Override + public Response getAgentSelf() { + return consulClient.getAgentSelf(); + } + + @Override + public Response getAgentSelf(String token) { + return consulClient.getAgentSelf(token); + } + + @Override + public Response agentSetMaintenance(boolean maintenanceEnabled) { + return consulClient.agentSetMaintenance(maintenanceEnabled); + } + + @Override + public Response agentSetMaintenance(boolean maintenanceEnabled, String reason) { + return consulClient.agentSetMaintenance(maintenanceEnabled, reason); + } + + @Override + public Response agentJoin(String address, boolean wan) { + return consulClient.agentJoin(address, wan); + } + + @Override + public Response agentForceLeave(String node) { + return consulClient.agentForceLeave(node); + } + + @Override + public Response agentCheckRegister(NewCheck newCheck) { + return consulClient.agentCheckRegister(newCheck); + } + + @Override + public Response agentCheckRegister(NewCheck newCheck, String token) { + return consulClient.agentCheckRegister(newCheck, token); + } + + @Override + public Response agentCheckDeregister(String checkId) { + return consulClient.agentCheckDeregister(checkId); + } + + @Override + public Response agentCheckDeregister(String checkId, String token) { + return consulClient.agentCheckDeregister(checkId, token); + } + + @Override + public Response agentCheckPass(String checkId) { + return consulClient.agentCheckPass(checkId); + } + + @Override + public Response agentCheckPass(String checkId, String note) { + return consulClient.agentCheckPass(checkId, note); + } + + @Override + public Response agentCheckPass(String checkId, String note, String token) { + return consulClient.agentCheckPass(checkId, note, token); + } + + @Override + public Response agentCheckWarn(String checkId) { + return consulClient.agentCheckWarn(checkId); + } + + @Override + public Response agentCheckWarn(String checkId, String note) { + return consulClient.agentCheckWarn(checkId, note); + } + + @Override + public Response agentCheckWarn(String checkId, String note, String token) { + return consulClient.agentCheckWarn(checkId, note, token); + } + + @Override + public Response agentCheckFail(String checkId) { + return consulClient.agentCheckFail(checkId); + } + + @Override + public Response agentCheckFail(String checkId, String note) { + return consulClient.agentCheckFail(checkId, note); + } + + @Override + public Response agentCheckFail(String checkId, String note, String token) { + return consulClient.agentCheckFail(checkId, note, token); + } + + @Override + public Response agentServiceRegister(NewService newService) { + return consulClient.agentServiceRegister(newService); + } + + @Override + public Response agentServiceRegister(NewService newService, String token) { + return consulClient.agentServiceRegister(newService, token); + } + + @Override + public Response agentServiceDeregister(String serviceId) { + return consulClient.agentServiceDeregister(serviceId); + } + + @Override + public Response agentServiceDeregister(String serviceId, String token) { + return consulClient.agentServiceDeregister(serviceId, token); + } + + @Override + public Response agentServiceSetMaintenance(String serviceId, boolean maintenanceEnabled) { + return consulClient.agentServiceSetMaintenance(serviceId, maintenanceEnabled); + } + + @Override + public Response agentServiceSetMaintenance(String serviceId, boolean maintenanceEnabled, String reason) { + return consulClient.agentServiceSetMaintenance(serviceId, maintenanceEnabled, reason); + } + + @Override + public Response agentReload() { + return consulClient.agentReload(); + } + + @Override + public Response catalogRegister(CatalogRegistration catalogRegistration) { + return consulClient.catalogRegister(catalogRegistration); + } + + @Override + public Response catalogRegister(CatalogRegistration catalogRegistration, String token) { + return consulClient.catalogRegister(catalogRegistration, token); + } + + @Override + public Response catalogDeregister(CatalogDeregistration catalogDeregistration) { + return consulClient.catalogDeregister(catalogDeregistration); + } + + @Override + public Response catalogDeregister(CatalogDeregistration catalogDeregistration, String token) { + return consulClient.catalogDeregister(catalogDeregistration, token); + } + + @Override + public Response> getCatalogDatacenters() { + return consulClient.getCatalogDatacenters(); + } + + @Override + @Deprecated + public Response> getCatalogNodes(QueryParams queryParams) { + return consulClient.getCatalogNodes(queryParams); + } + + @Override + public Response> getCatalogNodes(CatalogNodesRequest catalogNodesRequest) { + return consulClient.getCatalogNodes(catalogNodesRequest); + } + + @Override + @Deprecated + public Response>> getCatalogServices(QueryParams queryParams) { + return consulClient.getCatalogServices(queryParams); + } + + @Override + @Deprecated + public Response>> getCatalogServices(QueryParams queryParams, String token) { + return consulClient.getCatalogServices(queryParams, token); + } + + @Override + public Response>> getCatalogServices(CatalogServicesRequest catalogServicesRequest) { + return consulClient.getCatalogServices(catalogServicesRequest); + } + + @Override + @Deprecated + public Response> getCatalogService(String serviceName, QueryParams queryParams) { + return consulClient.getCatalogService(serviceName, queryParams); + } + + @Override + @Deprecated + public Response> getCatalogService(String serviceName, String tag, QueryParams queryParams) { + return consulClient.getCatalogService(serviceName, tag, queryParams); + } + + @Override + @Deprecated + public Response> getCatalogService(String serviceName, QueryParams queryParams, String token) { + return consulClient.getCatalogService(serviceName, queryParams, token); + } + + @Override + @Deprecated + public Response> getCatalogService(String serviceName, String tag, QueryParams queryParams, + String token) { + return consulClient.getCatalogService(serviceName, tag, queryParams, token); + } + + @Override + @Deprecated + public Response> getCatalogService(String serviceName, String[] tags, QueryParams queryParams, + String token) { + return consulClient.getCatalogService(serviceName, tags, queryParams, token); + } + + @Override + public Response> getCatalogService(String serviceName, + CatalogServiceRequest catalogServiceRequest) { + return consulClient.getCatalogService(serviceName, catalogServiceRequest); + } + + @Override + public Response getCatalogNode(String nodeName, QueryParams queryParams) { + return consulClient.getCatalogNode(nodeName, queryParams); + } + + @Override + public Response> getDatacenters() { + return consulClient.getDatacenters(); + } + + @Override + public Response> getNodes(QueryParams queryParams) { + return consulClient.getNodes(queryParams); + } + + @Override + public Response eventFire(String event, String payload, EventParams eventParams, QueryParams queryParams) { + return consulClient.eventFire(event, payload, eventParams, queryParams); + } + + @Override + @Deprecated + public Response> eventList(QueryParams queryParams) { + return consulClient.eventList(queryParams); + } + + @Override + @Deprecated + public Response> eventList(String event, QueryParams queryParams) { + return consulClient.eventList(event, queryParams); + } + + @Override + public Response> eventList(EventListRequest eventListRequest) { + return consulClient.eventList(eventListRequest); + } + + @Override + public Response> getHealthChecksForNode(String nodeName, + QueryParams queryParams) { + return consulClient.getHealthChecksForNode(nodeName, queryParams); + } + + @Override + @Deprecated + public Response> getHealthChecksForService(String serviceName, + QueryParams queryParams) { + return consulClient.getHealthChecksForService(serviceName, queryParams); + } + + @Override + public Response> getHealthChecksForService(String serviceName, + HealthChecksForServiceRequest healthChecksForServiceRequest) { + return consulClient.getHealthChecksForService(serviceName, healthChecksForServiceRequest); + } + + @Override + @Deprecated + public Response> getHealthServices(String serviceName, boolean onlyPassing, + QueryParams queryParams) { + return consulClient.getHealthServices(serviceName, onlyPassing, queryParams); + } + + @Override + @Deprecated + public Response> getHealthServices(String serviceName, String tag, boolean onlyPassing, + QueryParams queryParams) { + return consulClient.getHealthServices(serviceName, tag, onlyPassing, queryParams); + } + + @Override + @Deprecated + public Response> getHealthServices(String serviceName, boolean onlyPassing, + QueryParams queryParams, String token) { + return consulClient.getHealthServices(serviceName, onlyPassing, queryParams, token); + } + + @Override + @Deprecated + public Response> getHealthServices(String serviceName, String tag, boolean onlyPassing, + QueryParams queryParams, String token) { + return consulClient.getHealthServices(serviceName, tag, onlyPassing, queryParams, token); + } + + @Override + @Deprecated + public Response> getHealthServices(String serviceName, String[] tags, boolean onlyPassing, + QueryParams queryParams, String token) { + return consulClient.getHealthServices(serviceName, tags, onlyPassing, queryParams, token); + } + + @Override + public Response> getHealthServices(String serviceName, + HealthServicesRequest healthServicesRequest) { + return consulClient.getHealthServices(serviceName, healthServicesRequest); + } + + @Override + public Response> getHealthChecksState(QueryParams queryParams) { + return consulClient.getHealthChecksState(queryParams); + } + + @Override + public Response> getHealthChecksState( + com.ecwid.consul.v1.health.model.Check.CheckStatus checkStatus, QueryParams queryParams) { + return consulClient.getHealthChecksState(checkStatus, queryParams); + } + + @Override + public Response getKVValue(String key) { + return consulClient.getKVValue(key); + } + + @Override + public Response getKVValue(String key, String token) { + return consulClient.getKVValue(key, token); + } + + @Override + public Response getKVValue(String key, QueryParams queryParams) { + return consulClient.getKVValue(key, queryParams); + } + + @Override + public Response getKVValue(String key, String token, QueryParams queryParams) { + return consulClient.getKVValue(key, token, queryParams); + } + + @Override + public Response getKVBinaryValue(String key) { + return consulClient.getKVBinaryValue(key); + } + + @Override + public Response getKVBinaryValue(String key, String token) { + return consulClient.getKVBinaryValue(key, token); + } + + @Override + public Response getKVBinaryValue(String key, QueryParams queryParams) { + return consulClient.getKVBinaryValue(key, queryParams); + } + + @Override + public Response getKVBinaryValue(String key, String token, QueryParams queryParams) { + return consulClient.getKVBinaryValue(key, token, queryParams); + } + + @Override + public Response> getKVValues(String keyPrefix) { + return consulClient.getKVValues(keyPrefix); + } + + @Override + public Response> getKVValues(String keyPrefix, String token) { + return consulClient.getKVValues(keyPrefix, token); + } + + @Override + public Response> getKVValues(String keyPrefix, QueryParams queryParams) { + return consulClient.getKVValues(keyPrefix, queryParams); + } + + @Override + public Response> getKVValues(String keyPrefix, String token, QueryParams queryParams) { + return consulClient.getKVValues(keyPrefix, token, queryParams); + } + + @Override + public Response> getKVBinaryValues(String keyPrefix) { + return consulClient.getKVBinaryValues(keyPrefix); + } + + @Override + public Response> getKVBinaryValues(String keyPrefix, String token) { + return consulClient.getKVBinaryValues(keyPrefix, token); + } + + @Override + public Response> getKVBinaryValues(String keyPrefix, QueryParams queryParams) { + return consulClient.getKVBinaryValues(keyPrefix, queryParams); + } + + @Override + public Response> getKVBinaryValues(String keyPrefix, String token, QueryParams queryParams) { + return consulClient.getKVBinaryValues(keyPrefix, token, queryParams); + } + + @Override + public Response> getKVKeysOnly(String keyPrefix) { + return consulClient.getKVKeysOnly(keyPrefix); + } + + @Override + public Response> getKVKeysOnly(String keyPrefix, String separator, String token) { + return consulClient.getKVKeysOnly(keyPrefix, separator, token); + } + + @Override + public Response> getKVKeysOnly(String keyPrefix, QueryParams queryParams) { + return consulClient.getKVKeysOnly(keyPrefix, queryParams); + } + + @Override + public Response> getKVKeysOnly(String keyPrefix, String separator, String token, + QueryParams queryParams) { + return consulClient.getKVKeysOnly(keyPrefix, separator, token, queryParams); + } + + @Override + public Response setKVValue(String key, String value) { + return consulClient.setKVValue(key, value); + } + + @Override + public Response setKVValue(String key, String value, PutParams putParams) { + return consulClient.setKVValue(key, value, putParams); + } + + @Override + public Response setKVValue(String key, String value, String token, PutParams putParams) { + return consulClient.setKVValue(key, value, token, putParams); + } + + @Override + public Response setKVValue(String key, String value, QueryParams queryParams) { + return consulClient.setKVValue(key, value, queryParams); + } + + @Override + public Response setKVValue(String key, String value, PutParams putParams, QueryParams queryParams) { + return consulClient.setKVValue(key, value, putParams, queryParams); + } + + @Override + public Response setKVValue(String key, String value, String token, PutParams putParams, + QueryParams queryParams) { + return consulClient.setKVValue(key, value, token, putParams, queryParams); + } + + @Override + public Response setKVBinaryValue(String key, byte[] value) { + return consulClient.setKVBinaryValue(key, value); + } + + @Override + public Response setKVBinaryValue(String key, byte[] value, PutParams putParams) { + return consulClient.setKVBinaryValue(key, value, putParams); + } + + @Override + public Response setKVBinaryValue(String key, byte[] value, String token, PutParams putParams) { + return consulClient.setKVBinaryValue(key, value, token, putParams); + } + + @Override + public Response setKVBinaryValue(String key, byte[] value, QueryParams queryParams) { + return consulClient.setKVBinaryValue(key, value, queryParams); + } + + @Override + public Response setKVBinaryValue(String key, byte[] value, PutParams putParams, QueryParams queryParams) { + return consulClient.setKVBinaryValue(key, value, putParams, queryParams); + } + + @Override + public Response setKVBinaryValue(String key, byte[] value, String token, PutParams putParams, + QueryParams queryParams) { + return consulClient.setKVBinaryValue(key, value, token, putParams, queryParams); + } + + @Override + public Response deleteKVValue(String key) { + return consulClient.deleteKVValue(key); + } + + @Override + public Response deleteKVValue(String key, String token) { + return consulClient.deleteKVValue(key, token); + } + + @Override + public Response deleteKVValue(String key, QueryParams queryParams) { + return consulClient.deleteKVValue(key, queryParams); + } + + @Override + public Response deleteKVValue(String key, String token, QueryParams queryParams) { + return consulClient.deleteKVValue(key, token, queryParams); + } + + @Override + public Response deleteKVValues(String key) { + return consulClient.deleteKVValues(key); + } + + @Override + public Response deleteKVValues(String key, String token) { + return consulClient.deleteKVValues(key, token); + } + + @Override + public Response deleteKVValues(String key, QueryParams queryParams) { + return consulClient.deleteKVValues(key, queryParams); + } + + @Override + public Response deleteKVValues(String key, String token, QueryParams queryParams) { + return consulClient.deleteKVValues(key, token, queryParams); + } + + @Override + public Response executePreparedQuery(String uuid, QueryParams queryParams) { + return consulClient.executePreparedQuery(uuid, queryParams); + } + + @Override + public Response sessionCreate(NewSession newSession, QueryParams queryParams) { + return consulClient.sessionCreate(newSession, queryParams); + } + + @Override + public Response sessionCreate(NewSession newSession, QueryParams queryParams, String token) { + return consulClient.sessionCreate(newSession, queryParams, token); + } + + @Override + public Response sessionDestroy(String session, QueryParams queryParams) { + return consulClient.sessionDestroy(session, queryParams); + } + + @Override + public Response sessionDestroy(String session, QueryParams queryParams, String token) { + return consulClient.sessionDestroy(session, queryParams, token); + } + + @Override + public Response getSessionInfo(String session, QueryParams queryParams) { + return consulClient.getSessionInfo(session, queryParams); + } + + @Override + public Response getSessionInfo(String session, QueryParams queryParams, String token) { + return consulClient.getSessionInfo(session, queryParams, token); + } + + @Override + public Response> getSessionNode(String node, QueryParams queryParams) { + return consulClient.getSessionNode(node, queryParams); + } + + @Override + public Response> getSessionNode(String node, QueryParams queryParams, String token) { + return consulClient.getSessionNode(node, queryParams, token); + } + + @Override + public Response> getSessionList(QueryParams queryParams) { + return consulClient.getSessionList(queryParams); + } + + @Override + public Response> getSessionList(QueryParams queryParams, String token) { + return consulClient.getSessionList(queryParams, token); + } + + @Override + public Response renewSession(String session, QueryParams queryParams) { + return consulClient.renewSession(session, queryParams); + } + + @Override + public Response renewSession(String session, QueryParams queryParams, String token) { + return consulClient.renewSession(session, queryParams, token); + } + + @Override + public Response getStatusLeader() { + return consulClient.getStatusLeader(); + } + + @Override + public Response> getStatusPeers() { + return consulClient.getStatusPeers(); + } + +} diff --git a/spring-cloud-consul-discovery/src/main/java/org/springframework/cloud/consul/discovery/TtlScheduler.java b/spring-cloud-consul-discovery/src/main/java/org/springframework/cloud/consul/discovery/TtlScheduler.java index 4167031a..663d9b24 100644 --- a/spring-cloud-consul-discovery/src/main/java/org/springframework/cloud/consul/discovery/TtlScheduler.java +++ b/spring-cloud-consul-discovery/src/main/java/org/springframework/cloud/consul/discovery/TtlScheduler.java @@ -110,7 +110,8 @@ public class TtlScheduler { @Override public void run() { try { - this.ttlScheduler.client.agentCheckPass(this.checkId, null, this.ttlScheduler.discoveryProperties.getAclToken()); + this.ttlScheduler.client.agentCheckPass(this.checkId, null, + this.ttlScheduler.discoveryProperties.getAclToken()); if (log.isDebugEnabled()) { log.debug("Sending consul heartbeat for: " + this.checkId); } diff --git a/spring-cloud-consul-discovery/src/test/java/org/springframework/cloud/consul/discovery/TtlSchedulerTests.java b/spring-cloud-consul-discovery/src/test/java/org/springframework/cloud/consul/discovery/TtlSchedulerTests.java index e6284b72..e2aad8dd 100644 --- a/spring-cloud-consul-discovery/src/test/java/org/springframework/cloud/consul/discovery/TtlSchedulerTests.java +++ b/spring-cloud-consul-discovery/src/test/java/org/springframework/cloud/consul/discovery/TtlSchedulerTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2013-2019 the original author or authors. + * Copyright 2013-2023 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ package org.springframework.cloud.consul.discovery; import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; import com.ecwid.consul.v1.ConsulClient; import com.ecwid.consul.v1.QueryParams; @@ -31,10 +32,14 @@ import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationConfiguration; import org.springframework.cloud.consul.ConsulAutoConfiguration; +import org.springframework.cloud.consul.ConsulProperties; import org.springframework.cloud.consul.support.ConsulHeartbeatAutoConfiguration; import org.springframework.cloud.consul.test.ConsulTestcontainers; +import org.springframework.cloud.consul.test.TestConsulClient; +import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; +import org.springframework.context.annotation.Primary; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringRunner; @@ -58,6 +63,9 @@ public class TtlSchedulerTests { @Autowired private ConsulClient consul; + @Autowired + private AtomicBoolean agentCheckPassWithTokenCalled; + @Test public void should_send_a_check_before_ttl_for_all_services() throws InterruptedException { Thread.sleep(2100); // Wait for TTL to expired (TTL is set to 2 seconds) @@ -69,6 +77,7 @@ public class TtlSchedulerTests { assertThat(serviceManagementCheck).isNotNull(); assertThat(serviceManagementCheck.getStatus()).isEqualTo(PASSING) .as("Service management check is in wrong state"); + assertThat(agentCheckPassWithTokenCalled).isTrue(); } private Check getCheckForService(String serviceId) { @@ -86,6 +95,24 @@ public class TtlSchedulerTests { ConsulDiscoveryClientConfiguration.class, ConsulHeartbeatAutoConfiguration.class }) public static class TtlSchedulerTestConfig { + @Bean + AtomicBoolean agentCheckPassWithTokenCalled() { + return new AtomicBoolean(); + } + + @Bean + @Primary + ConsulClient testConsulClient(ConsulProperties consulProperties, AtomicBoolean agentCheckPassWithTokenCalled) { + ConsulClient consulClient = ConsulAutoConfiguration.createConsulClient(consulProperties); + return new TestConsulClient(consulClient) { + @Override + public Response agentCheckPass(String checkId, String note, String token) { + agentCheckPassWithTokenCalled.compareAndSet(false, true); + return super.agentCheckPass(checkId, note, token); + } + }; + } + } }