Beispiel #1
0
func TestNode_DeleteArrayChild(t *testing.T) {
	_, n := data.Setup(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.NoError(t, n.Map["ajs"].DeleteArrayChild(1))
		assert.Equal(t, 3, len(n.Map["ajs"].Array))
		assert.Equal(t, 0, n.Map["ajs"].Array[0].Index)
		assert.Equal(t, 1, n.Map["ajs"].Array[1].Index)
		assert.Equal(t, 2, n.Map["ajs"].Array[2].Index)
		assert.Equal(t, []string{"ajs0", "ajs2", "ajs3"}, m.Ajs)

		require.NoError(t, n.Map["ajs"].DeleteArrayChild(2))
		assert.Equal(t, 2, len(n.Map["ajs"].Array))
		assert.Equal(t, 0, n.Map["ajs"].Array[0].Index)
		assert.Equal(t, 1, n.Map["ajs"].Array[1].Index)
		assert.Equal(t, []string{"ajs0", "ajs2"}, m.Ajs)

		require.NoError(t, n.Map["ajs"].DeleteArrayChild(0))
		assert.Equal(t, 1, len(n.Map["ajs"].Array))
		assert.Equal(t, 0, n.Map["ajs"].Array[0].Index)
		assert.Equal(t, []string{"ajs2"}, m.Ajs)

		require.NoError(t, n.Map["ajs"].DeleteArrayChild(0))
		assert.Equal(t, 0, len(n.Map["ajs"].Array))
		assert.Equal(t, []string{}, m.Ajs)
	}
	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #2
0
func TestNode_DeleteObjectChild(t *testing.T) {
	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "js"))
		assert.True(t, n.Map["js"].Missing)
		assert.Equal(t, "", m.Js)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "ss"))
		assert.Nil(t, m.Ss)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "sr"))
		assert.Nil(t, m.Sr)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "jn"))
		assert.Equal(t, 0.0, m.Jn)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "sn"))
		assert.Nil(t, m.Sn)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "jb"))
		assert.Equal(t, false, m.Jb)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "sb"))
		assert.Nil(t, m.Sb)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "i"))
		assert.Nil(t, m.I)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "ajs"))
		assert.Nil(t, m.Ajs)
		require.NoError(t, n.DeleteObjectChild(cb.Ctx(), "mjs"))
		assert.Nil(t, m.Mjs)

	}
	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #3
