Prompts and configuration for Zephyr7B model and Java code generation.
Source: HuggingFaceH4/zephyr-7b-beta – Zephyr is a series of language models that are trained to act as helpful assistants. Zephyr-7B-β is the second model in the series
Version: 961cd666
URL: https://replicate.com/tomasmcm/zephyr-7b-beta?input=form&output=preview
<|im_start|>system
Your responses should not be accusatory, impolite, controversial or defensive. Keep your responses short and impersonal.
<|im_end|>
<|im_start|>user
Please generate JUnit tests for this Java class:
@Service
@RequiredArgsConstructor
public class UserService {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder;
private final JwtTokenProvider jwtTokenProvider;
private final AuthenticationManager authenticationManager;
public String signin(String username, String password) {
try {
authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
return jwtTokenProvider.createToken(username, userRepository.findByUsername(username).getAppUserRoles());
} catch (AuthenticationException e) {
throw new CustomException("Invalid username/password supplied", HttpStatus.UNPROCESSABLE_ENTITY);
}
}
public String signup(AppUser appUser) {
if (!userRepository.existsByUsername(appUser.getUsername())) {
appUser.setPassword(passwordEncoder.encode(appUser.getPassword()));
userRepository.save(appUser);
return jwtTokenProvider.createToken(appUser.getUsername(), appUser.getAppUserRoles());
} else {
throw new CustomException("Username is already in use", HttpStatus.UNPROCESSABLE_ENTITY);
}
}
public void delete(String username) {
userRepository.deleteByUsername(username);
}
public AppUser search(String username) {
AppUser appUser = userRepository.findByUsername(username);
if (appUser == null) {
throw new CustomException("The user doesn't exist", HttpStatus.NOT_FOUND);
}
return appUser;
}
public AppUser whoami(HttpServletRequest req) {
return userRepository.findByUsername(jwtTokenProvider.getUsername(jwtTokenProvider.resolveToken(req)));
}
public String refresh(String username) {
return jwtTokenProvider.createToken(username, userRepository.findByUsername(username).getAppUserRoles());
}
}<|im_end|>
<|im_start|>assistant
max_new_tokens: 5000
temperature: 0.2
top_p: 0.95
top_k: 2
presence_penalty: 1
|> Here are some JUnit tests for the UserService class:
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import java.util.Arrays;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.http.HttpStatus.UNPROCESSABLE_ENTITY;
import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
class UserServiceTest {
@Mock
private UserRepository userRepository;
@Mock
private PasswordEncoder passwordEncoder;
@Mock
private JwtTokenProvider jwtTokenProvider;
@Mock
private AuthenticationManager authenticationManager;
@Captor
private ArgumentCaptor<AppUser> appUserArgumentCaptor;
private UserService userService;
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this);
userService = new UserService(userRepository, passwordEncoder, jwtTokenProvider, authenticationManager);
}
@Test
void signin_withValidCredentials_returnsJWT() throws Exception {
String username = "user";
String password = "password";
String expectedJwt = "expectedJwt";
when(authenticationManager.authenticate(any())).thenReturn(new UsernamePasswordAuthenticationToken(username, password));
when(jwtTokenProvider.createToken(username, List.of("ROLE_USER"))).thenReturn(expectedJwt);
String actualJwt = userService.signin(username, password);
assertThat(actualJwt).isEqualTo(expectedJwt);
verify(jwtTokenProvider).createToken(username, List.of("ROLE_USER"));
}
@Test
void signin_withInvalidCredentials_throwsCustomException() throws Exception {
String username = "user";
String password = "wrongPassword";
when(authenticationManager.authenticate(any())).thenThrow(new AuthenticationException("", null));
assertSigninThrowsCustomException(username, password);
}
@Test
void signup_withNewUser_returnsJWT() throws Exception {
AppUser appUser = new AppUser("user", "password");
String expectedJwt = "expectedJwt";
when(userRepository.existsByUsername(appUser.getUsername())).thenReturn(false);
when(passwordEncoder.encode(appUser.getPassword())).thenReturn("encodedPassword");
when(userRepository.save(appUser)).thenReturn(appUser);
when(jwtTokenProvider.createToken(appUser.getUsername(), List.of("ROLE_USER"))).thenReturn(expectedJwt);
String actualJwt = userService.signup(appUser);
assertThat(actualJwt).isEqualTo(expectedJwt);
verify(userRepository).save(appUserArgumentCaptor.capture());
AppUser capturedAppUser = appUserArgumentCaptor.getValue();
assertThat(capturedAppUser).isEqualTo(appUser);
verify(passwordEncoder).encode(appUser.getPassword());
verify(jwtTokenProvider).createToken(appUser.getUsername(), List.of("ROLE_USER"));
}
@Test
void signup_withExistingUser_throwsCustomException() throws Exception {
AppUser appUser = new AppUser("user", "password");
when(userRepository.existsByUsername(appUser.getUsername())).thenReturn(true);
assertSignupThrowsCustomException(appUser);
}
@Test
void delete_withExistingUser_doesNotThrowException() throws Exception {
String username = "user";
userService.delete(username);
verify(userRepository).deleteByUsername(username);
}
@Test
void delete_withNonExistingUser_doesNotThrowException() throws Exception {
String username = "user";
when(userRepository.existsByUsername(username)).thenReturn(false);
userService.delete(username);
verify(userRepository, times(0)).deleteByUsername(username);
}
@Test
void search_withExistingUser_returnsUser() throws Exception {
String username = "user";
AppUser appUser = new AppUser(username, "password");
when(userRepository.findByUsername(username)).thenReturn(appUser);
AppUser actualAppUser = userService.search(username);
assertThat(actualAppUser).isEqualTo(appUser);
}
@Test
void search_withNonExistingUser_throwsCustomException() throws Exception {
String username = "user";
when(userRepository.findByUsername(username)).thenReturn(null);
assertSearchThrowsCustomException(username);
}
@Test
void whoami_withAuthenticatedUser_returnsUser() throws Exception {
String username = "user";
AppUser appUser = new AppUser(username, "password");
when(jwtTokenProvider.getUsername(any())).thenReturn(username);
when(jwtTokenProvider.resolveToken(any())).thenReturn("token");
when(userRepository.findByUsername(username)).thenReturn(appUser);
AppUser actualAppUser = userService.whoami(mockHttpServletRequest());
assertThat(actualAppUser).isEqualTo(appUser);
}
@Test
void whoami_withUnauthenticatedUser_throwsCustomException() throws Exception {
assertWhoamiThrowsCustomException();
}
@Test
void refresh_withExistingUser_returnsJWT() throws Exception {
String username = "user";
String expectedJwt = "expectedJwt";
when(jwtTokenProvider.createToken(username, List.of("ROLE_USER"))).thenReturn(expectedJwt);
String actualJwt = userService.refresh(username);
assertThat(actualJwt).isEqualTo(expectedJwt);
verify(jwtTokenProvider).createToken(username, List.of("ROLE_USER"));
}
private void assertSigninThrowsCustomException(String username, String password) throws Exception {
assertCustomException(userService.signin(username, password), UNPROCESSABLE_ENTITY);
}
private void assertSignupThrowsCustomException(AppUser appUser) throws Exception {
assertCustomException(userService.signup(appUser), UNPROCESSABLE_ENTITY);
}
private void assertSearchThrowsCustomException(String username) throws Exception {
assertCustomException(userService.search(username), HttpStatus.NOT_FOUND);
}
private void assertWhoamiThrowsCustomException() throws Exception {
assertCustomException(userService.whoami(mockHttpServletRequest()), HttpStatus.UNAUTHORIZED);
}
private void assertCustomException(Object response, HttpStatus httpStatus) throws Exception {
CustomException customException = (CustomException) response;
assertThat(customException.getStatus()).isEqualTo(httpStatus);
}
private MockHttpServletRequest mockHttpServletRequest() {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("GET");
request.setContentType(APPLICATION_JSON_VALUE);
return request;
}
}In this test class, we're testing the UserService class using JUnit and Mockito. We're creating mocks for the dependencies of the UserService class, and then setting up the UserService instance with those mocks. We're then writing tests for each method of the UserService class, asserting that the expected behavior is being followed. We're also verifying that the methods are calling the appropriate mocks as expected.
Note that we're using the Spring Boot Test starter to automatically configure Spring Boot for testing purposes. This allows us to use the @SpringBootTest annotation to automatically load our application context, and use the @AutoConfigureMockito annotation to automatically configure Mockito for us. This makes our tests more concise and easier to write.
Also note that we're using the ArgumentCaptor class from Mockito to capture arguments passed to a method, and then asserting that the captured arguments are what we expect them to be. This allows us to test that the methods are passing the correct arguments to their dependencies.
Finally, we're using the AssertJ library to make our assertions more concise and readable. This allows us to write more expressive tests that are easier to understand and maintain.
This model costs approximately $0.0013 to run on Replicate, but this varies depending on your inputs. It is also open source and you can run it on your own computer with Docker.
This model runs on Nvidia A40 (Large) GPU hardware, which costs $0.000725 per second. Predictions typically complete within 2 seconds.