A new user has just been registered for " + user.getEmail() + "
\n" + 54 | "To validate this email address please click on the following link " + link + "
\n" + 55 | ""; 56 | sendMessage(environment.getProperty("email.contact.address"), new String[]{user.getEmail()}, subject, formattedMessage); 57 | } 58 | 59 | public void sendUpdatePasswordMessage(User user, HttpServletRequest request) throws MalformedURLException, UnsupportedEncodingException { 60 | URL link = createUrl(user, request); 61 | String subject = NAME_PREFIX + "Update Password"; 62 | String formattedMessage = "To update your password please click on the following link " + link + "
\n" + 65 | ""; 66 | sendMessage(environment.getProperty("email.contact.address"), new String[]{user.getEmail()}, subject, formattedMessage); 67 | } 68 | 69 | @VisibleForTesting 70 | URL createUrl(User user, HttpServletRequest request) throws MalformedURLException, UnsupportedEncodingException { 71 | String hostHeader = request.getHeader("Host"); 72 | String host = environment.getProperty("server.host"); 73 | int port = request.getLocalPort(); 74 | if (!Strings.isNullOrEmpty(hostHeader)) { 75 | if (hostHeader.contains(":")) { 76 | host = StringUtils.substringBefore(hostHeader, ":"); 77 | try { 78 | port = Integer.parseInt(StringUtils.substringAfterLast(hostHeader, ":")); 79 | } catch (NumberFormatException nfe) { 80 | logger.warn("NumberFormatException parsing port from Host header [" + hostHeader + "]", nfe); 81 | } 82 | } else { 83 | host = hostHeader; 84 | } 85 | } 86 | return new URL( 87 | "https", 88 | host, 89 | port, 90 | "/updatePassword?email=" + URLEncoder.encode(user.getEmail(), "UTF-8") + "&oneTimeToken=" + URLEncoder.encode(user.getOneTimeToken(), "UTF-8") 91 | ); 92 | } 93 | 94 | public class SendMessageTask implements Runnable { 95 | private final String from; 96 | private final String[] to; 97 | private final String subject; 98 | private final String msg; 99 | private final JavaMailSender mailSender; 100 | 101 | public SendMessageTask(String from, String[] to, String subject, String msg, JavaMailSender mailSender) { 102 | this.from = from; 103 | this.to = to; 104 | this.subject = subject; 105 | this.msg = msg; 106 | this.mailSender = mailSender; 107 | } 108 | 109 | public void run() { 110 | try { 111 | mailSender.send(new MimeMessagePreparator() { 112 | public void prepare(MimeMessage mimeMessage) throws MessagingException { 113 | MimeMessageHelper message = new MimeMessageHelper(mimeMessage, false, "UTF-8"); 114 | message.setFrom(from); 115 | message.setTo(to); 116 | message.setSubject(subject); 117 | message.setText(msg, true); 118 | } 119 | }); 120 | } catch (Exception e) { 121 | logger.warn("Failed to send " + subject + "email to " + Arrays.asList(to), e); 122 | } 123 | } 124 | 125 | } 126 | } 127 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/security/CredentialValidation.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.security; 2 | 3 | import org.jamesdbloom.dao.UserDAO; 4 | import org.jamesdbloom.domain.User; 5 | import org.slf4j.Logger; 6 | import org.slf4j.LoggerFactory; 7 | import org.springframework.core.env.Environment; 8 | import org.springframework.security.authentication.BadCredentialsException; 9 | import org.springframework.security.crypto.password.PasswordEncoder; 10 | import org.springframework.stereotype.Component; 11 | 12 | import javax.annotation.Resource; 13 | import java.io.UnsupportedEncodingException; 14 | import java.net.URLDecoder; 15 | 16 | /** 17 | * @author jamesdbloom 18 | */ 19 | @Component 20 | public class CredentialValidation { 21 | 22 | protected Logger logger = LoggerFactory.getLogger(this.getClass()); 23 | 24 | @Resource 25 | private PasswordEncoder passwordEncoder; 26 | @Resource 27 | private UserDAO userDAO; 28 | @Resource 29 | private Environment environment; 30 | 31 | public User validateUsernameAndPassword(String username, CharSequence password) { 32 | User user = userDAO.findByEmail(decodeURL(username)); 33 | if (!credentialsMatch(password, user)) { 34 | logger.info(environment.getProperty("validation.user.invalidCredentials")); 35 | throw new BadCredentialsException(environment.getProperty("validation.user.invalidCredentials")); 36 | } 37 | return user; 38 | } 39 | 40 | private boolean credentialsMatch(CharSequence password, User user) { 41 | return user != null && password != null && user.getPassword() != null && passwordEncoder.matches(password, user.getPassword()); 42 | } 43 | 44 | private String decodeURL(String urlEncoded) { 45 | try { 46 | return URLDecoder.decode(urlEncoded, "UTF-8"); 47 | } catch (UnsupportedEncodingException e) { 48 | throw new RuntimeException("Exception decoding URL value [" + urlEncoded + "]", e); 49 | } 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/security/SecurityConfig.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.security; 2 | 3 | import org.springframework.context.annotation.Bean; 4 | import org.springframework.context.annotation.ComponentScan; 5 | import org.springframework.context.annotation.Configuration; 6 | import org.springframework.core.env.Environment; 7 | import org.springframework.security.authentication.AuthenticationProvider; 8 | import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; 9 | import org.springframework.security.config.annotation.web.builders.HttpSecurity; 10 | import org.springframework.security.config.annotation.web.builders.WebSecurity; 11 | import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; 12 | import org.springframework.security.config.annotation.web.servlet.configuration.EnableWebMvcSecurity; 13 | import org.springframework.security.crypto.password.PasswordEncoder; 14 | import org.springframework.security.crypto.password.StandardPasswordEncoder; 15 | 16 | import javax.annotation.Resource; 17 | 18 | @Configuration 19 | //@EnableGlobalMethodSecurity(prePostEnabled = true) 20 | @EnableWebMvcSecurity 21 | @ComponentScan("org.jamesdbloom.security") 22 | public class SecurityConfig extends WebSecurityConfigurerAdapter { 23 | 24 | @Resource 25 | private AuthenticationProvider springSecurityAuthenticationProvider; 26 | 27 | @Resource 28 | private Environment environment; 29 | 30 | @Bean 31 | protected PasswordEncoder passwordEncoder() { 32 | return new StandardPasswordEncoder("GMbO8etVKRFDEC8mZ1nCLxodpEd3BrrTn4Ju62R5"); 33 | } 34 | 35 | @Override 36 | protected void configure(AuthenticationManagerBuilder auth) throws Exception { 37 | auth.authenticationProvider(springSecurityAuthenticationProvider); 38 | } 39 | 40 | @Override 41 | public void configure(WebSecurity web) throws Exception { 42 | web.ignoring().antMatchers("/favicon.ico", "/resources/**", "/bundle/**"); 43 | } 44 | 45 | @Override 46 | protected void configure(HttpSecurity http) throws Exception { 47 | http 48 | .requiresChannel().anyRequest().requiresSecure() 49 | .and() 50 | .portMapper().http(Integer.parseInt(environment.getProperty("http.port", "8080"))).mapsTo(Integer.parseInt(environment.getProperty("https.port", "8443"))) 51 | .and() 52 | .sessionManagement().sessionFixation().newSession() 53 | .and() 54 | .authorizeRequests().antMatchers("/register", "/updatePassword").permitAll() 55 | .and() 56 | .formLogin().loginPage("/login").defaultSuccessUrl("/").permitAll() 57 | .and() 58 | .logout().logoutUrl("/logout").logoutSuccessUrl("/login").invalidateHttpSession(true).deleteCookies("JSESSIONID") 59 | .and() 60 | .authorizeRequests().antMatchers("/**").authenticated(); 61 | } 62 | } -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/security/SpringSecurityAuthenticationProvider.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.security; 2 | 3 | import org.jamesdbloom.domain.User; 4 | import org.springframework.security.authentication.AuthenticationProvider; 5 | import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; 6 | import org.springframework.security.core.Authentication; 7 | import org.springframework.security.core.AuthenticationException; 8 | import org.springframework.security.core.authority.AuthorityUtils; 9 | import org.springframework.stereotype.Component; 10 | 11 | import javax.annotation.Resource; 12 | 13 | /** 14 | * @author jamesdbloom 15 | */ 16 | @Component 17 | public class SpringSecurityAuthenticationProvider implements AuthenticationProvider { 18 | 19 | @Resource 20 | private CredentialValidation credentialValidation; 21 | 22 | @Resource 23 | private SpringSecurityUserContext springSecurityUserContext; 24 | 25 | @Override 26 | public Authentication authenticate(Authentication authentication) throws AuthenticationException { 27 | UsernamePasswordAuthenticationToken token = (UsernamePasswordAuthenticationToken) authentication; 28 | User user; 29 | if (token.getPrincipal() instanceof User) { 30 | user = (User) token.getPrincipal(); 31 | } else { 32 | user = credentialValidation.validateUsernameAndPassword(token.getName(), (CharSequence) token.getCredentials()); 33 | } 34 | springSecurityUserContext.setCurrentUser(user); 35 | return new UsernamePasswordAuthenticationToken(user, user.getPassword(), AuthorityUtils.createAuthorityList("USER")); 36 | } 37 | 38 | @Override 39 | public boolean supports(Class authentication) { 40 | return UsernamePasswordAuthenticationToken.class.equals(authentication); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/security/SpringSecurityUserContext.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.security; 2 | 3 | import org.jamesdbloom.domain.User; 4 | import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; 5 | import org.springframework.security.core.Authentication; 6 | import org.springframework.security.core.context.SecurityContext; 7 | import org.springframework.security.core.context.SecurityContextHolder; 8 | import org.springframework.stereotype.Component; 9 | 10 | /** 11 | * @author jamesdbloom 12 | */ 13 | @Component 14 | public class SpringSecurityUserContext { 15 | 16 | public User getCurrentUser() { 17 | SecurityContext securityContext = SecurityContextHolder.getContext(); 18 | Authentication authentication = securityContext.getAuthentication(); 19 | if (authentication == null || authentication.getPrincipal() == null || authentication.getPrincipal().equals("anonymousUser")) { 20 | return null; 21 | } 22 | return (User) authentication.getPrincipal(); 23 | } 24 | 25 | public void setCurrentUser(User user) { 26 | Authentication authentication = new UsernamePasswordAuthenticationToken(user, user.getPassword()); 27 | SecurityContextHolder.getContext().setAuthentication(authentication); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/uuid/UUIDFactory.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.uuid; 2 | 3 | import org.jamesdbloom.domain.User; 4 | 5 | import java.util.UUID; 6 | import java.util.regex.Pattern; 7 | 8 | /** 9 | * @author jamesdbloom 10 | */ 11 | public class UUIDFactory { 12 | 13 | private static final Pattern UUID_PATTERN = Pattern.compile("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"); 14 | 15 | public String generateUUID() { 16 | return UUID.randomUUID().toString(); 17 | } 18 | 19 | public boolean hasMatchingUUID(User user, String oneTimeToken) { 20 | boolean userTokenValid = user != null && user.getOneTimeToken() != null && UUID_PATTERN.matcher(user.getOneTimeToken()).matches(); 21 | boolean matchingTokenValid = oneTimeToken != null && UUID_PATTERN.matcher(oneTimeToken).matches(); 22 | return userTokenValid && matchingTokenValid && user.getOneTimeToken().equals(oneTimeToken); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/web/configuration/WebMvcConfiguration.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.configuration; 2 | 3 | import freemarker.cache.ClassTemplateLoader; 4 | import freemarker.cache.MultiTemplateLoader; 5 | import freemarker.cache.TemplateLoader; 6 | import freemarker.cache.WebappTemplateLoader; 7 | import freemarker.template.TemplateException; 8 | import freemarker.template.TemplateExceptionHandler; 9 | import org.jamesdbloom.web.interceptor.bundling.AddBundlingModelToViewModelInterceptor; 10 | import org.jamesdbloom.web.interceptor.bundling.WroModelHolder; 11 | import org.springframework.beans.factory.annotation.Autowired; 12 | import org.springframework.beans.factory.config.CustomScopeConfigurer; 13 | import org.springframework.context.ApplicationContext; 14 | import org.springframework.context.annotation.*; 15 | import org.springframework.core.env.Environment; 16 | import org.springframework.validation.Validator; 17 | import org.springframework.web.bind.WebDataBinder; 18 | import org.springframework.web.bind.annotation.InitBinder; 19 | import org.springframework.web.context.request.RequestScope; 20 | import org.springframework.web.servlet.LocaleResolver; 21 | import org.springframework.web.servlet.config.annotation.*; 22 | import org.springframework.web.servlet.i18n.SessionLocaleResolver; 23 | import org.springframework.web.servlet.view.freemarker.FreeMarkerConfig; 24 | import org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer; 25 | import org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver; 26 | import ro.isdc.wro.manager.factory.ConfigurableWroManagerFactory; 27 | import ro.isdc.wro.manager.factory.WroManagerFactory; 28 | 29 | import javax.annotation.Resource; 30 | import javax.servlet.ServletContext; 31 | import java.io.IOException; 32 | import java.util.Collections; 33 | import java.util.Locale; 34 | import java.util.Properties; 35 | 36 | /** 37 | * @author jamesdbloom 38 | */ 39 | @EnableWebMvc 40 | @Configuration 41 | @ComponentScan(basePackages = {"org.jamesdbloom.web"}) 42 | public class WebMvcConfiguration extends WebMvcConfigurationSupport { 43 | 44 | @Resource 45 | private Environment environment; 46 | 47 | @Resource 48 | private WroModelHolder wroModelHolder; 49 | 50 | @Resource 51 | private ServletContext servletContext; 52 | 53 | @Override 54 | public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { 55 | configurer.enable("default"); 56 | } 57 | 58 | @Override 59 | public void addInterceptors(InterceptorRegistry registry) { 60 | registry.addInterceptor(new AddBundlingModelToViewModelInterceptor(wroModelHolder, environment.getProperty("bundling.enabled"))); 61 | } 62 | 63 | @Override 64 | public void addResourceHandlers(ResourceHandlerRegistry registry) { 65 | registry.addResourceHandler("/resources/**").addResourceLocations("/resources/"); 66 | } 67 | 68 | @Bean 69 | public WroManagerFactory wroManagerFactory() { 70 | ConfigurableWroManagerFactory wroManagerFactory = new ConfigurableWroManagerFactory(); 71 | 72 | wroManagerFactory.setConfigProperties(new Properties() {{ 73 | setProperty("debug", environment.getProperty("bundling.enabled")); 74 | setProperty("preProcessors", "cssImport,semicolonAppender,conformColors"); 75 | setProperty("postProcessors", "yuiCssMin,googleClosureAdvanced"); 76 | setProperty("cacheGzippedContent", "true"); 77 | setProperty("hashStrategy", "MD5"); // should drive the naming strategy to fingerprint resource urls - NOT YET WORKING / CONFIGURED CORRECTLY 78 | setProperty("namingStrategy", "hashEncoder-CRC32"); // should drive the naming strategy to fingerprint resource urls - NOT YET WORKING / CONFIGURED CORRECTLY 79 | }}); 80 | 81 | return wroManagerFactory; 82 | } 83 | 84 | @Bean 85 | public FreeMarkerConfigurer freemarkerConfig() throws IOException, TemplateException { 86 | FreeMarkerConfigurer freeMarkerConfigurer = new FreeMarkerConfigurer(); 87 | freeMarkerConfigurer.setConfiguration(new freemarker.template.Configuration() {{ 88 | setTemplateLoader(new MultiTemplateLoader( 89 | new TemplateLoader[]{ 90 | new ClassTemplateLoader(FreeMarkerConfig.class, "/"), 91 | new WebappTemplateLoader(servletContext, "/") 92 | } 93 | )); 94 | setTemplateExceptionHandler(TemplateExceptionHandler.DEBUG_HANDLER); 95 | setStrictSyntaxMode(true); 96 | setWhitespaceStripping(true); 97 | }}); 98 | return freeMarkerConfigurer; 99 | } 100 | 101 | @Bean 102 | public FreeMarkerViewResolver freeMarkerViewResolver() { 103 | FreeMarkerViewResolver freeMarkerViewResolver = new FreeMarkerViewResolver(); 104 | freeMarkerViewResolver.setOrder(1); 105 | freeMarkerViewResolver.setPrefix("/WEB-INF/view/"); 106 | freeMarkerViewResolver.setSuffix(".ftl"); 107 | freeMarkerViewResolver.setContentType("text/html;charset=UTF-8"); 108 | return freeMarkerViewResolver; 109 | } 110 | } 111 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/web/controller/LandingPageController.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.controller; 2 | 3 | import org.springframework.stereotype.Controller; 4 | import org.springframework.web.bind.annotation.RequestMapping; 5 | import org.springframework.web.bind.annotation.RequestMethod; 6 | 7 | /** 8 | * @author jamesdbloom 9 | */ 10 | @Controller 11 | public class LandingPageController { 12 | 13 | @RequestMapping(value = "/", method = RequestMethod.GET) 14 | public String getPage() { 15 | return "landing"; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/web/controller/LoginPageController.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.controller; 2 | 3 | import org.springframework.security.web.csrf.CsrfToken; 4 | import org.springframework.stereotype.Controller; 5 | import org.springframework.ui.Model; 6 | import org.springframework.web.bind.annotation.RequestMapping; 7 | import org.springframework.web.bind.annotation.RequestMethod; 8 | 9 | import javax.servlet.http.HttpServletRequest; 10 | 11 | /** 12 | * @author jamesdbloom 13 | */ 14 | @Controller 15 | public class LoginPageController { 16 | 17 | @RequestMapping(value = "/login", method = RequestMethod.GET) 18 | public String getPage(HttpServletRequest request, Model model) { 19 | CsrfToken csrfToken = (CsrfToken) request.getAttribute(CsrfToken.class.getName()); 20 | if (csrfToken != null) { 21 | model.addAttribute("csrfParameterName", csrfToken.getParameterName()); 22 | model.addAttribute("csrfToken", csrfToken.getToken()); 23 | } 24 | return "login"; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/web/controller/RegistrationController.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.controller; 2 | 3 | import org.jamesdbloom.dao.UserDAO; 4 | import org.jamesdbloom.domain.User; 5 | import org.jamesdbloom.email.EmailService; 6 | import org.jamesdbloom.uuid.UUIDFactory; 7 | import org.slf4j.Logger; 8 | import org.slf4j.LoggerFactory; 9 | import org.springframework.core.env.Environment; 10 | import org.springframework.security.web.csrf.CsrfToken; 11 | import org.springframework.stereotype.Controller; 12 | import org.springframework.ui.Model; 13 | import org.springframework.validation.BindingResult; 14 | import org.springframework.validation.ObjectError; 15 | import org.springframework.web.bind.annotation.RequestMapping; 16 | import org.springframework.web.bind.annotation.RequestMethod; 17 | import org.springframework.web.servlet.mvc.support.RedirectAttributes; 18 | 19 | import javax.annotation.Resource; 20 | import javax.servlet.http.HttpServletRequest; 21 | import javax.validation.Valid; 22 | import java.io.UnsupportedEncodingException; 23 | import java.net.MalformedURLException; 24 | 25 | /** 26 | * @author jamesdbloom 27 | */ 28 | @Controller 29 | public class RegistrationController { 30 | 31 | protected Logger logger = LoggerFactory.getLogger(getClass()); 32 | @Resource 33 | private UserDAO userDAO; 34 | @Resource 35 | private Environment environment; 36 | @Resource 37 | private EmailService emailService; 38 | @Resource 39 | private UUIDFactory uuidFactory; 40 | 41 | private void setupModel(Model model) { 42 | model.addAttribute("passwordPattern", User.PASSWORD_PATTERN); 43 | model.addAttribute("emailPattern", User.EMAIL_PATTERN); 44 | model.addAttribute("environment", environment); 45 | } 46 | 47 | @RequestMapping(value = "/register", method = RequestMethod.GET) 48 | public String registerForm(HttpServletRequest request, Model model) { 49 | setupModel(model); 50 | model.addAttribute("user", new User()); 51 | CsrfToken csrfToken = (CsrfToken) request.getAttribute(CsrfToken.class.getName()); 52 | if (csrfToken != null) { 53 | model.addAttribute("csrfParameterName", csrfToken.getParameterName()); 54 | model.addAttribute("csrfToken", csrfToken.getToken()); 55 | } 56 | return "register"; 57 | } 58 | 59 | @RequestMapping(value = "/register", method = RequestMethod.POST) 60 | public String register(@Valid User user, BindingResult bindingResult, HttpServletRequest request, Model model, RedirectAttributes redirectAttributes) throws MalformedURLException, UnsupportedEncodingException { 61 | 62 | boolean userAlreadyExists = user.getEmail() != null && (userDAO.findByEmail(user.getEmail()) != null); 63 | if (bindingResult.hasErrors() || userAlreadyExists) { 64 | setupModel(model); 65 | if (userAlreadyExists) { 66 | bindingResult.addError(new ObjectError("user", "validation.user.alreadyExists")); 67 | } 68 | model.addAttribute("bindingResult", bindingResult); 69 | model.addAttribute("user", user); 70 | return "register"; 71 | } 72 | user.setOneTimeToken(uuidFactory.generateUUID()); 73 | userDAO.save(user); 74 | emailService.sendRegistrationMessage(user, request); 75 | redirectAttributes.addFlashAttribute("message", "Your account has been created and an email has been sent to " + user.getEmail() + " with a link to create your password and login, please check your spam folder if you don't see the email within 5 minutes"); 76 | redirectAttributes.addFlashAttribute("title", "Account Created"); 77 | return "redirect:/message"; 78 | } 79 | 80 | } 81 | -------------------------------------------------------------------------------- /src/main/java/org/jamesdbloom/web/controller/UpdatePasswordController.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.controller; 2 | 3 | import org.jamesdbloom.dao.UserDAO; 4 | import org.jamesdbloom.domain.User; 5 | import org.jamesdbloom.email.EmailService; 6 | import org.jamesdbloom.security.SpringSecurityUserContext; 7 | import org.jamesdbloom.uuid.UUIDFactory; 8 | import org.slf4j.Logger; 9 | import org.slf4j.LoggerFactory; 10 | import org.springframework.core.env.Environment; 11 | import org.springframework.security.crypto.password.PasswordEncoder; 12 | import org.springframework.security.web.csrf.CsrfToken; 13 | import org.springframework.stereotype.Controller; 14 | import org.springframework.transaction.annotation.Transactional; 15 | import org.springframework.ui.Model; 16 | import org.springframework.web.bind.annotation.RequestMapping; 17 | import org.springframework.web.bind.annotation.RequestMethod; 18 | import org.springframework.web.servlet.mvc.support.RedirectAttributes; 19 | 20 | import javax.annotation.Resource; 21 | import javax.servlet.http.HttpServletRequest; 22 | import java.io.UnsupportedEncodingException; 23 | import java.net.MalformedURLException; 24 | import java.net.URLEncoder; 25 | import java.util.ArrayList; 26 | import java.util.List; 27 | import java.util.regex.Pattern; 28 | 29 | /** 30 | * @author jamesdbloom 31 | */ 32 | @Controller 33 | public class UpdatePasswordController { 34 | protected Logger logger = LoggerFactory.getLogger(this.getClass()); 35 | private static final Pattern PASSWORD_MATCHER = Pattern.compile(User.PASSWORD_PATTERN); 36 | @Resource 37 | private Environment environment; 38 | @Resource 39 | private UserDAO userDAO; 40 | @Resource 41 | private UUIDFactory uuidFactory; 42 | @Resource 43 | private PasswordEncoder passwordEncoder; 44 | @Resource 45 | private SpringSecurityUserContext securityUserContext; 46 | @Resource 47 | private EmailService emailService; 48 | 49 | @RequestMapping(value = "/sendUpdatePasswordEmail", method = {RequestMethod.GET, RequestMethod.POST}, produces = "application/json; charset=UTF-8") 50 | public String sendUpdatePasswordEmail(String email, HttpServletRequest request, RedirectAttributes redirectAttributes) throws MalformedURLException, UnsupportedEncodingException { 51 | User user = userDAO.findByEmail(email); 52 | if (user != null) { 53 | user.setOneTimeToken(uuidFactory.generateUUID()); 54 | userDAO.save(user); 55 | emailService.sendUpdatePasswordMessage(user, request); 56 | } 57 | redirectAttributes.addFlashAttribute("message", "An email has been sent to " + email + " with a link to create your password and login"); 58 | redirectAttributes.addFlashAttribute("title", "Message Sent"); 59 | return "redirect:/message"; 60 | } 61 | 62 | private boolean hasInvalidToken(User user, String oneTimeToken, HttpServletRequest request, RedirectAttributes redirectAttributes) throws UnsupportedEncodingException { 63 | if (!uuidFactory.hasMatchingUUID(user, oneTimeToken)) { 64 | redirectAttributes.addFlashAttribute("message", "Invalid email or one-time-token" + (user != null ? " - click resend email to receive a new email" : "")); 65 | redirectAttributes.addFlashAttribute("title", "Invalid Request"); 66 | redirectAttributes.addFlashAttribute("error", true); 67 | redirectAttributes.addFlashAttribute("csrfParameterName", ((CsrfToken)request.getAttribute(CsrfToken.class.getName())).getParameterName()); 68 | redirectAttributes.addFlashAttribute("csrfToken", ((CsrfToken)request.getAttribute(CsrfToken.class.getName())).getToken()); 69 | return true; 70 | } 71 | return false; 72 | } 73 | 74 | @RequestMapping(value = "/updatePassword", method = RequestMethod.GET) 75 | public String updatePasswordForm(String email, String oneTimeToken, HttpServletRequest request, Model model, RedirectAttributes redirectAttributes) throws UnsupportedEncodingException { 76 | if (hasInvalidToken(userDAO.findByEmail(email), oneTimeToken, request, redirectAttributes)) { 77 | return "redirect:/message"; 78 | } 79 | model.addAttribute("passwordPattern", User.PASSWORD_PATTERN); 80 | model.addAttribute("environment", environment); 81 | model.addAttribute("email", email); 82 | model.addAttribute("oneTimeToken", oneTimeToken); 83 | CsrfToken csrfToken = (CsrfToken) request.getAttribute(CsrfToken.class.getName()); 84 | if (csrfToken != null) { 85 | model.addAttribute("csrfParameterName", csrfToken.getParameterName()); 86 | model.addAttribute("csrfToken", csrfToken.getToken()); 87 | } 88 | return "updatePassword"; 89 | } 90 | 91 | @Transactional 92 | @RequestMapping(value = "/updatePassword", method = RequestMethod.POST) 93 | public String updatePassword(String email, String password, String passwordConfirm, String oneTimeToken, HttpServletRequest request, Model model, RedirectAttributes redirectAttributes) throws UnsupportedEncodingException { 94 | User user = userDAO.findByEmail(email); 95 | if (hasInvalidToken(user, oneTimeToken, request, redirectAttributes)) { 96 | return "redirect:/message"; 97 | } 98 | boolean passwordFormatError = !PASSWORD_MATCHER.matcher(String.valueOf(password)).matches(); 99 | boolean passwordsMatchError = !String.valueOf(password).equals(passwordConfirm); 100 | if (passwordFormatError || passwordsMatchError) { 101 | model.addAttribute("passwordPattern", User.PASSWORD_PATTERN); 102 | model.addAttribute("environment", environment); 103 | model.addAttribute("email", email); 104 | model.addAttribute("oneTimeToken", oneTimeToken); 105 | List${SPRING_SECURITY_LAST_EXCEPTION.message}
10 | 11 | 12 | 33 | 34 | 35 | <@page_html/> -------------------------------------------------------------------------------- /src/main/webapp/WEB-INF/view/macro/messages.ftl: -------------------------------------------------------------------------------- 1 | <#-- @ftlvariable name="environment" type="org.springframework.core.env.Environment" --> 2 | 3 | <#-- 4 | * print_binding_errors 5 | * 6 | * Macro to print out binding errors 7 | --> 8 | <#macro print_binding_errors objectName=""> 9 | <#if bindingResult?? && (bindingResult.getAllErrors()?size > 0) && (bindingResult.objectName = objectName)> 10 |There were problems with the data you entered:
12 | <#list bindingResult.getAllErrors() as error> 13 |– ${environment.getProperty(error.defaultMessage)}
14 | 15 |There were problems with the data you entered:
28 | <#list validationErrors as error> 29 |– ${environment.getProperty(error)}
30 | 31 |class="error_message" <#else> class="message" >${message!""}
9 | 10 | 11 | <@page_html/> -------------------------------------------------------------------------------- /src/main/webapp/WEB-INF/view/register.ftl: -------------------------------------------------------------------------------- 1 | <#-- @ftlvariable name="environment" type="org.springframework.core.env.Environment" --> 2 | <#-- @ftlvariable name="name" type="java.lang.String" --> 3 | <#-- @ftlvariable name="email" type="java.lang.String" --> 4 | <#-- @ftlvariable name="emailPattern" type="java.lang.String" --> 5 | <#-- @ftlvariable name="csrfParameterName" type="java.lang.String" --> 6 | <#-- @ftlvariable name="csrfToken" type="java.lang.String" --> 7 | <#include "/WEB-INF/view/layout/default.ftl" /> 8 | 9 | <#macro page_body> 10 |A new user has just been registered for " + email + "
\n" + 108 | "To validate this email address please click on the following link https://" + hostName + ":" + port + "/updatePassword?email=to%40email.com&oneTimeToken=" + token + "
\n" + 109 | "", mimeMessage.getContent().toString()); 110 | } 111 | 112 | @Test 113 | public void shouldSendUpdatePasswordEmail() throws Exception { 114 | // given 115 | String token = "token"; 116 | String email = "to@email.com"; 117 | User user = new User() 118 | .withEmail(email) 119 | .withOneTimeToken(token); 120 | 121 | String hostName = "hostName"; 122 | int port = 666; 123 | HttpServletRequest request = mock(HttpServletRequest.class); 124 | when(request.getHeader("Host")).thenReturn(hostName); 125 | when(request.getLocalPort()).thenReturn(port); 126 | 127 | String leagueEmail = "info@squash-league.com"; 128 | when(environment.getProperty("email.contact.address")).thenReturn(leagueEmail); 129 | 130 | // when 131 | emailService.sendUpdatePasswordMessage(user, request); 132 | runnableArgumentCaptor.getValue().run(); 133 | preparatorArgumentCaptor.getValue().prepare(mimeMessage); 134 | 135 | // then 136 | String subject = EmailService.NAME_PREFIX + "Update Password"; 137 | assertEquals(leagueEmail, mimeMessage.getFrom()[0].toString()); 138 | assertEquals(email, mimeMessage.getAllRecipients()[0].toString()); 139 | assertEquals(subject, mimeMessage.getSubject()); 140 | 141 | assertEquals("To update your password please click on the following link https://" + hostName + ":" + port + "/updatePassword?email=to%40email.com&oneTimeToken=" + token + "
\n" + 144 | "", mimeMessage.getContent().toString()); 145 | } 146 | 147 | @Test 148 | public void shouldBuildCorrectURL() throws MalformedURLException, UnsupportedEncodingException { 149 | // given 150 | String hostName = "hostName"; 151 | int port = 666; 152 | HttpServletRequest request = mock(HttpServletRequest.class); 153 | when(request.getHeader("Host")).thenReturn(hostName); 154 | when(request.getLocalPort()).thenReturn(port); 155 | 156 | // when 157 | URL actual = emailService.createUrl(new User().withEmail("to@email.com").withOneTimeToken("token"), request); 158 | 159 | // then 160 | assertEquals("https://" + hostName + ":" + port + "/updatePassword?email=to%40email.com&oneTimeToken=token", actual.toString()); 161 | } 162 | 163 | @Test 164 | public void shouldBuildCorrectURLHostHeaderWithPort() throws MalformedURLException, UnsupportedEncodingException { 165 | // given 166 | String hostName = "hostName:12345"; 167 | HttpServletRequest request = mock(HttpServletRequest.class); 168 | when(request.getHeader("Host")).thenReturn(hostName); 169 | when(request.getLocalPort()).thenReturn(666); 170 | 171 | // when 172 | URL actual = emailService.createUrl(new User().withEmail("to@email.com").withOneTimeToken("token"), request); 173 | 174 | // then 175 | assertEquals("https://" + hostName + "/updatePassword?email=to%40email.com&oneTimeToken=token", actual.toString()); 176 | } 177 | } 178 | 179 | -------------------------------------------------------------------------------- /src/test/java/org/jamesdbloom/email/NewRegistrationEmail.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.email; 2 | 3 | import org.jamesdbloom.acceptance.BasePage; 4 | import org.jsoup.nodes.Element; 5 | 6 | import java.io.UnsupportedEncodingException; 7 | import java.net.URLEncoder; 8 | import java.nio.charset.StandardCharsets; 9 | 10 | import static org.hamcrest.Matchers.containsString; 11 | import static org.junit.Assert.assertEquals; 12 | import static org.junit.Assert.assertNotNull; 13 | import static org.junit.Assert.assertThat; 14 | 15 | /** 16 | * @author jamesdbloom 17 | */ 18 | public class NewRegistrationEmail extends BasePage { 19 | 20 | public NewRegistrationEmail(String body) throws UnsupportedEncodingException { 21 | super(body); 22 | } 23 | 24 | public String shouldHaveCorrectFields(String email) throws UnsupportedEncodingException { 25 | hasCorrectTitle(); 26 | return hasCorrectUpdatePasswordLink(email); 27 | } 28 | 29 | private void hasCorrectTitle() { 30 | Element title = html.select("h1").first(); 31 | assertNotNull(title); 32 | assertEquals("MyApplication - New Registration", title.text()); 33 | } 34 | 35 | private String hasCorrectUpdatePasswordLink(String email) throws UnsupportedEncodingException { 36 | Element updatePasswordLink = html.select("a").first(); 37 | assertNotNull(updatePasswordLink); 38 | assertThat(updatePasswordLink.attr("href"), containsString("updatePassword")); 39 | assertThat(updatePasswordLink.attr("href"), containsString("email=" + URLEncoder.encode(email, StandardCharsets.UTF_8.name()))); 40 | assertThat(updatePasswordLink.attr("href"), containsString("oneTimeToken=")); 41 | return updatePasswordLink.attr("href"); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/test/java/org/jamesdbloom/integration/SystemTest.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.integration; 2 | 3 | import org.apache.catalina.Context; 4 | import org.apache.catalina.LifecycleException; 5 | import org.apache.catalina.Service; 6 | import org.apache.catalina.connector.Connector; 7 | import org.apache.catalina.startup.ContextConfig; 8 | import org.apache.catalina.startup.Tomcat; 9 | import org.apache.http.HttpResponse; 10 | import org.apache.http.HttpStatus; 11 | import org.apache.http.client.HttpClient; 12 | import org.apache.http.client.entity.UrlEncodedFormEntity; 13 | import org.apache.http.client.methods.HttpGet; 14 | import org.apache.http.client.methods.HttpPost; 15 | import org.apache.http.config.SocketConfig; 16 | import org.apache.http.conn.ssl.AllowAllHostnameVerifier; 17 | import org.apache.http.conn.ssl.SSLContexts; 18 | import org.apache.http.conn.ssl.TrustStrategy; 19 | import org.apache.http.impl.client.CloseableHttpClient; 20 | import org.apache.http.impl.client.HttpClients; 21 | import org.apache.http.message.BasicNameValuePair; 22 | import org.apache.http.util.EntityUtils; 23 | import org.jamesdbloom.acceptance.login.LoginPage; 24 | import org.jamesdbloom.acceptance.registration.RegistrationPage; 25 | import org.jamesdbloom.acceptance.updatepassword.UpdatePasswordPage; 26 | import org.jamesdbloom.email.NewRegistrationEmail; 27 | import org.junit.AfterClass; 28 | import org.junit.BeforeClass; 29 | import org.junit.Test; 30 | import org.subethamail.wiser.Wiser; 31 | import org.subethamail.wiser.WiserMessage; 32 | 33 | import javax.mail.internet.MimeMessage; 34 | import java.io.File; 35 | import java.io.FileInputStream; 36 | import java.io.IOException; 37 | import java.security.KeyStore; 38 | import java.security.cert.CertificateException; 39 | import java.security.cert.X509Certificate; 40 | import java.util.Arrays; 41 | import java.util.concurrent.TimeUnit; 42 | import java.util.logging.Level; 43 | 44 | import static org.hamcrest.Matchers.empty; 45 | import static org.hamcrest.core.Is.is; 46 | import static org.hamcrest.core.IsNot.not; 47 | import static org.junit.Assert.assertThat; 48 | 49 | /** 50 | * @author jamesdbloom 51 | */ 52 | public class SystemTest { 53 | 54 | private static Tomcat tomcat; 55 | private static Wiser wiser; 56 | private static KeyStore trustStore; 57 | 58 | @BeforeClass 59 | public static void setupFixture() throws Exception { 60 | // setup mock smtp 61 | System.setProperty("email.host", "127.0.0.1"); 62 | System.setProperty("email.port", "2500"); 63 | System.setProperty("email.starttls", "false"); 64 | wiser = new Wiser(); 65 | wiser.setPort(2500); 66 | wiser.start(); 67 | 68 | // determine current filesystem location 69 | String classLocation = SystemTest.class.getCanonicalName().replace(".", "/") + ".class"; 70 | String projectBase = SystemTest.class.getClassLoader().getResource(classLocation).toString().replace(classLocation, "../../").replace("file:", ""); 71 | 72 | // start proxy (in tomcat) 73 | tomcat = new Tomcat(); 74 | tomcat.setBaseDir(new File(".").getCanonicalPath() + File.separatorChar + "tomcat"); 75 | 76 | // add http port 77 | tomcat.setPort(8080); 78 | 79 | // add https port 80 | Connector httpsConnector = new Connector(); 81 | httpsConnector.setPort(8443); 82 | httpsConnector.setSecure(true); 83 | httpsConnector.setScheme("https"); 84 | httpsConnector.setAttribute("keystorePass", "changeit"); 85 | httpsConnector.setAttribute("keystoreFile", projectBase + "keystore"); 86 | httpsConnector.setAttribute("clientAuth", "false"); 87 | httpsConnector.setAttribute("sslProtocol", "TLS"); 88 | httpsConnector.setAttribute("SSLEnabled", true); 89 | Service service = tomcat.getService(); 90 | service.addConnector(httpsConnector); 91 | 92 | // add servlet 93 | Context ctx = tomcat.addContext("/", projectBase + "src/main/webapp"); 94 | ContextConfig contextConfig = new ContextConfig(); 95 | ctx.addLifecycleListener(contextConfig); 96 | contextConfig.setDefaultWebXml(projectBase + "src/main/webapp/WEB-INF/web.xml"); 97 | 98 | // control logging level 99 | java.util.logging.Logger.getLogger("").setLevel(Level.FINER); 100 | 101 | // start server 102 | tomcat.start(); 103 | 104 | // load key store for certificates 105 | trustStore = KeyStore.getInstance(KeyStore.getDefaultType()); 106 | try (FileInputStream fileInputStream = new FileInputStream(new File(projectBase + "keystore"))) { 107 | trustStore.load(fileInputStream, "changeit".toCharArray()); 108 | } 109 | } 110 | 111 | @AfterClass 112 | public static void shutdownFixture() throws LifecycleException { 113 | // stop server 114 | tomcat.stop(); 115 | 116 | // stop smtp mock 117 | wiser.stop(); 118 | } 119 | 120 | @Test 121 | public void registerUpdatePasswordLoginAndViewPage() throws Exception { 122 | // given 123 | HttpClient httpClient = createApacheClient(); 124 | 125 | // when - register 126 | HttpResponse registerPageResponse = httpClient.execute(new HttpGet("https://127.0.0.1:8443/register")); 127 | RegistrationPage registrationPage = new RegistrationPage(getBodyAndClose(registerPageResponse)); 128 | registrationPage.shouldHaveCorrectFields(); 129 | String csrf = registrationPage.csrfValue(); 130 | 131 | HttpPost register = new HttpPost("https://127.0.0.1:8443/register"); 132 | register.setEntity(new UrlEncodedFormEntity(Arrays.asList( 133 | new BasicNameValuePair("name", "test_user"), 134 | new BasicNameValuePair("email", "fake@email.com"), 135 | new BasicNameValuePair("_csrf", csrf) 136 | ))); 137 | HttpResponse registerResponse = httpClient.execute(register); 138 | 139 | // then - should respond with success message 140 | assertThat(registerResponse.getStatusLine().getStatusCode(), is(HttpStatus.SC_MOVED_TEMPORARILY)); 141 | assertThat(registerResponse.getFirstHeader("Location").getValue(), is("https://127.0.0.1:8443/message")); 142 | getBodyAndClose(registerResponse); 143 | 144 | // then - should have sent correct email 145 | TimeUnit.SECONDS.sleep(2); 146 | assertThat(wiser.getMessages(), is(not(empty()))); 147 | WiserMessage registrationWiserMessage = wiser.getMessages().get(0); 148 | MimeMessage mimeMessage = registrationWiserMessage.getMimeMessage(); 149 | NewRegistrationEmail registrationEmail = new NewRegistrationEmail(mimeMessage.getContent().toString()); 150 | String updatePasswordURL = registrationEmail.shouldHaveCorrectFields("fake@email.com"); 151 | 152 | // when - updating password 153 | HttpResponse updatePasswordPageResponse = httpClient.execute(new HttpGet(updatePasswordURL)); 154 | UpdatePasswordPage updatePasswordPage = new UpdatePasswordPage(getBodyAndClose(updatePasswordPageResponse)); 155 | updatePasswordPage.shouldHaveCorrectFields(); 156 | csrf = updatePasswordPage.csrfValue(); 157 | 158 | HttpPost updatePasswordRequest = new HttpPost(updatePasswordURL); 159 | updatePasswordRequest.setEntity(new UrlEncodedFormEntity(Arrays.asList( 160 | new BasicNameValuePair("password", "NewPassword123"), 161 | new BasicNameValuePair("passwordConfirm", "NewPassword123"), 162 | new BasicNameValuePair("_csrf", csrf) 163 | ))); 164 | HttpResponse updatePasswordResponse = httpClient.execute(updatePasswordRequest); 165 | 166 | // then - should respond with success message 167 | assertThat(updatePasswordResponse.getStatusLine().getStatusCode(), is(HttpStatus.SC_MOVED_TEMPORARILY)); 168 | assertThat(updatePasswordResponse.getFirstHeader("Location").getValue(), is("https://127.0.0.1:8443/message")); 169 | getBodyAndClose(updatePasswordResponse); 170 | 171 | // when - hit secured page 172 | HttpResponse landingPageResponse = httpClient.execute(new HttpGet("http://127.0.0.1:8080/")); 173 | 174 | // then - login page is displayed 175 | LoginPage securePageResponse = new LoginPage(getBodyAndClose(landingPageResponse)); 176 | securePageResponse.shouldHaveCorrectFields(); 177 | csrf = securePageResponse.csrfValue(); 178 | 179 | // when - login is performed 180 | HttpPost login = new HttpPost("https://127.0.0.1:8443/login"); 181 | login.setEntity(new UrlEncodedFormEntity(Arrays.asList( 182 | new BasicNameValuePair("username", "fake@email.com"), 183 | new BasicNameValuePair("password", "NewPassword123"), 184 | new BasicNameValuePair("_csrf", csrf) 185 | ))); 186 | HttpResponse loginResponse = httpClient.execute(login); 187 | 188 | // then - secured page is displayed 189 | assertThat(loginResponse.getStatusLine().getStatusCode(), is(HttpStatus.SC_MOVED_TEMPORARILY)); 190 | assertThat(loginResponse.getFirstHeader("Location").getValue(), is("https://127.0.0.1:8443/")); 191 | getBodyAndClose(loginResponse); 192 | 193 | // when - logout 194 | httpClient = createApacheClient(); 195 | HttpResponse logoutResponse = httpClient.execute(new HttpGet("https://127.0.0.1:8443/logout")); 196 | 197 | // then - should get redirected to login page 198 | LoginPage logoutRequestResponse = new LoginPage(getBodyAndClose(logoutResponse)); 199 | logoutRequestResponse.shouldHaveCorrectFields(); 200 | } 201 | 202 | private String getBodyAndClose(HttpResponse httpResponse) throws IOException { 203 | String body = EntityUtils.toString(httpResponse.getEntity()); 204 | EntityUtils.consumeQuietly(httpResponse.getEntity()); 205 | return body; 206 | } 207 | 208 | private CloseableHttpClient createApacheClient() throws Exception { 209 | return HttpClients.custom() 210 | // make sure the tests don't block when server fails to start up 211 | .setDefaultSocketConfig(SocketConfig.custom() 212 | .setSoTimeout((int) TimeUnit.SECONDS.toMillis(4)) 213 | .build()) 214 | .setSslcontext( 215 | SSLContexts 216 | .custom() 217 | .loadTrustMaterial(trustStore, new TrustStrategy() { 218 | public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException { 219 | return true; 220 | } 221 | }) 222 | .build() 223 | ) 224 | .setHostnameVerifier(new AllowAllHostnameVerifier()) 225 | .build(); 226 | } 227 | } 228 | -------------------------------------------------------------------------------- /src/test/java/org/jamesdbloom/web/controller/LandingPageControllerTest.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.controller; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.junit.Assert.assertEquals; 6 | 7 | /** 8 | * @author jamesdbloom 9 | */ 10 | public class LandingPageControllerTest { 11 | 12 | @Test 13 | public void testShouldReturnCorrectLogicalViewName() { 14 | assertEquals("landing", new LandingPageController().getPage()); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/test/java/org/jamesdbloom/web/controller/LoginPageControllerTest.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.controller; 2 | 3 | import org.junit.Test; 4 | import org.springframework.security.web.csrf.CsrfToken; 5 | import org.springframework.ui.ExtendedModelMap; 6 | import org.springframework.ui.Model; 7 | 8 | import javax.servlet.http.HttpServletRequest; 9 | 10 | import static org.junit.Assert.assertEquals; 11 | import static org.mockito.Mockito.mock; 12 | import static org.mockito.Mockito.when; 13 | 14 | /** 15 | * @author jamesdbloom 16 | */ 17 | public class LoginPageControllerTest { 18 | 19 | @Test 20 | public void testShouldReturnCorrectLogicalViewName() { 21 | // given 22 | HttpServletRequest request = mock(HttpServletRequest.class); 23 | CsrfToken csrfToken = mock(CsrfToken.class); 24 | when(request.getAttribute(CsrfToken.class.getName())).thenReturn(csrfToken); 25 | when(csrfToken.getParameterName()).thenReturn("parameterName"); 26 | when(csrfToken.getToken()).thenReturn("token"); 27 | Model model = new ExtendedModelMap(); 28 | 29 | // when 30 | String page = new LoginPageController().getPage(request, model); 31 | 32 | // then 33 | assertEquals("login", page); 34 | assertEquals("parameterName", model.asMap().get("csrfParameterName")); 35 | assertEquals("token", model.asMap().get("csrfToken")); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/test/java/org/jamesdbloom/web/interceptor/bundling/AddBundlingModelToViewModelInterceptorTest.java: -------------------------------------------------------------------------------- 1 | package org.jamesdbloom.web.interceptor.bundling; 2 | 3 | import org.junit.Before; 4 | import org.junit.Test; 5 | import org.junit.runner.RunWith; 6 | import org.mockito.Mock; 7 | import org.mockito.runners.MockitoJUnitRunner; 8 | import org.springframework.mock.web.MockHttpServletRequest; 9 | import org.springframework.web.servlet.ModelAndView; 10 | import ro.isdc.wro.model.WroModel; 11 | import ro.isdc.wro.model.group.Group; 12 | import ro.isdc.wro.model.resource.Resource; 13 | import ro.isdc.wro.model.resource.ResourceType; 14 | 15 | import java.util.Arrays; 16 | import java.util.List; 17 | import java.util.Map; 18 | 19 | import static org.junit.Assert.assertEquals; 20 | import static org.mockito.Mockito.when; 21 | 22 | /** 23 | * @author jamesdbloom 24 | */ 25 | @RunWith(MockitoJUnitRunner.class) 26 | public class AddBundlingModelToViewModelInterceptorTest { 27 | 28 | @Mock 29 | private WroModelHolder wroModelHolder; 30 | private MockHttpServletRequest mockHttpServletRequest; 31 | 32 | @Before 33 | public void setupFixture() { 34 | WroModel wroModel = new WroModel(); 35 | 36 | Group group_one = new Group("group_one"); 37 | Group group_two = new Group("group_two"); 38 | wroModel.setGroups(Arrays.asList(group_one, group_two)); 39 | 40 | group_one.addResource(Resource.create("group_one_css_uri_one", ResourceType.CSS)); 41 | group_one.addResource(Resource.create("group_one_css_uri_two", ResourceType.CSS)); 42 | group_one.addResource(Resource.create("group_one_js_uri_one", ResourceType.JS)); 43 | group_one.addResource(Resource.create("group_one_js_uri_two", ResourceType.JS)); 44 | 45 | group_two.addResource(Resource.create("group_two_css_uri_one", ResourceType.CSS)); 46 | group_two.addResource(Resource.create("group_two_css_uri_two", ResourceType.CSS)); 47 | group_two.addResource(Resource.create("group_two_js_uri_one", ResourceType.JS)); 48 | group_two.addResource(Resource.create("group_two_js_uri_two", ResourceType.JS)); 49 | 50 | when(wroModelHolder.getWroModel()).thenReturn(wroModel); 51 | 52 | mockHttpServletRequest = new MockHttpServletRequest(); 53 | mockHttpServletRequest.setQueryString(""); 54 | } 55 | 56 | @Test 57 | public void testShouldReturnUnbundledResourcesWhenBundlingDisabled() throws Exception { 58 | // given - setupFixture and 59 | ModelAndView modelAndView = new ModelAndView(); 60 | 61 | // when 62 | new AddBundlingModelToViewModelInterceptor(wroModelHolder, "false").postHandle(mockHttpServletRequest, null, null, modelAndView); 63 | 64 | // then 65 | checkViewModelContainsCorrectUnbundledResources(modelAndView); 66 | } 67 | 68 | private void checkViewModelContainsCorrectUnbundledResources(ModelAndView modelAndView) { 69 | assertEquals(Arrays.asList("group_one_js_uri_one", "group_one_js_uri_two"), ((Map