gistfile1.txt

/*
 * Copyright (c) 2018 The Emirates Group. All Rights Reserved. The information specified here is confidential and remains property of the Emirates Group.
 * groupId     - com.emirates.ocsl
 * artifactId  - reservation-bookings-service
 * name        - reservation-bookings-service
 * description - reservation bookings service
 * 2019
 */
package com.emirates.ocsl.reservation.bookings.http.handlers;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import com.emirates.ocsl.dom.common.BeanValidation;
import com.emirates.ocsl.dom.common.bean.RequestHeaderType;
import com.emirates.ocsl.dom.exceptions.ClientException;
import com.emirates.ocsl.dom.exceptions.DomainError;
import com.emirates.ocsl.dom.exceptions.GeneralServiceException;
import com.emirates.ocsl.dom.http.RequestBodySerializer;
import com.emirates.ocsl.dom.http.handlers.ContextHandler;
import com.emirates.ocsl.dom.http.handlers.ErrorHandler;
import com.emirates.ocsl.logging.v2.logger.EventLogger;
import com.emirates.ocsl.logging.v2.logger.ServiceLogger;
import com.emirates.ocsl.reservation.bookings.domain.conversion.BeanConversion;
import com.emirates.ocsl.reservation.bookings.domain.dto.DeleteRemarksRequestDTO;
import com.emirates.ocsl.reservation.bookings.domain.dto.pnrmodification.RemarksAdditionDTO;
import com.emirates.ocsl.reservation.bookings.domain.dto.pnrmodification.TimeLimitRequestDTO;
import com.emirates.ocsl.reservation.bookings.domain.validation.ServiceValidation;
import com.emirates.ocsl.reservation.bookings.processor.PnrModificationProcessor;
import com.emirates.ocsl.soap.mrp.pnr.bean.PnrRetrievalResponseDTO;
import io.qameta.allure.Feature;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.function.Supplier;
import org.apache.commons.collections.map.HashedMap;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.ServerRequest;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;

@Feature("Unit - PnrModifyVersion1HandlerTest")
@DisplayName("Unit - PnrModifyVersion1HandlerTest")
public class PnrModificationVersion1HandlerTest {
    public static final String BOOKING_REFERENCE = "bookingReference";
    public static final String REMARK_ID         = "remarkId";
    public static final String TIME_LIMIT_ID     = "timeLimitId";

    private static final String HEADER_CORRELATION_ID   = "someCorrelationId";
    private static final String HEADER_REQUEST_ID       = "someRequestId";
    private static final String HEADER_CLIENT_IP        = "10.10.10.10";
    private static final String HEADER_APP_SERVER       = "appServer";
    private static final String HEADER_CHANNEL_NAME     = "channelName";
    private static final String HEADER_USER_AGENT       = "userAgent";
    private static final String HEADER_SITE_COUNTRY     = "siteCountry";
    private static final String HEADER_SITE_LOCALE      = "siteLocale";
    private static final String HEADER_DEVICE_TYPE      = "deviceType";
    private static final String SSO_CLIENT_KEY_TYPE     = "werewrewrw3423424erewrewrwer";
    private static final String SSO_CORRELATION_ID_TYPE = "werewrewrw3423424erewrewrwer";

