StubResponseGeneratorTest.java

package com.epam.wilma.webapp.stub.response;

/*==========================================================================
Copyright 2013-2017 EPAM Systems

This file is part of Wilma.

Wilma is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Wilma is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Wilma.  If not, see <http://www.gnu.org/licenses/>.
===========================================================================*/

import com.epam.wilma.common.helper.StackTraceToStringConverter;
import com.epam.wilma.core.MapBasedResponseDescriptorAccess;
import com.epam.wilma.domain.http.WilmaHttpEntity;
import com.epam.wilma.domain.http.WilmaHttpRequest;
import com.epam.wilma.domain.sequence.WilmaSequence;
import com.epam.wilma.domain.stubconfig.dialog.response.MimeType;
import com.epam.wilma.domain.stubconfig.dialog.response.ResponseDescriptor;
import com.epam.wilma.domain.stubconfig.dialog.response.ResponseDescriptorAttributes;
import com.epam.wilma.domain.stubconfig.dialog.response.template.Template;
import com.epam.wilma.domain.stubconfig.dialog.response.template.TemplateFormatter;
import com.epam.wilma.domain.stubconfig.dialog.response.template.TemplateFormatterDescriptor;
import com.epam.wilma.domain.stubconfig.parameter.ParameterList;
import com.epam.wilma.router.domain.ResponseDescriptorDTO;
import com.epam.wilma.sequence.helper.SequenceHeaderUtil;
import com.epam.wilma.sequence.matcher.SequenceMatcher;
import com.epam.wilma.webapp.domain.exception.TemplateFormattingFailedException;
import com.epam.wilma.webapp.stub.response.support.HttpServletRequestTransformer;
import com.epam.wilma.webapp.stub.response.support.SequenceResponseGuard;
import com.epam.wilma.webapp.stub.response.support.StubResponseHeaderConfigurer;
import com.epam.wilma.webapp.stub.servlet.helper.WaitProvider;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.slf4j.Logger;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashSet;
import java.util.Set;

import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;


/**
 * Tests for {@link StubResponseGenerator} class.
 *
 * @author Tamas_Bihari
 */
public class StubResponseGeneratorTest {
    private static final String SEQUENCE_DESCRIPTOR_KEY = "seqdesckey";
    private static final String WILMA_LOGGER_ID = "test";
    private final byte[] templateResource = "template-resource".getBytes();
    @Mock
    private MapBasedResponseDescriptorAccess responseDescriptorAccess;
    @Mock
    private StackTraceToStringConverter stackTraceConverter;
    @Mock
    private WaitProvider waitProvider;
    @Mock
    private StubResponseHeaderConfigurer headerConfigurer;
    @Mock
    private HttpServletRequestTransformer requestTransformer;
    @Mock
    private HttpServletRequest request;
    @Mock
    private HttpServletResponse response;
    @Mock
    private ResponseDescriptorDTO responseDescriptorDTO;
    @Mock
    private ResponseDescriptor responseDescriptor;
    //    @Mock
//    private ResponseDescriptorAttributes responseDescriptorAttributes;
    @Mock
    private Template template;
    @Mock
    private TemplateFormatterDescriptor templateFormatterDescriptor;
    @Mock
    private TemplateFormatter templateFormatter;
    @Mock
    private WilmaHttpRequest wilmaRequest;
    @Mock
    private Logger logger;
    @Mock
    private SequenceHeaderUtil headerCreator;
    @Mock
    private SequenceMatcher matcher;
    @Mock
    private SequenceResponseGuard sequenceResponseGuard;

    @InjectMocks
    private StubResponseGenerator underTest;

    private Set<TemplateFormatterDescriptor> templateFormatterDescriptors;

