base.js

"use strict"
import {
	Immer,
	nothing,
	original,
	isDraft,
	immerable,
	enablePatches,
	enableMapSet
} from "../src/immer"
import {each, shallowCopy, DRAFT_STATE} from "../src/internal"
import deepFreeze from "deep-freeze"
import * as lodash from "lodash"

enablePatches()
enableMapSet()

jest.setTimeout(1000)

const isProd = process.env.NODE_ENV === "production"

test("immer should have no dependencies", () => {
	expect(require("../package.json").dependencies).toBeUndefined()
})

for (const autoFreeze of [true, false]) {
	for (const useStrictShallowCopy of [true, false]) {
		for (const useListener of [true, false]) {
			const name = `${autoFreeze ? "auto-freeze=true" : "auto-freeze=false"}:${
				useStrictShallowCopy ? "shallow-copy=true" : "shallow-copy=false"
			}:${useListener ? "use-listener=true" : "use-listener=false"}`
			runBaseTest(name, autoFreeze, useStrictShallowCopy, useListener)
		}
	}
}

class Foo {}

function runBaseTest(name, autoFreeze, useStrictShallowCopy, useListener) {
	const listener = useListener ? function() {} : undefined
	const {produce, produceWithPatches} = createPatchedImmer({
		autoFreeze,
		useStrictShallowCopy
	})

	// When `useListener` is true, append a function to the arguments of every
	// uncurried `produce` call in every test. This makes tests easier to read.
	function createPatchedImmer(options) {
		const immer = new Immer(options)

		const {produce} = immer
		immer.produce = function(...args) {
			return typeof args[1] === "function" && args.length < 3
				? produce(...args, listener)
				: produce(...args)
		}

		return immer
	}

	describe(`base functionality - ${name}`, () => {
		let baseState
		let origBaseState

		beforeEach(() => {
			origBaseState = baseState = createBaseState()
		})

		it("returns the original state when no changes are made", () => {
			const nextState = produce(baseState, s => {
				expect(s.aProp).toBe("hi")
				expect(s.anObject.nested).toMatchObject({yummie: true})
			})
			expect(nextState).toBe(baseState)
		})

		it("does structural sharing", () => {
			const random = Math.random()
			const nextState = produce(baseState, s => {
				s.aProp = random
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState.aProp).toBe(random)
			expect(nextState.nested).toBe(baseState.nested)
		})

		it("deep change bubbles up", () => {
			const nextState = produce(baseState, s => {
				s.anObject.nested.yummie = false
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState.anObject).not.toBe(baseState.anObject)
			expect(baseState.anObject.nested.yummie).toBe(true)
			expect(nextState.anObject.nested.yummie).toBe(false)
			expect(nextState.anArray).toBe(baseState.anArray)
		})

		it("can add props", () => {
			const nextState = produce(baseState, s => {
				s.anObject.cookie = {tasty: true}
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState.anObject).not.toBe(baseState.anObject)
			expect(nextState.anObject.nested).toBe(baseState.anObject.nested)
			expect(nextState.anObject.cookie).toEqual({tasty: true})
		})

		it("can delete props", () => {
			const nextState = produce(baseState, s => {
				delete s.anObject.nested
				delete s.nonexisting
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState.anObject).not.toBe(baseState.anObject)
			expect(nextState.anObject.nested).toBe(undefined)
		})

		it("can delete props - 2", () => {
			const nextState = produce(baseState, s => {
				delete s.nonexisting
			})
			expect(nextState).toBe(baseState)
		})

		// Found by: https://github.com/mweststrate/immer/pull/267
		it("can delete props added in the producer", () => {
			const nextState = produce(baseState, s => {
				s.anObject.test = true
				delete s.anObject.test
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState).toEqual(baseState)
		})

		// Found by: https://github.com/mweststrate/immer/issues/328
		it("can set a property that was just deleted", () => {
			const baseState = {a: 1}
			const nextState = produce(baseState, s => {
				delete s.a
				s.a = 2
			})
			expect(nextState.a).toBe(2)
		})

		it("can set a property to its original value after deleting it", () => {
			const baseState = {a: {b: 1}}
			const nextState = produce(baseState, s => {
				const a = s.a
				delete s.a
				s.a = a
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState).toEqual(baseState)
		})

		it("can get property descriptors", () => {
			const getDescriptor = Object.getOwnPropertyDescriptor
			const baseState = deepFreeze([{a: 1}])
			produce(baseState, arr => {
				const obj = arr[0]
				const desc = {
					configurable: true,
					enumerable: true,
					writable: true
				}

				// Known property
				expect(getDescriptor(obj, "a")).toMatchObject(desc)
				expect(getDescriptor(arr, 0)).toMatchObject(desc)

				// Deleted property
				delete obj.a
				arr.pop()
				expect(getDescriptor(obj, "a")).toBeUndefined()
				expect(getDescriptor(arr, 0)).toBeUndefined()

				// Unknown property
				expect(getDescriptor(obj, "b")).toBeUndefined()
				expect(getDescriptor(arr, 100)).toBeUndefined()

				// Added property
				obj.b = 2
				arr[100] = 1
				expect(getDescriptor(obj, "b")).toBeDefined()
				expect(getDescriptor(arr, 100)).toBeDefined()
			})
		})

		describe("array drafts", () => {
			it("supports Array.isArray()", () => {
				const nextState = produce(baseState, s => {
					expect(Array.isArray(s.anArray)).toBeTruthy()
					s.anArray.push(1)
				})
				expect(Array.isArray(nextState.anArray)).toBeTruthy()
			})

			it("supports index access", () => {
				const value = baseState.anArray[0]
				const nextState = produce(baseState, s => {
					expect(s.anArray[0]).toBe(value)
				})
				expect(nextState).toBe(baseState)
			})

			it("supports iteration", () => {
				const base = [
					{id: 1, a: 1},
					{id: 2, a: 1}
				]
				const findById = (collection, id) => {
					for (const item of collection) {
						if (item.id === id) return item
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result[0].a).toEqual(2)
				expect(result[1].a).toEqual(2)
			})

			it("can assign an index via bracket notation", () => {
				const nextState = produce(baseState, s => {
					s.anArray[3] = true
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState.anArray).not.toBe(baseState.anArray)
				expect(nextState.anArray[3]).toEqual(true)
			})

			it("can use splice() to both add and remove items", () => {
				const nextState = produce(baseState, s => {
					s.anArray.splice(1, 1, "a", "b")
				})
				expect(nextState.anArray).not.toBe(baseState.anArray)
				expect(nextState.anArray[1]).toBe("a")
				expect(nextState.anArray[2]).toBe("b")
			})

			it("can truncate via the length property", () => {
				const baseLength = baseState.anArray.length
				const nextState = produce(baseState, s => {
					s.anArray.length = baseLength - 1
				})
				expect(nextState.anArray).not.toBe(baseState.anArray)
				expect(nextState.anArray.length).toBe(baseLength - 1)
			})

			it("can extend via the length property", () => {
				const baseLength = baseState.anArray.length
				const nextState = produce(baseState, s => {
					s.anArray.length = baseLength + 1
				})
				expect(nextState.anArray).not.toBe(baseState.anArray)
				expect(nextState.anArray.length).toBe(baseLength + 1)
			})

			// Reported here: https://github.com/mweststrate/immer/issues/116
			it("can pop then push", () => {
				const nextState = produce([1, 2, 3], s => {
					s.pop()
					s.push(100)
				})
				expect(nextState).toEqual([1, 2, 100])
			})

			it("can be sorted", () => {
				const baseState = [3, 1, 2]
				const nextState = produce(baseState, s => {
					s.sort()
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState).toEqual([1, 2, 3])
			})

			it("supports modifying nested objects", () => {
				const baseState = [{a: 1}, {}]
				const nextState = produce(baseState, s => {
					s[0].a++
					s[1].a = 0
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState[0].a).toBe(2)
				expect(nextState[1].a).toBe(0)
			})

			it("never preserves non-numeric properties", () => {
				const baseState = []
				baseState.x = 7
				const nextState = produce(baseState, s => {
					s.push(3)
				})
				expect("x" in nextState).toBeFalsy()
			})

			if (!global.USES_BUILD) {
				it("throws when a non-numeric property is added", () => {
					expect(() => {
						produce([], d => {
							d.x = 3
						})
					}).toThrowErrorMatchingSnapshot()
				})

				it("throws when a non-numeric property is deleted", () => {
					expect(() => {
						const baseState = []
						baseState.x = 7
						produce(baseState, d => {
							delete d.x
						})
					}).toThrowErrorMatchingSnapshot()
				})
			}
		})

		describe("map drafts", () => {
			it("supports key access", () => {
				const value = baseState.aMap.get("jedi")
				const nextState = produce(baseState, s => {
					expect(s.aMap.get("jedi")).toEqual(value)
				})
				expect(nextState).toBe(baseState)
			})

			it("supports key access for non-primitive keys", () => {
				const key = {prop: "val"}
				const base = new Map([[key, {id: 1, a: 1}]])
				const value = base.get(key)
				const nextState = produce(base, s => {
					expect(s.get(key)).toEqual(value)
				})
				expect(nextState).toBe(base)
			})

			it("supports iteration", () => {
				const base = new Map([
					["first", {id: 1, a: 1}],
					["second", {id: 2, a: 1}]
				])
				const findById = (map, id) => {
					for (const [, item] of map) {
						if (item.id === id) return item
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result).not.toBe(base)
				expect(result.get("first").a).toEqual(2)
				expect(result.get("second").a).toEqual(2)
			})

			it("supports 'entries'", () => {
				const base = new Map([
					["first", {id: 1, a: 1}],
					["second", {id: 2, a: 1}]
				])
				const findById = (map, id) => {
					for (const [, item] of map.entries()) {
						if (item.id === id) return item
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result).not.toBe(base)
				expect(result.get("first").a).toEqual(2)
				expect(result.get("second").a).toEqual(2)
			})

			it("supports 'values'", () => {
				const base = new Map([
					["first", {id: 1, a: 1}],
					["second", {id: 2, a: 1}]
				])
				const findById = (map, id) => {
					for (const item of map.values()) {
						if (item.id === id) return item
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result).not.toBe(base)
				expect(result.get("first").a).toEqual(2)
				expect(result.get("second").a).toEqual(2)
			})

			it("supports 'keys", () => {
				const base = new Map([
					["first", Symbol()],
					["second", Symbol()]
				])
				const result = produce(base, draft => {
					expect([...draft.keys()]).toEqual(["first", "second"])
					draft.set("third", Symbol())
					expect([...draft.keys()]).toEqual(["first", "second", "third"])
				})
			})

			it("supports forEach", () => {
				const key1 = {prop: "val1"}
				const key2 = {prop: "val2"}
				const base = new Map([
					["first", {id: 1, a: 1}],
					["second", {id: 2, a: 1}],
					[key1, {id: 3, a: 1}],
					[key2, {id: 4, a: 1}]
				])
				const result = produce(base, draft => {
					let sum1 = 0
					draft.forEach(({a}) => {
						sum1 += a
					})
					expect(sum1).toBe(4)
					let sum2 = 0
					draft.get("first").a = 10
					draft.get("second").a = 20
					draft.get(key1).a = 30
					draft.get(key2).a = 40
					draft.forEach(({a}) => {
						sum2 += a
					})
					expect(sum2).toBe(100)
				})
				expect(result).not.toBe(base)
				expect(base.get("first").a).toEqual(1)
				expect(base.get("second").a).toEqual(1)
				expect(base.get(key1).a).toEqual(1)
				expect(base.get(key2).a).toEqual(1)
				expect(result.get("first").a).toEqual(10)
				expect(result.get("second").a).toEqual(20)
				expect(result.get(key1).a).toEqual(30)
				expect(result.get(key2).a).toEqual(40)
			})

			it("supports forEach mutation", () => {
				const base = new Map([
					["first", {id: 1, a: 1}],
					["second", {id: 2, a: 1}]
				])
				const result = produce(base, draft => {
					draft.forEach(item => {
						item.a = 100
					})
				})
				expect(result).not.toBe(base)
				expect(result.get("first").a).toEqual(100)
				expect(result.get("second").a).toEqual(100)
			})

			it("can assign by key", () => {
				const nextState = produce(baseState, s => {
					// Map.prototype.set should return the Map itself
					const res = s.aMap.set("force", true)
					if (!global.USES_BUILD) expect(res).toBe(s.aMap[DRAFT_STATE].draft_)
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState.aMap).not.toBe(baseState.aMap)
				expect(nextState.aMap.get("force")).toEqual(true)
			})

			it("can assign by a non-primitive key", () => {
				const key = {prop: "val"}
				const value = {id: 1, a: 1}
				const base = new Map([[key, value]])
				const nextState = produce(base, s => {
					s.set(key, true)
				})
				expect(nextState).not.toBe(base)
				expect(base.get(key)).toEqual(value)
				expect(nextState.get(key)).toEqual(true)
			})

			it("state stays the same if the the same item is assigned by key", () => {
				const nextState = produce(baseState, s => {
					s.aMap.set("jediTotal", 42)
				})
				expect(nextState).toBe(baseState)
				expect(nextState.aMap).toBe(baseState.aMap)
			})

			it("returns 'size'", () => {
				const nextState = produce(baseState, s => {
					s.aMap.set("newKey", true)
					expect(s.aMap.size).toBe(baseState.aMap.size + 1)
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState.aMap).not.toBe(baseState.aMap)
				expect(nextState.aMap.get("newKey")).toEqual(true)
				expect(nextState.aMap.size).toEqual(baseState.aMap.size + 1)
			})

			it("can use 'delete' to remove items", () => {
				const nextState = produce(baseState, s => {
					expect(s.aMap.has("jedi")).toBe(true)
					expect(s.aMap.delete("jedi")).toBe(true)
					expect(s.aMap.has("jedi")).toBe(false)
				})
				expect(nextState.aMap).not.toBe(baseState.aMap)
				expect(nextState.aMap.size).toBe(baseState.aMap.size - 1)
				expect(baseState.aMap.has("jedi")).toBe(true)
				expect(nextState.aMap.has("jedi")).toBe(false)
			})

			it("can use 'clear' to remove items", () => {
				const nextState = produce(baseState, s => {
					expect(s.aMap.size).not.toBe(0)
					s.aMap.clear()
					expect(s.aMap.size).toBe(0)
				})
				expect(nextState.aMap).not.toBe(baseState.aMap)
				expect(baseState.aMap.size).not.toBe(0)
				expect(nextState.aMap.size).toBe(0)
			})

			it("support 'has'", () => {
				const nextState = produce(baseState, s => {
					expect(s.aMap.has("newKey")).toBe(false)
					s.aMap.set("newKey", true)
					expect(s.aMap.has("newKey")).toBe(true)
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState.aMap).not.toBe(baseState.aMap)
				expect(baseState.aMap.has("newKey")).toBe(false)
				expect(nextState.aMap.has("newKey")).toBe(true)
			})

			it("supports nested maps", () => {
				const base = new Map([["first", new Map([["second", {prop: "test"}]])]])
				const result = produce(base, draft => {
					draft.get("first").get("second").prop = "test1"
				})
				expect(result).not.toBe(base)
				expect(result.get("first")).not.toBe(base.get("first"))
				expect(result.get("first").get("second")).not.toBe(
					base.get("first").get("second")
				)
				expect(base.get("first").get("second").prop).toBe("test")
				expect(result.get("first").get("second").prop).toBe("test1")
			})

			it("treats void deletes as no-op", () => {
				const base = new Map([["x", 1]])
				const next = produce(base, d => {
					expect(d.delete("y")).toBe(false)
				})
				expect(next).toBe(base)
			})

			it("revokes map proxies", () => {
				let m
				produce(baseState, s => {
					m = s.aMap
				})
				expect(() => m.get("x")).toThrowErrorMatchingSnapshot()
				expect(() => m.set("x", 3)).toThrowErrorMatchingSnapshot()
			})

			it("does not draft map keys", () => {
				// anything else would be terribly confusing
				const key = {a: 1}
				const map = new Map([[key, 2]])
				const next = produce(map, d => {
					const dKey = Array.from(d.keys())[0]
					expect(isDraft(dKey)).toBe(false)
					expect(dKey).toBe(key)
					dKey.a += 1
					d.set(dKey, d.get(dKey) + 1)
					d.set(key, d.get(key) + 1)
					expect(d.get(key)).toBe(4)
					expect(key.a).toBe(2)
				})
				const entries = Array.from(next.entries())
				expect(entries).toEqual([[key, 4]])
				expect(entries[0][0]).toBe(key)
				expect(entries[0][0].a).toBe(2)
			})

			it("does support instanceof Map", () => {
				const map = new Map()
				produce(map, d => {
					expect(d instanceof Map).toBeTruthy()
				})
			})

			it("handles clear correctly", () => {
				const map = new Map([
					["a", 1],
					["c", 3]
				])
				const next = produce(map, draft => {
					draft.delete("a")
					draft.set("b", 2)
					draft.set("c", 4)
					draft.clear()
				})
				expect(next).toEqual(new Map())
			})
		})

		describe("set drafts", () => {
			it("supports iteration", () => {
				const base = new Set([
					{id: 1, a: 1},
					{id: 2, a: 1}
				])
				const findById = (set, id) => {
					for (const item of set) {
						if (item.id === id) return item
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result).not.toBe(base)
				expect(base).toEqual(
					new Set([
						{id: 1, a: 1},
						{id: 2, a: 1}
					])
				)
				expect(result).toEqual(
					new Set([
						{id: 1, a: 2},
						{id: 2, a: 2}
					])
				)
			})

			it("supports 'entries'", () => {
				const base = new Set([
					{id: 1, a: 1},
					{id: 2, a: 1}
				])
				const findById = (set, id) => {
					for (const [item1, item2] of set.entries()) {
						expect(item1).toBe(item2)
						if (item1.id === id) return item1
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result).not.toBe(base)
				expect(base).toEqual(
					new Set([
						{id: 1, a: 1},
						{id: 2, a: 1}
					])
				)
				expect(result).toEqual(
					new Set([
						{id: 1, a: 2},
						{id: 2, a: 2}
					])
				)
			})

			it("supports 'values'", () => {
				const base = new Set([
					{id: 1, a: 1},
					{id: 2, a: 1}
				])
				const findById = (set, id) => {
					for (const item of set.values()) {
						if (item.id === id) return item
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result).not.toBe(base)
				expect(base).toEqual(
					new Set([
						{id: 1, a: 1},
						{id: 2, a: 1}
					])
				)
				expect(result).toEqual(
					new Set([
						{id: 1, a: 2},
						{id: 2, a: 2}
					])
				)
			})

			it("supports 'keys'", () => {
				const base = new Set([
					{id: 1, a: 1},
					{id: 2, a: 1}
				])
				const findById = (set, id) => {
					for (const item of set.keys()) {
						if (item.id === id) return item
					}
					return null
				}
				const result = produce(base, draft => {
					const obj1 = findById(draft, 1)
					const obj2 = findById(draft, 2)
					obj1.a = 2
					obj2.a = 2
				})
				expect(result).not.toBe(base)
				expect(base).toEqual(
					new Set([
						{id: 1, a: 1},
						{id: 2, a: 1}
					])
				)
				expect(result).toEqual(
					new Set([
						{id: 1, a: 2},
						{id: 2, a: 2}
					])
				)
			})

			it("supports forEach with mutation after reads", () => {
				const base = new Set([
					{id: 1, a: 1},
					{id: 2, a: 2}
				])
				const result = produce(base, draft => {
					let sum1 = 0
					draft.forEach(({a}) => {
						sum1 += a
					})
					expect(sum1).toBe(3)
					let sum2 = 0
					draft.forEach(item => {
						item.a += 10
						sum2 += item.a
					})
					expect(sum2).toBe(23)
				})
				expect(result).not.toBe(base)
				expect(base).toEqual(
					new Set([
						{id: 1, a: 1},
						{id: 2, a: 2}
					])
				)
				expect(result).toEqual(
					new Set([
						{id: 1, a: 11},
						{id: 2, a: 12}
					])
				)
			})

			it("state stays the same if the same item is added", () => {
				const nextState = produce(baseState, s => {
					s.aSet.add("Luke")
				})
				expect(nextState).toBe(baseState)
				expect(nextState.aSet).toBe(baseState.aSet)
			})

			it("can add new items", () => {
				const nextState = produce(baseState, s => {
					// Set.prototype.set should return the Set itself
					const res = s.aSet.add("force")
					if (!global.USES_BUILD) expect(res).toBe(s.aSet[DRAFT_STATE].draft_)
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState.aSet).not.toBe(baseState.aSet)
				expect(baseState.aSet.has("force")).toBe(false)
				expect(nextState.aSet.has("force")).toBe(true)
			})

			it("returns 'size'", () => {
				const nextState = produce(baseState, s => {
					s.aSet.add("newKey")
					expect(s.aSet.size).toBe(baseState.aSet.size + 1)
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState.aSet).not.toBe(baseState.aSet)
				expect(nextState.aSet.has("newKey")).toBe(true)
				expect(nextState.aSet.size).toEqual(baseState.aSet.size + 1)
			})

			it("can use 'delete' to remove items", () => {
				const nextState = produce(baseState, s => {
					expect(s.aSet.has("Luke")).toBe(true)
					expect(s.aSet.delete("Luke")).toBe(true)
					expect(s.aSet.delete("Luke")).toBe(false)
					expect(s.aSet.has("Luke")).toBe(false)
				})
				expect(nextState.aSet).not.toBe(baseState.aSet)
				expect(baseState.aSet.has("Luke")).toBe(true)
				expect(nextState.aSet.has("Luke")).toBe(false)
				expect(nextState.aSet.size).toBe(baseState.aSet.size - 1)
			})

			it("can use 'clear' to remove items", () => {
				const nextState = produce(baseState, s => {
					expect(s.aSet.size).not.toBe(0)
					s.aSet.clear()
					expect(s.aSet.size).toBe(0)
				})
				expect(nextState.aSet).not.toBe(baseState.aSet)
				expect(baseState.aSet.size).not.toBe(0)
				expect(nextState.aSet.size).toBe(0)
			})

			it("supports 'has'", () => {
				const nextState = produce(baseState, s => {
					expect(s.aSet.has("newKey")).toBe(false)
					s.aSet.add("newKey")
					expect(s.aSet.has("newKey")).toBe(true)
				})
				expect(nextState).not.toBe(baseState)
				expect(nextState.aSet).not.toBe(baseState.aSet)
				expect(baseState.aSet.has("newKey")).toBe(false)
				expect(nextState.aSet.has("newKey")).toBe(true)
			})

			it("supports nested sets", () => {
				const base = new Set([new Set(["Serenity"])])
				const result = produce(base, draft => {
					draft.forEach(nestedItem => nestedItem.add("Firefly"))
				})
				expect(result).not.toBe(base)
				expect(base).toEqual(new Set([new Set(["Serenity"])]))
				expect(result).toEqual(new Set([new Set(["Serenity", "Firefly"])]))
			})

			it("supports has / delete on elements from the original", () => {
				const obj = {}
				const set = new Set([obj])
				const next = produce(set, d => {
					expect(d.has(obj)).toBe(true)
					d.add(3)
					expect(d.has(obj)).toBe(true)
					d.delete(obj)
					expect(d.has(obj)).toBe(false)
				})
				expect(next).toEqual(new Set([3]))
			})

			it("revokes sets", () => {
				let m
				produce(baseState, s => {
					m = s.aSet
				})
				expect(() => m.has("x")).toThrowErrorMatchingSnapshot()
				expect(() => m.add("x")).toThrowErrorMatchingSnapshot()
			})

			it("does support instanceof Set", () => {
				const set = new Set()
				produce(set, d => {
					expect(d instanceof Set).toBeTruthy()
				})
			})
		})

		it("supports `immerable` symbol on constructor", () => {
			class One {}
			One[immerable] = true
			const baseState = new One()
			const nextState = produce(baseState, draft => {
				expect(draft).not.toBe(baseState)
				draft.foo = true
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState.foo).toBeTruthy()
		})

		it("preserves symbol properties", () => {
			const test = Symbol("test")
			const baseState = {[test]: true}
			const nextState = produce(baseState, s => {
				expect(s[test]).toBeTruthy()
				s.foo = true
			})
			expect(nextState).toEqual({
				[test]: true,
				foo: true
			})
		})

		if (!global.USES_BUILD)
			it("preserves non-enumerable properties", () => {
				const baseState = {}
				// Non-enumerable object property
				Object.defineProperty(baseState, "foo", {
					value: {a: 1},
					enumerable: false
				})
				// Non-enumerable primitive property
				Object.defineProperty(baseState, "bar", {
					value: 1,
					enumerable: false
				})
				// Non-enumerable primitive property that won't modified.
				Object.defineProperty(baseState, "baz", {
					value: 1,
					enumerable: false
				})

				// When using Proxy, even non-enumerable keys will be copied if it's changed.
				const canReferNonEnumerableProperty = useStrictShallowCopy
				const nextState = produce(baseState, s => {
					if (canReferNonEnumerableProperty) expect(s.foo).toBeTruthy()
					if (useStrictShallowCopy) expect(isEnumerable(s, "foo")).toBeFalsy()
					if (canReferNonEnumerableProperty) s.bar++
					if (useStrictShallowCopy) expect(isEnumerable(s, "foo")).toBeFalsy()
					if (canReferNonEnumerableProperty) s.foo.a++
					if (useStrictShallowCopy) expect(isEnumerable(s, "foo")).toBeFalsy()
				})
				if (canReferNonEnumerableProperty) expect(nextState.foo).toBeTruthy()
				if (useStrictShallowCopy)
					expect(isEnumerable(nextState, "foo")).toBeFalsy()
				if (useStrictShallowCopy) expect(nextState.baz).toBeTruthy()
			})

		it("can work with own computed props", () => {
			const baseState = {
				x: 1,
				get y() {
					return this.x
				},
				set y(v) {
					this.x = v
				}
			}

			const nextState = produce(baseState, d => {
				expect(d.y).toBe(1)
				d.x = 2
				expect(d.x).toBe(2)
				expect(d.y).toBe(1) // this has been copied!
				d.y = 3
				expect(d.x).toBe(2)
			})
			expect(baseState.x).toBe(1)
			expect(baseState.y).toBe(1)

			expect(nextState.x).toBe(2)
			expect(nextState.y).toBe(3)
			if (!autoFreeze) {
				nextState.y = 4 // decoupled now!
				expect(nextState.y).toBe(4)
				expect(nextState.x).toBe(2)
				expect(Object.getOwnPropertyDescriptor(nextState, "y").value).toBe(4)
			}
		})

		it("can work with class with computed props", () => {
			class State {
				[immerable] = true

				x = 1

				set y(v) {
					this.x = v
				}

				get y() {
					return this.x
				}
			}

			const baseState = new State()

			const nextState = produce(baseState, d => {
				expect(d.y).toBe(1)
				d.y = 2
				expect(d.x).toBe(2)
				expect(d.y).toBe(2)
				expect(Object.getOwnPropertyDescriptor(d, "y")).toBeUndefined()
			})
			expect(baseState.x).toBe(1)
			expect(baseState.y).toBe(1)

			expect(nextState.x).toBe(2)
			expect(nextState.y).toBe(2)
			expect(Object.getOwnPropertyDescriptor(nextState, "y")).toBeUndefined()
		})

		it("allows inherited computed properties", () => {
			const proto = {}
			Object.defineProperty(proto, "foo", {
				get() {
					return this.bar
				},
				set(val) {
					this.bar = val
				}
			})
			proto[immerable] = true
			const baseState = Object.create(proto)
			produce(baseState, s => {
				expect(s.bar).toBeUndefined()
				s.foo = {}
				expect(s.bar).toBeDefined()
				expect(s.foo).toBe(s.bar)
			})
		})

		it("optimization: does not visit properties of new data structures if autofreeze is disabled and no drafts are unfinalized", () => {
			const newData = {}
			Object.defineProperty(newData, "x", {
				enumerable: true,
				get() {
					throw new Error("visited!")
				}
			})

			const run = () =>
				produce({}, d => {
					d.data = newData
				})
			if (autoFreeze) {
				expect(run).toThrow("visited!")
			} else {
				expect(run).not.toThrow("visited!")
			}
		})

		it("same optimization doesn't cause draft from nested producers to be unfinished", () => {
			const base = {
				y: 1,
				child: {
					x: 1
				}
			}
			const wrap = produce(draft => {
				return {
					wrapped: draft
				}
			})

			const res = produce(base, draft => {
				draft.y++
				draft.child = wrap(draft.child)
				draft.child.wrapped.x++
			})

			expect(res).toEqual({
				y: 2,
				child: {wrapped: {x: 2}}
			})
		})

		it("supports a base state with multiple references to an object", () => {
			const obj = {}
			const res = produce({a: obj, b: obj}, d => {
				// Two drafts are created for each occurrence of an object in the base state.
				expect(d.a).not.toBe(d.b)
				d.a.z = true
				expect(d.b.z).toBeUndefined()
			})
			expect(res.b).toBe(obj)
			expect(res.a).not.toBe(res.b)
			expect(res.a.z).toBeTruthy()
		})

		// NOTE: Except the root draft.
		it("supports multiple references to any modified draft", () => {
			const next = produce({a: {b: 1}}, d => {
				d.a.b++
				d.b = d.a
			})
			expect(next.a).toBe(next.b)
		})

		it("can rename nested objects (no changes)", () => {
			const nextState = produce({obj: {}}, s => {
				s.foo = s.obj
				delete s.obj
			})
			expect(nextState).toEqual({foo: {}})
		})

		// Very similar to the test before, but the reused object has one
		// property changed, one added, and one removed.
		it("can rename nested objects (with changes)", () => {
			const nextState = produce({obj: {a: 1, b: 1}}, s => {
				s.obj.a = true // change
				delete s.obj.b // delete
				s.obj.c = true // add

				s.foo = s.obj
				delete s.obj
			})
			expect(nextState).toEqual({foo: {a: true, c: true}})
		})

		it("can nest a draft in a new object (no changes)", () => {
			const baseState = {obj: {}}
			const nextState = produce(baseState, s => {
				s.foo = {bar: s.obj}
				delete s.obj
			})
			expect(nextState.foo.bar).toBe(baseState.obj)
		})

		it("can nest a modified draft in a new object", () => {
			const nextState = produce({obj: {a: 1, b: 1}}, s => {
				s.obj.a = true // change
				delete s.obj.b // delete
				s.obj.c = true // add

				s.foo = {bar: s.obj}
				delete s.obj
			})
			expect(nextState).toEqual({foo: {bar: {a: true, c: true}}})
		})

		it("supports assigning undefined to an existing property", () => {
			const nextState = produce(baseState, s => {
				s.aProp = undefined
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState.aProp).toBe(undefined)
		})

		it("supports assigning undefined to a new property", () => {
			const baseState = {}
			const nextState = produce(baseState, s => {
				s.aProp = undefined
			})
			expect(nextState).not.toBe(baseState)
			expect(nextState.aProp).toBe(undefined)
		})

		// NOTE: ES5 drafts only protect existing properties when revoked.
		if (!isProd)
			it("revokes the draft once produce returns", () => {
				const expectRevoked = fn => {
					expect(fn).toThrowErrorMatchingSnapshot()
				}

				// Test object drafts:
				let draft
				produce({a: 1, b: 1}, s => {
					draft = s
					delete s.b
				})

				// Access known property on object draft.
				expectRevoked(() => {
					draft.a
				})

				// Assign known property on object draft.
				expectRevoked(() => {
					draft.a = true
				})

				// Access unknown property on object draft.
				expectRevoked(() => {
					draft.z
				})

				// Assign unknown property on object draft.
				expectRevoked(() => {
					draft.z = true
				})

				// Test array drafts:
				produce([1, 2], s => {
					draft = s
					s.pop()
				})

				// Access known index of an array draft.
				expectRevoked(() => {
					draft[0]
				})

				// Assign known index of an array draft.
				expectRevoked(() => {
					draft[0] = true
				})

				// Access unknown index of an array draft.
				expectRevoked(() => {
					draft[1]
				})

				// Assign unknown index of an array draft.
				expectRevoked(() => {
					draft[1] = true
				})
			})

		it("can access a child draft that was created before the draft was modified", () => {
			produce({a: {}}, s => {
				const before = s.a
				s.b = 1
				expect(s.a).toBe(before)
			})
		})

		it("should reflect all changes made in the draft immediately", () => {
			produce(baseState, draft => {
				draft.anArray[0] = 5
				draft.anArray.unshift("test")
				if (!global.USES_BUILD)
					expect(enumerableOnly(draft.anArray)).toEqual([
						"test",
						5,
						2,
						{c: 3},
						1
					])
				draft.stuffz = "coffee"
				expect(draft.stuffz).toBe("coffee")
			})
		})

		it("throws when Object.defineProperty() is used on drafts", () => {
			expect(() => {
				produce({}, draft => {
					Object.defineProperty(draft, "xx", {
						enumerable: true,
						writeable: true,
						value: 2
					})
				})
			}).toThrowErrorMatchingSnapshot()
		})

		it("should handle constructor correctly", () => {
			const baseState = {
				arr: new Array(),
				obj: new Object()
			}
			const result = produce(baseState, draft => {
				draft.arrConstructed = draft.arr.constructor(1)
				draft.objConstructed = draft.obj.constructor(1)
			})
			expect(result.arrConstructed).toEqual(new Array().constructor(1))
			expect(result.objConstructed).toEqual(new Object().constructor(1))
		})

		it("should handle equality correctly - 1", () => {
			const baseState = {
				y: 3 / 0,
				z: NaN
			}
			const nextState = produce(baseState, draft => {
				draft.y = 4 / 0
				draft.z = NaN
			})
			expect(nextState).toBe(baseState)
		})

		it("should handle equality correctly - 2", () => {
			const baseState = {
				x: -0
			}
			const nextState = produce(baseState, draft => {
				draft.x = +0
			})
			// 0 === -0 // true
			// Object.is(0, -0) // false
			//
			// MWE:
			// Immer preserves the difference between -0 and +0,
			// so a new state is created.
			// This isn't defined anywhere explicitly, so could be changed
			// in the future to follow === behavior, rather than Object.is.
			// But I think this is fine as is.
			expect(nextState).not.toBe(baseState)
			expect(nextState.x).toBe(-0)
			expect(nextState.x).not.toBe(+0)
			// however, toEqual treats -0 === +0 (which is true!)
			expect(nextState).toEqual(baseState)
		})

		it("should handle equality correctly - 3", () => {
			const baseState = {
				x: "s1",
				y: 1,
				z: NaN
			}
			const nextState = produce(baseState, draft => {
				draft.x = "s2"
				draft.y = 1
				draft.z = NaN
				if (!isProd) {
					expect(draft[DRAFT_STATE].assigned_.x).toBe(true)
					expect(draft[DRAFT_STATE].assigned_.y).toBe(undefined)
					expect(draft[DRAFT_STATE].assigned_.z).toBe(undefined)
				}
			})
			expect(nextState.x).toBe("s2")
		})

		// AKA: recursive produce calls
		describe("nested producers", () => {
			describe("when base state is not a draft", () => {
				// This test ensures the global state used to manage proxies is
				// never left in a corrupted state by a nested `produce` call.
				it("never affects its parent producer implicitly", () => {
					const base = {obj: {a: 1}}
					const next = produce(base, draft => {
						// Notice how `base.obj` is passed, not `draft.obj`
						const obj2 = produce(base.obj, draft2 => {
							draft2.a = 0
						})
						expect(obj2.a).toBe(0)
						expect(draft.obj.a).toBe(1) // effects should not be visible outside
					})
					expect(next).toBe(base)
				})
			})

			describe("when base state is a draft", () => {
				it("always wraps the draft in a new draft", () => {
					produce({}, parent => {
						produce(parent, child => {
							expect(child).not.toBe(parent)
							expect(isDraft(child)).toBeTruthy()
							expect(original(child)).toBe(parent)
						})
					})
				})

				// Reported by: https://github.com/mweststrate/immer/issues/343
				it("ensures each property is drafted", () => {
					produce({a: {}, b: {}}, parent => {
						parent.a // Access "a" but not "b"
						produce(parent, child => {
							child.c = 1
							expect(isDraft(child.a)).toBeTruthy()
							expect(isDraft(child.b)).toBeTruthy()
						})
					})
				})

				it("preserves any pending changes", () => {
					produce({a: 1, b: 1, d: 1}, parent => {
						parent.b = 2
						parent.c = 2
						delete parent.d
						produce(parent, child => {
							expect(child.a).toBe(1) // unchanged
							expect(child.b).toBe(2) // changed
							expect(child.c).toBe(2) // added
							expect(child.d).toBeUndefined() // deleted
						})
					})
				})
			})

			describe("when base state contains a draft", () => {
				it("wraps unowned draft with its own draft", () => {
					produce({a: {}}, parent => {
						produce({a: parent.a}, child => {
							expect(child.a).not.toBe(parent.a)
							expect(isDraft(child.a)).toBeTruthy()
							expect(original(child.a)).toBe(parent.a)
						})
					})
				})

				it("returns unowned draft if no changes were made", () => {
					produce({a: {}}, parent => {
						const result = produce({a: parent.a}, () => {})
						expect(result.a).toBe(parent.a)
					})
				})

				it("clones the unowned draft when changes are made", () => {
					produce({a: {}}, parent => {
						const result = produce({a: parent.a}, child => {
							child.a.b = 1
						})
						expect(result.a).not.toBe(parent.a)
						expect(result.a.b).toBe(1)
						expect("b" in parent.a).toBeFalsy()
					})
				})

				// We cannot auto-freeze the result of a nested producer,
				// because it may contain a draft from a parent producer.
				it("never auto-freezes the result", () => {
					produce({a: {}}, parent => {
						const r = produce({a: parent.a}, child => {
							child.b = 1 // Ensure a copy is returned.
						})
						expect(Object.isFrozen(r)).toBeFalsy()
					})
				})
			})

			// "Upvalues" are variables from a parent scope.
			it("does not finalize upvalue drafts", () => {
				produce({a: {}, b: {}}, parent => {
					expect(produce({}, () => parent)).toBe(parent)
					parent.x // Ensure proxy not revoked.

					expect(produce({}, () => [parent])[0]).toBe(parent)
					parent.x // Ensure proxy not revoked.

					expect(produce({}, () => parent.a)).toBe(parent.a)
					parent.a.x // Ensure proxy not revoked.

					// Modified parent test
					parent.c = 1
					expect(produce({}, () => [parent.b])[0]).toBe(parent.b)
					parent.b.x // Ensure proxy not revoked.
				})
			})

			it("works with interweaved Immer instances", () => {
				const options = {autoFreeze}
				const one = createPatchedImmer(options)
				const two = createPatchedImmer(options)

				const base = {}
				const result = one.produce(base, s1 =>
					two.produce({s1}, s2 => {
						expect(original(s2.s1)).toBe(s1)
						s2.n = 1
						s2.s1 = one.produce({s2}, s3 => {
							expect(original(s3.s2)).toBe(s2)
							expect(original(s3.s2.s1)).toBe(s2.s1)
							return s3.s2.s1
						})
					})
				)
				expect(result.n).toBe(1)
				expect(result.s1).toBe(base)
			})
		})

		it("throws when Object.setPrototypeOf() is used on a draft", () => {
			produce({}, draft => {
				expect(() =>
					Object.setPrototypeOf(draft, Array)
				).toThrowErrorMatchingSnapshot()
			})
		})

		it("supports the 'in' operator", () => {
			produce(baseState, draft => {
				// Known property
				expect("anArray" in draft).toBe(true)
				expect(Reflect.has(draft, "anArray")).toBe(true)

				// Unknown property
				expect("bla" in draft).toBe(false)
				expect(Reflect.has(draft, "bla")).toBe(false)

				// Known index
				expect(0 in draft.anArray).toBe(true)
				expect("0" in draft.anArray).toBe(true)
				expect(Reflect.has(draft.anArray, 0)).toBe(true)
				expect(Reflect.has(draft.anArray, "0")).toBe(true)

				// Unknown index
				expect(17 in draft.anArray).toBe(false)
				expect("17" in draft.anArray).toBe(false)
				expect(Reflect.has(draft.anArray, 17)).toBe(false)
				expect(Reflect.has(draft.anArray, "17")).toBe(false)
			})
		})

		it("'this' should not be bound anymore - 1", () => {
			const base = {x: 3}
			const next1 = produce(base, function() {
				expect(this).toBe(undefined)
			})
		})

		it("'this' should not be bound anymore - 2", () => {
			const incrementor = produce(function() {
				expect(this).toBe(undefined)
			})
			incrementor()
		})

		it("should be possible to use dynamic bound this", () => {
			const world = {
				counter: {count: 1},
				inc: produce(function(draft) {
					expect(this).toBe(world)
					draft.counter.count = this.counter.count + 1
				})
			}

			expect(world.inc(world).counter.count).toBe(2)
		})

		it("doesnt recurse into frozen structures if external data is frozen", () => {
			const frozen = {}
			Object.defineProperty(frozen, "x", {
				get() {
					throw "oops"
				},
				enumerable: true,
				configurable: true
			})
			Object.freeze(frozen)

			expect(() => {
				produce({}, d => {
					d.x = frozen
				})
			}).not.toThrow()
		})

		// See here: https://github.com/mweststrate/immer/issues/89
		it("supports the spread operator", () => {
			const base = {foo: {x: 0, y: 0}, bar: [0, 0]}
			const result = produce(base, draft => {
				draft.foo = {x: 1, ...draft.foo, y: 1}
				draft.bar = [1, ...draft.bar, 1]
			})
			expect(result).toEqual({
				foo: {x: 0, y: 1},
				bar: [1, 0, 0, 1]
			})
		})

		it("processes with lodash.set", () => {
			const base = [{id: 1, a: 1}]
			const result = produce(base, draft => {
				lodash.set(draft, "[0].a", 2)
			})
			expect(base[0].a).toEqual(1)
			expect(result[0].a).toEqual(2)
		})

		it("processes with lodash.find", () => {
			const base = [{id: 1, a: 1}]
			const result = produce(base, draft => {
				const obj1 = lodash.find(draft, {id: 1})
				lodash.set(obj1, "a", 2)
			})
			expect(base[0].a).toEqual(1)
			expect(result[0].a).toEqual(2)
		})

		it("does not draft external data", () => {
			const externalData = {x: 3}
			const base = {}
			const next = produce(base, draft => {
				// potentially, we *could* draft external data automatically, but only if those statements are not switched...
				draft.y = externalData
				draft.y.x += 1
				externalData.x += 1
			})
			expect(next).toEqual({y: {x: 5}})
			expect(externalData.x).toBe(5)
			expect(next.y).toBe(externalData)
		})

		it("does not create new state unnecessary, #491", () => {
			const a = {highlight: true}
			const next1 = produce(a, draft => {
				draft.highlight = false
				draft.highlight = true
			})
			// See explanation in issue
			expect(next1).not.toBe(a)

			const next2 = produce(a, draft => {
				draft.highlight = true
			})
			expect(next2).toBe(a)
		})

		autoFreeze &&
			test("issue #462 - frozen", () => {
				var origin = {
					a: {
						value: "no"
					},
					b: {
						value: "no"
					}
				}
				const next = produce(origin, draft => {
					draft.a.value = "im"
				})
				expect(() => {
					origin.b.value = "yes"
				}).toThrowError(
					"Cannot assign to read only property 'value' of object '#<Object>'"
				)
				expect(() => {
					next.b.value = "yes"
				}).toThrowError(
					"Cannot assign to read only property 'value' of object '#<Object>'"
				) // should throw!
			})

		autoFreeze &&
			test("issue #469, state not frozen", () => {
				const project = produce(
					{
						id: 1,
						tracks: [{id: 1}]
					},
					() => {}
				)

				expect(() => {
					project.id = 2 // Does not throw error
				}).toThrowError("Cannot assign to read only property 'id'")

				expect(() => {
					Object.assign(project, {id: 2}) // Uncaught TypeError: Cannot assign to read only property 'id' of object '#<Object>'
				}).toThrowError("Cannot assign to read only property 'id'")
			})

		describe("recipe functions", () => {
			it("can return a new object", () => {
				const base = {x: 3}
				const res = produce(base, d => {
					return {x: d.x + 1}
				})
				expect(res).not.toBe(base)
				expect(res).toEqual({x: 4})
			})

			it("can return the draft", () => {
				const base = {x: 3}
				const res = produce(base, d => {
					d.x = 4
					return d
				})
				expect(res).not.toBe(base)
				expect(res).toEqual({x: 4})
			})

			it("can return an unmodified child draft", () => {
				const base = {a: {}}
				const res = produce(base, d => {
					return d.a
				})
				expect(res).toBe(base.a)
			})

			// TODO: Avoid throwing if only the child draft was modified.
			it("cannot return a modified child draft", () => {
				const base = {a: {}}
				expect(() => {
					produce(base, d => {
						d.a.b = 1
						return d.a
					})
				}).toThrowErrorMatchingSnapshot()
			})

			it("can return a frozen object", () => {
				const res = deepFreeze([{x: 3}])
				expect(produce({}, () => res)).toBe(res)
			})

			it("can return an object with two references to another object", () => {
				const next = produce({}, d => {
					const obj = {}
					return {obj, arr: [obj]}
				})
				expect(next.obj).toBe(next.arr[0])
			})

			it("can return an object with two references to an unmodified draft", () => {
				const base = {a: {}}
				const next = produce(base, d => {
					return [d.a, d.a]
				})
				expect(next[0]).toBe(base.a)
				expect(next[0]).toBe(next[1])
			})

			it("cannot return an object that references itself", () => {
				const res = {}
				res.self = res
				expect(() => {
					produce(res, () => res.self)
				}).toThrowErrorMatchingSnapshot()
			})
		})

		it("throws when the draft is modified and another object is returned", () => {
			const base = {x: 3}
			expect(() => {
				produce(base, draft => {
					draft.x = 4
					return {x: 5}
				})
			}).toThrowErrorMatchingSnapshot()
		})

		it("should fix #117 - 1", () => {
			const reducer = (state, action) =>
				produce(state, draft => {
					switch (action.type) {
						case "SET_STARTING_DOTS":
							return draft.availableStartingDots.map(a => a)
						default:
							break
					}
				})
			const base = {
				availableStartingDots: [
					{dots: 4, count: 1},
					{dots: 3, count: 2},
					{dots: 2, count: 3},
					{dots: 1, count: 4}
				]
			}
			const next = reducer(base, {type: "SET_STARTING_DOTS"})
			expect(next).toEqual(base.availableStartingDots)
			expect(next).not.toBe(base.availableStartingDots)
		})

		it("should fix #117 - 2", () => {
			const reducer = (state, action) =>
				produce(state, draft => {
					switch (action.type) {
						case "SET_STARTING_DOTS":
							return {
								dots: draft.availableStartingDots.map(a => a)
							}
						default:
							break
					}
				})
			const base = {
				availableStartingDots: [
					{dots: 4, count: 1},
					{dots: 3, count: 2},
					{dots: 2, count: 3},
					{dots: 1, count: 4}
				]
			}
			const next = reducer(base, {type: "SET_STARTING_DOTS"})
			expect(next).toEqual({dots: base.availableStartingDots})
		})

		it("cannot always detect noop assignments - 0", () => {
			const baseState = {x: {y: 3}}
			const nextState = produce(baseState, d => {
				const a = d.x
				d.x = a
			})
			expect(nextState).toBe(baseState)
		})

		it("cannot always detect noop assignments - 1", () => {
			const baseState = {x: {y: 3}}
			const nextState = produce(baseState, d => {
				const a = d.x
				d.x = 4
				d.x = a
			})
			// Ideally, this should actually be the same instances
			// but this would be pretty expensive to detect,
			// so we don't atm
			expect(nextState).not.toBe(baseState)
		})

		it("cannot always detect noop assignments - 2", () => {
			const baseState = {x: {y: 3}}
			const nextState = produce(baseState, d => {
				const a = d.x
				const stuff = a.y + 3
				d.x = 4
				d.x = a
			})
			// Ideally, this should actually be the same instances
			// but this would be pretty expensive to detect,
			// so we don't atm
			expect(nextState).not.toBe(baseState)
		})

		it("cannot always detect noop assignments - 3", () => {
			const baseState = {x: 3}
			const nextState = produce(baseState, d => {
				d.x = 3
			})
			expect(nextState).toBe(baseState)
		})

		it("cannot always detect noop assignments - 4", () => {
			const baseState = {x: 3}
			const nextState = produce(baseState, d => {
				d.x = 4
				d.x = 3
			})
			// Ideally, this should actually be the same instances
			// but this would be pretty expensive to detect,
			// so we don't atm
			expect(nextState).not.toBe(baseState)
		})

		it("cannot always detect noop assignments - 4", () => {
			const baseState = {}
			const [nextState, patches] = produceWithPatches(baseState, d => {
				d.x = 4
				delete d.x
			})
			expect(nextState).toEqual({})
			expect(patches).toEqual([])
			// This differs between ES5 and proxy, and ES5 does it better :(
			expect(nextState).not.toBe(baseState)
		})

		it("cannot produce undefined by returning undefined", () => {
			const base = 3
			expect(produce(base, () => 4)).toBe(4)
			expect(produce(base, () => null)).toBe(null)
			expect(produce(base, () => undefined)).toBe(3)
			expect(produce(base, () => {})).toBe(3)
			expect(produce(base, () => nothing)).toBe(undefined)

			expect(produce({}, () => undefined)).toEqual({})
			expect(produce({}, () => nothing)).toBe(undefined)
			expect(produce(3, () => nothing)).toBe(undefined)

			expect(produce(() => undefined)({})).toEqual({})
			expect(produce(() => nothing)({})).toBe(undefined)
			expect(produce(() => nothing)(3)).toBe(undefined)
		})

		describe("base state type", () => {
			if (!global.USES_BUILD) testObjectTypes(produce)
			testLiteralTypes(produce)
		})

		afterEach(() => {
			expect(baseState).toBe(origBaseState)
			expect(baseState).toEqual(createBaseState())
		})

		function createBaseState() {
			const data = {
				anInstance: new Foo(),
				anArray: [3, 2, {c: 3}, 1],
				aMap: new Map([
					["jedi", {name: "Luke", skill: 10}],
					["jediTotal", 42],
					["force", "these aren't the droids you're looking for"]
				]),
				aSet: new Set([
					"Luke",
					42,
					{
						jedi: "Yoda"
					}
				]),
				aProp: "hi",
				anObject: {
					nested: {
						yummie: true
					},
					coffee: false
				}
			}
			return autoFreeze ? deepFreeze(data) : data
		}
	})

	it(`works with spread #524 - ${name}`, () => {
		const state = {
			level1: {
				level2: {
					level3: "data"
				}
			}
		}

		const nextState = produce(state, draft => {
			return {...draft}
		})
		const nextState1 = produce(state, draft => {
			const newLevel1 = produce(draft.level1, level1Draft => {
				return {...level1Draft}
			})
			draft.level1 = newLevel1
		})

		const nextState2 = produce(state, draft => {
			const newLevel1 = produce(draft.level1, level1Draft => {
				return {...level1Draft}
			})
			return {
				level1: newLevel1
			}
		})

		const nextState3 = produce(state, draft => {
			const newLevel1 = produce(draft.level1, level1Draft => {
				return Object.assign({}, level1Draft)
			})
			return Object.assign(draft, {
				level1: newLevel1
			})
		})

		const expected = {level1: {level2: {level3: "data"}}}
		expect(nextState1).toEqual(expected)
		expect(nextState2).toEqual(expected)
		expect(nextState3).toEqual(expected)
	})

	it(`Something with nested producers #522 ${name}`, () => {
		function initialStateFactory() {
			return {
				substate: {
					array: [
						{id: "id1", value: 0},
						{id: "id2", value: 0}
					]
				},
				array: [
					{id: "id1", value: 0},
					{id: "id2", value: 0}
				]
			}
		}

		const globalProducer = produce(draft => {
			draft.substate = subProducer(draft.substate)
			draft.array = arrayProducer(draft.array)
		}, initialStateFactory())

		const subProducer = produce(draftSubState => {
			draftSubState.array = arrayProducer(draftSubState.array)
		})

		const arrayProducer = produce(draftArray => {
			draftArray[0].value += 5
		})

		{
			const state = globalProducer(undefined)
			expect(state.array[0].value).toBe(5)
			expect(state.array.length).toBe(2)
			expect(state.array[1]).toMatchObject({
				id: "id2",
				value: 0
			})
		}

		{
			const state = globalProducer(undefined)
			expect(state.substate.array[0].value).toBe(5)
			expect(state.substate.array.length).toBe(2)
			expect(state.substate.array[1]).toMatchObject({
				id: "id2",
				value: 0
			})
			expect(state.substate.array).toMatchObject(state.array)
		}
	})

	describe(`isDraft - ${name}`, () => {
		it("returns true for object drafts", () => {
			produce({}, state => {
				expect(isDraft(state)).toBeTruthy()
			})
		})
		it("returns true for array drafts", () => {
			produce([], state => {
				expect(isDraft(state)).toBeTruthy()
			})
		})
		it("returns true for objects nested in object drafts", () => {
			produce({a: {b: {}}}, state => {
				expect(isDraft(state.a)).toBeTruthy()
				expect(isDraft(state.a.b)).toBeTruthy()
			})
		})
		it("returns false for new objects added to a draft", () => {
			produce({}, state => {
				state.a = {}
				expect(isDraft(state.a)).toBeFalsy()
			})
		})
		it("returns false for objects returned by the producer", () => {
			const object = produce([], () => Object.create(null))
			expect(isDraft(object)).toBeFalsy()
		})
		it("returns false for arrays returned by the producer", () => {
			const array = produce({}, _ => [])
			expect(isDraft(array)).toBeFalsy()
		})
		it("returns false for object drafts returned by the producer", () => {
			const object = produce({}, state => state)
			expect(isDraft(object)).toBeFalsy()
		})
		it("returns false for array drafts returned by the producer", () => {
			const array = produce([], state => state)
			expect(isDraft(array)).toBeFalsy()
		})
	})

	describe(`complex nesting map / set / object`, () => {
		const a = {a: 1}
		const b = {b: 2}
		const c = {c: 3}
		const set1 = new Set([a, b])
		const set2 = new Set([c])
		const map = new Map([
			["set1", set1],
			["set2", set2]
		])
		const base = {map}

		function first(set) {
			return Array.from(set.values())[0]
		}

		function second(set) {
			return Array.from(set.values())[1]
		}

		test(`modify deep object`, () => {
			const [res, patches] = produceWithPatches(base, draft => {
				const v = first(draft.map.get("set1"))
				expect(original(v)).toBe(a)
				expect(v).toEqual(a)
				expect(v).not.toBe(a)
				v.a++
			})
			expect(res).toMatchSnapshot()
			expect(patches).toMatchSnapshot()
			expect(a.a).toBe(1)
			expect(base.map.get("set1")).toBe(set1)
			expect(first(base.map.get("set1"))).toBe(a)
			expect(res).not.toBe(base)
			expect(res.map).not.toBe(base.map)
			expect(res.map.get("set1")).not.toBe(base.map.get("set1"))
			expect(second(base.map.get("set1"))).toBe(b)
			expect(base.map.get("set2")).toBe(set2)
			expect(first(res.map.get("set1"))).toEqual({a: 2})
		})

		test(`modify deep object - keep value`, () => {
			const [res, patches] = produceWithPatches(base, draft => {
				const v = first(draft.map.get("set1"))
				expect(original(v)).toBe(a)
				expect(v).toEqual(a)
				expect(v).not.toBe(a)
				v.a = 1 // same value
			})
			expect(a.a).toBe(1)
			expect(base.map.get("set1")).toBe(set1)
			expect(first(base.map.get("set1"))).toBe(a)
			expect(res).toBe(base)
			expect(res.map).toBe(base.map)
			expect(res.map.get("set1")).toBe(base.map.get("set1"))
			expect(first(res.map.get("set1"))).toBe(a)
			expect(second(base.map.get("set1"))).toBe(b)
			expect(base.map.get("set2")).toBe(set2)
			expect(patches.length).toBe(0)
		})
	})

	if (!autoFreeze) {
		describe("#613", () => {
			const x1 = {}
			const y1 = produce(x1, draft => {
				draft.foo = produce({bar: "baz"}, draft1 => {
					draft1.bar = "baa"
				})
				draft.foo.bar = "a"
			})
			expect(y1.foo.bar).toBe("a")
		})
	}
}

function testObjectTypes(produce) {
	class Foo {
		constructor(foo) {
			this.foo = foo
			this[immerable] = true
		}
	}
	const values = {
		"empty object": {},
		"plain object": {a: 1, b: 2},
		"object (no prototype)": Object.create(null),
		"empty array": [],
		"plain array": [1, 2],
		"class instance (draftable)": new Foo(1)
	}
	for (const name in values) {
		const value = values[name]
		const copy = shallowCopy(value)
		testObjectType(name, value)
		testObjectType(name + " (frozen)", Object.freeze(copy))
	}
	function testObjectType(name, base) {
		describe(name, () => {
			it("creates a draft", () => {
				produce(base, draft => {
					expect(draft).not.toBe(base)
					expect(shallowCopy(draft, true)).toEqual(base)
				})
			})

			it("preserves the prototype", () => {
				const proto = Object.getPrototypeOf(base)
				produce(base, draft => {
					expect(Object.getPrototypeOf(draft)).toBe(proto)
				})
			})

			it("returns the base state when no changes are made", () => {
				expect(produce(base, () => {})).toBe(base)
			})

			it("returns a copy when changes are made", () => {
				const random = Math.random()
				const result = produce(base, draft => {
					draft[0] = random
				})
				expect(result).not.toBe(base)
				expect(result.constructor).toBe(base.constructor)
				expect(result[0]).toBe(random)
			})
		})
	}

	describe("class with getters", () => {
		class State {
			[immerable] = true
			_bar = {baz: 1}
			foo
			get bar() {
				return this._bar
			}
			syncFoo() {
				const value = this.bar.baz
				this.foo = value
				this.bar.baz++
			}
		}
		const state = new State()

		it("should use a method to assing a field using a getter that return a non primitive object", () => {
			const newState = produce(state, draft => {
				draft.syncFoo()
			})
			expect(newState.foo).toEqual(1)
			expect(newState.bar).toEqual({baz: 2})
			expect(state.bar).toEqual({baz: 1})
		})
	})

	describe("super class with getters", () => {
		class BaseState {
			[immerable] = true
			_bar = {baz: 1}
			foo
			get bar() {
				return this._bar
			}
			syncFoo() {
				const value = this.bar.baz
				this.foo = value
				this.bar.baz++
			}
		}

		class State extends BaseState {}

		const state = new State()

		it("should use a method to assing a field using a getter that return a non primitive object", () => {
			const newState = produce(state, draft => {
				draft.syncFoo()
			})
			expect(newState.foo).toEqual(1)
			expect(newState.bar).toEqual({baz: 2})
			expect(state.bar).toEqual({baz: 1})
		})
	})

	describe("class with setters", () => {
		class State {
			[immerable] = true
			_bar = 0
			get bar() {
				return this._bar
			}
			set bar(x) {
				this._bar = x
			}
		}
		const state = new State()

		it("should define a field with a setter", () => {
			const newState3 = produce(state, d => {
				d.bar = 1
				expect(d._bar).toEqual(1)
			})
			expect(newState3._bar).toEqual(1)
			expect(newState3.bar).toEqual(1)
			expect(state._bar).toEqual(0)
			expect(state.bar).toEqual(0)
		})
	})

	describe("setter only", () => {
		let setterCalled = 0
		class State {
			[immerable] = true
			x = 0
			set y(value) {
				setterCalled++
				this.x = value
			}
		}

		const state = new State()
		const next = produce(state, draft => {
			expect(draft.y).toBeUndefined()
			draft.y = 2 // setter is inherited, so works
			expect(draft.x).toBe(2)
		})
		expect(setterCalled).toBe(1)
		expect(next.x).toBe(2)
		expect(state.x).toBe(0)
	})

	describe("getter only", () => {
		let getterCalled = 0
		class State {
			[immerable] = true
			x = 0
			get y() {
				getterCalled++
				return this.x
			}
		}

		const state = new State()
		const next = produce(state, draft => {
			expect(draft.y).toBe(0)
			expect(() => {
				draft.y = 2
			}).toThrow("Cannot set property y")
			draft.x = 2
			expect(draft.y).toBe(2)
		})
		expect(next.x).toBe(2)
		expect(next.y).toBe(2)
		expect(state.x).toBe(0)
	})

	describe("own setter only", () => {
		let setterCalled = 0
		const state = {
			x: 0,
			set y(value) {
				setterCalled++
				this.x = value
			}
		}

		const next = produce(state, draft => {
			expect(draft.y).toBeUndefined()
			// setter is not preserved, so we can write
			draft.y = 2
			expect(draft.x).toBe(0)
			expect(draft.y).toBe(2)
		})
		expect(setterCalled).toBe(0)
		expect(next.x).toBe(0)
		expect(next.y).toBe(2)
		expect(state.x).toBe(0)
	})

	describe("own getter only", () => {
		let getterCalled = 0
		const state = {
			x: 0,
			get y() {
				getterCalled++
				return this.x
			}
		}

		const next = produce(state, draft => {
			expect(draft.y).toBe(0)
			// de-referenced, so stores it locally
			draft.y = 2
			expect(draft.y).toBe(2)
			expect(draft.x).toBe(0)
		})
		expect(getterCalled).not.toBe(1)
		expect(next.x).toBe(0)
		expect(next.y).toBe(2)
		expect(state.x).toBe(0)
	})

	describe("#620", () => {
		const customSymbol = Symbol("customSymbol")

		class TestClass {
			[immerable] = true;
			[customSymbol] = 1
		}

		/* Create class instance */
		let test0 = new TestClass()

		/* First produce. This works */
		let test1 = produce(test0, draft => {
			expect(draft[customSymbol]).toBe(1)
			draft[customSymbol] = 2
		})
		expect(test1).toEqual({
			[immerable]: true,
			[customSymbol]: 2
		})

		/* Second produce. This does NOT work. See console error */
		/* With version 6.0.9, this works though */
		let test2 = produce(test1, draft => {
			expect(draft[customSymbol]).toBe(2)
			draft[customSymbol] = 3
		})
		expect(test2).toEqual({
			[immerable]: true,
			[customSymbol]: 3
		})
	})
}

function testLiteralTypes(produce) {
	class Foo {}
	const values = {
		"falsy number": 0,
		"truthy number": 1,
		"negative number": -1,
		NaN: NaN,
		infinity: 1 / 0,
		true: true,
		false: false,
		"empty string": "",
		"truthy string": "1",
		null: null,
		undefined: undefined,

		/**
		 * These objects are treated as literals because Immer
		 * does not know how to draft them.
		 */
		function: () => {},
		"regexp object": /.+/g,
		"boxed number": new Number(0),
		"boxed string": new String(""),
		"boxed boolean": new Boolean(),
		"date object": new Date(),
		"class instance (not draftable)": new Foo()
	}
	for (const name in values) {
		describe(name, () => {
			const value = values[name]

			if (value && typeof value == "object") {
				it("does not return a copy when changes are made", () => {
					expect(() =>
						produce(value, draft => {
							draft.foo = true
						})
					).toThrowError(
						isProd
							? "[Immer] minified error nr: 1"
							: "produce can only be called on things that are draftable"
					)
				})
			} else {
				it("does not create a draft", () => {
					produce(value, draft => {
						expect(draft).toBe(value)
					})
				})

				it("returns the base state when no changes are made", () => {
					expect(produce(value, () => {})).toBe(value)
				})
			}
		})
	}
}

function enumerableOnly(x) {
	const copy = Array.isArray(x) ? x.slice() : Object.assign({}, x)
	each(copy, (prop, value) => {
		if (value && typeof value === "object") {
			copy[prop] = enumerableOnly(value)
		}
	})
	return copy
}

function isEnumerable(base, prop) {
	const desc = Object.getOwnPropertyDescriptor(base, prop)
	return desc && desc.enumerable ? true : false
}