Skip to content

Commit 3cb3946

Browse files
AlexP11223AlexP11223
committed
tests
1 parent 7724c3a commit 3cb3946

5 files changed

Lines changed: 227 additions & 5 deletions

File tree

‎src/main/java/alexp/blog/model/Role.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
package alexp.blog.model;
22

33
import javax.persistence.*;
4+
import java.util.ArrayList;
45
import java.util.Collection;
56

67
@Entity
@@ -14,7 +15,7 @@ public class Role {
1415
private String name;
1516

1617
@ManyToMany(mappedBy = "roles")
17-
private Collection<User> users;
18+
private Collection<User> users = new ArrayList<>();;
1819

1920
public Long getId() {
2021
return Id;

‎src/main/java/alexp/blog/model/User.java‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55

66
import javax.persistence.*;
77
import javax.validation.constraints.Size;
8+
import java.util.ArrayList;
89
import java.util.Collection;
910
import java.util.List;
1011

@@ -45,10 +46,10 @@ public class User {
4546
@JoinTable(name = "users_roles",
4647
joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id"),
4748
inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "id"))
48-
private Collection<Role> roles;
49+
private Collection<Role> roles = new ArrayList<>();
4950

5051
@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, mappedBy = "user")
51-
public List<Comment> comments;
52+
public List<Comment> comments = new ArrayList<>();;
5253

5354
public Long getId() {
5455
return Id;

‎src/test/java/alexp/blog/service/CommentServiceTest.java‎

Lines changed: 79 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,79 @@
1+
package alexp.blog.service;
2+
3+
import alexp.blog.model.Comment;
4+
import alexp.blog.model.Post;
5+
import alexp.blog.model.User;
6+
import alexp.blog.repository.CommentRepository;
7+
import org.junit.Before;
8+
import org.junit.Test;
9+
import org.mockito.*;
10+
11+
import java.util.Arrays;
12+
import java.util.List;
13+
14+
import static org.junit.Assert.*;
15+
16+
import static org.hamcrest.CoreMatchers.*;
17+
import static org.hamcrest.MatcherAssert.assertThat;
18+
import static org.mockito.Mockito.times;
19+
import static org.mockito.Mockito.verify;
20+
import static org.mockito.Mockito.when;
21+
22+
23+
public class CommentServiceTest {
24+
25+
@Mock
26+
private UserService userService;
27+
28+
@Mock
29+
private CommentRepository commentRepository;
30+
31+
@InjectMocks
32+
private CommentServiceImpl commentService;
33+
34+
@Spy
35+
private Post post;
36+
37+
38+
@Before
39+
public void setUp() throws Exception {
40+
MockitoAnnotations.initMocks(this);
41+
}
42+
43+
@Test
44+
public void shouldGetComments() {
45+
post.setComments(Arrays.asList(new Comment(), new Comment()));
46+
47+
List<Comment> comments = post.getComments();
48+
49+
assertThat(comments.size(), is(equalTo(2)));
50+
51+
verify(post, times(1)).getComments();
52+
}
53+
54+
@Test
55+
public void shouldReturnNoComments() {
56+
List<Comment> comments = post.getComments();
57+
58+
assertThat(comments.size(), is(equalTo(0)));
59+
60+
verify(post, times(1)).getComments();
61+
}
62+
63+
@Test
64+
public void shouldAddNewComment() {
65+
User user = new User();
66+
67+
when(userService.currentUser()).thenReturn(user);
68+
69+
Comment comment = new Comment();
70+
71+
commentService.saveNewComment(comment, post);
72+
73+
assertThat(comment.getPost(), is(equalTo(post)));
74+
75+
assertThat(comment.getUser(), is(equalTo(user)));
76+
77+
verify(commentRepository, times(1)).save(Matchers.any(Comment.class));
78+
}
79+
}

‎src/test/java/alexp/blog/service/PostServiceTest.java‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,6 @@
1717

1818
import static org.hamcrest.CoreMatchers.*;
1919
import static org.hamcrest.MatcherAssert.assertThat;
20-
import static org.mockito.Matchers.isNotNull;
21-
import static org.mockito.Matchers.refEq;
2220
import static org.mockito.Mockito.times;
2321
import static org.mockito.Mockito.verify;
2422
import static org.mockito.Mockito.when;

‎src/test/java/alexp/blog/service/UserServiceTest.java‎

Lines changed: 143 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,143 @@
1+
package alexp.blog.service;
2+
3+
import alexp.blog.model.Role;
4+
import alexp.blog.model.User;
5+
import alexp.blog.repository.UserRepository;
6+
import org.junit.Before;
7+
import org.junit.Test;
8+
import org.mockito.InjectMocks;
9+
import org.mockito.Matchers;
10+
import org.mockito.Mock;
11+
import org.mockito.MockitoAnnotations;
12+
import org.springframework.security.core.authority.SimpleGrantedAuthority;
13+
import org.springframework.security.core.userdetails.UserDetails;
14+
import org.springframework.security.core.userdetails.UsernameNotFoundException;
15+
import org.springframework.security.crypto.password.PasswordEncoder;
16+
17+
import java.util.Arrays;
18+
import java.util.List;
19+
import java.util.stream.Collectors;
20+
21+
import static org.hamcrest.CoreMatchers.*;
22+
import static org.hamcrest.MatcherAssert.assertThat;
23+
import static org.mockito.Mockito.*;
24+
25+
public class UserServiceTest {
26+
27+
public static final String NAME = "name";
28+
public static final String EMAIL = "email";
29+
@Mock
30+
private UserRepository userRepository;
31+
32+
@Mock
33+
private PasswordEncoder passwordEncoder;
34+
35+
@InjectMocks
36+
private UserServiceImpl userService;
37+
38+
@Before
39+
public void setUp() throws Exception {
40+
MockitoAnnotations.initMocks(this);
41+
}
42+
43+
@Test
44+
public void shouldFindByEmail() {
45+
User user = new User();
46+
47+
when(userRepository.findByEmail(EMAIL)).thenReturn(user);
48+
49+
assertThat(userService.emailExists(EMAIL), is(equalTo(true)));
50+
51+
assertThat(userService.findByEmail(EMAIL), is(equalTo(user)));
52+
53+
verify(userRepository, atLeastOnce()).findByEmail(Matchers.anyString());
54+
}
55+
56+
@Test
57+
public void shouldReturnNullWhenEmailNotExists() {
58+
assertThat(userService.emailExists(EMAIL), is(equalTo(false)));
59+
60+
assertThat(userService.findByEmail(EMAIL), is(equalTo(null)));
61+
62+
verify(userRepository, atLeastOnce()).findByEmail(Matchers.anyString());
63+
}
64+
65+
@Test
66+
public void shouldFindByUsername() {
67+
User user = new User();
68+
69+
when(userRepository.findByUsername(NAME)).thenReturn(user);
70+
71+
assertThat(userService.usernameExists(NAME), is(equalTo(true)));
72+
73+
assertThat(userService.findByUsername(NAME), is(equalTo(user)));
74+
75+
verify(userRepository, atLeastOnce()).findByUsername(Matchers.anyString());
76+
}
77+
78+
@Test
79+
public void shouldReturnNullWhenUsernameNotExists() {
80+
assertThat(userService.usernameExists(NAME), is(equalTo(false)));
81+
82+
assertThat(userService.findByUsername(NAME), is(equalTo(null)));
83+
84+
verify(userRepository, atLeastOnce()).findByUsername(Matchers.anyString());
85+
}
86+
87+
@Test
88+
public void shouldAddNewUser() {
89+
User user = new User();
90+
91+
userService.register(user);
92+
93+
assertThat(user.isEnabled(), is(equalTo(true)));
94+
95+
verify(userRepository, times(1)).saveAndFlush(user);
96+
}
97+
98+
@Test
99+
public void shouldEncodePassword() {
100+
String password = "password";
101+
String encodedPassword = "encodedPassword";
102+
103+
User user = new User();
104+
user.setPassword(password);
105+
106+
when(passwordEncoder.encode(password)).thenReturn(encodedPassword);
107+
108+
userService.register(user);
109+
110+
assertThat(user.getPassword(), is(equalTo(encodedPassword)));
111+
112+
verify(passwordEncoder, times(1)).encode(password);
113+
}
114+
115+
@Test
116+
public void shouldLoadUserDetails() {
117+
User user = new User();
118+
user.setUsername(NAME);
119+
user.setPassword("123");
120+
121+
List<String> role1Names = Arrays.asList("role1", "role2");
122+
for (String roleName : role1Names) {
123+
Role role = new Role();
124+
role.setName(roleName);
125+
user.getRoles().add(role);
126+
}
127+
128+
when(userRepository.findByUsernameOrEmail(NAME, NAME)).thenReturn(user);
129+
130+
UserDetails userDetails = userService.loadUserByUsername(NAME);
131+
132+
List<SimpleGrantedAuthority> authorities = role1Names.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
133+
assertThat(userDetails.getAuthorities().containsAll(authorities), is(equalTo(true)));
134+
135+
verify(userRepository, times(1)).findByUsernameOrEmail(NAME, NAME);
136+
}
137+
138+
@Test(expected = UsernameNotFoundException.class)
139+
public void shouldThrowUsernameNotFound() {
140+
userService.loadUserByUsername("notExisting");
141+
}
142+
143+
}

0 commit comments

Comments
 (0)