github.com/3JoB/go-json@v0.10.4/path_test.go (about)

     1  package json_test
     2  
     3  import (
     4  	"bytes"
     5  	"sort"
     6  	"testing"
     7  
     8  	"github.com/3JoB/go-reflect"
     9  
    10  	"github.com/3JoB/go-json"
    11  )
    12  
    13  func TestExtractPath(t *testing.T) {
    14  	src := []byte(`{"a":{"b":10,"c":true},"b":"text"}`)
    15  	t.Run("$.a.b", func(t *testing.T) {
    16  		path, err := json.CreatePath("$.a.b")
    17  		if err != nil {
    18  			t.Fatal(err)
    19  		}
    20  		contents, err := path.Extract(src)
    21  		if err != nil {
    22  			t.Fatal(err)
    23  		}
    24  		if len(contents) != 1 {
    25  			t.Fatal("failed to extract")
    26  		}
    27  		if !bytes.Equal(contents[0], []byte("10")) {
    28  			t.Fatal("failed to extract")
    29  		}
    30  	})
    31  	t.Run("$.b", func(t *testing.T) {
    32  		path, err := json.CreatePath("$.b")
    33  		if err != nil {
    34  			t.Fatal(err)
    35  		}
    36  		contents, err := path.Extract(src)
    37  		if err != nil {
    38  			t.Fatal(err)
    39  		}
    40  		if len(contents) != 1 {
    41  			t.Fatal("failed to extract")
    42  		}
    43  		if !bytes.Equal(contents[0], []byte(`"text"`)) {
    44  			t.Fatal("failed to extract")
    45  		}
    46  	})
    47  	t.Run("$.a", func(t *testing.T) {
    48  		path, err := json.CreatePath("$.a")
    49  		if err != nil {
    50  			t.Fatal(err)
    51  		}
    52  		contents, err := path.Extract(src)
    53  		if err != nil {
    54  			t.Fatal(err)
    55  		}
    56  		if len(contents) != 1 {
    57  			t.Fatal("failed to extract")
    58  		}
    59  		if !bytes.Equal(contents[0], []byte(`{"b":10,"c":true}`)) {
    60  			t.Fatal("failed to extract")
    61  		}
    62  	})
    63  }
    64  
    65  func TestUnmarshalPath(t *testing.T) {
    66  	t.Run("int", func(t *testing.T) {
    67  		src := []byte(`{"a":{"b":10,"c":true},"b":"text"}`)
    68  		t.Run("success", func(t *testing.T) {
    69  			path, err := json.CreatePath("$.a.b")
    70  			if err != nil {
    71  				t.Fatal(err)
    72  			}
    73  			var v int
    74  			if err := path.Unmarshal(src, &v); err != nil {
    75  				t.Fatal(err)
    76  			}
    77  			if v != 10 {
    78  				t.Fatal("failed to unmarshal path")
    79  			}
    80  		})
    81  		t.Run("failure", func(t *testing.T) {
    82  			path, err := json.CreatePath("$.a.c")
    83  			if err != nil {
    84  				t.Fatal(err)
    85  			}
    86  			var v map[string]any
    87  			if err := path.Unmarshal(src, &v); err == nil {
    88  				t.Fatal("expected error")
    89  			}
    90  		})
    91  	})
    92  	t.Run("bool", func(t *testing.T) {
    93  		src := []byte(`{"a":{"b":10,"c":true},"b":"text"}`)
    94  		t.Run("success", func(t *testing.T) {
    95  			path, err := json.CreatePath("$.a.c")
    96  			if err != nil {
    97  				t.Fatal(err)
    98  			}
    99  			var v bool
   100  			if err := path.Unmarshal(src, &v); err != nil {
   101  				t.Fatal(err)
   102  			}
   103  			if !v {
   104  				t.Fatal("failed to unmarshal path")
   105  			}
   106  		})
   107  		t.Run("failure", func(t *testing.T) {
   108  			path, err := json.CreatePath("$.a.b")
   109  			if err != nil {
   110  				t.Fatal(err)
   111  			}
   112  			var v bool
   113  			if err := path.Unmarshal(src, &v); err == nil {
   114  				t.Fatal("expected error")
   115  			}
   116  		})
   117  	})
   118  	t.Run("map", func(t *testing.T) {
   119  		src := []byte(`{"a":{"b":10,"c":true},"b":"text"}`)
   120  		t.Run("success", func(t *testing.T) {
   121  			path, err := json.CreatePath("$.a")
   122  			if err != nil {
   123  				t.Fatal(err)
   124  			}
   125  			var v map[string]any
   126  			if err := path.Unmarshal(src, &v); err != nil {
   127  				t.Fatal(err)
   128  			}
   129  			if len(v) != 2 {
   130  				t.Fatal("failed to decode map")
   131  			}
   132  		})
   133  	})
   134  
   135  	t.Run("path with single quote selector", func(t *testing.T) {
   136  		path, err := json.CreatePath("$['a.b'].c")
   137  		if err != nil {
   138  			t.Fatal(err)
   139  		}
   140  
   141  		var v string
   142  		if err := path.Unmarshal([]byte(`{"a.b": {"c": "world"}}`), &v); err != nil {
   143  			t.Fatal(err)
   144  		}
   145  		if v != "world" {
   146  			t.Fatal("failed to unmarshal path")
   147  		}
   148  	})
   149  	t.Run("path with double quote selector", func(t *testing.T) {
   150  		path, err := json.CreatePath(`$."a.b".c`)
   151  		if err != nil {
   152  			t.Fatal(err)
   153  		}
   154  
   155  		var v string
   156  		if err := path.Unmarshal([]byte(`{"a.b": {"c": "world"}}`), &v); err != nil {
   157  			t.Fatal(err)
   158  		}
   159  		if v != "world" {
   160  			t.Fatal("failed to unmarshal path")
   161  		}
   162  	})
   163  }
   164  
   165  func TestGetPath(t *testing.T) {
   166  	t.Run("selector", func(t *testing.T) {
   167  		var v any
   168  		if err := json.Unmarshal([]byte(`{"a":{"b":10,"c":true},"b":"text"}`), &v); err != nil {
   169  			t.Fatal(err)
   170  		}
   171  		path, err := json.CreatePath("$.a.b")
   172  		if err != nil {
   173  			t.Fatal(err)
   174  		}
   175  		var b int
   176  		if err := path.Get(v, &b); err != nil {
   177  			t.Fatal(err)
   178  		}
   179  		if b != 10 {
   180  			t.Fatalf("failed to decode by json.Get")
   181  		}
   182  	})
   183  	t.Run("index", func(t *testing.T) {
   184  		var v any
   185  		if err := json.Unmarshal([]byte(`{"a":[{"b":10,"c":true},{"b":"text"}]}`), &v); err != nil {
   186  			t.Fatal(err)
   187  		}
   188  		path, err := json.CreatePath("$.a[0].b")
   189  		if err != nil {
   190  			t.Fatal(err)
   191  		}
   192  		var b int
   193  		if err := path.Get(v, &b); err != nil {
   194  			t.Fatal(err)
   195  		}
   196  		if b != 10 {
   197  			t.Fatalf("failed to decode by json.Get")
   198  		}
   199  	})
   200  	t.Run("indexAll", func(t *testing.T) {
   201  		var v any
   202  		if err := json.Unmarshal([]byte(`{"a":[{"b":1,"c":true},{"b":2},{"b":3}]}`), &v); err != nil {
   203  			t.Fatal(err)
   204  		}
   205  		path, err := json.CreatePath("$.a[*].b")
   206  		if err != nil {
   207  			t.Fatal(err)
   208  		}
   209  		var b []int
   210  		if err := path.Get(v, &b); err != nil {
   211  			t.Fatal(err)
   212  		}
   213  		if !reflect.DeepEqual(b, []int{1, 2, 3}) {
   214  			t.Fatalf("failed to decode by json.Get")
   215  		}
   216  	})
   217  	t.Run("recursive", func(t *testing.T) {
   218  		var v any
   219  		if err := json.Unmarshal([]byte(`{"a":[{"b":1,"c":true},{"b":2},{"b":3}],"a2":{"b":4}}`), &v); err != nil {
   220  			t.Fatal(err)
   221  		}
   222  		path, err := json.CreatePath("$..b")
   223  		if err != nil {
   224  			t.Fatal(err)
   225  		}
   226  		var b []int
   227  		if err := path.Get(v, &b); err != nil {
   228  			t.Fatal(err)
   229  		}
   230  		sort.Ints(b)
   231  		if !reflect.DeepEqual(b, []int{1, 2, 3, 4}) {
   232  			t.Fatalf("failed to decode by json.Get")
   233  		}
   234  	})
   235  }