public DependencyConstraint attributes(Action<? super AttributeContainer> configureAction) {
        if (attributesFactory == null) {
            warnAboutInternalApiUse();
            return this;
        }
        validateMutation();
        if (attributes == null) {
            attributes = attributesFactory.mutable();
        }
        configureAction.execute(attributes);
        return this;
    }

    @Override
    public void because(String reason) {
        validateMutation();
    }

    @Override
    protected void validateMutation() {
        throw new UnsupportedOperationException("Minimal dependencies are immutable.");
    }

    @Override
    protected void validateMutation(Object currentValue, Object newValue) {
        validateMutation();
    }

    @Override

    @Override
    public void because(String reason) {
        validateMutation();
    }

    @Override
    protected void validateMutation() {
        throw new UnsupportedOperationException("Minimal dependencies are immutable.");
    }

    @Override
    protected void validateMutation(Object currentValue, Object newValue) {
        validateMutation();
    }

    @Override

    public void because(@Nullable String reason) {
        validateMutation();
        this.reason = reason;
    }

    @Override
    public AttributeContainer getAttributes() {
        return projectDependency.getAttributes();
    }

    @Override
    public DependencyConstraint attributes(Action<? super AttributeContainer> configureAction) {
        validateMutation();
        projectDependency.attributes(configureAction);

        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.all(Closure.IDENTITY)
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.all(ruleSource)
        then: 1 * checker.validateMutation(STRATEGY)

        when: rules.withModule("something:else", Actions.doNothing())
        then: 1 * checker.validateMutation(STRATEGY)

        validateMutation(this.changing, changing);
        this.changing = changing;
        return this;
    }

    @Override
    public VersionConstraint getVersionConstraint() {
        return versionConstraint;
    }

    @Override
    public void version(Action<? super MutableVersionConstraint> configureAction) {
        validateMutation();

            ((DependencyConstraintInternal) dependencyConstraint).addMutationValidator(constraint ->
                ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES)
            );
        }
        return addInternalDependencyConstraint(dependencyConstraint);
    }

        def root = builder.toRootComponent('root')
        def variant = root.rootComponent.getConfiguration('conf')

        when:
        builder.validator.validateMutation(mutationType)
        def otherRoot = builder.toRootComponent('root')

        then:
        root.rootComponent.is(otherRoot.rootComponent)
        root.rootComponent.metadata.is(otherRoot.rootComponent.metadata)

    public RunnableMutationValidator(MutationType typeAsRunnable) {
        this.typeAsRunnable = typeAsRunnable;
    }

    @Override
    public void run() {
        validateMutation(typeAsRunnable);
    }

    @Override
    public void addMutationValidator(Action<? super DependencyConstraint> action) {
        this.onMutate = onMutate.add(action);
    }

    protected void validateMutation() {
        onMutate.execute(this);
    }