Java Code Examples for org.apache.commons.lang3.RandomStringUtils#random()

@Test
public void select() throws Exception {
    GroupedTimingStatistics groupedTimingStatistics = new GroupedTimingStatistics();
    groupedTimingStatistics.setStartTime(System.currentTimeMillis());

    JtwigTemplate jtwigTemplate = JtwigTemplate.inlineTemplate("{{ var.nested.field[0] }}");
    for (int i = 0; i < SIZE; i++) {
        StopWatch stopWatch = new StopWatch("selection");
        String random = RandomStringUtils.random(6);
        JtwigModel jtwigModel = newModel().with("var", new SelectionTest.TestClass(random));
        stopWatch.start();
        jtwigTemplate.render(jtwigModel);
        stopWatch.stop();
        groupedTimingStatistics.addStopWatch(stopWatch);
    }

    groupedTimingStatistics.setStopTime(System.currentTimeMillis());
    System.out.println(groupedTimingStatistics.toString());
}
 

@Test
public void test_MongoTemplate_UpdateFirst() {
	String firstName = "firstName"+ RandomStringUtils.random(3);
	String lastName  = "lastName"+ RandomStringUtils.random(3);
	savePerson(firstName, lastName);

	final String updateFirstNameTo = "TESTER";
	mongoTemplate.updateFirst(
			query(where("lastname").is(lastName)),
			update("firstname", updateFirstNameTo),
			Person.class);

	Person foundPerson = mongoTemplate.findOne(
			query(where("lastname").is(lastName)),
			Person.class);

	Assert.isTrue(foundPerson != null, "Must not be null");
	Assert.isTrue(foundPerson.getFirstname().equals(updateFirstNameTo), "Must have changed");
}
 

@Test
public void testIsExist() throws Exception {
  try (Table<String, String> testTable = createTypedTable(
      "Eighth")) {
    String key =
        RandomStringUtils.random(10);
    String value = RandomStringUtils.random(10);
    testTable.put(key, value);
    Assert.assertTrue(testTable.isExist(key));

    String invalidKey = key + RandomStringUtils.random(1);
    Assert.assertFalse(testTable.isExist(invalidKey));

    testTable.delete(key);
    Assert.assertFalse(testTable.isExist(key));
  }
}
 

@Test
@Transactional
@WithMockUser("change-password-too-long")
public void testChangePasswordTooLong() throws Exception {
    User user = new User();
    String currentPassword = RandomStringUtils.random(60);
    user.setPassword(passwordEncoder.encode(currentPassword));
    user.setLogin("change-password-too-long");
    user.setEmail("[email protected]");
    userRepository.saveAndFlush(user);

    restMvc.perform(post("/api/account/change-password")
        .contentType(TestUtil.APPLICATION_JSON_UTF8)
        .content(TestUtil.convertObjectToJsonBytes(new PasswordChangeDTO(currentPassword, RandomStringUtils.random(101)))))
        .andExpect(status().isBadRequest());

    User updatedUser = userRepository.findOneByLogin("change-password-too-long").orElse(null);
    assertThat(updatedUser.getPassword()).isEqualTo(user.getPassword());
}
 

@Test
@Transactional
@WithMockUser("change-password-wrong-existing-password")
public void testChangePasswordWrongExistingPassword() throws Exception {
    User user = new User();
    String currentPassword = RandomStringUtils.random(60);
    user.setPassword(passwordEncoder.encode(currentPassword));
    user.setLogin("change-password-wrong-existing-password");
    user.setEmail("[email protected]");
    userRepository.saveAndFlush(user);

    restMvc.perform(post("/api/account/change-password")
        .contentType(TestUtil.APPLICATION_JSON_UTF8)
        .content(TestUtil.convertObjectToJsonBytes(new PasswordChangeDTO("1"+currentPassword, "new password"))))
        .andExpect(status().isBadRequest());

    User updatedUser = userRepository.findOneByLogin("change-password-wrong-existing-password").orElse(null);
    assertThat(passwordEncoder.matches("new password", updatedUser.getPassword())).isFalse();
    assertThat(passwordEncoder.matches(currentPassword, updatedUser.getPassword())).isTrue();
}
 

private String generate() {
  String symbols = "!\"$%^&*()-_=+[{]};:'@#~|,<.>/?\n\t\\\r";
  String alphaNum = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890";
  int low = 96;
  int high = 145;
  Random random = new Random();
  int count = random.nextInt(high - low) + low;
  return RandomStringUtils.random(count, symbols + alphaNum);
}
 

@Test
public void testBasicAttributes() {
    final ContentRepository repository = Simple.createContentRepository();
    final String random = RandomStringUtils.random(5);
    final ScenarioBuilder builder = createScenario();
    builder.name(random).description(random);
    final Result<Scenario, String> result = builder.build(repository);
    assertThat(result.isValid()).isTrue();
    final ScenarioType config = result.getObject().getConfiguration();
    assertThat(config.getName()).isEqualTo(random);
    assertThat(config.getDescription()).isNotNull();
    assertThat(config.getDescription().getPOrOlOrUl()).isNotEmpty();
}
 

@Test
public void testReadWrongKey() throws IOException {
	String data = RandomStringUtils.random(1000);
	fileAgent.writeCache("key", data.getBytes());
	byte[] read = fileAgent.readCache("wrongKey");
	assertNull(read);
}
 

/**
 * Generate random password. If no digits and no special characters included, letters will be used by default.
 *
 * @param minLength password minimum length
 * @param maxLength password maximum length
 * @param digits include digits
 * @param letters include ASCII letters(both lower and upper case)
 * @param specialChars include following characters: "!@#$%^&*()-=[]{};:.,"
 */
