nested_test.go

package orderedmap

import (
	"encoding/json"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// TestNestedMapsAreOrdered demonstrates that nested JSON objects are unmarshaled
// as OrderedMaps instead of native Go maps when the value type is 'any'
func TestNestedMapsAreOrdered(t *testing.T) {
	t.Run("simple nested object", func(t *testing.T) {
		jsonData := `{
			"outer": {
				"first": "a",
				"second": "b",
				"third": "c"
			}
		}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Get the nested value
		nestedValue, ok := om.Get("outer")
		require.True(t, ok)

		// Verify it's an OrderedMap, not a regular map
		nestedOM, isOrderedMap := nestedValue.(*OrderedMap[string, any])
		assert.True(t, isOrderedMap, "nested object should be an OrderedMap")
		require.NotNil(t, nestedOM)

		// Verify the order is preserved
		keys := []string{}
		for pair := nestedOM.Oldest(); pair != nil; pair = pair.Next() {
			keys = append(keys, pair.Key)
		}
		assert.Equal(t, []string{"first", "second", "third"}, keys)
	})

	t.Run("deeply nested objects", func(t *testing.T) {
		jsonData := `{
			"level1": {
				"level2": {
					"level3": {
						"a": 1,
						"b": 2,
						"c": 3
					}
				}
			}
		}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Navigate to level 1
		level1Value, ok := om.Get("level1")
		require.True(t, ok)
		level1OM, ok := level1Value.(*OrderedMap[string, any])
		require.True(t, ok, "level1 should be an OrderedMap")

		// Navigate to level 2
		level2Value, ok := level1OM.Get("level2")
		require.True(t, ok)
		level2OM, ok := level2Value.(*OrderedMap[string, any])
		require.True(t, ok, "level2 should be an OrderedMap")

		// Navigate to level 3
		level3Value, ok := level2OM.Get("level3")
		require.True(t, ok)
		level3OM, ok := level3Value.(*OrderedMap[string, any])
		require.True(t, ok, "level3 should be an OrderedMap")

		// Verify the deepest level maintains order
		keys := []string{}
		for pair := level3OM.Oldest(); pair != nil; pair = pair.Next() {
			keys = append(keys, pair.Key)
		}
		assert.Equal(t, []string{"a", "b", "c"}, keys)
	})

	t.Run("nested object within nested object", func(t *testing.T) {
		jsonData := `{
			"data": {
				"config": {
					"first": "a",
					"second": "b"
				}
			}
		}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Get data object
		dataValue, ok := om.Get("data")
		require.True(t, ok)
		dataOM, ok := dataValue.(*OrderedMap[string, any])
		require.True(t, ok)

		// Get config object
		configValue, ok := dataOM.Get("config")
		require.True(t, ok)
		configOM, ok := configValue.(*OrderedMap[string, any])
		require.True(t, ok, "nested config should be an OrderedMap")

		// Verify order
		keys := []string{}
		for pair := configOM.Oldest(); pair != nil; pair = pair.Next() {
			keys = append(keys, pair.Key)
		}
		assert.Equal(t, []string{"first", "second"}, keys)
	})

	t.Run("array with nested objects", func(t *testing.T) {
		jsonData := `{
			"items": [
				{"name": "first", "value": 1},
				{"name": "second", "value": 2}
			]
		}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Get items array
		itemsValue, ok := om.Get("items")
		require.True(t, ok)
		itemsArray, ok := itemsValue.([]interface{})
		require.True(t, ok)

		// Verify array elements are OrderedMaps
		require.Len(t, itemsArray, 2)

		firstItem, ok := itemsArray[0].(*OrderedMap[string, interface{}])
		require.True(t, ok, "array element should be an OrderedMap")

		nameValue, ok := firstItem.Get("name")
		require.True(t, ok)
		assert.Equal(t, "first", nameValue)

		// Verify order is preserved in array elements
		keys := []string{}
		for pair := firstItem.Oldest(); pair != nil; pair = pair.Next() {
			keys = append(keys, pair.Key)
		}
		assert.Equal(t, []string{"name", "value"}, keys)
	})

	t.Run("deeply nested arrays and objects", func(t *testing.T) {
		jsonData := `{
			"data": {
				"users": [
					{
						"id": 1,
						"profile": {
							"name": "Alice",
							"age": 30
						}
					},
					{
						"id": 2,
						"profile": {
							"name": "Bob",
							"age": 25
						}
					}
				]
			}
		}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Navigate to data
		dataValue, ok := om.Get("data")
		require.True(t, ok)
		dataOM, ok := dataValue.(*OrderedMap[string, interface{}])
		require.True(t, ok)

		// Get users array
		usersValue, ok := dataOM.Get("users")
		require.True(t, ok)
		usersArray, ok := usersValue.([]interface{})
		require.True(t, ok)

		// Check first user
		firstUser, ok := usersArray[0].(*OrderedMap[string, interface{}])
		require.True(t, ok)

		// Check profile within first user
		profileValue, ok := firstUser.Get("profile")
		require.True(t, ok)
		profileOM, ok := profileValue.(*OrderedMap[string, interface{}])
		require.True(t, ok)

		// Verify profile order
		keys := []string{}
		for pair := profileOM.Oldest(); pair != nil; pair = pair.Next() {
			keys = append(keys, pair.Key)
		}
		assert.Equal(t, []string{"name", "age"}, keys)
	})

	t.Run("simple array with primitives", func(t *testing.T) {
		jsonData := `{"numbers": [1, 2, 3], "strings": ["a", "b", "c"]}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Get numbers array
		numbersValue, ok := om.Get("numbers")
		require.True(t, ok, "should have 'numbers' key")
		require.NotNil(t, numbersValue, "numbers should not be nil")

		numbersArray, ok := numbersValue.([]interface{})
		require.True(t, ok, "numbers should be an array")
		require.Len(t, numbersArray, 3)
		assert.Equal(t, float64(1), numbersArray[0])
		assert.Equal(t, float64(2), numbersArray[1])
		assert.Equal(t, float64(3), numbersArray[2])

		// Get strings array
		stringsValue, ok := om.Get("strings")
		require.True(t, ok, "should have 'strings' key")
		require.NotNil(t, stringsValue, "strings should not be nil")

		stringsArray, ok := stringsValue.([]interface{})
		require.True(t, ok, "strings should be an array")
		require.Len(t, stringsArray, 3)
		assert.Equal(t, "a", stringsArray[0])
		assert.Equal(t, "b", stringsArray[1])
		assert.Equal(t, "c", stringsArray[2])
	})

	t.Run("stringified JSON remains as string", func(t *testing.T) {
		jsonData := `{
			"stringified_array": "[1,2,3]",
			"stringified_object": "{\"key\":\"value\"}",
			"data": ["normal string", "[1,2,3]"]
		}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Stringified array should remain a string
		stringifiedArray, ok := om.Get("stringified_array")
		require.True(t, ok)
		assert.Equal(t, "[1,2,3]", stringifiedArray, "stringified array should remain as string")

		// Stringified object should remain a string
		stringifiedObject, ok := om.Get("stringified_object")
		require.True(t, ok)
		assert.Equal(t, `{"key":"value"}`, stringifiedObject, "stringified object should remain as string")

		// Array with stringified JSON should have string elements
		dataValue, ok := om.Get("data")
		require.True(t, ok)
		dataArray, ok := dataValue.([]interface{})
		require.True(t, ok)
		require.Len(t, dataArray, 2)
		assert.Equal(t, "normal string", dataArray[0])
		assert.Equal(t, "[1,2,3]", dataArray[1], "stringified JSON in array should remain as string")
	})

	t.Run("round-trip preserves order", func(t *testing.T) {
		jsonData := `{"z":{"y":{"x":"value"}}}`

		om := New[string, any]()
		require.NoError(t, json.Unmarshal([]byte(jsonData), &om))

		// Marshal back to JSON
		result, err := json.Marshal(om)
		require.NoError(t, err)

		// Should maintain the original order
		assert.Equal(t, jsonData, string(result))
	})
}