@Test
  public void shouldProcessRegistration() throws Exception {
    Spitter unsaved = new Spitter("Gustavo", "Diaz", "gdiaz", "gd123");
    Spitter saved = new Spitter(24L, "Gustavo", "Diaz", "gdiaz", "gd123");
    SpitterRepository spittlerRepository = Mockito.mock(SpitterRepository.class);
    Mockito.when(spittlerRepository.save(unsaved)).thenReturn(saved);

    SpitterController spittleController = new SpitterController(spittlerRepository);

    MockMvc mockSpittleController = MockMvcBuilders.standaloneSetup(spittleController).build();

    mockSpittleController
        .perform(
            MockMvcRequestBuilders.post("/spitter/registerNoPic")
                .param("firstName", "Gustavo")
                .param("lastName", "Diaz")
                .param("userName", "gdiaz")
                .param("password", "gd123"))
        .andExpect(
            MockMvcResultMatchers.redirectedUrl(
                "/spitter/" + unsaved.getUserName() + "?id=" + unsaved.getFirstName()));

    // capture arguments pass to save call.
    ArgumentCaptor<Spitter> spitterArgumentCaptor = ArgumentCaptor.forClass(Spitter.class);
    Mockito.verify(spittlerRepository, Mockito.atLeastOnce()).save(spitterArgumentCaptor.capture());

    // assert save method was called using same arguments.
    Assert.assertThat(
        spitterArgumentCaptor.getValue(),
        org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs(unsaved));
  }
Example #2
0
  @Before
  public void setup() {

    TagController tagController = new TagController();
    ReflectionTestUtils.setField(tagController, "timelineService", timelineService);
    ReflectionTestUtils.setField(tagController, "tagMembershipService", tagMembershipService);
    ReflectionTestUtils.setField(tagController, "userTagRepository", userTagRepository);

    User authenticateUser = constructAUser(username + "@ippon.fr");
    AuthenticationService mockAuthenticationService = mock(AuthenticationService.class);
    when(mockAuthenticationService.getCurrentUser()).thenReturn(authenticateUser);
    ReflectionTestUtils.setField(tagController, "authenticationService", mockAuthenticationService);
    ReflectionTestUtils.setField(
        timelineService, "authenticationService", mockAuthenticationService);
    ReflectionTestUtils.setField(
        statusUpdateService, "authenticationService", mockAuthenticationService);
    ReflectionTestUtils.setField(
        tagMembershipService, "authenticationService", mockAuthenticationService);
    this.mockMvc = MockMvcBuilders.standaloneSetup(tagController).build();

    TimelineController timelineController = new TimelineController();
    ReflectionTestUtils.setField(timelineController, "timelineService", timelineService);
    ReflectionTestUtils.setField(timelineController, "statusUpdateService", statusUpdateService);
    this.timelineMockMvc = MockMvcBuilders.standaloneSetup(timelineController).build();
  }
  @Before
  public void setup() {
    Mockito.reset(bookService);

    InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
    viewResolver.setPrefix("/WEB-INF/templates/");
    viewResolver.setSuffix(".html");

    mockMvc =
        MockMvcBuilders.standaloneSetup(new BookController())
            .setViewResolvers(viewResolver)
            .build();
    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
  }
  @Test
  public void mock_mvc_instance_is_overwritten_when_defined_in_specification() {
    // Given
    MockMvc otherMockMvcInstance = MockMvcBuilders.standaloneSetup(new PostController()).build();
    MockMvc thisMockMvcInstance = MockMvcBuilders.standaloneSetup(new GreetingController()).build();

    MockMvcRequestSpecification specToMerge =
        new MockMvcRequestSpecBuilder().setMockMvc(otherMockMvcInstance).build();

    // When
    MockMvcRequestSpecification spec = given().mockMvc(thisMockMvcInstance).spec(specToMerge);

    // Then
    assertThat(implOf(spec).getInstanceMockMvc()).isSameAs(otherMockMvcInstance);
  }
