varnitgoyal95/deployment-portal-be
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

INFRA-3970 | Dhruv | updates tests for egress service

Browse Source
This commit is contained in:
dhruvjoshi
2024-12-12 09:31:44 +05:30
parent 27ce9cfb0a
commit 911b4c4530
5 changed files with 164 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/main/java/com/navi/infra/portal/v2/egress/Egress.java
View File

@@ -56,16 +56,29 @@ public class Egress extends BaseEntity {
Egress egress = (Egress) o;
return port.equals(egress.port)
&& Objects.equals(host, egress.host)
&& Objects.equals(cluster, egress.cluster)
&& Objects.equals(vertical, egress.vertical)
&& Objects.equals(team, egress.team)
&& Objects.equals(manifestName, egress.manifestName)
&& Objects.equals(manifestEnvironment, egress.manifestEnvironment);
&& Objects.equals(cluster, egress.cluster);
}
public boolean equalsAllFields(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Egress egress = (Egress) o;
return port.equals(egress.port)
&& host.equals(egress.host)
&& cluster.equals(egress.cluster)
&& vertical.equals(egress.vertical)
&& team.equals(egress.team)
&& manifestName.equals(egress.manifestName)
&& manifestEnvironment.equals(egress.manifestEnvironment);
}
@Override
public int hashCode() {
return Objects.hash(host, port, cluster, vertical, team, manifestName, manifestEnvironment);
return Objects.hash(host, port, cluster);
}
@Override

10
src/main/java/com/navi/infra/portal/v2/egress/EgressDto.java
View File

