ResponseDescriptorParserTest.java

package com.epam.wilma.stubconfig.dom.parser.node;
/*==========================================================================
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 static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.verify;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;

import java.util.LinkedHashSet;
import java.util.Set;

import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

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.template.TemplateFormatter;
import com.epam.wilma.domain.stubconfig.dialog.response.template.TemplateFormatterDescriptor;
import com.epam.wilma.domain.stubconfig.dialog.response.template.TemplateGenerator;
import com.epam.wilma.domain.stubconfig.dialog.response.template.TemplateType;
import com.epam.wilma.domain.stubconfig.parameter.ParameterList;
import com.epam.wilma.sequence.helper.SequenceDescriptorKeyUtil;
import com.epam.wilma.stubconfig.dom.parser.NodeParser;
import com.epam.wilma.stubconfig.dom.parser.node.helper.StubConfigXPathEvaluator;
import com.epam.wilma.domain.stubconfig.exception.DescriptorCannotBeParsedException;
import com.epam.wilma.domain.stubconfig.exception.DescriptorValidationFailedException;
import com.epam.wilma.stubconfig.initializer.template.TemplateFileReader;
import com.epam.wilma.stubconfig.initializer.template.TemplateGeneratorInitializer;

/**
 * Provides unit tests for the class {@link ResponseDescriptorParser}.
 * @author Tunde_Kovacs
 *
 */
public class ResponseDescriptorParserTest {

    @Mock
    private Element responseDescriptorNode;
    @Mock
    private TemplateGeneratorInitializer templateGeneratorInitializer;
    @Mock
    private Element templateElement;
    @Mock
    private Element rootElement;
    @Mock
    private TemplateFileReader templateFileReader;
    @Mock
    private Document document;
    @Mock
    private StubConfigXPathEvaluator xPathEvaluator;
    @Mock
    private SequenceDescriptorKeyUtil sequenceDescriptorKeyUtil;
    @Mock
    private NodeParser<Set<TemplateFormatterDescriptor>> templateDescriptorParser;
    @Mock
    private TemplateGenerator templateGenerator;
    @Mock
    private TemplateFormatter templateFormatter;
    private Set<TemplateFormatterDescriptor> templateFormatterSet;
    private final TemplateFormatterDescriptor templateFormatterDescriptor = new TemplateFormatterDescriptor(templateFormatter, new ParameterList());

    @InjectMocks
    private ResponseDescriptorParser underTest;

    @BeforeMethod
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        templateFormatterSet = new LinkedHashSet<>();
        templateFormatterSet.add(templateFormatterDescriptor);
        given(templateDescriptorParser.parseNode(responseDescriptorNode, document)).willReturn(templateFormatterSet);
        given(responseDescriptorNode.getAttribute("delay")).willReturn("1");
        given(responseDescriptorNode.getAttribute("code")).willReturn("200");
        given(responseDescriptorNode.getAttribute("mimetype")).willReturn(MimeType.TEXT.getOfficialMimeType());
        given(responseDescriptorNode.getAttribute("template")).willReturn("Checker.class");
        given(responseDescriptorNode.getAttribute("sequenceDescriptorName")).willReturn("a-b-c");
        given(document.getDocumentElement()).willReturn(rootElement);
        given(rootElement.getAttribute("groupname")).willReturn("TestGroupname");
        given(xPathEvaluator.getElementByXPath(Mockito.anyString(), Mockito.eq(document))).willReturn(templateElement);
        given(templateElement.getAttribute("type")).willReturn("text");
        given(templateElement.getAttribute("resource")).willReturn("resource");
        given(sequenceDescriptorKeyUtil.createDescriptorKey("TestGroupname", "a-b-c")).willReturn("TestGroupname_a-b-c");
    }

    @Test
    public void testParseNodeShouldReturnResponseDescriptorDelay() {
        //GIVEN in setUp
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getDelay(), 1);
    }

    @Test
    public void testParseNodeShouldReturnResponseDescriptorCode() {
        //GIVEN in setUp
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getCode(), "200");
    }

    @Test
    public void testParseNodeShouldReturnResponseDescriptorMimeType() {
        //GIVEN in setUp
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getMimeType(), MimeType.TEXT.getOfficialMimeType());
    }

    @Test
    public void testParseNodeShouldReturnResponseDescriptorTemplateName() {
        //GIVEN in setUp
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getTemplate().getName(), "Checker.class");
    }

    @Test
    public void testParseNodeShouldReturnSequenceDescriptorNameOfResponseDescriptor() {
        //GIVEN in setUp
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getSequenceDescriptorKey(), "TestGroupname_a-b-c");
    }

    @Test
    public void testParseNodeShouldCallTemplateFileReaderWhenTemplateTypeIsXML() {
        //GIVEN
        given(templateElement.getAttribute("type")).willReturn("xml");
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getTemplate().getType(), TemplateType.XML);
    }

    @Test
    public void testParseNodeShouldCallTemplateFileReaderWhenTemplateTypeIsHTML() {
        //GIVEN
        given(templateElement.getAttribute("type")).willReturn("html");
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getTemplate().getType(), TemplateType.HTML);
    }

    @Test
    public void testParseNodeShouldCallTemplateFileReaderWhenTemplateTypeIsFile() {
        //GIVEN
        given(templateElement.getAttribute("type")).willReturn("xmlfile");
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        verify(templateFileReader).readTemplate(anyString());
        assertEquals(actual.getAttributes().getTemplate().getType(), TemplateType.XMLFILE);
    }

    @Test
    public void testParseNodeShouldCallTemplateGeneratorInitializerWhenTemplateTypeIsExternal() {
        //GIVEN
        given(templateElement.getAttribute("type")).willReturn("external");
        given(templateGeneratorInitializer.getTemplateGenerator(anyString())).willReturn(templateGenerator);
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        verify(templateGenerator).generateTemplate();
        assertEquals(actual.getAttributes().getTemplate().getType(), TemplateType.EXTERNAL);
    }

    @Test(expectedExceptions = DescriptorCannotBeParsedException.class)
    public void testParseNodeShouldShouldThrowSystemExceptionWhenTemplateGenerationFail() {
        //GIVEN
        given(templateElement.getAttribute("type")).willReturn("external");
        given(templateGeneratorInitializer.getTemplateGenerator(anyString())).willReturn(templateGenerator);
        given(templateGenerator.generateTemplate()).willThrow(new DescriptorValidationFailedException(""));
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getTemplate().getType(), TemplateType.EXTERNAL);
    }

    @Test
    public void testParseNodeShouldReturnResponseDescriptorTemplateResource() {
        String resourceString = "resource";
        //GIVEN
        given(templateFileReader.readTemplate(resourceString)).willReturn(resourceString.getBytes());
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertEquals(actual.getAttributes().getTemplate().getResource(), resourceString.getBytes());
    }

    @Test
    public void testParseNodeShouldReturnResponseDescriptorTemplateFormatter() {
        //GIVEN in setUp
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(responseDescriptorNode, document);
        //THEN
        assertTrue(actual.getTemplateFormatters().contains(templateFormatterDescriptor));
    }

    @Test
    public void testParseNodeWhenNodeIsNullShouldReturnNull() {
        //GIVEN in setUp
        //WHEN
        ResponseDescriptor actual = underTest.parseNode(null, document);
        //THEN
        assertNull(actual);
    }
}