Example #5
0
  @BeforeClass(alwaysRun = true)
  public void init() throws Exception {
    MockitoAnnotations.initMocks(this);
    mockMvc = MockMvcBuilders.webAppContextSetup(wac).apply(springSecurity()).build();

    testUser =
        new SpringUser(
            3L,
            "*****@*****.**",
            "Test",
            "User",
            "testuser",
            "testuser",
            "es",
            getGrantedAuthorities(),
            true,
            true,
            true,
            true);
    token =
        new TokenHandler(
                DatatypeConverter.parseBase64Binary(
                    "9SyECk96oDsTmXfogIfgdjhdsgvagHJLKNLvfdsfR8cbXTvoPjX+Pq/T/b1PqpHX0lYm0oCBjXWICA=="))
            .createTokenForUser(testUser);
  }
 @Before
 public void setup() {
   this.mockMvc =
       MockMvcBuilders.standaloneSetup(petController)
           .setConversionService(formattingConversionServiceFactoryBean.getObject())
           .build();
 }
  @Test
  @Transactional
  public void getBloodPressureForLast30Days() throws Exception {
    ZonedDateTime now = ZonedDateTime.now();
    ZonedDateTime firstOfMonth = now.withDayOfMonth(1);
    ZonedDateTime firstDayOfLastMonth = firstOfMonth.minusMonths(1);
    createBloodPressureByMonth(firstOfMonth, firstDayOfLastMonth);

    // create security-aware mockMvc
    restBloodPressureMockMvc =
        MockMvcBuilders.webAppContextSetup(context).apply(springSecurity()).build();

    // Get all the blood pressure readings
    restBloodPressureMockMvc
        .perform(get("/api/bloodPressures").with(user("user").roles("USER")))
        .andExpect(status().isOk())
        .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$", hasSize(6)));

    // Get the blood pressure readings for the last 30 days
    restBloodPressureMockMvc
        .perform(get("/api/bp-by-days/{days}", 30).with(user("user").roles("USER")))
        .andDo(print())
        .andExpect(status().isOk())
        .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$.period").value("Last 30 Days"))
        .andExpect(jsonPath("$.readings.[*].systolic").value(hasItem(120)))
        .andExpect(jsonPath("$.readings.[*].diastolic").value(hasItem(75)));
  }
 @Before
 public void setUp() {
   mockMvc =
       MockMvcBuilders.webAppContextSetup(webApplicationContext)
           .addFilter(springSecurityFilterChain)
           .build();
 }
  @Before
  public void setup() {
    logger.info("setup");

    this.mockMvc =
        MockMvcBuilders.webAppContextSetup(context).addFilters(springSecurityFilterChain).build();

    User user = null;
    try {
      user = userService.findByLogin("johndoe");
    } catch (ServiceException e) {
      logger.error(e.getLocalizedMessage());
    }

    Authentication authentication = null;
    if (user != null) {
      authentication = new UsernamePasswordAuthenticationToken(user.getLogin(), user.getPassword());
    }
    Authentication result = authenticationManager.authenticate(authentication);
    SecurityContext securityContext = SecurityContextHolder.getContext();
    securityContext.setAuthentication(result);
    session = new MockHttpSession();
    session.setAttribute(
        HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, securityContext);
  }
 @Test
 public void correctlyRecordsMetricsForFailedDeferredResultResponse() throws Exception {
   AnnotationConfigApplicationContext context =
       new AnnotationConfigApplicationContext(Config.class, MetricFilterAutoConfiguration.class);
   MetricsFilter filter = context.getBean(MetricsFilter.class);
   CountDownLatch latch = new CountDownLatch(1);
   MockMvc mvc =
       MockMvcBuilders.standaloneSetup(new MetricFilterTestController(latch))
           .addFilter(filter)
           .build();
   String attributeName = MetricsFilter.class.getName() + ".StopWatch";
   MvcResult result =
       mvc.perform(post("/createFailure"))
           .andExpect(status().isOk())
           .andExpect(request().asyncStarted())
           .andExpect(request().attribute(attributeName, is(notNullValue())))
           .andReturn();
   latch.countDown();
   try {
     mvc.perform(asyncDispatch(result));
     fail();
   } catch (Exception ex) {
     assertThat(result.getRequest().getAttribute(attributeName)).isNull();
     verify(context.getBean(CounterService.class)).increment("status.500.createFailure");
   } finally {
     context.close();
   }
 }