    private static final Supplier<HttpHeaders> HTTP_HEADERS = () -> {
        final HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_STREAM_JSON);
        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_STREAM_JSON));
        headers.put(RequestHeaderType.CORRELATION_ID.getHeaderKey(), Collections.singletonList(HEADER_CORRELATION_ID));
        headers.put(RequestHeaderType.REQUEST_ID.getHeaderKey(), Collections.singletonList(HEADER_REQUEST_ID));
        headers.put(RequestHeaderType.TRUE_CLIENT_IP.getHeaderKey(), Collections.singletonList(HEADER_CLIENT_IP));
        headers.put(RequestHeaderType.APP_SERVER.getHeaderKey(), Collections.singletonList(HEADER_APP_SERVER));
        headers.put(RequestHeaderType.CHANNEL_NAME.getHeaderKey(), Collections.singletonList(HEADER_CHANNEL_NAME));
        headers.put(RequestHeaderType.USER_AGENT.getHeaderKey(), Collections.singletonList(HEADER_USER_AGENT));
        headers.put(RequestHeaderType.SITE_COUNTRY.getHeaderKey(), Collections.singletonList(HEADER_SITE_COUNTRY));
        headers.put(RequestHeaderType.SITE_LOCALE.getHeaderKey(), Collections.singletonList(HEADER_SITE_LOCALE));
        headers.put(RequestHeaderType.DEVICE_TYPE.getHeaderKey(), Collections.singletonList(HEADER_DEVICE_TYPE));
        headers.put(RequestHeaderType.SSO_CLIENT_KEY.getHeaderKey(), Collections.singletonList(SSO_CLIENT_KEY_TYPE));
        headers.put(RequestHeaderType.SSO_CORRELATION_ID.getHeaderKey(), Collections.singletonList(SSO_CORRELATION_ID_TYPE));
        return headers;
    };

    private static Supplier<TimeLimitRequestDTO> deleteTimeLimitRequestDTOSupplier = () -> TimeLimitRequestDTO
        .builder()
        .bookingCreationDateTime(LocalDateTime.parse("2017-01-13T17:09:42.411"))
        .passengerLastName("passengerLastName")
        .build();

    private static final Supplier<Map<String, String>>     pathVariables                   = () -> {
        final Map<String, String> map = new HashedMap();
        map.put(BOOKING_REFERENCE, "AT053");
        map.put(REMARK_ID, "remarks-AT053-123947-152a-40e1-b6a7-196dbbc50ebf");
        map.put(TIME_LIMIT_ID, "timelimits-AT053-123947-152a-40e1-b6a7-196dbbc50ebf");
        return map;
    };
    private static       Supplier<DeleteRemarksRequestDTO> deleteRemarksRequestDTOSupplier = () -> DeleteRemarksRequestDTO
        .builder()
        .bookingCreationDateTime(LocalDateTime.parse("2017-01-13T17:09:42.411"))
        .passengerLastName("passengerLastName")
        .build();
    private static       Supplier<GeneralServiceException> generalServiceExceptionSupplier = () -> ClientException.builder
        .get()
        .withLocation(DomainError.Location.SERVICE)
        .withSequence("01")
        .withStatus(HttpStatus.BAD_REQUEST)
        .withHttpRecord("ERR_RES")
        .build();

    private Supplier<RemarksAdditionDTO> GET_REMARKS_ADDITION = () -> RemarksAdditionDTO.builder()
            .bookingCreationDateTime(LocalDateTime.now())
            .bookingReference("kiref")
            .passengerLastName("test")
            .remarks(Arrays.asList(PnrRetrievalResponseDTO.RemarksDTO.builder()
                    .text("text")
                    .id("ab8ab8d1-7ee7-4ea6-9914-b2b08df70000")
                    .type("typo")
                    .build()))
            .build();

    private PnrModificationVersion1Handler pnrModificationVersion1Handler;

    @Mock
    private ServiceLogger            serviceLogger;
    private ErrorHandler             errorHandler;
    private ServiceValidation        serviceValidation;
    @Mock
    private RequestBodySerializer    requestBodySerializer;
    @Mock
    private BeanValidation           beanValidation;
    @Mock
    private PnrModificationProcessor pnrModificationProcessor;

    @Mock
    private EventLogger eventLogger;

    @Mock
    private BeanConversion beanConversion;

    private ServerRequest serverRequest;

    @BeforeEach
    void setup() {
        MockitoAnnotations.initMocks(this);
        serviceValidation = new ServiceValidation();
        final EventLogger eventLogger = mock(EventLogger.class);
        errorHandler = new ErrorHandler(eventLogger, new ContextHandler());
        pnrModificationVersion1Handler = new PnrModificationVersion1Handler(serviceLogger, errorHandler, serviceValidation,
            pnrModificationProcessor, eventLogger, beanConversion);
        ServerRequest.Headers headers = mock(ServerRequest.Headers.class);
        serverRequest = mock(ServerRequest.class);
        doReturn(headers)
            .when(serverRequest)
            .headers();
        doReturn(HTTP_HEADERS.get())
            .when(headers)
            .asHttpHeaders();
        when(serverRequest.bodyToMono(DeleteRemarksRequestDTO.class))
            .thenReturn(Mono.just(deleteRemarksRequestDTOSupplier.get()));
        when(serverRequest.pathVariables()).thenReturn(pathVariables.get());
        when(requestBodySerializer.readRequestBody(any(), any())).thenReturn(Mono.just(deleteRemarksRequestDTOSupplier.get()));
        when(beanConversion.serviceRequestToDeleteRemarksDTO(any())).thenReturn(Mono.just(deleteRemarksRequestDTOSupplier.get()));
        when(beanConversion.serviceRequestToTimeLimitRequestDTO(any())).thenReturn(Mono.just(deleteTimeLimitRequestDTOSupplier.get()));
        when(beanValidation.dtoValidation(any())).thenReturn(deleteTimeLimitRequestDTOSupplier.get());
        when(pnrModificationProcessor.deleteRemarks(any())).thenReturn(Mono.just(204));
        when(beanConversion.serviceRequestToDeleteRemarksDTO(any())).thenReturn(Mono.just(deleteRemarksRequestDTOSupplier.get()));
        when(pnrModificationProcessor.deleteTimeLimits(any())).thenReturn(Mono.just(204));
    }

    @Test
    void deleteRemarksValidCase1() {
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(204, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase1() {
        Map<String, String> paths = pathVariables.get();
        paths.put(BOOKING_REFERENCE, "");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase2() {
        Map<String, String> paths = pathVariables.get();
        paths.put(BOOKING_REFERENCE, null);
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(500, res.rawStatusCode());//TODO:need to check
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase3() {
        Map<String, String> paths = pathVariables.get();
        paths.put(BOOKING_REFERENCE, "ABP03432438");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase4() {
        Map<String, String> paths = pathVariables.get();
        paths.put(REMARK_ID, "remarks--123947-152a-40e1-b6a7-196dbbc50ebf");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase5() {
        Map<String, String> paths = pathVariables.get();
        paths.put(REMARK_ID, "");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase6() {
        Map<String, String> paths = pathVariables.get();
        paths.put(REMARK_ID, null);
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(500, res.rawStatusCode());//TODO:need to check
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase7() {
        when(beanValidation.dtoValidation(any())).thenThrow(generalServiceExceptionSupplier.get());
        when(beanConversion.serviceRequestToDeleteRemarksDTO(any())).thenThrow(generalServiceExceptionSupplier.get());
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteRemarksInValidCase8() {
        when(pnrModificationProcessor.deleteRemarks(any())).thenReturn(Mono.error(generalServiceExceptionSupplier.get()));
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void shouldValidateFallback() {
        doNothing()
            .when(eventLogger)
            .error(any(), any(), any());
        StepVerifier
            .create(pnrModificationVersion1Handler.fallback(serverRequest, new RuntimeException("fallback-test")))
            .expectNextMatches(res -> {
                assertNotNull(res);
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsValidCase1() {
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(204, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase1() {
        Map<String, String> paths = pathVariables.get();
        paths.put(BOOKING_REFERENCE, "");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase2() {
        Map<String, String> paths = pathVariables.get();
        paths.put(BOOKING_REFERENCE, null);
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(500, res.rawStatusCode());//TODO:need to check
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase3() {
        Map<String, String> paths = pathVariables.get();
        paths.put(BOOKING_REFERENCE, "ABP03432438");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase4() {
        Map<String, String> paths = pathVariables.get();
        paths.put(TIME_LIMIT_ID, "timelimits--123947-152a-40e1-b6a7-196dbbc50ebf");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase5() {
        Map<String, String> paths = pathVariables.get();
        paths.put(TIME_LIMIT_ID, "");
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase6() {
        Map<String, String> paths = pathVariables.get();
        paths.put(TIME_LIMIT_ID, null);
        when(serverRequest.pathVariables()).thenReturn(paths);
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(500, res.rawStatusCode());//TODO:need to check
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase7() {
        when(beanConversion.serviceRequestToTimeLimitRequestDTO(any())).thenReturn(Mono.error(generalServiceExceptionSupplier.get()));
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void deleteTimeLimitsInValidCase8() {
        when(pnrModificationProcessor.deleteTimeLimits(any())).thenReturn(Mono.error(generalServiceExceptionSupplier.get()));
        StepVerifier
            .create(pnrModificationVersion1Handler.deleteTimeLimits(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                assertEquals(400, res.rawStatusCode());
                return Boolean.TRUE;
            })
            .verifyComplete();
    }

    @Test
    void addRemarksCaseError() {
        when(pnrModificationProcessor.addRemarks(RemarksAdditionDTO.builder().build())).thenReturn(Mono.just(RemarksAdditionDTO.builder().build()));
        when(beanConversion.serviceRequestToRemarksAdditionDTO(serverRequest)).thenReturn(Mono.just( GET_REMARKS_ADDITION.get()));
        StepVerifier
                .create(pnrModificationVersion1Handler.addRemarks(serverRequest))
            .expectNextMatches(res -> {
                assertNotNull(res);
                return Boolean.TRUE;
            }).verifyComplete();
    }

    @Test
    void addRemarksCaseSuccess() {
        RemarksAdditionDTO remarksAdditionDTO = GET_REMARKS_ADDITION.get();
        when(serverRequest.bodyToMono(RemarksAdditionDTO.class)).thenReturn(Mono.just(remarksAdditionDTO));
        when(serverRequest.pathVariables()).thenReturn(pathVariables.get());
        when(requestBodySerializer.readRequestBody(any(), any())).thenReturn(Mono.just(remarksAdditionDTO));
        when(pnrModificationProcessor.addRemarks(any())).thenReturn(Mono.just(remarksAdditionDTO));
        when(beanConversion.serviceRequestToRemarksAdditionDTO(serverRequest)).thenReturn(Mono.just(remarksAdditionDTO));

        StepVerifier
                .create(pnrModificationVersion1Handler.addRemarks(serverRequest))
                .expectNextMatches(res -> {
                    return Boolean.TRUE;
                }).verifyComplete();
    }
}