new ModuleMetadataSpec.LocalVariant(
                    variant.getName(),
                    attributesFor(variant.getAttributes()),
                    capabilitiesFor(variant.getCapabilities()),
                    dependenciesOf(variant, resolvers.getComponentResolver()),
                    dependencyConstraintsFor(variant, resolvers.getComponentResolver()),
                    artifactsOf(variant)

                component.getId(),
                Describables.of(metadata.getName()),
                component.attributeDesugaring.desugar(metadata.getAttributes()),
                component.capabilitiesFor(metadata.getCapabilities()),
                externalVariant);
        }
    }

            getName() >> name
        }
    }

    NodeState node(ComponentState cs) {
        def metadata = Mock(VariantGraphResolveMetadata) {
            getDependencies() >> []
            getCapabilities() >> ImmutableCapabilities.of([])
        }
        def state = Mock(VariantGraphResolveState) {
            getMetadata() >> metadata
        }

        }
        return builder.build();
    }

    @Override
    public List<? extends MutableComponentVariant> getMutableVariants() {
        return newVariants;

     * (For external module components, we just instantiate a new artifact metadata).
     */
    ComponentArtifactMetadata artifact(IvyArtifactName artifact);

    ImmutableCapabilities getCapabilities();

    boolean isExternalVariant();

                        Cast.uncheckedCast(sourceVariant.getArtifacts()),
                        sourceVariant.getExcludes(),
                        sourceVariant.getAttributes(),
                        sourceVariant.getCapabilities(),
                        dependencies,
                        false,
                        sourceVariant.isExternalVariant()
                    );
                    builder.add(derivedVariantMetadata);

    def componentId = Mock(ComponentIdentifier)

    def setup() {
        ConfigurationPublications outgoing = Mock(ConfigurationPublications)
        outgoing.getCapabilities() >> Collections.emptySet()

        configuration.isCanBeDeclared() >> true
        configuration.name >> "config"
        configuration.extendsFrom >> []
        configuration.hierarchy >> [configuration]

        }
    }

    @Override
    public Collection<? extends Capability> getCapabilities() {
        return capabilities == null ? Collections.emptyList() : ImmutableList.copyOf(capabilities);
    }

    @Override
    public void preventFromFurtherMutation() {
        canCreate = false;

            }
        }

        if (!variant.getCapabilities().isEmpty()) {
            for (Capability capability : variant.getCapabilities()) {
                if (isNotDefaultCapability(capability, coordinates)) {

        Map<String, String> targetAttributes = AttributesToMapConverter.convertToMap(targetComponentVariant.getAttributes());
        List<Capability> capabilities = targetComponentVariant.getCapabilities().asSet().stream()
            .map(TransformStepNode::convertCapability)
            .collect(Collectors.toList());

        return new DefaultPlannedTransformStepIdentity(
            consumerBuildPath,