Example #11
0
 @PostConstruct
 public void setup() {
   MockitoAnnotations.initMocks(this);
   CouponResource couponResource = new CouponResource();
   ReflectionTestUtils.setField(couponResource, "couponRepository", couponRepository);
   this.restCouponMockMvc = MockMvcBuilders.standaloneSetup(couponResource).build();
 }
  @Test
  public void testUpdatePasswordBadCurrentPassword() throws Exception {
    String username = "******";
    String currentPassword = "******";
    String password = "******";

    mockMvc =
        MockMvcBuilders.webAppContextSetup(context).addFilters(springSecurityFilterChain).build();

    // user must ge logged in
    HttpSession session =
        mockMvc
            .perform(
                post("/j_security_check").param("j_username", "admin").param("j_password", "admin"))
            .andExpect(status().is(HttpStatus.FOUND.value()))
            .andExpect(redirectedUrl("/"))
            .andReturn()
            .getRequest()
            .getSession();

    mockMvc
        .perform(
            post("/updatePassword")
                .session((MockHttpSession) session)
                .param("username", username)
                .param("currentPassword", currentPassword)
                .param("password", password))
        .andExpect(status().isOk());

    assertNull(session.getAttribute(BaseFormController.MESSAGES_KEY));
    assertNotNull(session.getAttribute(BaseFormController.ERRORS_MESSAGES_KEY));
  }
 @Before
 public void setup() {
   UserResource userResource = new UserResource();
   ReflectionTestUtils.setField(userResource, "userRepository", userRepository);
   ReflectionTestUtils.setField(userResource, "userService", userService);
   this.restUserMockMvc = MockMvcBuilders.standaloneSetup(userResource).build();
 }
  @Test
  public void testGetText() throws Exception {
    String inputString = "User related info!";
    FormData data = new FormData();
    data.setComment(inputString);

    mockMvc = MockMvcBuilders.standaloneSetup(new ActionController()).build();
    MvcResult result =
        this.mockMvc
            .perform(get("/users").contentType(MediaType.APPLICATION_JSON).content(data.toString()))
            .andExpect(status().isOk())
            .andReturn();
    String returnString = result.getResponse().getContentAsString();
    ObjectMapper objectMapper = new ObjectMapper();
    logger.info("Call to /users returned: " + returnString);

    // convert json string to object
    FormActionResult returnData =
        objectMapper.readValue(returnString.getBytes(), FormActionResult.class);
    String expectedString = returnData.getFormData().getComment();
    logger.debug("USERS ACTION RETURNED: " + expectedString);

    assertTrue(
        "Expected data: \"" + inputString + "\"  actual data=\"" + expectedString + "\" ",
        inputString.equals(expectedString));
  }
  @Before
  public void setup() {

    MockitoAnnotations.initMocks(this);

    account =
        new Account(
            "john",
            "malkovich",
            "Ireland",
            new BigInteger("500600700"),
            new BigInteger("1234567890"),
            new BigDecimal(25),
            "EUR");

    accountForm = new AccountForm();
    accountForm.setName("john");
    accountForm.setSurname("malkovich");
    accountForm.setAddress("Ireland");
    accountForm.setPhone(new BigInteger("500600700"));
    accountForm.setIban(new BigInteger("1234567890"));
    accountForm.setBalance(new BigDecimal(25));
    accountForm.setCurrency("EUR");

    viewResolver = new InternalResourceViewResolver();
    viewResolver.setPrefix("/WEB-INF/views/");
    viewResolver.setSuffix(".jsp");

    mockMvc =
        MockMvcBuilders.standaloneSetup(accountController).setViewResolvers(viewResolver).build();
  }
 @PostConstruct
 public void setup() {
   MockitoAnnotations.initMocks(this);
   TableNoResource tableNoResource = new TableNoResource();
   ReflectionTestUtils.setField(tableNoResource, "tableNoRepository", tableNoRepository);
   this.restTableNoMockMvc = MockMvcBuilders.standaloneSetup(tableNoResource).build();
 }
 @BeforeMethod
 public void setUp() {
   mockMvc =
       MockMvcBuilders.standaloneSetup(homeController)
           .setMessageConverters(new GsonHttpMessageConverter())
           .build();
 }
 @PostConstruct
 public void setup() {
   MockitoAnnotations.initMocks(this);
   DTUserResource dTUserResource = new DTUserResource();
   ReflectionTestUtils.setField(dTUserResource, "dTUserRepository", dTUserRepository);
   this.restDTUserMockMvc = MockMvcBuilders.standaloneSetup(dTUserResource).build();
 }
 @PostConstruct
 public void setup() {
   MockitoAnnotations.initMocks(this);
   AuthorResource authorResource = new AuthorResource();
   ReflectionTestUtils.setField(authorResource, "authorRepository", authorRepository);
   this.restAuthorMockMvc = MockMvcBuilders.standaloneSetup(authorResource).build();
 }
