git.gammaspectra.live/P2Pool/go-json@v0.99.0/path_test.go (about)

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