    @BeforeMethod
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        templateFormatterDescriptors = new HashSet<>();
        given(responseDescriptorAccess.getResponseDescriptor(anyString())).willReturn(responseDescriptorDTO);
        given(responseDescriptorDTO.getResponseDescriptor()).willReturn(responseDescriptor);
        Template template = new Template(null, null, null);
        ResponseDescriptorAttributes attributes = new ResponseDescriptorAttributes.Builder().delay(0).mimeType(MimeType.HTML.getOfficialMimeType())
                .template(template).sequenceDescriptorKey(SEQUENCE_DESCRIPTOR_KEY).build();
        given(responseDescriptor.getAttributes()).willReturn(attributes);
        given(responseDescriptor.getTemplateFormatters()).willReturn(templateFormatterDescriptors);
        given(requestTransformer.transformToWilmaHttpRequest(WILMA_LOGGER_ID, request, responseDescriptorDTO)).willReturn(wilmaRequest);
        given(stackTraceConverter.getStackTraceAsString(Matchers.any(Exception.class))).willReturn("exception-message");
        given(request.getHeader(WilmaHttpRequest.WILMA_LOGGER_ID)).willReturn(WILMA_LOGGER_ID);
        given(request.getHeader(WilmaHttpEntity.WILMA_SEQUENCE_ID)).willReturn("Test");
        given(headerCreator.resolveSequenceHeader("Test")).willReturn(new String[]{"Test"});
    }

    @Test
    public void testGenerateResponseShouldGetWilmaLoggerIdFromRequestHeaders() {
        //GIVEN in setUp
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(request).getHeader(WilmaHttpRequest.WILMA_LOGGER_ID);
    }

    @Test
    public void testGenerateResponseShouldGetResponseDescriptorDTOFromResponseDescriptorAccess() {
        //GIVEN in setUp
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(responseDescriptorAccess).getResponseDescriptor(anyString());
    }

    @Test
    public void testGenerateResponseShouldTemplateFormatterDescriptorsFromResponseDescriptorDTO() {
        //GIVEN in setUp
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(responseDescriptorDTO, times(2)).getResponseDescriptor();
        verify(responseDescriptor).getTemplateFormatters();
    }

    @Test
    public void testGenerateResponseShouldTransformWilmaHttpRequestFromHttpServletRequestAndResponseDescriptorDTO() {
        //GIVEN in setUp
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(requestTransformer).transformToWilmaHttpRequest(WILMA_LOGGER_ID, request, responseDescriptorDTO);
    }

    @Test
    public void testGenerateResponseShouldAddWilmaInfoToWilmaHttpRequest() {
        //GIVEN
        String descriptorName = "dialog-descriptor-name";
        given(responseDescriptorDTO.getDialogDescriptorName()).willReturn(descriptorName);
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(headerConfigurer).addWilmaInfoToResponseHeader(request, response, descriptorName);
    }

    @Test
    public void testGenerateResponseShouldReturnTemplateResourceAndSetResponseHeadersWhenTemplateFormatterDescriptorsArrayIsNull() throws InterruptedException {
        //GIVEN
        mockTemplateResource();
        templateFormatterDescriptors = null;
        //WHEN
        byte[] actual = underTest.generateResponse(request, response);
        //THEN
        //verify set response headers
        verify(headerConfigurer).setResponseContentTypeAndStatus(response, responseDescriptorDTO);
        Assert.assertEquals(actual, templateResource);
    }

    @Test
    public void testGenerateResponseShouldReturnTemplateResourceAndSetResponseHeadersWhenNoTemplateFormatterDefined() throws InterruptedException {
        //GIVEN
        mockTemplateResource();
        //WHEN
        byte[] actual = underTest.generateResponse(request, response);
        //THEN
        verify(headerConfigurer).setResponseContentTypeAndStatus(response, responseDescriptorDTO);
        Assert.assertEquals(actual, templateResource);
    }

    @Test
    public void testGenerateResponseShouldReturnTemplateResourceAndSetResponseHeadersWhenTemplateFormatterDefined() throws Exception {
        //GIVEN
        ParameterList params = new ParameterList();
        templateFormatterDescriptors.add(templateFormatterDescriptor);
        mockTemplateResource();
        given(templateFormatterDescriptor.getParams()).willReturn(params);
        given(templateFormatterDescriptor.getTemplateFormatter()).willReturn(templateFormatter);
        given(templateFormatter.formatTemplate(wilmaRequest, response, templateResource, params)).willReturn(templateResource);
        //WHEN
        byte[] actual = underTest.generateResponse(request, response);
        //THEN
        verify(headerConfigurer).setResponseContentTypeAndStatus(response, responseDescriptorDTO);
        Assert.assertEquals(actual, templateResource);
    }

    @Test
    public void testGenerateResponseShouldReturnStackTraceAsResourceAndSetErrorResponseWhenTemplateFormattingFailed() throws Exception {
        //GIVEN
        ParameterList params = new ParameterList();
        templateFormatterDescriptors.add(templateFormatterDescriptor);
        mockTemplateResource();
        given(templateFormatterDescriptor.getTemplateFormatter()).willReturn(templateFormatter);
        given(templateFormatterDescriptor.getParams()).willReturn(params);
        given(templateFormatter.formatTemplate(wilmaRequest, response, templateResource, params)).willThrow(
                new TemplateFormattingFailedException("Template formatting failed....", new TemplateFormattingFailedException("")));
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(stackTraceConverter).getStackTraceAsString(Matchers.any(TemplateFormattingFailedException.class));
        verify(headerConfigurer).setErrorResponseContentTypeAndStatus(response);
    }

    @Test(expectedExceptions = InterruptedException.class)
    public void testGenerateResponseShouldLogErrorWhenWaitProviderFail() throws Exception {
        //GIVEN
        mockTemplateResource();
        doThrow(new InterruptedException()).when(waitProvider).waitMilliSeconds(anyInt());
        //WHEN
        waitProvider.waitMilliSeconds(1);
        //THEN we should not arrive here
        Assert.fail();
    }

    private void mockTemplateResource() {
        ResponseDescriptorAttributes attributes = new ResponseDescriptorAttributes.Builder().delay(0).mimeType(MimeType.HTML.getOfficialMimeType())
                .template(template).build();
        given(responseDescriptor.getAttributes()).willReturn(attributes);
        given(template.getResource()).willReturn(templateResource);
    }

    @Test
    public void testGenerateResponseShouldReturnWithNullWhenNotFindWilmaLoggerIdInRequestHeader() throws Exception {
        //GIVEN
        given(request.getHeader(WilmaHttpRequest.WILMA_LOGGER_ID)).willReturn(null);
        //WHEN
        byte[] result = underTest.generateResponse(request, response);
        //THEN
        Assert.assertNull(result);
    }

    @Test
    public void testWhenActualSequenceIsNullShouldNotWaitForSequenceResponses() throws InterruptedException {
        //GIVEN
        given(wilmaRequest.getHeader(WilmaHttpEntity.WILMA_SEQUENCE_ID)).willReturn("abcd");
        String[] sequenceIds = new String[]{"id"};
        given(headerCreator.resolveSequenceHeader("abcd")).willReturn(sequenceIds);
        given(matcher.matchSequenceKeyWithDescriptor(SEQUENCE_DESCRIPTOR_KEY, sequenceIds)).willReturn(null);
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(sequenceResponseGuard, never()).waitForResponses(wilmaRequest, null);
    }

    @Test
    public void testWhenActualSequenceIsNotNullShouldWaitForSequenceResponses() throws InterruptedException {
        //GIVEN
        WilmaSequence sequence = Mockito.mock(WilmaSequence.class);
        given(wilmaRequest.getHeader(WilmaHttpEntity.WILMA_SEQUENCE_ID)).willReturn("abcd");
        String[] sequenceIds = new String[]{"id"};
        given(headerCreator.resolveSequenceHeader("abcd")).willReturn(sequenceIds);
        given(matcher.matchSequenceKeyWithDescriptor(SEQUENCE_DESCRIPTOR_KEY, sequenceIds)).willReturn(sequence);
        //WHEN
        underTest.generateResponse(request, response);
        //THEN
        verify(sequenceResponseGuard).waitForResponses(wilmaRequest, sequence);
    }
}