SpringCloud/spring-cloud-kubernetes
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add tests

Browse Source
This commit is contained in:
Haytham Mohamed
2020-06-24 22:42:20 -05:00
parent e78f3b176b
commit 9df02f137d
3 changed files with 218 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
spring-cloud-kubernetes-discovery/src/main/java/org/springframework/cloud/kubernetes/discovery/KubernetesDiscoveryClient.java
View File

@@ -115,7 +115,7 @@ public class KubernetesDiscoveryClient implements DiscoveryClient {
return instances;
}
private List<Endpoints> getEndPointsList(String serviceId) {
public List<Endpoints> getEndPointsList(String serviceId) {
return this.properties.isAllNamespaces()
? this.client.endpoints().inAnyNamespace()
.withField("metadata.name", serviceId)

21
spring-cloud-kubernetes-discovery/src/test/java/org/springframework/cloud/kubernetes/discovery/KubernetesDiscoveryClientFilterMetadataTest.java
View File

@@ -16,6 +16,7 @@
package org.springframework.cloud.kubernetes.discovery;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -34,6 +35,9 @@ import io.fabric8.kubernetes.api.model.ServiceList;
import io.fabric8.kubernetes.api.model.ServicePort;
import io.fabric8.kubernetes.api.model.ServicePortBuilder;
import io.fabric8.kubernetes.client.KubernetesClient;
import io.fabric8.kubernetes.client.Watch;
import io.fabric8.kubernetes.client.Watcher;
import io.fabric8.kubernetes.client.dsl.FilterWatchListDeletable;
import io.fabric8.kubernetes.client.dsl.MixedOperation;
import io.fabric8.kubernetes.client.dsl.Resource;
import io.fabric8.kubernetes.client.dsl.ServiceResource;
@@ -49,7 +53,9 @@ import org.springframework.cloud.client.ServiceInstance;
import static java.util.stream.Collectors.toList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.entry;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
@@ -79,6 +85,9 @@ public class KubernetesDiscoveryClientFilterMetadataTest {
@Mock
private Resource<Endpoints, DoneableEndpoints> endpointsResource;
@Mock
FilterWatchListDeletable<Endpoints, EndpointsList, Boolean, Watch, Watcher<Endpoints>> filter;
@InjectMocks
private KubernetesDiscoveryClient underTest;
@@ -360,10 +369,16 @@ public class KubernetesDiscoveryClientFilterMetadataTest {
.addNewSubset().addAllToPorts(getEndpointPorts(ports)).addNewAddress()
.endAddress().endSubset().build();
when(this.endpointsResource.get()).thenReturn(endpoints);
when(this.endpointsOperation.withName(serviceId))
.thenReturn(this.endpointsResource);
when(this.kubernetesClient.endpoints()).thenReturn(this.endpointsOperation);
EndpointsList endpointsList = new EndpointsList(null,
Collections.singletonList(endpoints), null, null);
when(filter.list()).thenReturn(endpointsList);
when(filter.withLabels(anyMap())).thenReturn(filter);
when(this.kubernetesClient.endpoints().withField(eq("metadata.name"),
eq(serviceId))).thenReturn(filter);
}
private List<ServicePort> getServicePorts(Map<Integer, String> ports) {

312
spring-cloud-kubernetes-discovery/src/test/java/org/springframework/cloud/kubernetes/discovery/KubernetesDiscoveryClientTest.java
View File

@@ -19,6 +19,7 @@ package org.springframework.cloud.kubernetes.discovery;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import io.fabric8.kubernetes.api.model.Endpoints;
import io.fabric8.kubernetes.api.model.EndpointsBuilder;
@@ -61,106 +62,44 @@ public class KubernetesDiscoveryClientTest {
}
@Test
public void getInstancesShouldBeAbleToHandleEndpointsFromMultipleNamespaces() {
Endpoints endPoints1 = new EndpointsBuilder().withNewMetadata()
.withName("endpoint").withNamespace("test").endMetadata().addNewSubset()
.addNewAddress().withIp("ip1").withNewTargetRef().withUid("uid1")
.endTargetRef().endAddress().addNewPort("http", 80, "TCP").endSubset()
.build();
public void getInstancesShouldBeAbleToHandleEndpointsSingleAddress() {
Map<String, String> labels = new HashMap();
labels.put("l", "v");
Endpoints endpoints2 = new EndpointsBuilder().withNewMetadata()
.withName("endpoint").withNamespace("test2").endMetadata().addNewSubset()
.addNewAddress().withIp("ip2").withNewTargetRef().withUid("uid2")
Endpoints endPoint = new EndpointsBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(labels).endMetadata().addNewSubset()
.addNewAddress().withIp("ip1").withNewTargetRef().withUid("10")
.endTargetRef().endAddress().addNewPort("http", 80, "TCP").endSubset()
.build();
List<Endpoints> endpointsList = new ArrayList<>();
endpointsList.add(endPoints1);
endpointsList.add(endpoints2);
endpointsList.add(endPoint);
EndpointsList endpoints = new EndpointsList();
endpoints.setItems(endpointsList);
mockServer.expect().get().withPath(
"/api/v1/namespaces/test/endpoints?labelSelector=l%3Dv&fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
mockServer.expect().get()
.withPath("/api/v1/endpoints?fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
mockServer.expect().get().withPath("/api/v1/namespaces/test/endpoints/endpoint")
.andReturn(200, endPoints1).once();
mockServer.expect().get().withPath(
"/api/v1/namespaces/test/endpoints?fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
mockServer.expect().get().withPath("/api/v1/namespaces/test2/endpoints/endpoint")
.andReturn(200, endpoints2).once();
Service service1 = new ServiceBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(new HashMap<String, String>() {
{
put("l", "v");
}
}).endMetadata().build();
Service service2 = new ServiceBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test2").withLabels(new HashMap<String, String>() {
{
put("l", "v");
}
}).endMetadata().build();
List<Service> servicesList = new ArrayList<>();
servicesList.add(service1);
servicesList.add(service2);
ServiceList services = new ServiceList();
services.setItems(servicesList);
mockServer.expect().get()
.withPath("/api/v1/services?fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, services).once();
Service service = new ServiceBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(labels).endMetadata().build();
mockServer.expect().get().withPath("/api/v1/namespaces/test/services/endpoint")
.andReturn(200, service1).always();
mockServer.expect().get().withPath("/api/v1/namespaces/test2/services/endpoint")
.andReturn(200, service2).always();
final KubernetesDiscoveryProperties properties = new KubernetesDiscoveryProperties();
properties.setAllNamespaces(true);
final DiscoveryClient discoveryClient = new KubernetesDiscoveryClient(mockClient,
properties, KubernetesClient::services,
new DefaultIsServicePortSecureResolver(properties));
final List<ServiceInstance> instances = discoveryClient.getInstances("endpoint");
assertThat(instances).hasSize(2);
assertThat(instances).filteredOn(s -> s.getHost().equals("ip1") && !s.isSecure())
.hasSize(1);
assertThat(instances).filteredOn(s -> s.getHost().equals("ip2") && !s.isSecure())
.hasSize(1);
assertThat(instances).filteredOn(s -> s.getInstanceId().equals("uid1"))
.hasSize(1);
assertThat(instances).filteredOn(s -> s.getInstanceId().equals("uid2"))
.hasSize(1);
}
@Test
public void getInstancesShouldBeAbleToHandleEndpointsSingleAddress() {
mockServer.expect().get().withPath("/api/v1/namespaces/test/endpoints/endpoint")
.andReturn(200, new EndpointsBuilder().withNewMetadata()
.withName("endpoint").endMetadata().addNewSubset().addNewAddress()
.withIp("ip1").withNewTargetRef().withUid("uid1").endTargetRef()
.endAddress().addNewPort("http", 80, "TCP").endSubset().build())
.once();
mockServer.expect().get().withPath("/api/v1/services/endpoint")
.andReturn(200, new ServiceBuilder().withNewMetadata()
.withName("endpoint").withLabels(new HashMap<String, String>() {
{
put("l", "v");
}
}).endMetadata().build())
.always();
.andReturn(200, service).always();
final KubernetesDiscoveryProperties properties = new KubernetesDiscoveryProperties();
properties.setServiceLabels(labels);
properties.getMetadata().setAddLabels(false);
properties.getMetadata().setAddAnnotations(false);
final DiscoveryClient discoveryClient = new KubernetesDiscoveryClient(mockClient,
properties, KubernetesClient::services,
@@ -170,30 +109,45 @@ public class KubernetesDiscoveryClientTest {
assertThat(instances).hasSize(1)
.filteredOn(s -> s.getHost().equals("ip1") && !s.isSecure()).hasSize(1)
.filteredOn(s -> s.getInstanceId().equals("uid1")).hasSize(1);
.filteredOn(s -> s.getInstanceId().equals("10")).hasSize(1);
}
@Test
public void getInstancesShouldBeAbleToHandleEndpointsSingleAddressAndMultiplePorts() {
mockServer.expect().get().withPath("/api/v1/namespaces/test/endpoints/endpoint")
.andReturn(200, new EndpointsBuilder().withNewMetadata()
.withName("endpoint").endMetadata().addNewSubset().addNewAddress()
.withIp("ip1").withNewTargetRef().withUid("uid").endTargetRef()
.endAddress().addNewPort("mgmt", 9000, "TCP")
.addNewPort("http", 80, "TCP").endSubset().build())
.once();
Map<String, String> labels = new HashMap();
labels.put("l2", "v2");
Endpoints endPoint1 = new EndpointsBuilder().withNewMetadata()
.withName("endpoint").withNamespace("test").withLabels(labels)
.endMetadata().addNewSubset().addNewAddress().withIp("ip1")
.withNewTargetRef().withUid("20").endTargetRef().endAddress()
.addNewPort("mgmt", 900, "TCP").addNewPort("http", 80, "TCP").endSubset()
.build();
List<Endpoints> endpointsList = new ArrayList<>();
endpointsList.add(endPoint1);
EndpointsList endpoints = new EndpointsList();
endpoints.setItems(endpointsList);
mockServer.expect().get().withPath(
"/api/v1/namespaces/test/endpoints?labelSelector=l2%3Dv2&fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
mockServer.expect().get().withPath(
"/api/v1/namespaces/test/endpoints?fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
Service service = new ServiceBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(labels).withAnnotations(labels)
.endMetadata().build();
mockServer.expect().get().withPath("/api/v1/namespaces/test/services/endpoint")
.andReturn(200, new ServiceBuilder().withNewMetadata()
.withName("endpoint").withLabels(new HashMap<String, String>() {
{
put("l", "v");
}
}).endMetadata().build())
.always();
.andReturn(200, service).always();
final KubernetesDiscoveryProperties properties = new KubernetesDiscoveryProperties();
properties.setPrimaryPortName("http");
final DiscoveryClient discoveryClient = new KubernetesDiscoveryClient(mockClient,
properties, KubernetesClient::services,
new DefaultIsServicePortSecureResolver(properties));
@@ -202,29 +156,81 @@ public class KubernetesDiscoveryClientTest {
assertThat(instances).hasSize(1)
.filteredOn(s -> s.getHost().equals("ip1") && !s.isSecure()).hasSize(1)
.filteredOn(s -> s.getInstanceId().equals("uid")).hasSize(1)
.filteredOn(s -> s.getInstanceId().equals("20")).hasSize(1)
.filteredOn(s -> 80 == s.getPort()).hasSize(1);
}
@Test
public void getInstancesShouldBeAbleToHandleEndpointsMultipleAddresses() {
mockServer.expect().get().withPath("/api/v1/namespaces/test/endpoints/endpoint")
.andReturn(200, new EndpointsBuilder().withNewMetadata()
.withName("endpoint").endMetadata().addNewSubset().addNewAddress()
.withIp("ip1").endAddress().addNewAddress().withIp("ip2")
.endAddress().addNewPort("https", 443, "TCP").endSubset().build())
.once();
public void getEndPointsListTest() {
Map<String, String> labels = new HashMap();
labels.put("l", "v");
mockServer.expect().get().withPath("/api/v1/namespaces/test/services/endpoint")
.andReturn(200, new ServiceBuilder().withNewMetadata()
.withName("endpoint").withLabels(new HashMap<String, String>() {
{
put("l", "v");
}
}).endMetadata().build())
.always();
Endpoints endPoint = new EndpointsBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(labels).endMetadata().addNewSubset()
.addNewAddress().withIp("ip1").withNewTargetRef().withUid("30")
.endTargetRef().endAddress().addNewPort("http", 80, "TCP").endSubset()
.build();
List<Endpoints> endpointsList = new ArrayList<>();
endpointsList.add(endPoint);
EndpointsList endpoints = new EndpointsList();
endpoints.setItems(endpointsList);
mockServer.expect().get().withPath(
"/api/v1/namespaces/test/endpoints?labelSelector=l%3Dv&fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
final KubernetesDiscoveryProperties properties = new KubernetesDiscoveryProperties();
properties.setServiceLabels(labels);
final KubernetesDiscoveryClient discoveryClient = new KubernetesDiscoveryClient(
mockClient, properties, KubernetesClient::services,
new DefaultIsServicePortSecureResolver(properties));
final List<Endpoints> result_endpoints = discoveryClient
.getEndPointsList("endpoint");
assertThat(result_endpoints).hasSize(1);
}
@Test
public void getInstancesShouldBeAbleToHandleEndpointsMultipleAddresses() {
Map<String, String> labels = new HashMap();
labels.put("l1", "v1");
Endpoints endPoint = new EndpointsBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(labels).endMetadata().addNewSubset()
.addNewAddress().withIp("ip1").withNewTargetRef().withUid("40")
.endTargetRef().endAddress().addNewAddress().withIp("ip2")
.withNewTargetRef().withUid("50").endTargetRef().endAddress()
.addNewPort("https", 443, "TCP").endSubset().build();
List<Endpoints> endpointsList = new ArrayList<>();
endpointsList.add(endPoint);
EndpointsList endpoints = new EndpointsList();
endpoints.setItems(endpointsList);
mockServer.expect().get().withPath(
"/api/v1/namespaces/test/endpoints?labelSelector=l1%3Dv1&fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
mockServer.expect().get().withPath(
"/api/v1/namespaces/test/endpoints?fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
Service service = new ServiceBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(labels).endMetadata().build();
mockServer.expect().get().withPath("/api/v1/namespaces/test/services/endpoint")
.andReturn(200, service).always();
final KubernetesDiscoveryProperties properties = new KubernetesDiscoveryProperties();
properties.setServiceLabels(labels);
properties.getMetadata().setAddAnnotations(false);
properties.getMetadata().setAddLabels(false);
final DiscoveryClient discoveryClient = new KubernetesDiscoveryClient(mockClient,
properties, KubernetesClient::services,
new DefaultIsServicePortSecureResolver(properties));
@@ -295,4 +301,84 @@ public class KubernetesDiscoveryClientTest {
assertThat(services).containsOnly("s1", "s2");
}
@Test
public void getInstancesShouldBeAbleToHandleEndpointsFromMultipleNamespaces() {
Endpoints endPoints1 = new EndpointsBuilder().withNewMetadata()
.withName("endpoint").withNamespace("test").endMetadata().addNewSubset()
.addNewAddress().withIp("ip1").withNewTargetRef().withUid("60")
.endTargetRef().endAddress().addNewPort("http", 80, "TCP").endSubset()
.build();
Endpoints endpoints2 = new EndpointsBuilder().withNewMetadata()
.withName("endpoint").withNamespace("test2").endMetadata().addNewSubset()
.addNewAddress().withIp("ip2").withNewTargetRef().withUid("70")
.endTargetRef().endAddress().addNewPort("http", 80, "TCP").endSubset()
.build();
List<Endpoints> endpointsList = new ArrayList<>();
endpointsList.add(endPoints1);
endpointsList.add(endpoints2);
EndpointsList endpoints = new EndpointsList();
endpoints.setItems(endpointsList);
mockServer.expect().get()
.withPath("/api/v1/endpoints?fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, endpoints).once();
mockServer.expect().get().withPath("/api/v1/namespaces/test/endpoints/endpoint")
.andReturn(200, endPoints1).once();
mockServer.expect().get().withPath("/api/v1/namespaces/test2/endpoints/endpoint")
.andReturn(200, endpoints2).once();
Service service1 = new ServiceBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test").withLabels(new HashMap<String, String>() {
{
put("l", "v");
}
}).endMetadata().build();
Service service2 = new ServiceBuilder().withNewMetadata().withName("endpoint")
.withNamespace("test2").withLabels(new HashMap<String, String>() {
{
put("l", "v");
}
}).endMetadata().build();
List<Service> servicesList = new ArrayList<>();
servicesList.add(service1);
servicesList.add(service2);
ServiceList services = new ServiceList();
services.setItems(servicesList);
mockServer.expect().get()
.withPath("/api/v1/services?fieldSelector=metadata.name%3Dendpoint")
.andReturn(200, services).once();
mockServer.expect().get().withPath("/api/v1/namespaces/test/services/endpoint")
.andReturn(200, service1).always();
mockServer.expect().get().withPath("/api/v1/namespaces/test2/services/endpoint")
.andReturn(200, service2).always();
final KubernetesDiscoveryProperties properties = new KubernetesDiscoveryProperties();
properties.setAllNamespaces(true);
final DiscoveryClient discoveryClient = new KubernetesDiscoveryClient(mockClient,
properties, KubernetesClient::services,
new DefaultIsServicePortSecureResolver(properties));
final List<ServiceInstance> instances = discoveryClient.getInstances("endpoint");
assertThat(instances).hasSize(2);
assertThat(instances).filteredOn(s -> s.getHost().equals("ip1") && !s.isSecure())
.hasSize(1);
assertThat(instances).filteredOn(s -> s.getHost().equals("ip2") && !s.isSecure())
.hasSize(1);
assertThat(instances).filteredOn(s -> s.getInstanceId().equals("60")).hasSize(1);
assertThat(instances).filteredOn(s -> s.getInstanceId().equals("70")).hasSize(1);
}
}