templates.repository.DAOImplTest.ftl Maven / Gradle / Ivy
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'>);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy