Examples with StringUtils.join org.apache.commons.lang3.StringUtils.join used on opensource projects

Example 46 with StringUtils.join

use of org.apache.commons.lang3.StringUtils.join in project dcos-commons by mesosphere.

the class PodSpecsCannotChangeNetworkRegime method validate.

@Override
public Collection<ConfigValidationError> validate(Optional<ServiceSpec> oldConfig, ServiceSpec newConfig) {
    if (!oldConfig.isPresent()) {
        return Collections.emptyList();
    }
    Map<String, PodSpec> newPods;
    try {
        newPods = newConfig.getPods().stream().collect(Collectors.toMap(podSpec -> podSpec.getType(), podSpec -> podSpec));
    } catch (IllegalStateException e) {
        return Arrays.asList(ConfigValidationError.valueError("PodSpecs", "null", "Duplicate pod types detected."));
    }
    // check the PodSpecs to make sure none of them make a transition from a state where they use host ports
    // to one where they don't (or vice versa).
    Collection<ConfigValidationError> errors = new ArrayList<>();
    Map<String, PodSpec> oldPods = oldConfig.get().getPods().stream().collect(Collectors.toMap(PodSpec::getType, podSpec -> podSpec));
    for (Map.Entry<String, PodSpec> kv : newPods.entrySet()) {
        PodSpec newPod = kv.getValue();
        // first we check that the new pod's networks (if present) do not erroneously use port mapping
        List<String> offendingNetworkNames = getNetworksWithInvalidPortMappings(newPod);
        if (offendingNetworkNames.size() > 0) {
            errors.add(ConfigValidationError.transitionError(String.format("PodSpec[name:%s]", newPod.getType()), "null", newPod.getNetworks().toString(), String.format("New config has pod %s that indicates port mapping for virtual network(s) %s, " + "that do not support port mapping.", newPod.getType(), StringUtils.join(offendingNetworkNames, ", "))));
        }
        // now we check that the none of the new pods move from not using host ports to using them (or vice
        // versa)
        PodSpec oldPod = oldPods.get(kv.getKey());
        if (oldPod != null && podSpecUsesHostPorts(oldPod) != podSpecUsesHostPorts(newPod)) {
            errors.add(ConfigValidationError.transitionError(String.format("PodSpec[name:%s]", oldPod.getType()), oldPod.getNetworks().toString(), newPod.getNetworks().toString(), String.format("New config has pod %s moving networks from %s to %s, changing its " + "host ports requirements from %s to %s, not allowed.", newPod.getType(), oldPod.getNetworks().toString(), newPod.getNetworks().toString(), podSpecUsesHostPorts(oldPod), podSpecUsesHostPorts(newPod))));
        }
    }
    return errors;
}

Example 47 with StringUtils.join

use of org.apache.commons.lang3.StringUtils.join in project selenium_java by sergueik.

the class SuvianTest method test25_2.

