templates.repository.DAOImplTest.ftl Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of autoplsp Show documentation
Show all versions of autoplsp Show documentation
Maven plugin to generate Java classes from StoredProcedure and Functions in Database
package ${javaPackage}.${repositoryFolderName};
<#assign importList = ["java.sql.SQLException"]>
<#list proc.parameters as parameter>
<#if parameter.object || parameter.array>
<#assign importConnectionUtils = 1>
<#assign importList = importList + ["java.sql.Connection"]>
<#if utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}ConnectionUtil"]>
<#if parameter.date>
<#assign importList = importList + ["java.util.Date"]>
<#list proc.outputParameters as parameter>
<#if parameter.clob>
<#assign importClobUtil = 1>
<#if utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}ClobUtil"]>
<#elseif parameter.blob>
<#assign importBlobUtil = 1>
<#if utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}BlobUtil"]>
<#list proc.arrayImports as parameter>
<#if arrayFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${arrayFolderName}.${parameter.javaTypeName}", "${javaPackage}.${arrayFolderName}.${parameter.javaTypeName}BuilderUtil"]>
<#list proc.parameters as parameter>
<#if parameter.resultSet || parameter.returnResultSet>
<#if cursorFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${cursorFolderName}.${parameter.javaTypeName}"]>
<#if proc.hasInput && domainFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${domainFolderName}.${proc.className}IN", "${javaPackage}.${domainFolderName}.${proc.className}INBuilder"]>
<#if proc.hasOutput && domainFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${domainFolderName}.${proc.className}OUT"]>
<#if !proc.functionInline>
<#assign importList = importList + ["${javaPackage}.${repositoryFolderName}.sp.${proc.className}SP"]>
<#else>
<#assign importList = importList + ["${javaPackage}.${repositoryFolderName}.sp.${proc.className}SqlQuery"]>
<#list proc.objectImports as parameter>
<#if objectFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${objectFolderName}.${parameter.javaTypeName}", "${javaPackage}.${objectFolderName}.${parameter.javaTypeName}BuilderUtil"]>
<#if proc.checkResult && utilFolderName != repositoryFolderName>
<#assign importList = importList + ["${javaPackage}.${utilFolderName}.${prefixUtilityName}CheckResult"]>
<#if proc.hasInput>
<#assign importList = importList + ["org.mockito.ArgumentCaptor", "org.mockito.Captor"]>
<#assign importList = importList + ["org.mockito.InOrder", "org.mockito.Mock", "org.mockito.Mockito"]>
<#if junit == 'junit5'>
<#if proc.hasInput || proc.hasOutput>
<#assign importList = importList + ["org.junit.jupiter.api.Assertions", "org.junit.jupiter.api.BeforeEach"]>
<#assign importList = importList + ["org.junit.jupiter.api.Test", "org.junit.jupiter.api.extension.ExtendWith", "org.mockito.junit.jupiter.MockitoExtension"]>
<#else>
<#if proc.hasInput || proc.hasOutput>
<#assign importList = importList + ["org.junit.Assert", "org.junit.Before"]>
<#assign importList = importList + ["org.junit.Test", "org.junit.runner.RunWith", "org.mockito.runners.MockitoJUnitRunner"]>
<#if proc.hasInput || proc.hasOutput>
<#assign importList = importList + ["com.github.javafaker.Faker"]>
<#list importSort(importList) as import>
<#if previousImportMatch?? && !import?starts_with(previousImportMatch)>
import ${import};
<#assign previousImportMatch = import?keep_before_last(".") >
<#if importList?has_content>
<#if junit == 'junit5'>
@ExtendWith(MockitoExtension.class)
<#else>
@RunWith(MockitoJUnitRunner.class)
@SuppressWarnings({"unchecked"})
class ${proc.className}DAOImplTest {
@Mock
private ${proc.className}<#if !proc.functionInline>SP<#else>SqlQuery <#if proc.function>function<#else>procedureMock;
<#if importConnectionUtils??>
@Mock
private Connection connectionMock;
@Mock
private ${prefixUtilityName}ConnectionUtil connectionUtilMock;
<#if importBlobUtil??>
@Mock
private ${prefixUtilityName}BlobUtil blobUtilMock;
<#if importClobUtil??>
@Mock
private ${prefixUtilityName}ClobUtil clobUtilMock;
<#list proc.arrayImports as parameter>
@Mock
private ${parameter.javaTypeName}BuilderUtil ${parameter.javaTypeFieldName}BuilderUtilMock;
<#list proc.objectImports as parameter>
@Mock
private ${parameter.javaTypeName}BuilderUtil ${parameter.javaTypeFieldName}BuilderUtilMock;
<#if proc.checkResult>
@Mock
private ${prefixUtilityName}CheckResult checkResultMock;
<#if proc.hasInput>
@Captor
private ArgumentCaptor> captorParameters;
<#if proc.hasInput || proc.hasOutput>
private Faker faker;
private ${proc.className}DAO repository;
@<#if junit == 'junit5'>BeforeEach<#else>Before
void setUp() {
<#if proc.hasInput || proc.hasOutput>
faker = new Faker();
repository = new ${proc.className}DAOImpl(${'\n'} <#if proc.function>function<#else>procedureMock<#if importConnectionUtils??>,${'\n'} connectionUtilMock<#if importBlobUtil??>,${'\n'} blobUtilMock<#if importClobUtil??>,${'\n'} clobUtilMock<#list proc.objectImports as parameter>,${'\n'} ${parameter.javaTypeFieldName}BuilderUtilMock<#list proc.arrayImports as parameter>,${'\n'} ${parameter.javaTypeFieldName}BuilderUtilMock<#if proc.checkResult>,${'\n'} checkResultMock${'\n'} );
}
@Test
void should_check_${proc.constantFullName?lower_case}_dao_execute() throws SQLException {
<#if proc.hasInput>
${proc.className}IN params;
<#list proc.inputParameters as parameter>
<#if parameter.date>
${parameter.javaTypeName} ${parameter.fieldName} = faker.date().birthday();
<#elseif parameter.blob>
byte[] ${parameter.fieldName} = new byte[faker.random().nextInt(${parameter.position} * 100)];
<#elseif parameter.number>
${parameter.javaTypeName} ${parameter.fieldName} = faker.random().nextLong();
<#elseif parameter.array || parameter.object>
${parameter.javaTypeName} ${parameter.fieldName} = Mockito.mock(${parameter.javaTypeName}.class);
<#else>
${parameter.javaTypeName} ${parameter.fieldName} = faker.internet().uuid();
params = new ${proc.className}INBuilder()<#list proc.inputParameters as parameter>${'\n'} .${parameter.fieldName}(${parameter.fieldName})${'\n'} .build();
<#if importConnectionUtils??>
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Object[] ${parameter.fieldName}Builder = new Object[0];
java.util.Map mapResult = new java.util.HashMap<<#if !diamond>String, Object>();
<#if proc.hasOutput>
<#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} = faker.random().nextLong();
<#elseif parameter.date>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.date().birthday();
<#else>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.internet().uuid();
<#list proc.outputParameters as parameter>
mapResult.put("${parameter.name}", obj${parameter.propertyName});
<#if importConnectionUtils??>
Mockito.when(connectionUtilMock.process()).thenReturn(connectionMock);
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Mockito.when(${parameter.javaTypeFieldName}BuilderUtilMock.process(Mockito.same(connectionMock), Mockito.same(${parameter.fieldName}))).thenReturn(${parameter.fieldName}Builder);
<#if proc.hasInput || proc.hasOutput>
<#list proc.outputParameters as parameter>
<#if parameter.blob>
Mockito.when(blobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn(new byte[0]);
<#elseif parameter.clob>
Mockito.when(clobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn("${parameter.name}");
Mockito.when(<#if proc.function>function<#else>procedureMock.execute(<#if proc.hasInput>captorParameters.capture()<#else>Mockito.anyMap())).thenReturn(mapResult);
<#if proc.hasInput || proc.hasOutput>
repository.execute(<#if proc.hasInput>params);
InOrder inOrder = Mockito.inOrder(<#if proc.function>function<#else>procedureMock<#if proc.checkResult>, checkResultMock<#if importConnectionUtils??>, connectionUtilMock);
<#if importConnectionUtils??>
inOrder.verify(connectionUtilMock, Mockito.times(1)).process();
inOrder.verify(<#if proc.function>function<#else>procedureMock, Mockito.times(1)).execute(<#if proc.hasInput>captorParameters.capture()<#else>Mockito.anyMap());
<#if importConnectionUtils??>
inOrder.verify(connectionUtilMock, Mockito.times(1)).release(Mockito.same(connectionMock));
<#if proc.checkResult && proc.hasOutput>
inOrder.verify(checkResultMock, Mockito.times(1)).check(Mockito.same(mapResult));
<#if importConnectionUtils??>
Mockito.verify(connectionMock, Mockito.never()).close();
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Mockito.verify(${parameter.javaTypeFieldName}BuilderUtilMock, Mockito.times(1)).process(Mockito.same(connectionMock), Mockito.same(${parameter.fieldName}));
}
<#list proc.inputParameters as parameterTest>
@Test
void should_check_${proc.constantFullName?lower_case}_dao_execute_with_check_input_parameter_${parameterTest.name?lower_case}_value() throws SQLException {
${proc.className}IN params;
<#list proc.inputParameters as parameter>
<#if parameter.date>
${parameter.javaTypeName} ${parameter.fieldName} = faker.date().birthday();
<#elseif parameter.blob>
byte[] ${parameter.fieldName} = new byte[faker.random().nextInt(${parameter.position} * 100)];
<#elseif parameter.number>
${parameter.javaTypeName} ${parameter.fieldName} = faker.random().nextLong();
<#elseif parameter.array || parameter.object>
${parameter.javaTypeName} ${parameter.fieldName} = Mockito.mock(${parameter.javaTypeName}.class);
<#else>
${parameter.javaTypeName} ${parameter.fieldName} = faker.internet().uuid();
params = new ${proc.className}INBuilder()<#list proc.inputParameters as parameter>${'\n'} .${parameter.fieldName}(${parameter.fieldName})${'\n'} .build();
<#if importConnectionUtils??>
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Object[] ${parameter.fieldName}Builder = new Object[0];
java.util.Map mapResult = new java.util.HashMap<<#if !diamond>String, Object>();
<#if proc.hasOutput>
<#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} = faker.random().nextLong();
<#elseif parameter.date>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.date().birthday();
<#else>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.internet().uuid();
<#list proc.outputParameters as parameter>
mapResult.put("${parameter.name}", obj${parameter.propertyName});
<#if importConnectionUtils??>
Mockito.when(connectionUtilMock.process()).thenReturn(connectionMock);
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Mockito.when(${parameter.javaTypeFieldName}BuilderUtilMock.process(Mockito.same(connectionMock), Mockito.same(${parameter.fieldName}))).thenReturn(${parameter.fieldName}Builder);
<#if proc.hasInput || proc.hasOutput>
<#list proc.outputParameters as parameter>
<#if parameter.blob>
Mockito.when(blobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn(new byte[0]);
<#elseif parameter.clob>
Mockito.when(clobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn("${parameter.name}");
Mockito.when(<#if proc.function>function<#else>procedureMock.execute(<#if proc.hasInput>captorParameters.capture()<#else>Mockito.anyMap())).thenReturn(mapResult);
<#if proc.hasInput || proc.hasOutput>
repository.execute(<#if proc.hasInput>params);
java.util.Map mapParamsResult = captorParameters.getValue();
<#if junit == 'junit5'>Assertions<#else>Assert.assertNotNull(mapParamsResult);
<#if parameterTest.object || parameterTest.array>
<#if junit == 'junit5'>Assertions<#else>Assert.assertSame(${parameterTest.fieldName}Builder, mapParamsResult.get("${parameterTest.name}"));
<#elseif parameterTest.date>
<#if junit == 'junit5'>Assertions<#else>Assert.assertEquals(${parameterTest.fieldName}, mapParamsResult.get("${parameterTest.name}"));
<#elseif parameterTest.blob>
<#if junit == 'junit5'>Assertions<#else>Assert.<#if junit == 'junit5'>assertArrayEquals(${parameterTest.fieldName}, (byte[]) mapParamsResult.get("${parameterTest.name}"))<#else>assertTrue(java.util.Arrays.equals(${parameterTest.fieldName}, (byte[])mapParamsResult.get("${parameterTest.name}")));
<#else>
<#if junit == 'junit5'>Assertions<#else>Assert.assertSame(${parameterTest.fieldName}, mapParamsResult.get("${parameterTest.name}"));
}
<#list proc.inputParameters as parameterTest>
@Test
void should_check_${proc.constantFullName?lower_case}_dao_execute_with_check_input_parameter_${parameterTest.name?lower_case}_value_from_build() throws SQLException {
${proc.className}IN params;
<#list proc.inputParameters as parameter>
<#if parameter.date>
${parameter.javaTypeName} ${parameter.fieldName} = faker.date().birthday();
<#elseif parameter.blob>
byte[] ${parameter.fieldName} = new byte[faker.random().nextInt(${parameter.position} * 100)];
<#elseif parameter.number>
${parameter.javaTypeName} ${parameter.fieldName} = faker.random().nextLong();
<#elseif parameter.array || parameter.object>
${parameter.javaTypeName} ${parameter.fieldName} = Mockito.mock(${parameter.javaTypeName}.class);
<#else>
${parameter.javaTypeName} ${parameter.fieldName} = faker.internet().uuid();
params = new ${proc.className}INBuilder()<#list proc.inputParameters as parameter>${'\n'} .${parameter.fieldName}(${parameter.fieldName})${'\n'} .build();
<#if importConnectionUtils??>
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Object[] ${parameter.fieldName}Builder = new Object[0];
java.util.Map mapResult = new java.util.HashMap<<#if !diamond>String, Object>();
<#if proc.hasOutput>
<#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} = faker.random().nextLong();
<#elseif parameter.date>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.date().birthday();
<#else>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.internet().uuid();
<#list proc.outputParameters as parameter>
mapResult.put("${parameter.name}", obj${parameter.propertyName});
<#if importConnectionUtils??>
Mockito.when(connectionUtilMock.process()).thenReturn(connectionMock);
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Mockito.when(${parameter.javaTypeFieldName}BuilderUtilMock.process(Mockito.same(connectionMock), Mockito.same(${parameter.fieldName}))).thenReturn(${parameter.fieldName}Builder);
<#if proc.hasInput || proc.hasOutput>
<#list proc.outputParameters as parameter>
<#if parameter.blob>
Mockito.when(blobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn(new byte[0]);
<#elseif parameter.clob>
Mockito.when(clobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn("${parameter.name}");
Mockito.when(<#if proc.function>function<#else>procedureMock.execute(<#if proc.hasInput>captorParameters.capture()<#else>Mockito.anyMap())).thenReturn(mapResult);
<#if proc.hasInput || proc.hasOutput>
repository.execute(<#if proc.hasInput>params);
java.util.Map mapParamsResult = captorParameters.getValue();
<#if junit == 'junit5'>Assertions<#else>Assert.assertNotNull(mapParamsResult);
<#if parameterTest.object || parameterTest.array>
<#if junit == 'junit5'>Assertions<#else>Assert.assertSame(${parameterTest.fieldName}Builder, mapParamsResult.get("${parameterTest.name}"));
<#elseif parameterTest.date>
<#if junit == 'junit5'>Assertions<#else>Assert.assertEquals(${parameterTest.fieldName}, mapParamsResult.get("${parameterTest.name}"));
<#elseif parameterTest.blob>
<#if junit == 'junit5'>Assertions<#else>Assert.<#if junit == 'junit5'>assertArrayEquals(${parameterTest.fieldName}, (byte[]) mapParamsResult.get("${parameterTest.name}"))<#else>assertTrue(java.util.Arrays.equals(${parameterTest.fieldName}, (byte[])mapParamsResult.get("${parameterTest.name}")));
<#else>
<#if junit == 'junit5'>Assertions<#else>Assert.assertSame(${parameterTest.fieldName}, mapParamsResult.get("${parameterTest.name}"));
}
<#list proc.outputParameters as parameterTest>
@Test
void should_check_${proc.constantFullName?lower_case}_dao_execute_with_output_parameters_check_parameter_${parameterTest.name?lower_case}_value() throws SQLException {
<#if proc.hasInput>
${proc.className}IN params;
<#list proc.inputParameters as parameter>
<#if parameter.date>
${parameter.javaTypeName} ${parameter.fieldName} = faker.date().birthday();
<#elseif parameter.blob>
byte[] ${parameter.fieldName} = new byte[faker.random().nextInt(${parameter.position} * 100)];
<#elseif parameter.number>
${parameter.javaTypeName} ${parameter.fieldName} = faker.random().nextLong();
<#elseif parameter.array || parameter.object>
${parameter.javaTypeName} ${parameter.fieldName} = Mockito.mock(${parameter.javaTypeName}.class);
<#else>
${parameter.javaTypeName} ${parameter.fieldName} = faker.internet().uuid();
params = new ${proc.className}INBuilder()<#list proc.inputParameters as parameter>${'\n'} .${parameter.fieldName}(${parameter.fieldName})${'\n'} .build();
<#if importConnectionUtils??>
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Object[] ${parameter.fieldName}Builder = new Object[0];
java.util.Map mapResult = new java.util.HashMap<<#if !diamond>String, Object>();
<#if proc.hasOutput>
${proc.className}OUT out;
<#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} = faker.random().nextLong();
<#elseif parameter.date>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.date().birthday();
<#else>
${parameter.javaTypeName} obj${parameter.propertyName} = faker.internet().uuid();
<#list proc.outputParameters as parameter>
mapResult.put("${parameter.name}", obj${parameter.propertyName});
<#if importConnectionUtils??>
Mockito.when(connectionUtilMock.process()).thenReturn(connectionMock);
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Mockito.when(${parameter.javaTypeFieldName}BuilderUtilMock.process(Mockito.same(connectionMock), Mockito.same(${parameter.fieldName}))).thenReturn(${parameter.fieldName}Builder);
<#if proc.hasInput || proc.hasOutput>
<#list proc.outputParameters as parameter>
<#if parameter.blob>
Mockito.when(blobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn(new byte[0]);
<#elseif parameter.clob>
Mockito.when(clobUtilMock.process(Mockito.same(obj${parameter.propertyName}))).thenReturn("${parameter.name}");
Mockito.when(<#if proc.function>function<#else>procedureMock.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 junit == 'junit5'>Assertions<#else>Assert.assertNotNull(out);
<#if parameterTest.date>
<#if junit == 'junit5'>Assertions<#else>Assert.assertEquals(obj${parameterTest.propertyName}, out.get${parameterTest.propertyName}());
<#elseif parameterTest.clob>
<#if junit == 'junit5'>Assertions<#else>Assert.assertEquals("${parameterTest.name}", out.get${parameterTest.propertyName}());
<#elseif parameterTest.blob>
<#if junit == 'junit5'>Assertions<#else>Assert.assertNotNull(out.get${parameterTest.propertyName}());
<#else>
<#if junit == 'junit5'>Assertions<#else>Assert.assertSame(obj${parameterTest.propertyName}, out.get${parameterTest.propertyName}());
}
@Test<#if junit != 'junit5'>(expected = SQLException.class)
void should_check_${proc.constantFullName?lower_case}_dao_error()<#if importConnectionUtils?? || junit != 'junit5'> throws SQLException {
<#if proc.hasInput>
${proc.className}IN params = Mockito.mock(${proc.className}IN.class);
<#if importConnectionUtils??>
Mockito.when(connectionUtilMock.process()).thenReturn(connectionMock);
<#list proc.inputParameters as parameter>
<#if parameter.object || parameter.array>
Mockito.when(${parameter.javaTypeFieldName}BuilderUtilMock.process(Mockito.same(connectionMock), Mockito.any(${parameter.javaTypeName}.class))).thenReturn(null);
Mockito.when(<#if proc.function>function<#else>procedureMock.execute(Mockito.anyMap())).thenThrow(new RuntimeException());
<#if junit == 'junit5'>Assertions.assertThrows(SQLException.class,() -> repository.execute(<#if proc.hasInput>params)<#if junit == 'junit5'>);
}
<#if proc.hasInput>
@Test<#if junit != 'junit5'>(expected = SQLException.class)
void should_check_${proc.constantFullName?lower_case}_dao_input_null_parameter_error()<#if importConnectionUtils?? || junit != 'junit5'> throws SQLException {
${proc.className}IN params = null;
<#if importConnectionUtils??>
Mockito.when(connectionUtilMock.process()).thenReturn(connectionMock);
<#if junit == 'junit5'>Assertions.assertThrows(SQLException.class,() -> repository.execute(params)<#if junit == 'junit5'>);
}
}