package org.apache.ibatis.session;
import domain.blog.*;
import domain.blog.mappers.AuthorMapper;
import domain.blog.mappers.AuthorMapperWithMultipleHandlers;
import domain.blog.mappers.AuthorMapperWithRowBounds;
import domain.blog.mappers.BlogMapper;
import org.apache.ibatis.BaseDataTest;
import org.apache.ibatis.binding.BindingException;
import org.apache.ibatis.cache.impl.PerpetualCache;
import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.executor.result.DefaultResultHandler;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.defaults.DefaultSqlSessionFactory;
import static org.junit.Assert.*;
import org.junit.BeforeClass;
import org.junit.Test;
import java.io.Reader;
import java.util.*;
public class SqlSessionTest extends BaseDataTest {
private static SqlSessionFactory sqlMapper;
@BeforeClass
public static void setup() throws Exception {
createBlogDataSource();
final String resource = "org/apache/ibatis/builder/MapperConfig.xml";
final Reader reader = Resources.getResourceAsReader(resource);
sqlMapper = new SqlSessionFactoryBuilder().build(reader);
}
@Test
public void shouldResolveBothSimpleNameAndFullyQualifiedName() {
Configuration c = new Configuration();
final String fullName = "com.mycache.MyCache";
final String shortName = "MyCache";
final PerpetualCache cache = new PerpetualCache(fullName);
c.addCache(cache);
assertEquals(cache, c.getCache(fullName));
assertEquals(cache, c.getCache(shortName));
}
@Test(expected=IllegalArgumentException.class)
public void shouldFailOverToMostApplicableSimpleName() {
Configuration c = new Configuration();
final String fullName = "com.mycache.MyCache";
final String invalidName = "unknown.namespace.MyCache";
final PerpetualCache cache = new PerpetualCache(fullName);
c.addCache(cache);
assertEquals(cache, c.getCache(fullName));
assertEquals(cache, c.getCache(invalidName));
}
@Test
public void shouldSucceedWhenFullyQualifiedButFailDueToAmbiguity() {
Configuration c = new Configuration();
final String name1 = "com.mycache.MyCache";
final PerpetualCache cache1 = new PerpetualCache(name1);
c.addCache(cache1);
final String name2 = "com.other.MyCache";
final PerpetualCache cache2 = new PerpetualCache(name2);
c.addCache(cache2);
final String shortName = "MyCache";
assertEquals(cache1, c.getCache(name1));
assertEquals(cache2, c.getCache(name2));
try {
c.getCache(shortName);
fail("Exception expected.");
} catch (Exception e) {
assertTrue(e.getMessage().contains("ambiguous"));
}
}
@Test
public void shouldFailToAddDueToNameConflict() {
Configuration c = new Configuration();
final String fullName = "com.mycache.MyCache";
final PerpetualCache cache = new PerpetualCache(fullName);
try {
c.addCache(cache);
c.addCache(cache);
fail("Exception expected.");
} catch (Exception e) {
assertTrue(e.getMessage().contains("already contains value"));
}
}
@Test
public void shouldSelectAllAuthors() throws Exception {
SqlSession session = sqlMapper.openSession(TransactionIsolationLevel.SERIALIZABLE);
try {
List<Author> authors = session.selectList("domain.blog.mappers.AuthorMapper.selectAllAuthors");
assertEquals(2, authors.size());
} finally {
session.close();
}
}
@Test
public void shouldSelectAllAuthorsAsMap() throws Exception {
SqlSession session = sqlMapper.openSession(TransactionIsolationLevel.SERIALIZABLE);
try {
final Map<Integer,Author> authors = session.selectMap("domain.blog.mappers.AuthorMapper.selectAllAuthors", "id");
assertEquals(2, authors.size());
for(Map.Entry<Integer,Author> authorEntry : authors.entrySet()) {
assertEquals(authorEntry.getKey(), (Integer) authorEntry.getValue().getId());
}
} finally {
session.close();
}
}
@Test
public void shouldSelectCountOfPosts() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Integer count = (Integer) session.selectOne("domain.blog.mappers.BlogMapper.selectCountOfPosts");
assertEquals(5, count.intValue());
} finally {
session.close();
}
}
@Test
public void shouldEnsureThatBothEarlyAndLateResolutionOfNesteDiscriminatorsResolesToUseNestedResultSetHandler() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Configuration configuration = sqlMapper.getConfiguration();
assertTrue(configuration.getResultMap("domain.blog.mappers.BlogMapper.earlyNestedDiscriminatorPost").hasNestedResultMaps());
assertTrue(configuration.getResultMap("domain.blog.mappers.BlogMapper.lateNestedDiscriminatorPost").hasNestedResultMaps());
} finally {
session.close();
}
}
@Test
public void shouldSelectOneAuthor() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Author author = (Author) session.selectOne(
"domain.blog.mappers.AuthorMapper.selectAuthor", new Author(101));
assertEquals(101, author.getId());
assertEquals(Section.NEWS, author.getFavouriteSection());
} finally {
session.close();
}
}
@Test
public void shouldSelectOneAuthorAsList() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Author> authors = session.selectList(
"domain.blog.mappers.AuthorMapper.selectAuthor", new Author(101));
assertEquals(101, authors.get(0).getId());
assertEquals(Section.NEWS, authors.get(0).getFavouriteSection());
} finally {
session.close();
}
}
@Test
public void shouldSelectOneImmutableAuthor() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
ImmutableAuthor author = (ImmutableAuthor) session.selectOne(
"domain.blog.mappers.AuthorMapper.selectImmutableAuthor", new Author(101));
assertEquals(101, author.getId());
assertEquals(Section.NEWS, author.getFavouriteSection());
} finally {
session.close();
}
}
@Test
public void shouldSelectOneAuthorWithInlineParams() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Author author = (Author) session.selectOne(
"domain.blog.mappers.AuthorMapper.selectAuthorWithInlineParams", new Author(101));
assertEquals(101, author.getId());
} finally {
session.close();
}
}
@Test
public void shouldInsertAuthor() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Author expected = new Author(500, "cbegin", "******", "cbegin@somewhere.com", "Something...", null);
session.insert("domain.blog.mappers.AuthorMapper.insertAuthor", expected);
Author actual = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", new Author(500));
assertNotNull(actual);
assertEquals(expected.getId(), actual.getId());
assertEquals(expected.getUsername(), actual.getUsername());
assertEquals(expected.getPassword(), actual.getPassword());
assertEquals(expected.getEmail(), actual.getEmail());
assertEquals(expected.getBio(), actual.getBio());
} finally {
session.close();
}
}
@Test
public void shouldUpdateAuthorImplicitRollback() throws Exception {
SqlSession session = sqlMapper.openSession();
Author original;
Author updated;
try {
original = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
original.setEmail("new@email.com");
session.update("domain.blog.mappers.AuthorMapper.updateAuthor", original);
updated = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
assertEquals(original.getEmail(), updated.getEmail());
} finally {
session.close();
}
try {
session = sqlMapper.openSession();
updated = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
assertEquals("jim@ibatis.apache.org", updated.getEmail());
} finally {
session.close();
}
}
@Test
public void shouldUpdateAuthorCommit() throws Exception {
SqlSession session = sqlMapper.openSession();
Author original;
Author updated;
try {
original = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
original.setEmail("new@email.com");
session.update("domain.blog.mappers.AuthorMapper.updateAuthor", original);
updated = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
assertEquals(original.getEmail(), updated.getEmail());
session.commit();
} finally {
session.close();
}
try {
session = sqlMapper.openSession();
updated = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
assertEquals(original.getEmail(), updated.getEmail());
} finally {
session.close();
}
}
@Test
public void shouldUpdateAuthorIfNecessary() throws Exception {
SqlSession session = sqlMapper.openSession();
Author original;
Author updated;
try {
original = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
original.setEmail("new@email.com");
original.setBio(null);
session.update("domain.blog.mappers.AuthorMapper.updateAuthorIfNecessary", original);
updated = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
assertEquals(original.getEmail(), updated.getEmail());
session.commit();
} finally {
session.close();
}
try {
session = sqlMapper.openSession();
updated = (Author) session.selectOne("domain.blog.mappers.AuthorMapper.selectAuthor", 101);
assertEquals(original.getEmail(), updated.getEmail());
} finally {
session.close();
}
}
@Test
public void shouldDeleteAuthor() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
final int id = 102;
List<Author> authors = session.selectList("domain.blog.mappers.AuthorMapper.selectAuthor", id);
assertEquals(1, authors.size());
session.delete("domain.blog.mappers.AuthorMapper.deleteAuthor", id);
authors = session.selectList("domain.blog.mappers.AuthorMapper.selectAuthor", id);
assertEquals(0, authors.size());
session.rollback();
authors = session.selectList("domain.blog.mappers.AuthorMapper.selectAuthor", id);
assertEquals(1, authors.size());
} finally {
session.close();
}
}
@Test
public void shouldSelectBlogWithPostsAndAuthorUsingSubSelects() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Blog blog = (Blog) session.selectOne("domain.blog.mappers.BlogMapper.selectBlogWithPostsUsingSubSelect", 1);
assertEquals("Jim Business", blog.getTitle());
assertEquals(2, blog.getPosts().size());
assertEquals("Corn nuts", blog.getPosts().get(0).getSubject());
assertEquals(101, blog.getAuthor().getId());
assertEquals("jim", blog.getAuthor().getUsername());
} finally {
session.close();
}
}
@Test
public void shouldSelectBlogWithPostsAndAuthorUsingJoin() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Blog blog = (Blog) session.selectOne("domain.blog.mappers.BlogMapper.selectBlogJoinedWithPostsAndAuthor", 1);
assertEquals("Jim Business", blog.getTitle());
final Author author = blog.getAuthor();
assertEquals(101, author.getId());
assertEquals("jim", author.getUsername());
final List<Post> posts = blog.getPosts();
assertEquals(2, posts.size());
final Post post = blog.getPosts().get(0);
assertEquals(1, post.getId());
assertEquals("Corn nuts", post.getSubject());
final List<Comment> comments = post.getComments();
assertEquals(2, comments.size());
final List<Tag> tags = post.getTags();
assertEquals(3, tags.size());
final Comment comment = comments.get(0);
assertEquals(1, comment.getId());
assertEquals(DraftPost.class, blog.getPosts().get(0).getClass());
assertEquals(Post.class, blog.getPosts().get(1).getClass());
} finally {
session.close();
}
}
@Test
public void shouldSelectNestedBlogWithPostsAndAuthorUsingJoin() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
Blog blog = (Blog) session.selectOne("domain.blog.mappers.NestedBlogMapper.selectBlogJoinedWithPostsAndAuthor", 1);
assertEquals("Jim Business", blog.getTitle());
final Author author = blog.getAuthor();
assertEquals(101, author.getId());
assertEquals("jim", author.getUsername());
final List<Post> posts = blog.getPosts();
assertEquals(2, posts.size());
final Post post = blog.getPosts().get(0);
assertEquals(1, post.getId());
assertEquals("Corn nuts", post.getSubject());
final List<Comment> comments = post.getComments();
assertEquals(2, comments.size());
final List<Tag> tags = post.getTags();
assertEquals(3, tags.size());
final Comment comment = comments.get(0);
assertEquals(1, comment.getId());
assertEquals(DraftPost.class, blog.getPosts().get(0).getClass());
assertEquals(Post.class, blog.getPosts().get(1).getClass());
} finally {
session.close();
}
}
@Test
public void shouldThrowExceptionIfMappedStatementDoesNotExist() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
session.selectList("ThisStatementDoesNotExist");
fail("Expected exception to be thrown due to statement that does not exist.");
} catch (Exception e) {
assertTrue(e.getMessage().contains("does not contain value for ThisStatementDoesNotExist"));
} finally {
session.close();
}
}
@Test
public void shouldThrowExceptionIfTryingToAddStatementWithSameName() throws Exception {
Configuration config = sqlMapper.getConfiguration();
try {
config.addMappedStatement(config.getMappedStatement("domain.blog.mappers.BlogMapper.selectBlogWithPostsUsingSubSelect"));
fail("Expected exception to be thrown due to statement that already exists.");
} catch (Exception e) {
assertTrue(e.getMessage().contains("already contains value for domain.blog.mappers.BlogMapper.selectBlogWithPostsUsingSubSelect"));
}
}
@Test
public void shouldCacheAllAuthors() throws Exception {
int first = -1;
int second = -1;
SqlSession session = sqlMapper.openSession();
try {
List<Author> authors = session.selectList("com.domain.CachedAuthorMapper.selectAllAuthors");
first = System.identityHashCode(authors);
session.commit(); // commit should not be required for read/only activity.
} finally {
session.close();
}
session = sqlMapper.openSession();
try {
List<Author> authors = session.selectList("com.domain.CachedAuthorMapper.selectAllAuthors");
second = System.identityHashCode(authors);
} finally {
session.close();
}
assertEquals(first, second);
}
@Test
public void shouldNotCacheAllAuthors() throws Exception {
int first = -1;
int second = -1;
SqlSession session = sqlMapper.openSession();
try {
List<Author> authors = session.selectList("domain.blog.mappers.AuthorMapper.selectAllAuthors");
first = System.identityHashCode(authors);
} finally {
session.close();
}
session = sqlMapper.openSession();
try {
List<Author> authors = session.selectList("domain.blog.mappers.AuthorMapper.selectAllAuthors");
second = System.identityHashCode(authors);
} finally {
session.close();
}
assertTrue(first != second);
}
@Test
public void shouldSelectAuthorsUsingMapperClass() {
SqlSession session = sqlMapper.openSession();
try {
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
List authors = mapper.selectAllAuthors();
assertEquals(2, authors.size());
} finally {
session.close();
}
}
@Test
public void shouldExecuteSelectOneAuthorUsingMapperClass() {
SqlSession session = sqlMapper.openSession();
try {
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
Author author = mapper.selectAuthor(101);
assertEquals(101, author.getId());
} finally {
session.close();
}
}
@Test
public void shouldExecuteSelectOneAuthorUsingMapperClassWithResultHandler() {
SqlSession session = sqlMapper.openSession();
try {
DefaultResultHandler handler = new DefaultResultHandler();
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
mapper.selectAuthor(101, handler);
Author author = (Author) handler.getResultList().get(0);
assertEquals(101, author.getId());
} finally {
session.close();
}
}
@Test
public void shouldSelectAuthorsUsingMapperClassWithResultHandler() {
SqlSession session = sqlMapper.openSession();
try {
DefaultResultHandler handler = new DefaultResultHandler();
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
mapper.selectAllAuthors(handler);
assertEquals(2, handler.getResultList().size());
} finally {
session.close();
}
}
@Test(expected = BindingException.class)
public void shouldFailSelectOneAuthorUsingMapperClassWithTwoResultHandlers() {
Configuration configuration = new Configuration(sqlMapper.getConfiguration().getEnvironment());
configuration.addMapper(AuthorMapperWithMultipleHandlers.class);
SqlSessionFactory sqlMapperWithMultipleHandlers = new DefaultSqlSessionFactory(configuration);
SqlSession sqlSession = sqlMapperWithMultipleHandlers.openSession();
try {
DefaultResultHandler handler1 = new DefaultResultHandler();
DefaultResultHandler handler2 = new DefaultResultHandler();
AuthorMapperWithMultipleHandlers mapper = sqlSession.getMapper(AuthorMapperWithMultipleHandlers.class);
mapper.selectAuthor(101, handler1, handler2);
} finally {
sqlSession.close();
}
}
@Test(expected = BindingException.class)
public void shouldFailSelectOneAuthorUsingMapperClassWithTwoRowBounds() {
Configuration configuration = new Configuration(sqlMapper.getConfiguration().getEnvironment());
configuration.addMapper(AuthorMapperWithRowBounds.class);
SqlSessionFactory sqlMapperWithMultipleHandlers = new DefaultSqlSessionFactory(configuration);
SqlSession sqlSession = sqlMapperWithMultipleHandlers.openSession();
try {
RowBounds bounds1 = new RowBounds(0, 1);
RowBounds bounds2 = new RowBounds(0, 1);
AuthorMapperWithRowBounds mapper = sqlSession.getMapper(AuthorMapperWithRowBounds.class);
mapper.selectAuthor(101, bounds1, bounds2);
} finally {
sqlSession.close();
}
}
@Test
public void shouldInsertAuthorUsingMapperClass() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
Author expected = new Author(500, "cbegin", "******", "cbegin@somewhere.com", "Something...", null);
mapper.insertAuthor(expected);
Author actual = mapper.selectAuthor(500);
assertNotNull(actual);
assertEquals(expected.getId(), actual.getId());
assertEquals(expected.getUsername(), actual.getUsername());
assertEquals(expected.getPassword(), actual.getPassword());
assertEquals(expected.getEmail(), actual.getEmail());
assertEquals(expected.getBio(), actual.getBio());
} finally {
session.close();
}
}
@Test
public void shouldDeleteAuthorUsingMapperClass() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
int count = mapper.deleteAuthor(101);
assertEquals(1, count);
assertNull(mapper.selectAuthor(101));
} finally {
session.close();
}
}
@Test
public void shouldUpdateAuthorUsingMapperClass() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
AuthorMapper mapper = session.getMapper(AuthorMapper.class);
Author expected = mapper.selectAuthor(101);
expected.setUsername("NewUsername");
int count = mapper.updateAuthor(expected);
assertEquals(1, count);
Author actual = mapper.selectAuthor(101);
assertEquals(expected.getUsername(), actual.getUsername());
} finally {
session.close();
}
}
@Test
public void shouldSelectAllPostsUsingMapperClass() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
BlogMapper mapper = session.getMapper(BlogMapper.class);
List<Map> posts = mapper.selectAllPosts();
assertEquals(5, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldLimitResultsUsingMapperClass() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
BlogMapper mapper = session.getMapper(BlogMapper.class);
List<Map> posts = mapper.selectAllPosts(new RowBounds(0, 2), null);
assertEquals(2, posts.size());
assertEquals(1, posts.get(0).get("ID"));
assertEquals(2, posts.get(1).get("ID"));
} finally {
session.close();
}
}
private static class TestResultHandler implements ResultHandler {
int count = 0;
public void handleResult(ResultContext context) {
count++;
}
}
@Test
public void shouldHandleZeroParameters() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
final TestResultHandler resultHandler = new TestResultHandler();
session.select("domain.blog.mappers.BlogMapper.selectAllPosts", resultHandler);
assertEquals(5, resultHandler.count);
} finally {
session.close();
}
}
private static class TestResultStopHandler implements ResultHandler {
int count = 0;
public void handleResult(ResultContext context) {
count++;
if (count == 2) context.stop();
}
}
@Test
public void shouldStopResultHandler() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
final TestResultStopHandler resultHandler = new TestResultStopHandler();
session.select("domain.blog.mappers.BlogMapper.selectAllPosts", null, resultHandler);
assertEquals(2, resultHandler.count);
} finally {
session.close();
}
}
@Test
public void shouldOffsetAndLimitResultsUsingMapperClass() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
BlogMapper mapper = session.getMapper(BlogMapper.class);
List<Map> posts = mapper.selectAllPosts(new RowBounds(2, 3));
assertEquals(3, posts.size());
assertEquals(3, posts.get(0).get("ID"));
assertEquals(4, posts.get(1).get("ID"));
assertEquals(5, posts.get(2).get("ID"));
} finally {
session.close();
}
}
@Test
public void shouldFindPostsAllPostsWithDynamicSql() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.findPost");
assertEquals(5, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldFindPostByIDWithDynamicSql() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.findPost",
new HashMap() {{
put("id", 1);
}});
assertEquals(1, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldFindPostsInSetOfIDsWithDynamicSql() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.findPost",
new HashMap() {{
put("ids", new ArrayList() {{
add(1);
add(2);
add(3);
}});
}});
assertEquals(3, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldFindPostsWithBlogIdUsingDynamicSql() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.findPost",
new HashMap() {{
put("blog_id", 1);
}});
assertEquals(2, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldFindPostsWithAuthorIdUsingDynamicSql() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.findPost",
new HashMap() {{
put("author_id", 101);
}});
assertEquals(3, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldFindPostsWithAuthorAndBlogIdUsingDynamicSql() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.findPost",
new HashMap() {{
put("ids", new ArrayList() {{
add(1);
add(2);
add(3);
}});
put("blog_id", 1);
}});
assertEquals(2, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldFindPostsInList() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.selectPostIn",
new ArrayList() {{
add(1);
add(3);
add(5);
}});
assertEquals(3, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldFindOddPostsInList() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.selectOddPostsIn",
new ArrayList() {{
add(1);
add(2);
add(3);
add(4);
add(5);
}});
assertEquals(3, posts.size());
} finally {
session.close();
}
}
@Test
public void shouldSelectOddPostsInKeysList() throws Exception {
SqlSession session = sqlMapper.openSession();
try {
List<Post> posts = session.selectList("domain.blog.mappers.PostMapper.selectOddPostsInKeysList",
new HashMap() {{put("keys",new ArrayList() {{
add(1);
add(2);
add(3);
add(4);
add(5);
}});
}});
assertEquals(3, posts.size());
} finally {
session.close();
}
}
}