public static String generatePassword( int minLength, int maxLength, boolean digits, boolean letters,
                                       boolean specialChars )
{
    Preconditions.checkArgument( minLength > 0, "Invalid min length" );
    Preconditions.checkArgument( maxLength > 0 && maxLength >= minLength, "Invalid max length" );

    StringBuilder chars = new StringBuilder();

    if ( letters || !digits && !specialChars )
    {
        chars.append( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" );
    }

    if ( digits )
    {
        chars.append( "0123456789" );
    }

    if ( specialChars )
    {
        chars.append( "!#$%^&*()=[]{};:.,<>?" );
    }

    int length = minLength + new Random().nextInt( maxLength - minLength );

    return RandomStringUtils.random( length, chars.toString() );
}
 

@Test
public void update() throws IOException {
  final UUID uuid = UUID.fromString("f89dee73-af9f-4cd4-b330-db93c25ff3c7");
  final Advertisement adv = getContainer().getAdvertisements().getByKey(uuid);
  final String random = RandomStringUtils.random(124, "abcdefghijklmnopqrstuvwxyz");
  adv.uploadStream(getContainer().newEdmStreamValue("application/octet-stream", IOUtils.toInputStream(random)));
  getContainer().flush();
  assertEquals(random,
      IOUtils.toString(getContainer().getAdvertisements().getByKey(uuid).loadStream().getStream()));
  getService().getContext().detachAll();
}
 

private ServiceEndpointRequest<HttpsServiceEndpoint> createServiceEndpointRequest(String hostAddressString, Integer port) {
    String targetInstanceId = RandomStringUtils.random(10);
    HostEndpoint hostEndpoint = mock(HostEndpoint.class);
    when(hostEndpoint.getHostAddressString()).thenReturn(hostAddressString);
    int randomValue = RandomUtils.nextInt(0, 2);
    ServiceFamily<HttpsServiceEndpoint> serviceFamily = (randomValue == 0) ? ServiceFamilies.GATEWAY : ServiceFamilies.KNOX;
    return ServiceEndpointRequest.createDefaultServiceEndpointRequest(targetInstanceId, hostEndpoint, port, serviceFamily, false);
}
 

/**
 * 随机字母，固定长度
 */
public static String randomLetterFixLength(int length) {
	return RandomStringUtils.random(length, 0, 0, true, false, null, threadLocalRandom());
}
 

public static String getRandomId() {
    return RandomStringUtils.random(ID_LENGTH, "abcdefghijklmnopqrstuvwxyz1234567890");
}
 

/**
 * 随机字母或数字，固定长度
 */
public static String randomStringFixLength(int length) {
	return RandomStringUtils.random(length, 0, 0, true, true, null, threadLocalRandom());
}
 

private static String generateRandom(int length) {
  boolean useLetters = true;
  boolean useNumbers = false;
  return RandomStringUtils.random(length, useLetters, useNumbers);
}
 

/**
 * 随机字母，固定长度
 */
public static String randomLetterFixLength(int length) {
	return RandomStringUtils.random(length, 0, 0, true, false, null, threadLocalRandom());
}
 

/**
 * 随机ASCII字符(含字母，数字及其他符号)，固定长度
 */
public static String randomAsciiFixLength(Random random, int length) {
	return RandomStringUtils.random(length, 32, 127, false, false, null, random);
}
 

@SuppressWarnings("unchecked")
@Test
void fetchMatchingResources_WithKeySet_ShouldFetchResourcesAndCacheKeys() {
    //preparation
    final String key1 = RandomStringUtils.random(15);
    final String key2 = RandomStringUtils.random(15);

    final HashSet<String> resourceKeys = new HashSet<>();
    resourceKeys.add(key1);
    resourceKeys.add(key2);

    final Product mock1 = mock(Product.class);
    when(mock1.getId()).thenReturn(RandomStringUtils.random(15));
    when(mock1.getKey()).thenReturn(key1);

    final Product mock2 = mock(Product.class);
    when(mock2.getId()).thenReturn(RandomStringUtils.random(15));
    when(mock2.getKey()).thenReturn(key2);

    final PagedQueryResult result = mock(PagedQueryResult.class);
    when(result.getResults()).thenReturn(Arrays.asList(mock1, mock2));

    when(client.execute(any(ProductQuery.class))).thenReturn(completedFuture(result));

    //test fetch
    final Set<Product> resources = service
        .fetchMatchingProductsByKeys(resourceKeys)
        .toCompletableFuture().join();

    //assertions
    assertThat(resources).containsExactlyInAnyOrder(mock1, mock2);
    verify(client, times(1)).execute(any(ProductQuery.class));

    //test caching
    final Optional<String> cachedKey1 = service
        .getIdFromCacheOrFetch(mock1.getKey())
        .toCompletableFuture().join();

    final Optional<String> cachedKey2 = service
        .getIdFromCacheOrFetch(mock2.getKey())
        .toCompletableFuture().join();

    //assertions
    assertThat(cachedKey1).contains(mock1.getId());
    assertThat(cachedKey2).contains(mock2.getId());
    // still 1 request from the first #fetchMatchingProductsByKeys call
    verify(client, times(1)).execute(any(ProductQuery.class));
}
 

/**
 * 随机字母或数字，随机长度
 */
public static String randomStringRandomLength(int minLength, int maxLength) {
	return RandomStringUtils.random(nextInt(minLength, maxLength), 0, 0, true, true, null, threadLocalRandom());
}
 

/**
 * Generate a random of RandomisedUrlService.SECURE length
 * @return
 */
private String generateSecure() {
	return RandomStringUtils.random(SECURE, true, true);
}