@@ -1,5 +1,6 @@
package com.navi.infra.portal.v2.egress;
import com.fasterxml.jackson.annotation.JsonProperty;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import lombok.EqualsAndHashCode;
@@ -30,14 +31,19 @@ public class EgressDto {
@NotNull
private String port;
@JsonProperty("owner_team")
private String team;
private String vertical;
@JsonProperty("owner_manifest_name")
private String manifestName;
@JsonProperty("owner_vertical")
private String vertical;
@JsonProperty("owner_environment")
private String manifestEnvironment;
public EgressDto(Egress egress) {
this.host = egress.getHost();
this.port = egress.getPort();

53
src/main/java/com/navi/infra/portal/v2/egress/EgressServiceImpl.java
View File

@@ -13,6 +13,7 @@ import com.navi.infra.portal.service.manifest.ManifestService;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
@@ -21,13 +22,16 @@ import org.springframework.stereotype.Service;
@Slf4j
@Service
class EgressServiceImpl implements EgressService {
private final EgressRepository egressRepository;
private final ObjectMapper objectMapper;
private final ManifestService manifestService;
public EgressServiceImpl(EgressRepository egressRepository,
ManifestService manifestService, ObjectMapper objectMapper) {
public EgressServiceImpl(
EgressRepository egressRepository,
ManifestService manifestService, ObjectMapper objectMapper
) {
this.egressRepository = egressRepository;
this.manifestService = manifestService;
this.objectMapper = objectMapper;
@@ -61,19 +65,42 @@ class EgressServiceImpl implements EgressService {
.collect(toList());
}
public EgressUpdateResponse updateEgresses(List<EgressUpdateRequestData> egresses,
Boolean dryRun) {
public EgressUpdateResponse updateEgresses(
List<EgressUpdateRequestData> egresses,
Boolean dryRun
) {
log.info("Updating egresses with dryRun: {}", dryRun);
List<Egress> flattenedEgresses = flattenEgresses(egresses);
Set<Egress> existingEgresses = new HashSet<>(egressRepository.findAll());
Map<String, Egress> flattenedEgressMap = flattenedEgresses.stream()
.collect(Collectors.toMap(
egress -> egress.getHost() + ":" + egress.getPort() + ":" + egress.getCluster(),
egress -> egress
));
Set<Egress> updatedEgresses = existingEgresses.stream()
.map(egress -> {
String key = egress.getHost() + ":" + egress.getPort() + ":" + egress.getCluster();
Egress flattenedEgress = flattenedEgressMap.get(key);
if (flattenedEgress != null && !flattenedEgress.equalsAllFields(egress)) {
egress.setTeam(flattenedEgress.getTeam());
egress.setVertical(flattenedEgress.getVertical());
egress.setManifestEnvironment(flattenedEgress.getManifestEnvironment());
egress.setManifestName(flattenedEgress.getManifestName());
return egress;
}
return null;
})
.filter(Objects::nonNull)
.collect(Collectors.toSet());
Set<Egress> newEgresses = flattenedEgresses.stream()
.filter(egress -> !existingEgresses.contains(egress)).collect(toSet());
Set<Egress> removedEgresses = existingEgresses.stream()
.filter(egress -> !flattenedEgresses.contains(egress)).collect(toSet());
log.info("Egresses to be updated: {}",
updatedEgresses.stream().map(Egress::toString).collect(toList()));
log.info("New Egress to be added egresses: {}",
newEgresses.stream().map(Egress::toString).collect(toList()));
@@ -85,6 +112,7 @@ class EgressServiceImpl implements EgressService {
if (!dryRun) {
egressRepository.saveAll(newEgresses);
egressRepository.saveAll(updatedEgresses);
egressRepository.deleteAll(removedEgresses);
} else {
log.info("Dry run enabled, Skipping adding new egresses and "
@@ -109,7 +137,8 @@ class EgressServiceImpl implements EgressService {
private Map.Entry<String, List<Egress>> filterConflictingEgresses(
Map.Entry<String, List<Egress>> manifestWithEgressList,
Set<Egress> removedEgresses) {
Set<Egress> removedEgresses
) {
List<Egress> conflictingEgresses = manifestWithEgressList.getValue().stream()
.filter(removedEgresses::contains)
.collect(toList());
@@ -117,16 +146,17 @@ class EgressServiceImpl implements EgressService {
}
private Map<String, List<Egress>> fetchConflictingManifestsWithEgressHostList(
Map<String, List<Egress>> manifestWithEgressMap, Set<Egress> removedEgresses) {
Map<String, List<Egress>> manifestWithEgressMap, Set<Egress> removedEgresses
) {
log.info("Fetching conflicting manifests with egress");
return manifestWithEgressMap
.entrySet()
.stream()
.map(manifestWithEgressList ->
.map(manifestWithEgressList ->
filterConflictingEgresses(manifestWithEgressList, removedEgresses))
.filter(entry -> !entry.getValue().isEmpty())
.peek(entry -> log.info("Manifest: {} contains following egress which are being "
+ "deleted: {}", entry.getKey(), entry.getValue().stream().map(Egress::toString)
+ "deleted: {}", entry.getKey(), entry.getValue().stream().map(Egress::toString)
.collect(Collectors.toList())))
.collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
}
@@ -140,13 +170,14 @@ class EgressServiceImpl implements EgressService {
Manifest::fullName,
manifest -> {
EgressUpdateRequestData egressUpdateRequestData = new EgressUpdateRequestData();
egressUpdateRequestData.setEgressData(convertEgressObjectToEgressDtoList(manifest.getEgress()));
egressUpdateRequestData.setEgressData(
convertEgressObjectToEgressDtoList(manifest.getEgress()));
egressUpdateRequestData.setCluster(manifest.getCluster());
return flattenEgresses(List.of(egressUpdateRequestData));
}));
}
private List<EgressDto> convertEgressObjectToEgressDtoList(Object egressList) {
return objectMapper.convertValue(egressList, new TypeReference<List<EgressDto>>(){});
return objectMapper.convertValue(egressList, new TypeReference<List<EgressDto>>() {});
}
}

2
src/main/resources/db/migration/V1.99__Adds_new.column.type.in.egress.sql
View File

@@ -1,4 +1,4 @@
ALTER TABLE egress ADD COLUMN IF NOT EXISTS vertical VARCHAR(255) NOT NULL DEFAULT 'NA';
ALTER TABLE egress ADD COLUMN IF NOT EXISTS team VARCHAR(255) NOT NULL DEFAULT 'Infra';
ALTER TABLE egress ADD COLUMN IF NOT EXISTS team VARCHAR(255) NOT NULL DEFAULT 'Shared';
ALTER TABLE egress ADD COLUMN IF NOT EXISTS manifest_name VARCHAR(255) NOT NULL DEFAULT 'NA';
ALTER TABLE egress ADD COLUMN IF NOT EXISTS manifest_environment VARCHAR(255) NOT NULL DEFAULT 'NA';

122
src/test/java/com/navi/infra/portal/v2/egress/EgressServiceImplTest.java
View File

@@ -1,6 +1,5 @@
package com.navi.infra.portal.v2.egress;
import static java.util.stream.Collectors.toSet;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -9,10 +8,12 @@ import static org.mockito.Mockito.when;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.navi.infra.portal.service.manifest.ManifestService;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
@@ -41,52 +42,80 @@ class EgressServiceImplTest {
return egressDto;
}
private static EgressUpdateRequestData getEgressUpdateRequestData(String cluster,
List<EgressDto> egressData) {
private static EgressDto getEgressDto(
String host, String port, String team,
String vertical, String manifestEnvironment, String manifestName
) {
EgressDto egressDto = new EgressDto();
egressDto.setHost(host);
egressDto.setPort(port);
egressDto.setTeam(team);
egressDto.setVertical(vertical);
egressDto.setManifestEnvironment(manifestEnvironment);
egressDto.setManifestName(manifestName);
return egressDto;
}
private static EgressUpdateRequestData getEgressUpdateRequestData(
String cluster,
List<EgressDto> egressData
) {
EgressUpdateRequestData egressUpdateRequestData = new EgressUpdateRequestData();
egressUpdateRequestData.setCluster(cluster);
egressUpdateRequestData.setEgressData(egressData);
return egressUpdateRequestData;
}
private static List<EgressDto> getEgressDtoList() {
return List.of(getEgressDto("test1.com", "8080"),
getEgressDto("test2.com", "8081"),
getEgressDto("test3.com", "8082"));
}
private static Egress getEgress(String host, String port, String cluster) {
private static Egress getEgress(
String host, String port, String cluster, String team,
String vertical, String manifestEnvironment, String manifestName
) {
Egress egress = new Egress();
egress.setHost(host);
egress.setPort(port);
egress.setCluster(cluster);
egress.setTeam(team);
egress.setVertical(vertical);
egress.setManifestEnvironment(manifestEnvironment);
egress.setManifestName(manifestName);
return egress;
}
private static List<Egress> getEgressList() {
return List.of(getEgress("test1.com", "8080", "spike.np.navi-tech.in"),
getEgress("test2.com", "8081", "prod.cmd.navi-tech.in"),
getEgress("test3.com", "8082", "aps1.prod.navi-tech.in"));
private static List<Egress> getEgressList() {
return List.of(
getEgress("test1.com", "8080", "spike.np.navi-tech.in",
"team1", "vertical1", "env1",
"manifest1"),
getEgress("test2.com", "8081", "prod.cmd.navi-tech.in",
"team2", "vertical2", "evn2",
"manifest2"),
getEgress("test3.com", "8082", "aps1.prod.navi-tech.in",
"team3", "vertical3", "env3",
"manifest3"));
}
private static Egress getEgress(EgressDto egressDto, String cluster) {
return new Egress(egressDto.getHost(), egressDto.getPort(), cluster,
egressDto.getVertical(), egressDto.getTeam(), egressDto.getManifestName(),
egressDto.getManifestEnvironment());
}
@BeforeEach
void setup() {
egressService = new EgressServiceImpl(egressRepository, manifestService, objectMapper);
}
// @Test
// @DisplayName("should get egresses")
// void shouldGetEgresses() {
// String cluster = "test-cluster";
// List<EgressDto> egresses = List.of(getEgressDto("test1.com", "8080"),
// getEgressDto("test2.com", "8081"),
// getEgressDto("test3.com", "8082"));
// when(egressRepository.findByCluster(cluster)).thenReturn(egresses);
// List<EgressDto> result = egressService.getEgresses(cluster);
// verify(egressRepository, times(1)).findByCluster(cluster);
// assertEquals(egresses, result);
// }
@Test
@DisplayName("should get egresses")
void shouldGetEgresses() {
String cluster = "test-cluster";
var egresses = getEgressList();
var egressDtos = egresses.stream().map(EgressDto::new).collect(Collectors.toList());
when(egressRepository.findByCluster(cluster)).thenReturn(egresses);
List<EgressDto> result = egressService.getEgresses(cluster);
verify(egressRepository, times(1)).findByCluster(cluster);
assertEquals(egressDtos, result);
}
@Test
@DisplayName("Update Add new egress")
@@ -106,7 +135,8 @@ class EgressServiceImplTest {
verify(egressRepository, times(1)).saveAll(newEgresses);
verify(egressRepository, times(1)).deleteAll(Set.of());
verify(egressRepository, times(2)).findAll();
EgressUpdateResponse egressUpdateResponse = new EgressUpdateResponse(Map.of(), egresses, dryRun);
EgressUpdateResponse egressUpdateResponse = new EgressUpdateResponse(Map.of(), egresses,
dryRun);
assertEquals(egressUpdateResponse, result);
}
@@ -128,7 +158,43 @@ class EgressServiceImplTest {
verify(egressRepository, times(0)).saveAll(newEgresses);
verify(egressRepository, times(0)).deleteAll(Set.of());
verify(egressRepository, times(1)).findAll();
EgressUpdateResponse egressUpdateResponse = new EgressUpdateResponse(Map.of(), List.of(), dryRun);
EgressUpdateResponse egressUpdateResponse = new EgressUpdateResponse(Map.of(), List.of(),
dryRun);
assertEquals(egressUpdateResponse, result);
}
@Test
@DisplayName("should update egress which differs in fields other than host, port, cluster")
void shouldUpdateEgressWhichDiffersInFieldsOtherThanHostPortCluster() {
List<EgressUpdateRequestData> egressUpdateRequestData = new ArrayList<>();
var updatedEgressDto1 = getEgressDto("test1.com", "8080", "team4", "vertical1", "env1",
"manifest1");
var updatedEgressDto2 = getEgressDto("test2.com", "8081", "team6", "vertical2", "evn2",
"manifest6");
var updatedEgressDto3 = getEgressDto("test3.com", "8082", "team7", "vertical3", "env3",
"manifest7");
egressUpdateRequestData.add(getEgressUpdateRequestData("spike.np.navi-tech.in",
List.of(updatedEgressDto1)));
egressUpdateRequestData.add(getEgressUpdateRequestData("prod.cmd.navi-tech.in",
List.of(updatedEgressDto2)));
egressUpdateRequestData.add(getEgressUpdateRequestData("aps1.prod.navi-tech.in",
List.of(updatedEgressDto3)));
Set<Egress> newEgresses = new HashSet<>(List.of(
getEgress(updatedEgressDto1, "spike.np.navi-tech.in"),
getEgress(updatedEgressDto2, "prod.cmd.navi-tech.in"),
getEgress(updatedEgressDto3, "aps1.prod.navi-tech.in")
));
List<Egress> egresses = getEgressList();
boolean dryRun = false;
when(egressRepository.findAll()).thenReturn(egresses);
EgressUpdateResponse result = egressService.updateEgresses(egressUpdateRequestData, dryRun);
verify(egressRepository, times(1)).saveAll(Collections.emptySet());
verify(egressRepository, times(1)).saveAll(newEgresses);
verify(egressRepository, times(1)).deleteAll(Set.of());
verify(egressRepository, times(2)).findAll();
EgressUpdateResponse egressUpdateResponse = new EgressUpdateResponse(Map.of(), egresses,
dryRun);
assertEquals(egressUpdateResponse, result);
}
}