0
func TestNode_InitialiseMapChild(t *testing.T) {
	cb, n := data.Setup(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {

		c := node.NewNode()
		require.NoError(t, c.InitialiseMapItem(cb.Ctx(), n.Map["mjs"], "c"))
		require.NoError(t, c.AddToMap(cb.Ctx(), n.Map["mjs"], "c", true))
		assert.Equal(t, 3, len(n.Map["mjs"].Map))
		assert.True(t, n.Map["mjs"].Map["c"].Null)
		assert.False(t, n.Map["mjs"].Map["c"].Missing)
		assert.Equal(t, c, n.Map["mjs"].Map["c"])
		assert.Equal(t, "", m.Mjs["c"])

		c1 := node.NewNode()
		require.NoError(t, c1.InitialiseMapItem(cb.Ctx(), n.Map["mss"], "c"))
		require.NoError(t, c1.AddToMap(cb.Ctx(), n.Map["mss"], "c", true))
		assert.Equal(t, 3, len(n.Map["mss"].Map))
		assert.Nil(t, m.Mss["c"])

		c2 := node.NewNode()
		require.NoError(t, c2.InitialiseMapItem(cb.Ctx(), n.Map["mm"], "c"))
		require.NoError(t, c2.AddToMap(cb.Ctx(), n.Map["mm"], "c", true))
		assert.Equal(t, 3, len(m.Mm))
		assert.Nil(t, m.Mm["c"])
	}
	data.Run(t, n, n.Value.(*data.Multi), test)

}
Beispiel #4
0
func TestNode_SetValueNumber(t *testing.T) {

	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		n.Map["jn"].SetValueNumber(cb.Ctx(), 11.0)
		assert.Equal(t, 11.0, m.Jn)

		n.Map["sn"].SetValueNumber(cb.Ctx(), 12.0)
		assert.Equal(t, 12.0, m.Sn.Value())

		n.Map["ajn"].Array[0].SetValueNumber(cb.Ctx(), 13.0)
		assert.Equal(t, 13.0, m.Ajn[0])

		n.Map["ajn"].Array[1].SetValueNumber(cb.Ctx(), 14.0)
		assert.Equal(t, 14.0, m.Ajn[1])

		n.Map["mjn"].Map["a"].SetValueNumber(cb.Ctx(), 15.0)
		assert.Equal(t, 15.0, m.Mjn["a"])

		n.Map["mjn"].Map["b"].SetValueNumber(cb.Ctx(), 16.0)
		assert.Equal(t, 16.0, m.Mjn["b"])
	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #5
0
func TestNode_SetValueBool(t *testing.T) {

	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		n.Map["jb"].SetValueBool(cb.Ctx(), true)
		assert.Equal(t, true, m.Jb)

		n.Map["sb"].SetValueBool(cb.Ctx(), true)
		assert.Equal(t, true, m.Sb.Value())

		n.Map["ajb"].Array[0].SetValueBool(cb.Ctx(), true)
		assert.Equal(t, true, m.Ajb[0])

		n.Map["ajb"].Array[1].SetValueBool(cb.Ctx(), true)
		assert.Equal(t, true, m.Ajb[1])

		n.Map["mjb"].Map["a"].SetValueBool(cb.Ctx(), true)
		assert.Equal(t, true, m.Mjb["a"])

		n.Map["mjb"].Map["b"].SetValueBool(cb.Ctx(), true)
		assert.Equal(t, true, m.Mjb["b"])
	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #6
0
func TestNode_NativeValue(t *testing.T) {
	_, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {

		require.Equal(t, "js1", n.Map["js"].NativeValue())
		require.Equal(t, "ss1", n.Map["ss"].NativeValue())

		require.Equal(t, true, n.Map["jb"].NativeValue())
		require.Equal(t, false, n.Map["sb"].NativeValue())

		require.Equal(t, 1.1, n.Map["jn"].NativeValue())
		require.Equal(t, 1.2, n.Map["sn"].NativeValue())

		require.Equal(t, nil, n.Map["ajs"].NativeValue())
		require.Equal(t, nil, n.Map["mjs"].NativeValue())

		require.Equal(t, true, n.Map["aljb"].NativeValue())
		require.Equal(t, 2.0, n.Map["aljn"].NativeValue())
		require.Equal(t, "aljs", n.Map["aljs"].NativeValue())

	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #7
0
func TestNode_SetValueString(t *testing.T) {

	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		n.Map["js"].SetValueString(cb.Ctx(), "aa")
		assert.Equal(t, "aa", m.Js)

		n.Map["ss"].SetValueString(cb.Ctx(), "bb")
		assert.Equal(t, "bb", m.Ss.Value())

		n.Map["sr"].SetValueString(cb.Ctx(), "cc")
		assert.Equal(t, "cc", m.Sr.Name)

		n.Map["i"].Map["a"].SetValueString(cb.Ctx(), "dd")
		assert.Equal(t, "dd", m.I.Face())

		n.Map["ajs"].Array[0].SetValueString(cb.Ctx(), "ee")
		assert.Equal(t, "ee", m.Ajs[0])

		n.Map["ajs"].Array[1].SetValueString(cb.Ctx(), "ff")
		assert.Equal(t, "ff", m.Ajs[1])

		n.Map["mjs"].Map["a"].SetValueString(cb.Ctx(), "gg")
		assert.Equal(t, "gg", m.Mjs["a"])

		n.Map["mjs"].Map["b"].SetValueString(cb.Ctx(), "hh")
		assert.Equal(t, "hh", m.Mjs["b"])
	}

	data.Run(t, n, n.Value.(*data.Multi), test)

}
Beispiel #8
0
func TestNode_SetValueZero2(t *testing.T) {
	cb, n := data.Empty(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		sstring, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/system", "string")
		assert.True(t, ok)
		snumber, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/system", "number")
		assert.True(t, ok)

		require.NoError(t, n.Map["ss"].SetValueZero(cb.Ctx(), true, sstring))
		assert.Nil(t, m.Ss)

		require.NoError(t, n.Map["sn"].SetValueZero(cb.Ctx(), false, snumber))
		assert.NotNil(t, m.Sn)

		require.NoError(t, n.Map["mnri"].SetValueZero(cb.Ctx(), true, nil))
		assert.Nil(t, m.Mnri)

		require.NoError(t, n.Map["mi"].SetValueZero(cb.Ctx(), false, nil))
		assert.NotNil(t, m.Mi)
		assert.Equal(t, 0, len(m.Mi))

		require.NoError(t, n.Map["anri"].SetValueZero(cb.Ctx(), true, nil))
		assert.Nil(t, m.Anri)

		require.NoError(t, n.Map["ai"].SetValueZero(cb.Ctx(), false, nil))
		assert.NotNil(t, m.Ai)
		assert.Equal(t, 0, len(m.Ai))

	}
	data.Run(t, n, n.Value.(*data.Multi), test)

}
Beispiel #9
0
func TestNode_Backup(t *testing.T) {

	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		var err error
		b := n.Backup()
		err = n.RecomputeHash(cb.Ctx(), true)
		require.NoError(t, err)
		err = b.RecomputeHash(cb.Ctx(), true)
		require.NoError(t, err)
		require.Equal(t, b.Hash(), n.Hash())
		require.Equal(t, b.Value, n.Value)

		r := &node.Node{}
		r.Restore(cb.Ctx(), b)
		err = r.RecomputeHash(cb.Ctx(), true)
		require.NoError(t, err)
		require.Equal(t, r.Hash(), n.Hash())
		require.Equal(t, r.Value, n.Value)

	}

	data.Run(t, n, n.Value.(*data.Multi), test)

}
Beispiel #10
0
func TestData(t *testing.T) {
	_, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.Equal(t, "almsa", m.Alms["a"].Js)
	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #11
0
func TestNode_SetIdField(t *testing.T) {
	cb, n := data.Setup(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.HasError(t, n.Map["js"].SetIdField(cb.Ctx(), "a"), "QVLAEAEWEB")
		require.NoError(t, n.Map["m"].SetIdField(cb.Ctx(), "a"))
		require.Equal(t, "a", n.Map["m"].Value.(*data.Multi).Id.Name)
	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #12
0
Datei: main.go Projekt: kego/ke
func main() {
	t := &testing.T{}
	_, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.Equal(t, "aljs", *m.Aljs)
	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #13
0
func TestNode_SetValue(t *testing.T) {
	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.NoError(t, n.Map["js"].SetValue(cb.Ctx(), "aa"))
		assert.Equal(t, "aa", m.Js)

		require.NoError(t, n.Map["js"].SetValue(cb.Ctx(), "aa"))
		assert.Equal(t, "aa", m.Js)

		require.NoError(t, n.Map["ss"].SetValue(cb.Ctx(), "bb"))
		assert.Equal(t, "bb", m.Ss.Value())

		require.NoError(t, n.Map["ss"].SetValue(cb.Ctx(), "bb"))
		assert.Equal(t, "bb", m.Ss.Value())

		require.NoError(t, n.Map["jb"].SetValue(cb.Ctx(), false))
		assert.Equal(t, false, m.Jb)

		require.NoError(t, n.Map["jb"].SetValue(cb.Ctx(), false))
		assert.Equal(t, false, m.Jb)

		require.NoError(t, n.Map["sb"].SetValue(cb.Ctx(), true))
		assert.Equal(t, true, m.Sb.Value())

		require.NoError(t, n.Map["sb"].SetValue(cb.Ctx(), true))
		assert.Equal(t, true, m.Sb.Value())

		require.NoError(t, n.Map["jn"].SetValue(cb.Ctx(), 2.5))
		assert.Equal(t, 2.5, m.Jn)

		require.NoError(t, n.Map["jn"].SetValue(cb.Ctx(), 2.5))
		assert.Equal(t, 2.5, m.Jn)

		require.NoError(t, n.Map["sn"].SetValue(cb.Ctx(), 2.6))
		assert.Equal(t, 2.6, m.Sn.Value())

		require.NoError(t, n.Map["sn"].SetValue(cb.Ctx(), 2.6))
		assert.Equal(t, 2.6, m.Sn.Value())

		require.NoError(t, n.Map["aljb"].SetValue(cb.Ctx(), false))
		assert.Equal(t, data.Aljb(false), *m.Aljb)

		require.NoError(t, n.Map["aljn"].SetValue(cb.Ctx(), 2.1))
		assert.Equal(t, data.Aljn(2.1), *m.Aljn)

		require.NoError(t, n.Map["aljs"].SetValue(cb.Ctx(), "aljs1"))
		assert.Equal(t, data.Aljs("aljs1"), *m.Aljs)

	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #14
0
func TestNode_DeleteMapChild(t *testing.T) {
	_, n := data.Setup(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.NoError(t, n.Map["mjs"].DeleteMapChild("a"))
		assert.Equal(t, 1, len(n.Map["mjs"].Map))
		assert.Equal(t, 1, len(m.Mjs))
		require.NoError(t, n.Map["mjs"].DeleteMapChild("b"))
		assert.Equal(t, 0, len(n.Map["mjs"].Map))
		assert.Equal(t, 0, len(m.Mjs))
		require.NoError(t, n.Map["mm"].DeleteMapChild("b"))
		assert.Equal(t, 1, len(n.Map["mm"].Map))
		assert.Equal(t, 1, len(m.Mm))
	}
	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #15
0
func TestNode_Unpack2(t *testing.T) {

	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		assert.Equal(t, "js1", m.Js)
		assert.Equal(t, "ss1", m.Ss.Value())
		assert.Equal(t, "sr1", m.Sr.Name)
		assert.Equal(t, 1.1, m.Jn)
		assert.Equal(t, 1.2, m.Sn.Value())
		assert.Equal(t, true, m.Jb)
		assert.Equal(t, false, m.Sb.Value())
		assert.Equal(t, "ia", m.I.Face())
		assert.Equal(t, "ajs0", m.Ajs[0])
		assert.Equal(t, "ajs1", m.Ajs[1])
		assert.Equal(t, "ass0", m.Ass[0].Value())
		assert.Equal(t, "ass1", m.Ass[1].Value())
		assert.Equal(t, 2.1, m.Ajn[0])
		assert.Equal(t, 2.2, m.Ajn[1])
		assert.Equal(t, 3.1, m.Asn[0].Value())
		assert.Equal(t, 3.2, m.Asn[1].Value())
		assert.Equal(t, true, m.Ajb[0])
		assert.Equal(t, false, m.Ajb[1])
		assert.Equal(t, false, m.Asb[0].Value())
		assert.Equal(t, true, m.Asb[1].Value())
		assert.Equal(t, "mjsa", m.Mjs["a"])
		assert.Equal(t, "mjsb", m.Mjs["b"])
		assert.Equal(t, "mssa", m.Mss["a"].Value())
		assert.Equal(t, "mssb", m.Mss["b"].Value())
		assert.Equal(t, 4.1, m.Mjn["a"])
		assert.Equal(t, 4.2, m.Mjn["b"])
		assert.Equal(t, 5.1, m.Msn["a"].Value())
		assert.Equal(t, 5.2, m.Msn["b"].Value())
		assert.Equal(t, true, m.Mjb["a"])
		assert.Equal(t, false, m.Mjb["b"])
		assert.Equal(t, false, m.Msb["a"].Value())
		assert.Equal(t, true, m.Msb["b"].Value())
		assert.Equal(t, "anri0", m.Anri[0].GetString(cb.Ctx()).Value())
		assert.Equal(t, "anri1", m.Anri[1].GetString(cb.Ctx()).Value())
		assert.Equal(t, "anri2", m.Anri[2].GetString(cb.Ctx()).Value())
		assert.Equal(t, "mnria", m.Mnri["a"].GetString(cb.Ctx()).Value())
		assert.Equal(t, "mnrib", m.Mnri["b"].GetString(cb.Ctx()).Value())
		assert.Equal(t, "mnric", m.Mnri["c"].GetString(cb.Ctx()).Value())
	}

	data.Run(t, n, n.Value.(*data.Multi), test)

}
Beispiel #16
0
func TestNode_ReorderArrayChild(t *testing.T) {
	_, n := data.Setup(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		require.NoError(t, n.Map["ajs"].ReorderArrayChild(0, 1))
		assert.Equal(t, 4, len(n.Map["ajs"].Array))
		assert.Equal(t, 0, n.Map["ajs"].Array[0].Index)
		assert.Equal(t, 1, n.Map["ajs"].Array[1].Index)
		assert.Equal(t, 2, n.Map["ajs"].Array[2].Index)
		assert.Equal(t, 3, n.Map["ajs"].Array[3].Index)
		assert.Equal(t, "ajs1", n.Map["ajs"].Array[0].ValueString)
		assert.Equal(t, "ajs0", n.Map["ajs"].Array[1].ValueString)
		assert.Equal(t, "ajs2", n.Map["ajs"].Array[2].ValueString)
		assert.Equal(t, "ajs3", n.Map["ajs"].Array[3].ValueString)
		assert.Equal(t, []string{"ajs1", "ajs0", "ajs2", "ajs3"}, m.Ajs)
	}
	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #17
0
func TestAddMutation(t *testing.T) {

	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		var a, p, b *node.Node

		a = node.NewNode()
		p = n.Map["ajs"]
		b = node.NewNode()
		require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 0, nil, ""))
		assert.Equal(t, 5, len(n.Map["ajs"].Array))
		assert.Equal(t, 5, len(m.Ajs))

		require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
		assert.Equal(t, 4, len(n.Map["ajs"].Array))
		assert.Equal(t, 4, len(m.Ajs))

		a = node.NewNode()
		p = n.Map["ass"]
		b = node.NewNode()
		require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 0, nil, ""))
		assert.Equal(t, 5, len(n.Map["ass"].Array))
		assert.Equal(t, 5, len(m.Ass))
		require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
		assert.Equal(t, 4, len(n.Map["ass"].Array))
		assert.Equal(t, 4, len(m.Ass))

		a = node.NewNode()
		p = n.Map["am"]
		b = node.NewNode()
		require.NoError(t, mutateAddNode(cb.Ctx(), a, p, "", 0, nil, ""))
		assert.Equal(t, 3, len(n.Map["am"].Array))
		assert.Equal(t, 3, len(n.Map["am"].Value.([]*data.Multi)))
		assert.Equal(t, 3, len(m.Am))
		require.NoError(t, mutateDeleteNode(cb.Ctx(), a, p, b))
		assert.Equal(t, 2, len(n.Map["am"].Array))
		assert.Equal(t, 2, len(n.Map["am"].Value.([]*data.Multi)))
		assert.Equal(t, 2, len(m.Am))
	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #18
0
func TestNode_InitialiseArrayChild(t *testing.T) {
	cb, n := data.Setup(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		c := node.NewNode()
		require.NoError(t, c.InitialiseArrayItem(cb.Ctx(), n.Map["ajs"], 4))
		require.NoError(t, c.AddToArray(cb.Ctx(), n.Map["ajs"], 4, true))
		assert.Equal(t, 5, len(n.Map["ajs"].Array))
		assert.True(t, n.Map["ajs"].Array[4].Null)
		assert.False(t, n.Map["ajs"].Array[4].Missing)
		assert.Equal(t, c, n.Map["ajs"].Array[4])
		assert.Equal(t, []string{"ajs0", "ajs1", "ajs2", "ajs3", ""}, m.Ajs)

		c1 := node.NewNode()
		require.NoError(t, c1.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 4))
		require.NoError(t, c1.AddToArray(cb.Ctx(), n.Map["ass"], 4, true))
		assert.Equal(t, 5, len(m.Ass))
		assert.Nil(t, m.Ass[4])

		c2 := node.NewNode()
		require.NoError(t, c2.InitialiseArrayItem(cb.Ctx(), n.Map["ajs"], 0))
		require.NoError(t, c2.AddToArray(cb.Ctx(), n.Map["ajs"], 0, true))
		assert.Equal(t, 6, len(n.Map["ajs"].Array))
		assert.Equal(t, []string{"", "ajs0", "ajs1", "ajs2", "ajs3", ""}, m.Ajs)

		c3 := node.NewNode()
		require.NoError(t, c3.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 0))
		require.NoError(t, c3.AddToArray(cb.Ctx(), n.Map["ass"], 0, true))
		assert.Equal(t, 6, len(m.Ass))
		assert.Nil(t, m.Ass[0])

		c4 := node.NewNode()
		require.NoError(t, c4.InitialiseArrayItem(cb.Ctx(), n.Map["am"], 2))
		require.NoError(t, c4.AddToArray(cb.Ctx(), n.Map["am"], 2, true))
		assert.Equal(t, 3, len(m.Am))
		assert.Nil(t, m.Am[2])
	}
	data.Run(t, n, n.Value.(*data.Multi), test)

}
Beispiel #19
0
func TestDeleteMutation(t *testing.T) {

	cb, n := data.Setup(t)

	test := func(t *testing.T, n *node.Node, m *data.Multi) {
		var b, d, p *node.Node

		b = node.NewNode()
		d = n.Map["jb"]
		p = n
		require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
		assert.False(t, n.Map["jb"].ValueBool)
		assert.False(t, m.Jb)
		require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
		assert.True(t, n.Map["jb"].ValueBool)
		assert.True(t, m.Jb)

		b = node.NewNode()
		d = n.Map["ss"]
		p = n
		require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
		assert.True(t, n.Map["ss"].Missing)
		assert.Equal(t, "", n.Map["ss"].ValueString)
		assert.Nil(t, m.Ss)
		require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
		assert.False(t, n.Map["ss"].Missing)
		assert.Equal(t, "ss1", n.Map["ss"].ValueString)
		require.NotNil(t, m.Ss)
		assert.Equal(t, "ss1", m.Ss.Value())

		b = node.NewNode()
		d = n.Map["i"]
		p = n
		require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
		assert.True(t, n.Map["i"].Missing)
		assert.Nil(t, m.I)
		require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
		assert.False(t, n.Map["i"].Missing)
		assert.Equal(t, "ia", n.Map["i"].Value.(*data.Facea).A.Value())
		require.NotNil(t, m.I)
		assert.Equal(t, "ia", m.I.Face())

		b = node.NewNode()
		d = n.Map["ass"]
		p = n
		require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
		assert.True(t, n.Map["ass"].Missing)
		assert.Equal(t, 0, len(m.Ass))
		require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
		assert.False(t, n.Map["ass"].Missing)
		assert.Equal(t, 4, len(m.Ass))

		b = node.NewNode()
		d = n.Map["mss"]
		p = n
		require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
		assert.True(t, n.Map["mss"].Missing)
		assert.Nil(t, m.Mss)
		require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
		assert.False(t, n.Map["mss"].Missing)
		require.NotNil(t, m.Mss)
		assert.Equal(t, 2, len(m.Mss))
		require.NotNil(t, m.Mss["a"])
		assert.Equal(t, "mssa", m.Mss["a"].Value())

		b = node.NewNode()
		d = n.Map["ass"].Array[0]
		p = n.Map["ass"]
		require.NoError(t, mutateDeleteNode(cb.Ctx(), d, p, b))
		assert.Equal(t, 3, len(n.Map["ass"].Array))
		assert.Equal(t, 3, len(m.Ass))
		require.NoError(t, mutateRestoreNode(cb.Ctx(), d, p, b))
		assert.Equal(t, 4, len(n.Map["ass"].Array))
		assert.Equal(t, 4, len(m.Ass))
		assert.Equal(t, "ass0", n.Map["ass"].Array[0].ValueString)
		require.NotNil(t, m.Ass[0])
		assert.Equal(t, "ass0", m.Ass[0].Value())

	}

	data.Run(t, n, n.Value.(*data.Multi), test)
}
Beispiel #20
0
func TestNode_SetValueZero(t *testing.T) {
	cb, n := data.Setup(t)
	test := func(t *testing.T, n *node.Node, m *data.Multi) {

		sstring, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/system", "string")
		assert.True(t, ok)
		facea, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/tests/data", "facea")
		assert.True(t, ok)
		faceb, ok := system.GetTypeFromCache(cb.Ctx(), "kego.io/tests/data", "faceb")
		assert.True(t, ok)

		c1 := node.NewNode()
		require.NoError(t, c1.InitialiseMapItem(cb.Ctx(), n.Map["mss"], "c"))
		require.NoError(t, c1.AddToMap(cb.Ctx(), n.Map["mss"], "c", true))
		require.NoError(t, c1.SetValueZero(cb.Ctx(), true, nil))
		assert.False(t, n.Map["mss"].Map["c"].Missing)
		assert.True(t, n.Map["mss"].Map["c"].Null)
		assert.Nil(t, m.Mss["c"])

		c1a := node.NewNode()
		require.NoError(t, c1a.InitialiseMapItem(cb.Ctx(), n.Map["mss"], "d"))
		require.NoError(t, c1a.AddToMap(cb.Ctx(), n.Map["mss"], "d", true))
		require.NoError(t, c1a.SetValueZero(cb.Ctx(), false, nil))
		assert.False(t, n.Map["mss"].Map["d"].Missing)
		assert.False(t, n.Map["mss"].Map["d"].Null)
		assert.NotNil(t, m.Mss["d"])
		assert.Equal(t, "", m.Mss["d"].Value())

		c2 := node.NewNode()
		require.NoError(t, c2.InitialiseMapItem(cb.Ctx(), n.Map["mm"], "c"))
		require.NoError(t, c2.AddToMap(cb.Ctx(), n.Map["mm"], "c", true))
		require.NoError(t, c2.SetValueZero(cb.Ctx(), true, nil))
		assert.Nil(t, m.Mm["c"])

		c2a := node.NewNode()
		require.NoError(t, c2a.InitialiseMapItem(cb.Ctx(), n.Map["mm"], "d"))
		require.NoError(t, c2a.AddToMap(cb.Ctx(), n.Map["mm"], "d", true))
		require.NoError(t, c2a.SetValueZero(cb.Ctx(), false, nil))
		assert.NotNil(t, m.Mm["d"])
		assert.Equal(t, "", m.Mm["d"].Js)

		require.NoError(t, n.Map["i"].SetValueZero(cb.Ctx(), true, faceb))
		assert.Nil(t, m.I)
		assert.IsType(t, &data.Faceb{}, m.I)

		require.NoError(t, n.Map["sri"].SetValueZero(cb.Ctx(), false, facea))
		assert.NotNil(t, m.Sri)
		assert.IsType(t, &data.Facea{}, m.Sri)

		c3 := node.NewNode()
		require.NoError(t, c3.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 4))
		require.NoError(t, c3.AddToArray(cb.Ctx(), n.Map["ass"], 4, true))
		require.NoError(t, c3.SetValueZero(cb.Ctx(), true, nil))
		assert.Nil(t, m.Ass[4])

		c3a := node.NewNode()
		require.NoError(t, c3a.InitialiseArrayItem(cb.Ctx(), n.Map["ass"], 5))
		require.NoError(t, c3a.AddToArray(cb.Ctx(), n.Map["ass"], 5, true))
		require.NoError(t, c3a.SetValueZero(cb.Ctx(), false, nil))
		assert.NotNil(t, m.Ass[5])

		c4 := node.NewNode()
		require.NoError(t, c4.InitialiseArrayItem(cb.Ctx(), n.Map["am"], 2))
		require.NoError(t, c4.AddToArray(cb.Ctx(), n.Map["am"], 2, true))
		require.NoError(t, c4.SetValueZero(cb.Ctx(), true, nil))
		assert.Nil(t, m.Am[2])

		c4a := node.NewNode()
		require.NoError(t, c4a.InitialiseArrayItem(cb.Ctx(), n.Map["am"], 3))
		require.NoError(t, c4a.AddToArray(cb.Ctx(), n.Map["am"], 3, true))
		require.NoError(t, c4a.SetValueZero(cb.Ctx(), false, nil))
		assert.NotNil(t, m.Am[3])

		c5 := node.NewNode()
		require.NoError(t, c5.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 3))
		require.NoError(t, c5.AddToArray(cb.Ctx(), n.Map["anri"], 3, true))
		require.NoError(t, c5.SetValueZero(cb.Ctx(), true, sstring))
		assert.Nil(t, m.Anri[3])
		assert.IsType(t, system.NewString(""), m.Anri[3])

		c5a := node.NewNode()
		require.NoError(t, c5a.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 4))
		require.NoError(t, c5a.AddToArray(cb.Ctx(), n.Map["anri"], 4, true))
		require.NoError(t, c5a.SetValueZero(cb.Ctx(), false, sstring))
		assert.NotNil(t, m.Anri[4])
		assert.IsType(t, system.NewString(""), m.Anri[4])

		c6 := node.NewNode()
		require.NoError(t, c6.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 5))
		require.NoError(t, c6.AddToArray(cb.Ctx(), n.Map["anri"], 5, true))
		require.NoError(t, c6.SetValueZero(cb.Ctx(), true, facea))
		assert.Nil(t, m.Anri[5])
		assert.IsType(t, &data.Facea{}, m.Anri[5])

		c6a := node.NewNode()
		require.NoError(t, c6a.InitialiseArrayItem(cb.Ctx(), n.Map["anri"], 6))
		require.NoError(t, c6a.AddToArray(cb.Ctx(), n.Map["anri"], 6, true))
		require.NoError(t, c6a.SetValueZero(cb.Ctx(), false, facea))
		assert.NotNil(t, m.Anri[6])
		assert.IsType(t, &data.Facea{}, m.Anri[6])

		c7 := node.NewNode()
		require.NoError(t, c7.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "d"))
		require.NoError(t, c7.AddToMap(cb.Ctx(), n.Map["mnri"], "d", true))
		require.NoError(t, c7.SetValueZero(cb.Ctx(), true, sstring))
		assert.Nil(t, m.Mnri["d"])
		assert.IsType(t, system.NewString(""), m.Mnri["d"])

		c7a := node.NewNode()
		require.NoError(t, c7a.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "e"))
		require.NoError(t, c7a.AddToMap(cb.Ctx(), n.Map["mnri"], "e", true))
		require.NoError(t, c7a.SetValueZero(cb.Ctx(), false, sstring))
		assert.NotNil(t, m.Mnri["e"])
		assert.IsType(t, system.NewString(""), m.Mnri["e"])

		c8 := node.NewNode()
		require.NoError(t, c8.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "f"))
		require.NoError(t, c8.AddToMap(cb.Ctx(), n.Map["mnri"], "f", true))
		require.NoError(t, c8.SetValueZero(cb.Ctx(), true, facea))
		assert.Nil(t, m.Mnri["f"])
		assert.IsType(t, &data.Facea{}, m.Mnri["f"])

		c8a := node.NewNode()
		require.NoError(t, c8a.InitialiseMapItem(cb.Ctx(), n.Map["mnri"], "g"))
		require.NoError(t, c8a.AddToMap(cb.Ctx(), n.Map["mnri"], "g", true))
		require.NoError(t, c8a.SetValueZero(cb.Ctx(), false, facea))
		assert.NotNil(t, m.Mnri["g"])
		assert.IsType(t, &data.Facea{}, m.Mnri["g"])
	}
	data.Run(t, n, n.Value.(*data.Multi), test)

}