templates.repository.DAOTest.ftl Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of autoplsp Show documentation
Maven plugin to generate Java classes from StoredProcedure and Functions in Database
There is a newer version: 1.8.20
package ${javaPackage}.repository;
<#list proc.parameters as parameter>
<#if parameter.object || parameter.array>
<#assign importConnectionUtils = 1>

<#if parameter.object>
<#assign importObjectUtil = 1>

<#if parameter.date>
<#assign importDate = 1>


<#list proc.outputParameters as parameter>
<#if parameter.clob>
<#assign importClobUtil = 1>
<#elseif parameter.blob>
<#assign importBlobUtil = 1>



<#if importConnectionUtils??>
import java.sql.Connection;


<#list proc.arrayImports as parameter>
import ${javaPackage}.array.${parameter.javaTypeName};
import ${javaPackage}.array.${parameter.javaTypeName}Builder;

<#list proc.parameters as parameter>
<#if parameter.resultSet || parameter.returnResultSet>
import ${javaPackage}.domain.${parameter.javaTypeName};


<#if proc.hasInput>
import ${javaPackage}.domain.${proc.className}IN;

<#if proc.hasOutput>
import ${javaPackage}.domain.${proc.className}OUT;

<#if !proc.functionInline>
import ${javaPackage}.repository.sp.${proc.className}SP;
<#else>
import ${javaPackage}.repository.sp.${proc.className}SqlQuery;

<#list proc.objectImports as parameter>
import ${javaPackage}.object.${parameter.javaTypeName};
import ${javaPackage}.object.${parameter.javaTypeName}Builder;

<#if importBlobUtil??>
import ${javaPackage}.util.BlobUtil;

<#if proc.checkResult>
import ${javaPackage}.util.CheckResult;

<#if importClobUtil??>
import ${javaPackage}.util.ClobUtil;

<#if importConnectionUtils??>
import ${javaPackage}.util.ConnectionUtil;


<#if importDate??>
import java.util.Date;


<#if proc.hasInput || proc.hasOutput>
import org.junit.Assert;

import org.junit.Test;
import org.junit.runner.RunWith;
<#if proc.hasInput>
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;

import org.mockito.InOrder;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
@SuppressWarnings({"unchecked"})
public class ${proc.className}DAOTest {

    @InjectMocks
    ${proc.className}DAOImpl repository;
<#if importBlobUtil??>

    @Mock
    private BlobUtil blobUtil;

<#if proc.checkResult>

    @Mock
    private CheckResult checkResult;

<#if importClobUtil??>

    @Mock
    private ClobUtil clobUtil;

<#if importConnectionUtils??>

    @Mock
    private Connection connection;

    @Mock
    private ConnectionUtil connectionUtil;
<#list proc.arrayImports as parameter>

    @Mock
    private ${parameter.javaTypeName}Builder ${parameter.javaTypeFieldName}Builder;

<#list proc.objectImports as parameter>

    @Mock
    private ${parameter.javaTypeName}Builder ${parameter.javaTypeFieldName}Builder;



    @Mock(name = "${proc.className}<#if !proc.functionInline>SP<#else>SqlQuery")
    private ${proc.className}<#if !proc.functionInline>SP<#else>SqlQuery <#if proc.function>function<#else>procedure;
<#if proc.hasInput>

    @Captor
    private ArgumentCaptor> captorParameters;