// This test was developed with Selenium Driver 2.53 and needs update to work
// with Selenium 3.x.x
@Test(enabled = true)
public void test25_2() {
    // Arrange
    driver.get("http://suvian.in/selenium/3.5cricketScorecard.html");
    WebElement link = wait.until(ExpectedConditions.visibilityOf(driver.findElement(By.cssSelector(".container .row .intro-message h3 a"))));
    // Act
    assertThat(link, notNullValue());
    assertThat(link.getText(), containsString("Generate Scorecard"));
    link.click();
    // Wait page to update
    com.google.common.base.Predicate<WebDriver> hasScore = d -> {
        return (boolean) (d.findElement(By.cssSelector(".container .row .intro-message table tbody tr td p#sachinruns")).getText().trim().length() > 0);
    };
    try {
        wait.until(d -> {
            return (boolean) (d.findElement(By.cssSelector(".container .row .intro-message table tbody tr td p#sachinruns")).getText().trim().length() > 0);
        });
    } catch (UnreachableBrowserException e) {
    }
    // Assert
    List<Integer> scores = driver.findElements(By.cssSelector(".container .row .intro-message table tbody tr td:nth-of-type(2) p[id]")).stream().map(e -> Integer.parseInt(e.getText().trim())).collect(Collectors.toList());
    Collections.sort(scores, Collections.reverseOrder());
    int maxScore = scores.get(0);
    int minScore = scores.get(scores.size() - 1);
    assertTrue(maxScore >= minScore);
    List<String> players = driver.findElements(By.cssSelector(".container .row .intro-message table tbody tr td:nth-of-type(1)")).stream().filter(o -> {
        WebElement s = o.findElement(By.xpath("following-sibling::td"));
        return (Boolean) (Integer.parseInt(s.getText()) == maxScore);
    }).map(e -> e.getText()).collect(Collectors.toList());
    System.err.println(players.get(0));
    WebElement playerNameInput = wait.until(ExpectedConditions.visibilityOf(driver.findElement(By.cssSelector("form.form-inline input#score[name='topscorer']"))));
    playerNameInput.clear();
    playerNameInput.sendKeys(StringUtils.join(players, ","));
    Integer scoreSachin = Integer.parseInt(driver.findElement(By.cssSelector(".container .row .intro-message table tbody tr td p#sachinruns")).getText().trim());
    WebElement scoreInput = wait.until(ExpectedConditions.visibilityOf(driver.findElement(By.cssSelector("form.form-inline input#score[name='sachinruns']"))));
    scoreInput.clear();
    scoreInput.sendKeys(String.format("%d", scoreSachin));
    sleep(1000);
}

Example 48 with StringUtils.join

use of org.apache.commons.lang3.StringUtils.join in project spring-roo by spring-projects.

the class RepositoryJpaMetadataProviderImpl method getMetadata.

