yq/pkg/yqlib/data_navigator_test.go

package yqlib

import (
	"fmt"
	"sort"
	"testing"

	"github.com/mikefarah/yq/v2/test"
	logging "gopkg.in/op/go-logging.v1"
)

func TestDataNavigator(t *testing.T) {
	var log = logging.MustGetLogger("yq")
	subject := NewDataNavigator(log)

	t.Run("TestReadMap_simple", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  c: 2
`)
		got, _ := subject.ReadChildValue(data, []string{"b", "c"})
		test.AssertResult(t, 2, got)
	})

	t.Run("TestReadMap_numberKey", func(t *testing.T) {
		var data = test.ParseData(`
---
200: things
`)
		got, _ := subject.ReadChildValue(data, []string{"200"})
		test.AssertResult(t, "things", got)
	})

	t.Run("TestReadMap_splat", func(t *testing.T) {
		var data = test.ParseData(`
---
mapSplat:
  item1: things
  item2: whatever
  otherThing: cat
`)
		res, _ := subject.ReadChildValue(data, []string{"mapSplat", "*"})
		test.AssertResult(t, "[things whatever cat]", fmt.Sprintf("%v", res))
	})

	t.Run("TestReadMap_prefixSplat", func(t *testing.T) {
		var data = test.ParseData(`
---
mapSplat:
  item1: things
  item2: whatever
  otherThing: cat
`)
		res, _ := subject.ReadChildValue(data, []string{"mapSplat", "item*"})
		test.AssertResult(t, "[things whatever]", fmt.Sprintf("%v", res))
	})

	t.Run("TestReadMap_deep_splat", func(t *testing.T) {
		var data = test.ParseData(`
---
mapSplatDeep:
  item1:
    cats: bananas
  item2:
    cats: apples
`)

		res, _ := subject.ReadChildValue(data, []string{"mapSplatDeep", "*", "cats"})
		result := res.([]interface{})
		var actual = []string{result[0].(string), result[1].(string)}
		sort.Strings(actual)
		test.AssertResult(t, "[apples bananas]", fmt.Sprintf("%v", actual))
	})

	t.Run("TestReadMap_key_doesnt_exist", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  c: 2
`)
		got, _ := subject.ReadChildValue(data, []string{"b", "x", "f", "c"})
		test.AssertResult(t, nil, got)
	})

	t.Run("TestReadMap_recurse_against_string", func(t *testing.T) {
		var data = test.ParseData(`
---
a: cat
`)
		got, _ := subject.ReadChildValue(data, []string{"a", "b"})
		test.AssertResult(t, nil, got)
	})

	t.Run("TestReadMap_with_array", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  d:
    - 3
    - 4
`)
		got, _ := subject.ReadChildValue(data, []string{"b", "d", "1"})
		test.AssertResult(t, 4, got)
	})

	t.Run("TestReadMap_with_array_and_bad_index", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  d:
    - 3
    - 4
`)
		_, err := subject.ReadChildValue(data, []string{"b", "d", "x"})
		if err == nil {
			t.Fatal("Expected error due to invalid path")
		}
		expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
		test.AssertResult(t, expectedOutput, err.Error())
	})

	t.Run("TestReadMap_with_mapsplat_array_and_bad_index", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  d:
    e:
      - 3
      - 4
    f:
      - 1
      - 2
`)
		_, err := subject.ReadChildValue(data, []string{"b", "d", "*", "x"})
		if err == nil {
			t.Fatal("Expected error due to invalid path")
		}
		expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
		test.AssertResult(t, expectedOutput, err.Error())
	})

	t.Run("TestReadMap_with_arraysplat_map_array_and_bad_index", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  d:
    - names:
        - fred
        - smith
    - names:
        - sam
        - bo
`)
		_, err := subject.ReadChildValue(data, []string{"b", "d", "*", "names", "x"})
		if err == nil {
			t.Fatal("Expected error due to invalid path")
		}
		expectedOutput := `error accessing array: strconv.ParseInt: parsing "x": invalid syntax`
		test.AssertResult(t, expectedOutput, err.Error())
	})

	t.Run("TestReadMap_with_array_out_of_bounds", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  d:
    - 3
    - 4
`)
		got, _ := subject.ReadChildValue(data, []string{"b", "d", "3"})
		test.AssertResult(t, nil, got)
	})

	t.Run("TestReadMap_with_array_out_of_bounds_by_1", func(t *testing.T) {
		var data = test.ParseData(`
---
b:
  d:
    - 3
    - 4
`)
		got, _ := subject.ReadChildValue(data, []string{"b", "d", "2"})
		test.AssertResult(t, nil, got)
	})

	t.Run("TestReadMap_with_array_splat", func(t *testing.T) {
		var data = test.ParseData(`
e:
  -
    name: Fred
    thing: cat
  -
    name: Sam
    thing: dog
`)
		got, _ := subject.ReadChildValue(data, []string{"e", "*", "name"})
		test.AssertResult(t, "[Fred Sam]", fmt.Sprintf("%v", got))
	})

	t.Run("TestWrite_really_simple", func(t *testing.T) {
		var data = test.ParseData(`
b: 2
`)

		updated := subject.UpdatedChildValue(data, []string{"b"}, "4")
		test.AssertResult(t, "[{b 4}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_simple", func(t *testing.T) {
		var data = test.ParseData(`
b:
  c: 2
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "c"}, "4")
		test.AssertResult(t, "[{b [{c 4}]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_new", func(t *testing.T) {
		var data = test.ParseData(`
b:
  c: 2
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "d"}, "4")
		test.AssertResult(t, "[{b [{c 2} {d 4}]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_new_deep", func(t *testing.T) {
		var data = test.ParseData(`
b:
  c: 2
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "d", "f"}, "4")
		test.AssertResult(t, "[{b [{c 2} {d [{f 4}]}]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_array", func(t *testing.T) {
		var data = test.ParseData(`
b:
  - aa
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "0"}, "bb")

		test.AssertResult(t, "[{b [bb]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_new_array", func(t *testing.T) {
		var data = test.ParseData(`
b:
  c: 2
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "0"}, "4")
		test.AssertResult(t, "[{b [{c 2} {0 4}]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_new_array_deep", func(t *testing.T) {
		var data = test.ParseData(`
a: apple
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "+", "c"}, "4")
		test.AssertResult(t, "[{a apple} {b [[{c 4}]]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_new_map_array_deep", func(t *testing.T) {
		var data = test.ParseData(`
b:
  c: 2
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "d", "+"}, "4")
		test.AssertResult(t, "[{b [{c 2} {d [4]}]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_add_to_array", func(t *testing.T) {
		var data = test.ParseData(`
b:
  - aa
`)

		updated := subject.UpdatedChildValue(data, []string{"b", "1"}, "bb")
		test.AssertResult(t, "[{b [aa bb]}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWrite_with_no_tail", func(t *testing.T) {
		var data = test.ParseData(`
b:
  c: 2
`)
		updated := subject.UpdatedChildValue(data, []string{"b"}, "4")

		test.AssertResult(t, "[{b 4}]", fmt.Sprintf("%v", updated))
	})

	t.Run("TestWriteMap_no_paths", func(t *testing.T) {
		var data = test.ParseData(`
b: 5
`)
		var new = test.ParseData(`
c: 4
`)
		result := subject.UpdatedChildValue(data, []string{}, new)
		test.AssertResult(t, fmt.Sprintf("%v", new), fmt.Sprintf("%v", result))
	})

	t.Run("TestWriteArray_no_paths", func(t *testing.T) {
		var data = make([]interface{}, 1)
		data[0] = "mike"
		var new = test.ParseData(`
c: 4
`)
		result := subject.UpdatedChildValue(data, []string{}, new)
		test.AssertResult(t, fmt.Sprintf("%v", new), fmt.Sprintf("%v", result))
	})

	t.Run("TestDelete_MapItem", func(t *testing.T) {
		var data = test.ParseData(`
a: 123
b: 456
`)
		var expected = test.ParseData(`
b: 456
`)

		result, _ := subject.DeleteChildValue(data, []string{"a"})
		test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
	})

	// Ensure deleting an index into a string does nothing
	t.Run("TestDelete_index_to_string", func(t *testing.T) {
		var data = test.ParseData(`
a: mystring
`)
		result, _ := subject.DeleteChildValue(data, []string{"a", "0"})
		test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
	})

	t.Run("TestDelete_list_index", func(t *testing.T) {
		var data = test.ParseData(`
a: [3, 4]
`)
		var expected = test.ParseData(`
a: [3]
`)
		result, _ := subject.DeleteChildValue(data, []string{"a", "1"})
		test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
	})

	t.Run("TestDelete_list_index_beyond_bounds", func(t *testing.T) {
		var data = test.ParseData(`
a: [3, 4]
`)
		result, _ := subject.DeleteChildValue(data, []string{"a", "5"})
		test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
	})

	t.Run("TestDelete_list_index_out_of_bounds_by_1", func(t *testing.T) {
		var data = test.ParseData(`
a: [3, 4]
`)
		result, _ := subject.DeleteChildValue(data, []string{"a", "2"})
		test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
	})

	t.Run("TestDelete_no_paths", func(t *testing.T) {
		var data = test.ParseData(`
a: [3, 4]
b:
  - name: test
`)
		result, _ := subject.DeleteChildValue(data, []string{})
		test.AssertResult(t, fmt.Sprintf("%v", data), fmt.Sprintf("%v", result))
	})

	t.Run("TestDelete_array_map_item", func(t *testing.T) {
		var data = test.ParseData(`
b:
- name: fred
  value: blah
- name: john
  value: test
`)
		var expected = test.ParseData(`
b:
- value: blah
- name: john
  value: test
`)
		result, _ := subject.DeleteChildValue(data, []string{"b", "0", "name"})
		test.AssertResult(t, fmt.Sprintf("%v", expected), fmt.Sprintf("%v", result))
	})
}