setProperty("projectMutatedBuildProperty", "mutated")
            require(projectMutatedBuildProperty == "mutated")

            val projectMutatedUserHomeProperty: String by project
            require(projectMutatedUserHomeProperty == "user home value")

            setProperty("projectMutatedUserHomeProperty", "mutated")
            require(projectMutatedUserHomeProperty == "mutated")
        }
        """.trimIndent()

	tcs := []struct {
		config   string
		webhook  string
		mutated  bool
		expected string
	}{
		{
			config:   "test-config",
			webhook:  "test-webhook",
			mutated:  true,
			expected: `{"configuration":"test-config","webhook":"test-webhook","mutated":true}`,
		},
		{
			config:   "test-config",
			webhook:  "test-webhook",
			mutated:  false,

        when:
        mutate {
            create('foo')
        }
        mutate {
            get('foo')
        }
        realizeAsModelMap()

        then:
        def e = thrown ModelRuleExecutionException
        e.cause instanceof WriteOnlyModelViewException
    }

    def "cannot read size in mutative method"() {
        when:
        mutate {
            size()
        }

    def "can remove using index"() {
        when:
        mutate {
            add 'foo'
            add 'bar'
            add 'baz'
            remove(1)
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['foo', 'baz'])
    }

    def "can add using index"() {
        when:
        mutate {
            add 'foo'
            add(0, 'bar')

                }

                @Mutate
                void second(@Path("recorder") MutationRecorder recorder) {
                    recorder.mutations << "second source"
                }

                @Mutate
                void third(MutationRecorder recorder) {
                    recorder.mutations << "third source"
                }

                @Mutate

        failure.assertHasCause("Exception thrown while executing model rule: RulePlugin#mutate(ModelMap<Task>, ModelMap<Person>)")
        failure.assertHasCause("Attempt to modify a read only view of model element 'people' of type 'ModelMap<Person>' given to rule RulePlugin#mutate(ModelMap<Task>, ModelMap<Person>)")
    }

    def "cannot mutate when used as subject of validate rule"() {
        when:
        buildScript '''
            @Managed

        @Model
        MutationRecorder recorder() {
            new MutationRecorder()
        }

        @Mutate
        void b(@Path("recorder") MutationRecorder recorder) {
            recorder.mutations << "b"
        }

        @Mutate
        void a(@Path("recorder") MutationRecorder recorder) {
            recorder.mutations << "a"
        }
    }

                void afterPerson(Person person) {
                    person.name += " after"
                }

                @Mutate
                void configurePerson(Person person) {
                    person.name += " configure"
                }

                @Mutate
                void addEchoTask(ModelMap<Task> tasks, Person person) {
                    tasks.create("echo") {

                @Model
                void managedNamed(ManagedNamed namedThing) {
                }

                @Mutate
                void setName(Named named) {
                    named.name = "superclass"
                }

                @Mutate
                void addTask(ModelMap<Task> tasks, Named named) {
                    tasks.create("echo") {
                        it.doLast {

import javax.annotation.concurrent.ThreadSafe;
import org.gradle.model.Mutate;
import org.gradle.model.internal.core.ModelActionRole;

@ThreadSafe
public class MutateModelRuleExtractor extends AbstractMutationModelRuleExtractor<Mutate> {
    @Override
    protected ModelActionRole getMutationType() {
        return ModelActionRole.Mutate;
    }