@Override
protected ItdTypeDetailsProvidingMetadataItem getMetadata(final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) {
    final RepositoryJpaAnnotationValues annotationValues = new RepositoryJpaAnnotationValues(governorPhysicalTypeMetadata);
    final JavaType domainType = annotationValues.getEntity();
    // XXX clear entitiesDetails by security
    entitiesDetails.clear();
    // Remember that this entity JavaType matches up with this metadata
    // identification string
    // Start by clearing any previous association
    final JavaType oldEntity = repositoryMidToDomainTypeMap.get(metadataIdentificationString);
    if (oldEntity != null) {
        domainTypeToRepositoryMidMap.remove(oldEntity);
    }
    domainTypeToRepositoryMidMap.put(domainType, metadataIdentificationString);
    repositoryMidToDomainTypeMap.put(metadataIdentificationString, domainType);
    // Getting associated entity
    JavaType entity = annotationValues.getEntity();
    ClassOrInterfaceTypeDetails entityDetails = getTypeLocationService().getTypeDetails(entity);
    MemberDetails entityMemberDetails = getMemberDetailsScanner().getMemberDetails(this.getClass().getName(), entityDetails);
    final String entityMetadataId = JpaEntityMetadata.createIdentifier(entityDetails);
    final JpaEntityMetadata entityMetadata = getMetadataService().get(entityMetadataId);
    if (entityMetadata == null) {
        return null;
    }
    // Getting java bean metadata
    final String javaBeanMetadataKey = JavaBeanMetadata.createIdentifier(entityDetails);
    // Register dependency between repositoryMetadata and jpaEntityMetadata
    registerDependency(entityMetadataId, metadataIdentificationString);
    // Create dependency between repository and java bean annotation
    registerDependency(javaBeanMetadataKey, metadataIdentificationString);
    // Check if related entity is setted as readOnly
    JavaType readOnlyRepository = null;
    if (entityMetadata.isReadOnly()) {
        // Getting ReadOnlyRepository interface annotated with
        // @RooReadOnlyRepository
        Set<ClassOrInterfaceTypeDetails> readOnlyRepositories = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(ROO_READ_ONLY_REPOSITORY);
        Validate.notEmpty(readOnlyRepositories, "ERROR: You should define a ReadOnlyRepository interface annotated with @RooReadOnlyRepository to be able to generate repositories of readOnly entities.");
        Iterator<ClassOrInterfaceTypeDetails> it = readOnlyRepositories.iterator();
        while (it.hasNext()) {
            ClassOrInterfaceTypeDetails readOnlyRepositoryDetails = it.next();
            readOnlyRepository = readOnlyRepositoryDetails.getType();
            break;
        }
    }
    List<JavaType> repositoryCustomList = new ArrayList<JavaType>();
    // Getting RepositoryCustom interface annotated with
    // @RooJpaRepositoryCustom
    Set<ClassOrInterfaceTypeDetails> customRepositories = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(ROO_REPOSITORY_JPA_CUSTOM);
    Iterator<ClassOrInterfaceTypeDetails> customRepositoriesIt = customRepositories.iterator();
    while (customRepositoriesIt.hasNext()) {
        ClassOrInterfaceTypeDetails customRepository = customRepositoriesIt.next();
        AnnotationMetadata annotation = customRepository.getAnnotation(ROO_REPOSITORY_JPA_CUSTOM);
        if (annotation.getAttribute("entity").getValue().equals(entity)) {
            repositoryCustomList.add(customRepository.getType());
        }
    }
    Validate.notEmpty(repositoryCustomList, "Can't find any interface annotated with @%s(entity=%s)", ROO_REPOSITORY_JPA_CUSTOM.getSimpleTypeName(), entity.getSimpleTypeName());
    Validate.isTrue(repositoryCustomList.size() == 1, "More than one interface annotated with @%s(entity=%s): %s", ROO_REPOSITORY_JPA_CUSTOM.getSimpleTypeName(), entity.getSimpleTypeName(), StringUtils.join(repositoryCustomList, ","));
    JavaType defaultReturnType;
    final JavaType annotationDefaultReturnType = annotationValues.getDefaultReturnType();
    // Get and check defaultReturnType
    if (annotationDefaultReturnType == null || annotationDefaultReturnType.equals(JavaType.CLASS) || annotationDefaultReturnType.equals(entity)) {
        defaultReturnType = entity;
    } else {
        // Validate that defaultReturnValue is projection of current entity
        ClassOrInterfaceTypeDetails returnTypeCid = getTypeLocationService().getTypeDetails(annotationDefaultReturnType);
        AnnotationMetadata projectionAnnotation = returnTypeCid.getAnnotation(RooJavaType.ROO_ENTITY_PROJECTION);
        Validate.notNull(projectionAnnotation, "ERROR: %s defined on %s.@%s.defaultReturnType must be annotated with @%s annotation", annotationDefaultReturnType, governorPhysicalTypeMetadata.getType(), RooJavaType.ROO_REPOSITORY_JPA, RooJavaType.ROO_ENTITY_PROJECTION);
        Validate.isTrue(entity.equals(projectionAnnotation.getAttribute("entity").getValue()), "ERROR: %s defined on %s.@%s.defaultReturnType must be annotated with @%s annotation and match the 'entity' attribute value", annotationDefaultReturnType, governorPhysicalTypeMetadata.getType(), RooJavaType.ROO_REPOSITORY_JPA, RooJavaType.ROO_ENTITY_PROJECTION);
        defaultReturnType = annotationDefaultReturnType;
    }
    // Get field which entity is field part
    List<Pair<FieldMetadata, RelationInfo>> relationsAsChild = getJpaOperations().getFieldChildPartOfRelation(entityDetails);
    // Get Annotation
    ClassOrInterfaceTypeDetails cid = governorPhysicalTypeMetadata.getMemberHoldingTypeDetails();
    AnnotationMetadata repositoryAnnotation = cid.getAnnotation(ROO_REPOSITORY_JPA);
    // Create list of finder to add
    List<FinderMethod> findersToAdd = new ArrayList<FinderMethod>();
    // Create list of finder to add in RespositoryCustom
    List<Pair<FinderMethod, PartTree>> findersToAddInCustom = new ArrayList<Pair<FinderMethod, PartTree>>();
    Map<JavaType, ClassOrInterfaceTypeDetails> detailsCache = new HashMap<JavaType, ClassOrInterfaceTypeDetails>();
    List<String> declaredFinderNames = new ArrayList<String>();
    RooFinder[] findersAnnValue = annotationValues.getFinders();
    // Get finders attributes
    AnnotationAttributeValue<?> currentFinders = repositoryAnnotation.getAttribute("finders");
    if (currentFinders != null) {
        List<?> values = (List<?>) currentFinders.getValue();
        Iterator<?> valuesIt = values.iterator();
        while (valuesIt.hasNext()) {
            NestedAnnotationAttributeValue finderAnnotation = (NestedAnnotationAttributeValue) valuesIt.next();
            if (finderAnnotation.getValue() != null && finderAnnotation.getValue().getAttribute("value") != null) {
                // Get finder name
                String finderName = null;
                if (finderAnnotation.getValue().getAttribute("value").getValue() instanceof String) {
                    finderName = (String) finderAnnotation.getValue().getAttribute("value").getValue();
                }
                Validate.notNull(finderName, "'finder' attribute in @RooFinder must be a String");
                declaredFinderNames.add(finderName);
                // Get finder return type
                JavaType returnType = getNestedAttributeValue(finderAnnotation, "returnType");
                JavaType finderReturnType;
                if (returnType == null || JavaType.CLASS.equals(returnType)) {
                    finderReturnType = defaultReturnType;
                    returnType = null;
                } else {
                    finderReturnType = returnType;
                }
                // Get finder return type
                JavaType formBean = getNestedAttributeValue(finderAnnotation, "formBean");
                boolean isDeclaredFormBean = false;
                if (JavaType.CLASS.equals(formBean)) {
                    formBean = null;
                }
                // Create FinderMethods
                PartTree finder = new PartTree(finderName, entityMemberDetails, this, finderReturnType);
                Validate.notNull(finder, String.format("ERROR: '%s' is not a valid finder. Use autocomplete feature (TAB or CTRL + Space) to include finder that follows Spring Data nomenclature.", finderName));
                FinderMethod finderMethod = new FinderMethod(finder);
                // Add dependencies between modules
                List<JavaType> types = new ArrayList<JavaType>();
                types.add(finder.getReturnType());
                types.addAll(finder.getReturnType().getParameters());
                for (FinderParameter parameter : finder.getParameters()) {
                    types.add(parameter.getType());
                    types.addAll(parameter.getType().getParameters());
                }
                for (JavaType parameter : types) {
                    getTypeLocationService().addModuleDependency(governorPhysicalTypeMetadata.getType().getModule(), parameter);
                }
                if (formBean == null && (returnType == null || entity.equals(returnType))) {
                    // Add to finder methods list
                    findersToAdd.add(finderMethod);
                } else {
                    // RepositoryCustom classes.
                    if (returnType != null && !returnType.equals(entity)) {
                        ClassOrInterfaceTypeDetails returnTypeDetails = getDetailsFor(returnType, detailsCache);
                        Validate.isTrue(returnTypeDetails != null && returnTypeDetails.getAnnotation(RooJavaType.ROO_ENTITY_PROJECTION) != null, "ERROR: finder '%s' declared 'returnType' (%s) is not annotated with @%s annotation", finderName, returnType.getSimpleTypeName(), RooJavaType.ROO_ENTITY_PROJECTION.getSimpleTypeName());
                    }
                    Validate.notNull(formBean, "ERROR: finder '%s' requires 'formBean' value if 'defaultReturnType' is defined", finderName);
                    ClassOrInterfaceTypeDetails formBeanDetails = getTypeLocationService().getTypeDetails(formBean);
                    Validate.isTrue(formBeanDetails != null && formBeanDetails.getAnnotation(RooJavaType.ROO_DTO) != null, "ERROR: finder '%s' declared 'formBean' (%s) is not annotated with @%s annotation", finderName, formBean.getSimpleTypeName(), RooJavaType.ROO_ENTITY_PROJECTION.getSimpleTypeName());
                    checkDtoFieldsForFinder(formBeanDetails, finder, governorPhysicalTypeMetadata.getType());
                    if (returnType == null) {
                        returnType = entity;
                    }
                    finderMethod = new FinderMethod(returnType, new JavaSymbolName(finderName), Arrays.asList(new FinderParameter(formBean, new JavaSymbolName(StringUtils.uncapitalize(formBean.getSimpleTypeName())))));
                    findersToAddInCustom.add(Pair.of(finderMethod, finder));
                }
            }
        }
    }
    return new RepositoryJpaMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, annotationValues, entityMetadata, readOnlyRepository, repositoryCustomList.get(0), defaultReturnType, relationsAsChild, findersToAdd, findersToAddInCustom, declaredFinderNames);
}