    @Test
    public void test${proc.className}DAOExecute() throws java.sql.SQLException {
<#if proc.hasInput>

        ${proc.className}IN params = new ${proc.className}IN();

<#list proc.inputParameters as parameter>
<#if parameter.date>
        ${parameter.javaTypeName} ${parameter.fieldName} = new ${parameter.javaTypeName}(${parameter.position});
<#elseif parameter.blob>
        byte[] ${parameter.fieldName} = new byte[0];
<#elseif parameter.number>
        ${parameter.javaTypeName} ${parameter.fieldName} = ${parameter.position};
<#elseif parameter.array || parameter.object>
        ${parameter.javaTypeName} ${parameter.fieldName} = new ${parameter.javaTypeName}();
<#else>
        ${parameter.javaTypeName} ${parameter.fieldName} = "${parameter.name}";



<#list proc.inputParameters as parameter>
        params.set${parameter.propertyName}(${parameter.fieldName});

<#if importConnectionUtils??>

<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
        Object[] ${parameter.fieldName}Builder = new Object[0];





<#if proc.hasOutput>
        ${proc.className}OUT out;

        java.util.Map mapResult = new java.util.HashMap<<#if !diamond>String, Object>();

<#list proc.outputParameters as parameter>
<#if parameter.resultSet || parameter.returnResultSet>
        java.util.List<${parameter.javaTypeName}> obj${parameter.propertyName} = new java.util.ArrayList<<#if !diamond>${parameter.javaTypeName}>();
<#elseif parameter.clob>
        java.sql.Clob obj${parameter.propertyName} = Mockito.mock(java.sql.Clob.class);
<#elseif parameter.blob>
        java.sql.Blob obj${parameter.propertyName} = Mockito.mock(java.sql.Blob.class);
<#elseif parameter.number>
        ${parameter.javaTypeName} obj${parameter.propertyName} = ${parameter.position};
<#elseif parameter.date>
        ${parameter.javaTypeName} obj${parameter.propertyName} = new ${parameter.javaTypeName}(${parameter.javaTypeName});
<#else>
        ${parameter.javaTypeName} obj${parameter.propertyName} = "${parameter.name}";



<#list proc.outputParameters as parameter>
        mapResult.put("${parameter.name}", obj${parameter.propertyName});



<#if importConnectionUtils??>
        Mockito.when(connectionUtil.process()).thenReturn(connection);
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
        Mockito.when(${parameter.javaTypeFieldName}Builder.process(Mockito.same(connection), Mockito.same(${parameter.fieldName}))).thenReturn(${parameter.fieldName}Builder);



<#if proc.hasOutput>

<#list proc.outputParameters as parameter>
<#if parameter.blob>
        Mockito.when(blobUtil.process(Mockito.same(obj${parameter.propertyName}))).thenReturn(new byte[0]);
<#elseif parameter.clob>
        Mockito.when(clobUtil.process(Mockito.same(obj${parameter.propertyName}))).thenReturn("${parameter.name}");


        Mockito.when(<#if proc.function>function<#else>procedure.execute(<#if proc.hasInput>captorParameters.capture()<#else>Mockito.anyMap())).thenReturn(mapResult);

<#if proc.hasInput || proc.hasOutput>


        <#if proc.hasOutput>out = repository.execute(<#if proc.hasInput>params);
<#if proc.hasOutput>

        Assert.assertNotNull(out);

<#list proc.outputParameters as parameter>
<#if parameter.date>
        Assert.assertEquals(obj${parameter.propertyName}, out.get${parameter.propertyName}());
<#elseif parameter.clob>
        Assert.assertEquals("${parameter.name}", out.get${parameter.propertyName}());
<#elseif parameter.blob>
        Assert.assertNotNull(out.get${parameter.propertyName}());
<#else>
        Assert.assertSame(obj${parameter.propertyName}, out.get${parameter.propertyName}());




        InOrder inOrder = Mockito.inOrder(<#if proc.function>function<#else>procedure<#if proc.checkResult>, checkResult<#if importConnectionUtils??>, connectionUtil);

<#if importConnectionUtils??>
        inOrder.verify(connectionUtil, Mockito.times(1)).process();

        inOrder.verify(<#if proc.function>function<#else>procedure, Mockito.times(1)).execute(<#if proc.hasInput>captorParameters.capture()<#else>Mockito.anyMap());
<#if importConnectionUtils??>
        inOrder.verify(connectionUtil, Mockito.times(1)).release(Mockito.same(connection));

<#if proc.checkResult>
        inOrder.verify(checkResult, Mockito.times(1)).check(<#if proc.hasOutput>Mockito.same(mapResult));

<#if importConnectionUtils??>

<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
        Mockito.verify(${parameter.javaTypeFieldName}Builder, Mockito.times(1)).process(Mockito.same(connection), Mockito.same(${parameter.fieldName}));



<#if proc.hasInput>

        java.util.Map mapParamsResult = captorParameters.getValue();

        Assert.assertNotNull(mapParamsResult);

<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
        Assert.assertSame(${parameter.fieldName}Builder, mapParamsResult.get("${parameter.name}"));
<#elseif parameter.date>
        Assert.assertEquals(${parameter.fieldName}, mapParamsResult.get("${parameter.name}"));
<#else>
        Assert.assertSame(${parameter.fieldName}, mapParamsResult.get("${parameter.name}"));



    }

    @Test(expected = java.sql.SQLException.class)
    public void testExecute${proc.className}DAOError() throws java.sql.SQLException {
<#if proc.hasInput>
        ${proc.className}IN params = new ${proc.className}IN();

<#list proc.inputParameters as parameter>
        params.set${parameter.propertyName}(null);



<#if importConnectionUtils??>
        Mockito.when(connectionUtil.process()).thenReturn(connection);

<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
        Mockito.when(${parameter.javaTypeFieldName}Builder.process(Mockito.same(connection), Mockito.any(${parameter.javaTypeName}.class))).thenReturn(null);


        Mockito.when(<#if proc.function>function<#else>procedure.execute(Mockito.anyMap())).thenThrow(new RuntimeException());

        repository.execute(<#if proc.hasInput>params);
    }
<#if proc.hasInput>

    @Test(expected = java.sql.SQLException.class)
    public void testExecute${proc.className}DAOInputNullParameterError() throws java.sql.SQLException {
        ${proc.className}IN params = null;
<#if importConnectionUtils??>

        Mockito.when(connectionUtil.process()).thenReturn(connection);


        repository.execute(params);
    }

}