Golang: remove entry from a map[interface{}]interface{} unmarshalled from YAML

I'm working on writing some tests where I need to check different error conditions when loading the application config from a YAML file. As the YAML file is quite long, my approach is to read the full YAML content from the file on disk, unmarshall its content to a variable, dynamically remove some section/s from the generated map[interface{}]interface{} based on their string keys, and finally marshall it and write the content to a different file on disk that will be used as the text input. That said, I'm facing issues when trying to remove sections from the unmarshalled yaml. Below is my code:

func getYAMLWithoutSection(t *testing.T, section string) map[interface{}]interface{} {
	t.Helper()

	yml := unmarshalYAML(t, getYAMLContentFromFile(t))
	var tmp interface{}
	tmp = yml

	keys := strings.Split(section, ".")
	for _, key := range keys {
		tmp = tmp.(map[interface{}]interface{})[key]
	}

	tmp = nil

	return yml
}

// Reads file from disk and returns its content
func getYAMLContentFromFile(t *testing.T) []byte {
	/* ... */
}

func unmarshalYAML(t *testing.T, ymlIn []byte) map[interface{}]interface{} {
    /* ... */
}

This doesn't work because at the end of the day, the tmp var contains the value of the targeted YAML section instead of its memory address (its type is interface{}, not a pointer), so when I set it to nil it has no effect over the value in the original yml variable that it finally returns. I've tried different things like switching the type of tmp to *interface{}, but with no success, and I can't figure out what would be the proper way of doing this.

You're storing the value into a variable and then setting that variable to nil. That won't modify the map only the variable.

Depending on how you want to modify the map, when you're on the last iteration while ranging over keys you can either:

m := tmp.(map[interface{}]interface{})
m[key] = nil

or

m := tmp.(map[interface{}]interface{})
delete(m, key)

The first approach will leave the key in the map but the value will be nil. The second approach removes the key from the map.

https://go.dev/tour/moretypes/22

I've finally found the way of achieving what I was looking for (dynamically editing the nested map that contains the unmarshalled YAML). This is how my code looks like now:

func getYAMLWithoutSection(t *testing.T, section string) map[interface{}]interface{} {
	t.Helper()

	yml := unmarshalYAML(t, getConfigFileContent(t))
	tmp := yml

	keys := strings.Split(section, ".")
	nKeys := len(keys) - 1
	for i, key := range keys {
		if i == nKeys {
			tmp[key] = nil
			break
		}

		tmp = tmp[key].(map[interface{}]interface{})
	}

	return yml
}

The thing is in the original version (the one I posted in my question) I was using a tmp variable with type interface{} so every time I assign a submap to this variable, its content is copied to it and removing keys (or modifying their values) on this variable has no effect over the original yml one. However, in this version I switch tmp to a map map[interface{}]interface{}, and taking into account that in Go maps are reference types, every modification on this variable is actually reflected on the tmp one.