Example #20
0
 @Before
 public void setUp() throws Exception {
   this.mock = MockMvcBuilders.webAppContextSetup(wac).build();
   test = new ResultMessage();
   test.set_result("success");
   test.set_resultCode("200");
 }
 @Before
 @Transactional
 public void setUp() throws Exception {
   comment = repo.save(new Comment(ObjectId.get().toHexString(), 1L, "#foos"));
   this.parser = new JsonParser(mapper);
   mvc = MockMvcBuilders.webAppContextSetup(wac).alwaysDo(print()).build();
 }
 @Before
 public void setup() {
   MockitoAnnotations.initMocks(this);
   AuditEventService auditEventService =
       new AuditEventService(auditEventRepository, auditEventConverter);
   AuditResource auditResource = new AuditResource(auditEventService);
   this.restAuditMockMvc = MockMvcBuilders.standaloneSetup(auditResource).build();
 }
  @Before
  public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    mvc = MockMvcBuilders.standaloneSetup(logController).build();

    setUpActivityServiceMock();
    setUpLogServiceMock();
  }
 @Before
 public void setUp() {
   this.mockMvc =
       MockMvcBuilders.webAppContextSetup(this.context)
           .apply(documentationConfiguration())
           .alwaysDo(document("{method-name}/{step}/"))
           .build();
 }
  @Before
  public void setUp() {
    Mockito.reset(userServiceMock);

    mockMvc = MockMvcBuilders.webAppContextSetup(webAppContext).build();

    SecurityContextHolder.getContext().setAuthentication(null);
  }
Example #26
0
 @Before
 public void init() {
   MockitoAnnotations.initMocks(this);
   tc = new MobileController();
   ReflectionTestUtils.setField(tc, "tripsService", tripsService);
   ReflectionTestUtils.setField(tc, "messageSource", messageSource);
   mockMvc = MockMvcBuilders.standaloneSetup(tc).build();
 }
 @Before
 public void setUp() throws java.text.ParseException {
   this.mockMvc = MockMvcBuilders.webAppContextSetup(this.webApplicationContext).build();
   user.setName("User Name");
   user.setEmail("*****@*****.**");
   user.setPicture(
       "https://lh4.googleusercontent.com/-N5NiXjGy98Q/AAAAAAAAAAI/AAAAAAAAAB4/GhIWSa3iyR4/photo.jpg");
 }
  @Before
  public void setUp() throws Exception {

    // this.mockMvc =
    // MockMvcBuilders.webAppContextSetup(this.wac).addFilter(this.springSecurityFilterChain).build();
    this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
    mockMvc.perform(post("/api/user/login").param("username", "admin").param("password", "admin"));
  }
 @Before
 public void setUp() {
   this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
   TestUtility.initialize();
   TestUtility.setUp(userDao, profileDao);
   this.authUser =
       TestUtility.createPrincipal(TestUtility.testUser.getEmail(), "password", "ROLE_TUTOR");
 }
 @Before
 public void setUp() {
   logger.debug("LocalSystemTest::setUp");
   mockMvc =
       MockMvcBuilders.webAppContextSetup(webApplicationContext)
           .addFilter(transactionFilter)
           .build();
 }