Example 49 with StringUtils.join

use of org.apache.commons.lang3.StringUtils.join in project spring-roo by spring-projects.

the class JSONMetadataProviderImpl method getMetadata.

@Override
protected ItdTypeDetailsProvidingMetadataItem getMetadata(final String metadataIdentificationString, final JavaType aspectName, final PhysicalTypeMetadata governorPhysicalTypeMetadata, final String itdFilename) {
    final JSONAnnotationValues annotationValues = new JSONAnnotationValues(governorPhysicalTypeMetadata);
    ClassOrInterfaceTypeDetails controllerDetail = governorPhysicalTypeMetadata.getMemberHoldingTypeDetails();
    // Getting controller metadata
    final String controllerMetadataKey = ControllerMetadata.createIdentifier(controllerDetail);
    final ControllerMetadata controllerMetadata = getMetadataService().get(controllerMetadataKey);
    // This metadata is not available yet.
    if (controllerMetadata == null) {
        return null;
    }
    // Getting entity and check if is a readOnly entity or not
    final JavaType entity = controllerMetadata.getEntity();
    JavaType itemController = null;
    if (controllerMetadata.getType() != ControllerType.ITEM) {
        // Locate ItemController
        Collection<ClassOrInterfaceTypeDetails> itemControllers = getControllerLocator().getControllers(entity, ControllerType.ITEM, RooJavaType.ROO_JSON);
        if (itemControllers.isEmpty()) {
            // We can't create metadata "Jet"
            return null;
        } else {
            // Get controller with the same package
            JavaPackage controllerPackage = controllerDetail.getType().getPackage();
            for (ClassOrInterfaceTypeDetails controller : itemControllers) {
                if (controllerPackage.equals(controller.getType().getPackage())) {
                    itemController = controller.getType();
                    break;
                }
            }
            Validate.notNull(itemController, "ERROR: Can't find ITEM-type controller related to controller '%s'", controllerDetail.getType().getFullyQualifiedTypeName());
        }
    }
    Validate.notNull(entity, "ERROR: You should provide a valid entity for controller '%s'", controllerDetail.getType().getFullyQualifiedTypeName());
    final ClassOrInterfaceTypeDetails entityDetails = getTypeLocationService().getTypeDetails(entity);
    Validate.notNull(entityDetails, "ERROR: Can't load details of %s", entity.getFullyQualifiedTypeName());
    final JpaEntityMetadata entityMetadata = getMetadataService().get(JpaEntityMetadata.createIdentifier(entityDetails));
    Validate.notNull(entityMetadata, "ERROR: Can't get Jpa Entity metada of %s", entity.getFullyQualifiedTypeName());
    // Get entity plural
    final String entityPlural = getPluralService().getPlural(entity);
    final String entityIdentifierPlural = getPluralService().getPlural(entityMetadata.getCurrentIndentifierField().getFieldName());
    // Getting service and its metadata
    final JavaType service = controllerMetadata.getService();
    ClassOrInterfaceTypeDetails serviceDetails = getTypeLocationService().getTypeDetails(service);
    final String serviceMetadataKey = ServiceMetadata.createIdentifier(serviceDetails);
    registerDependency(serviceMetadataKey, metadataIdentificationString);
    final ServiceMetadata serviceMetadata = getMetadataService().get(serviceMetadataKey);
    // Prepare information about ONE-TO-ONE relations
    final List<Pair<RelationInfo, JpaEntityMetadata>> compositionRelationOneToOne = new ArrayList<Pair<RelationInfo, JpaEntityMetadata>>();
    ClassOrInterfaceTypeDetails childEntityDetails;
    JpaEntityMetadata childEntityMetadata;
    for (RelationInfo info : entityMetadata.getRelationInfos().values()) {
        if (info.cardinality == Cardinality.ONE_TO_ONE && info.type == JpaRelationType.COMPOSITION) {
            childEntityDetails = getTypeLocationService().getTypeDetails(info.childType);
            childEntityMetadata = getMetadataService().get(JpaEntityMetadata.createIdentifier(childEntityDetails));
            compositionRelationOneToOne.add(Pair.of(info, childEntityMetadata));
        }
    }
    Map<String, MethodMetadata> findersToAdd = new HashMap<String, MethodMetadata>();
    // Getting annotated finders
    final SearchAnnotationValues searchAnnotationValues = new SearchAnnotationValues(governorPhysicalTypeMetadata);
    // Add finders only if controller is of search type
    if (controllerMetadata.getType() == ControllerType.SEARCH && searchAnnotationValues != null && searchAnnotationValues.getFinders() != null) {
        List<String> finders = new ArrayList<String>(Arrays.asList(searchAnnotationValues.getFinders()));
        // Search indicated finders in its related service
        for (MethodMetadata serviceFinder : serviceMetadata.getFinders()) {
            String finderName = serviceFinder.getMethodName().getSymbolName();
            if (finders.contains(finderName)) {
                findersToAdd.put(finderName, serviceFinder);
                // Add dependencies between modules
                List<JavaType> types = new ArrayList<JavaType>();
                types.add(serviceFinder.getReturnType());
                types.addAll(serviceFinder.getReturnType().getParameters());
                for (AnnotatedJavaType parameter : serviceFinder.getParameterTypes()) {
                    types.add(parameter.getJavaType());
                    types.addAll(parameter.getJavaType().getParameters());
                }
                for (JavaType parameter : types) {
                    getTypeLocationService().addModuleDependency(governorPhysicalTypeMetadata.getType().getModule(), parameter);
                }
                finders.remove(finderName);
            }
        }
        // Check all finders have its service method
        if (!finders.isEmpty()) {
            throw new IllegalArgumentException(String.format("ERROR: Service %s does not have these finder methods: %s ", service.getFullyQualifiedTypeName(), StringUtils.join(finders, ", ")));
        }
    }
    return new JSONMetadata(metadataIdentificationString, aspectName, governorPhysicalTypeMetadata, annotationValues, controllerMetadata, serviceMetadata, entityMetadata, entityPlural, entityIdentifierPlural, compositionRelationOneToOne, itemController, findersToAdd);
}

Example 50 with StringUtils.join

use of org.apache.commons.lang3.StringUtils.join in project spring-roo by spring-projects.

the class ParseResult method toString.

@Override
public String toString() {
    final ToStringBuilder builder = new ToStringBuilder(this);
    builder.append("method", method);
    builder.append("instance", instance);
    builder.append("arguments", StringUtils.join(arguments, ","));
    return builder.toString();
}