github.com/lmorg/murex@v0.0.0-20240217211045-e081c89cd4ef/builtins/core/datatools/structkeys_test.go (about)

     1  package datatools_test
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  
     7  	_ "github.com/lmorg/murex/builtins"
     8  	"github.com/lmorg/murex/test"
     9  )
    10  
    11  func TestStructKeysNoParams(t *testing.T) {
    12  	var input = `{
    13  		"firstName": "John",
    14  		"lastName": "Smith",
    15  		"isAlive": true,
    16  		"age": 27,
    17  		"address": {
    18  		  "streetAddress": "21 2nd Street",
    19  		  "city": "New York",
    20  		  "state": "NY",
    21  		  "postalCode": "10021-3100"
    22  		},
    23  		"phoneNumbers": [
    24  		  {
    25  			"type": "home",
    26  			"number": "212 555-1234"
    27  		  },
    28  		  {
    29  			"type": "office",
    30  			"number": "646 555-4567"
    31  		  },
    32  		  {
    33  			"type": "mobile",
    34  			"number": "123 456-7890"
    35  		  }
    36  		],
    37  		"children": [],
    38  		"spouse": null
    39  	  }`
    40  
    41  	var expected = `/address
    42  		/address/city
    43  		/address/postalCode
    44  		/address/state
    45  		/address/streetAddress
    46  		/age
    47  		/children
    48  		/firstName
    49  		/isAlive
    50  		/lastName
    51  		/phoneNumbers
    52  		/phoneNumbers/0
    53  		/phoneNumbers/0/number
    54  		/phoneNumbers/0/type
    55  		/phoneNumbers/1
    56  		/phoneNumbers/1/number
    57  		/phoneNumbers/1/type
    58  		/phoneNumbers/2
    59  		/phoneNumbers/2/number
    60  		/phoneNumbers/2/type
    61  		/spouse
    62  	`
    63  
    64  	expected = strings.Replace(expected, "\t", "", -1)
    65  	expected = strings.Replace(expected, " ", "", -1)
    66  
    67  	tests := []test.MurexTest{{
    68  		Block: `
    69  			tout json (` + input + `) -> struct-keys -> format str -> msort
    70  		`,
    71  		ExitNum: 0,
    72  		Stdout:  expected,
    73  		Stderr:  ``,
    74  	}}
    75  
    76  	test.RunMurexTests(tests, t)
    77  }
    78  
    79  func TestStructKeysParamStr(t *testing.T) {
    80  	var input = `{
    81  		"firstName": "John",
    82  		"lastName": "Smith",
    83  		"isAlive": true,
    84  		"age": 27,
    85  		"address": {
    86  		  "streetAddress": "21 2nd Street",
    87  		  "city": "New York",
    88  		  "state": "NY",
    89  		  "postalCode": "10021-3100"
    90  		},
    91  		"phoneNumbers": [
    92  		  {
    93  			"type": "home",
    94  			"number": "212 555-1234"
    95  		  },
    96  		  {
    97  			"type": "office",
    98  			"number": "646 555-4567"
    99  		  },
   100  		  {
   101  			"type": "mobile",
   102  			"number": "123 456-7890"
   103  		  }
   104  		],
   105  		"children": [],
   106  		"spouse": null
   107  	  }`
   108  
   109  	var expected = `/address
   110  	  /address/city
   111  	  /address/postalCode
   112  	  /address/state
   113  	  /address/streetAddress
   114  	  /age
   115  	  /children
   116  	  /firstName
   117  	  /isAlive
   118  	  /lastName
   119  	  /phoneNumbers
   120  	  /phoneNumbers/0
   121  	  /phoneNumbers/0/number
   122  	  /phoneNumbers/0/type
   123  	  /phoneNumbers/1
   124  	  /phoneNumbers/1/number
   125  	  /phoneNumbers/1/type
   126  	  /phoneNumbers/2
   127  	  /phoneNumbers/2/number
   128  	  /phoneNumbers/2/type
   129  	  /spouse
   130    `
   131  
   132  	expected = strings.Replace(expected, "\t", "", -1)
   133  	expected = strings.Replace(expected, " ", "", -1)
   134  
   135  	tests := []test.MurexTest{{
   136  		Block: `
   137  			tout json (` + input + `) -> struct-keys foobar -> format str -> msort
   138  		`,
   139  		ExitNum: 0,
   140  		Stdout:  expected,
   141  		Stderr:  ``,
   142  	}}
   143  
   144  	test.RunMurexTests(tests, t)
   145  }
   146  
   147  func TestStructKeysParam0(t *testing.T) {
   148  	var input = `{
   149  		"firstName": "John",
   150  		"lastName": "Smith",
   151  		"isAlive": true,
   152  		"age": 27,
   153  		"address": {
   154  		  "streetAddress": "21 2nd Street",
   155  		  "city": "New York",
   156  		  "state": "NY",
   157  		  "postalCode": "10021-3100"
   158  		},
   159  		"phoneNumbers": [
   160  		  {
   161  			"type": "home",
   162  			"number": "212 555-1234"
   163  		  },
   164  		  {
   165  			"type": "office",
   166  			"number": "646 555-4567"
   167  		  },
   168  		  {
   169  			"type": "mobile",
   170  			"number": "123 456-7890"
   171  		  }
   172  		],
   173  		"children": [],
   174  		"spouse": null
   175  	  }`
   176  
   177  	var expected = `/address
   178  	  /address/city
   179  	  /address/postalCode
   180  	  /address/state
   181  	  /address/streetAddress
   182  	  /age
   183  	  /children
   184  	  /firstName
   185  	  /isAlive
   186  	  /lastName
   187  	  /phoneNumbers
   188  	  /phoneNumbers/0
   189  	  /phoneNumbers/0/number
   190  	  /phoneNumbers/0/type
   191  	  /phoneNumbers/1
   192  	  /phoneNumbers/1/number
   193  	  /phoneNumbers/1/type
   194  	  /phoneNumbers/2
   195  	  /phoneNumbers/2/number
   196  	  /phoneNumbers/2/type
   197  	  /spouse
   198    `
   199  
   200  	expected = strings.Replace(expected, "\t", "", -1)
   201  	expected = strings.Replace(expected, " ", "", -1)
   202  
   203  	tests := []test.MurexTest{
   204  		{
   205  			Block: `
   206  				tout json (` + input + `) -> struct-keys 0 -> format str -> msort
   207  			`,
   208  			ExitNum: 0,
   209  			Stdout:  expected,
   210  			Stderr:  ``,
   211  		},
   212  		{
   213  			Block: `
   214  				tout json (` + input + `) -> struct-keys -d 0 -> format str -> msort
   215  			`,
   216  			ExitNum: 0,
   217  			Stdout:  expected,
   218  			Stderr:  ``,
   219  		},
   220  		{
   221  			Block: `
   222  				tout json (` + input + `) -> struct-keys --depth 0 -> format str -> msort
   223  			`,
   224  			ExitNum: 0,
   225  			Stdout:  expected,
   226  			Stderr:  ``,
   227  		},
   228  	}
   229  
   230  	test.RunMurexTests(tests, t)
   231  }
   232  
   233  func TestStructKeysParam1(t *testing.T) {
   234  	var input = `{
   235  		"firstName": "John",
   236  		"lastName": "Smith",
   237  		"isAlive": true,
   238  		"age": 27,
   239  		"address": {
   240  		  "streetAddress": "21 2nd Street",
   241  		  "city": "New York",
   242  		  "state": "NY",
   243  		  "postalCode": "10021-3100"
   244  		},
   245  		"phoneNumbers": [
   246  		  {
   247  			"type": "home",
   248  			"number": "212 555-1234"
   249  		  },
   250  		  {
   251  			"type": "office",
   252  			"number": "646 555-4567"
   253  		  },
   254  		  {
   255  			"type": "mobile",
   256  			"number": "123 456-7890"
   257  		  }
   258  		],
   259  		"children": [],
   260  		"spouse": null
   261  	  }`
   262  
   263  	var expected = `/address
   264  	  /age
   265  	  /children
   266  	  /firstName
   267  	  /isAlive
   268  	  /lastName
   269  	  /phoneNumbers
   270  	  /spouse
   271    `
   272  
   273  	expected = strings.Replace(expected, "\t", "", -1)
   274  	expected = strings.Replace(expected, " ", "", -1)
   275  
   276  	tests := []test.MurexTest{
   277  		{
   278  			Block: `
   279  				tout json (` + input + `) -> struct-keys 1 -> format str -> msort
   280  			`,
   281  			ExitNum: 0,
   282  			Stdout:  expected,
   283  			Stderr:  ``,
   284  		},
   285  		{
   286  			Block: `
   287  				tout json (` + input + `) -> struct-keys -d 1 -> format str -> msort
   288  			`,
   289  			ExitNum: 0,
   290  			Stdout:  expected,
   291  			Stderr:  ``,
   292  		},
   293  		{
   294  			Block: `
   295  				tout json (` + input + `) -> struct-keys --depth 1 -> format str -> msort
   296  			`,
   297  			ExitNum: 0,
   298  			Stdout:  expected,
   299  			Stderr:  ``,
   300  		},
   301  	}
   302  
   303  	test.RunMurexTests(tests, t)
   304  }
   305  
   306  func TestStructKeysParam2(t *testing.T) {
   307  	var input = `{
   308  		"firstName": "John",
   309  		"lastName": "Smith",
   310  		"isAlive": true,
   311  		"age": 27,
   312  		"address": {
   313  		  "streetAddress": "21 2nd Street",
   314  		  "city": "New York",
   315  		  "state": "NY",
   316  		  "postalCode": "10021-3100"
   317  		},
   318  		"phoneNumbers": [
   319  		  {
   320  			"type": "home",
   321  			"number": "212 555-1234"
   322  		  },
   323  		  {
   324  			"type": "office",
   325  			"number": "646 555-4567"
   326  		  },
   327  		  {
   328  			"type": "mobile",
   329  			"number": "123 456-7890"
   330  		  }
   331  		],
   332  		"children": [],
   333  		"spouse": null
   334  	  }`
   335  
   336  	var expected = `/address
   337  	  /address/city
   338  	  /address/postalCode
   339  	  /address/state
   340  	  /address/streetAddress
   341  	  /age
   342  	  /children
   343  	  /firstName
   344  	  /isAlive
   345  	  /lastName
   346  	  /phoneNumbers
   347  	  /phoneNumbers/0
   348  	  /phoneNumbers/1
   349  	  /phoneNumbers/2
   350  	  /spouse
   351    `
   352  
   353  	expected = strings.Replace(expected, "\t", "", -1)
   354  	expected = strings.Replace(expected, " ", "", -1)
   355  
   356  	tests := []test.MurexTest{
   357  		{
   358  			Block: `
   359  			tout json (` + input + `) -> struct-keys 2 -> format str -> msort
   360  		`,
   361  			ExitNum: 0,
   362  			Stdout:  expected,
   363  			Stderr:  ``,
   364  		},
   365  		{
   366  			Block: `
   367  			tout json (` + input + `) -> struct-keys -d 2 -> format str -> msort
   368  		`,
   369  			ExitNum: 0,
   370  			Stdout:  expected,
   371  			Stderr:  ``,
   372  		},
   373  		{
   374  			Block: `
   375  			tout json (` + input + `) -> struct-keys --depth 2 -> format str -> msort
   376  		`,
   377  			ExitNum: 0,
   378  			Stdout:  expected,
   379  			Stderr:  ``,
   380  		},
   381  	}
   382  
   383  	test.RunMurexTests(tests, t)
   384  }
   385  
   386  func TestStructKeysParam3(t *testing.T) {
   387  	var input = `{
   388  		"firstName": "John",
   389  		"lastName": "Smith",
   390  		"isAlive": true,
   391  		"age": 27,
   392  		"address": {
   393  		  "streetAddress": "21 2nd Street",
   394  		  "city": "New York",
   395  		  "state": "NY",
   396  		  "postalCode": "10021-3100"
   397  		},
   398  		"phoneNumbers": [
   399  		  {
   400  			"type": "home",
   401  			"number": "212 555-1234"
   402  		  },
   403  		  {
   404  			"type": "office",
   405  			"number": "646 555-4567"
   406  		  },
   407  		  {
   408  			"type": "mobile",
   409  			"number": "123 456-7890"
   410  		  }
   411  		],
   412  		"children": [],
   413  		"spouse": null
   414  	  }`
   415  
   416  	var expected = `/address
   417  	  /address/city
   418  	  /address/postalCode
   419  	  /address/state
   420  	  /address/streetAddress
   421  	  /age
   422  	  /children
   423  	  /firstName
   424  	  /isAlive
   425  	  /lastName
   426  	  /phoneNumbers
   427  	  /phoneNumbers/0
   428  	  /phoneNumbers/0/number
   429  	  /phoneNumbers/0/type
   430  	  /phoneNumbers/1
   431  	  /phoneNumbers/1/number
   432  	  /phoneNumbers/1/type
   433  	  /phoneNumbers/2
   434  	  /phoneNumbers/2/number
   435  	  /phoneNumbers/2/type
   436  	  /spouse
   437    `
   438  
   439  	expected = strings.Replace(expected, "\t", "", -1)
   440  	expected = strings.Replace(expected, " ", "", -1)
   441  
   442  	tests := []test.MurexTest{
   443  		{
   444  			Block: `
   445  				tout json (` + input + `) -> struct-keys 3 -> format str -> msort
   446  			`,
   447  			ExitNum: 0,
   448  			Stdout:  expected,
   449  			Stderr:  ``,
   450  		},
   451  		{
   452  			Block: `
   453  				tout json (` + input + `) -> struct-keys -d 3 -> format str -> msort
   454  			`,
   455  			ExitNum: 0,
   456  			Stdout:  expected,
   457  			Stderr:  ``,
   458  		},
   459  		{
   460  			Block: `
   461  				tout json (` + input + `) -> struct-keys --depth 3 -> format str -> msort
   462  			`,
   463  			ExitNum: 0,
   464  			Stdout:  expected,
   465  			Stderr:  ``,
   466  		},
   467  	}
   468  
   469  	test.RunMurexTests(tests, t)
   470  }
   471  
   472  func TestStructKeysParam200(t *testing.T) {
   473  	var input = `{
   474  		"firstName": "John",
   475  		"lastName": "Smith",
   476  		"isAlive": true,
   477  		"age": 27,
   478  		"address": {
   479  		  "streetAddress": "21 2nd Street",
   480  		  "city": "New York",
   481  		  "state": "NY",
   482  		  "postalCode": "10021-3100"
   483  		},
   484  		"phoneNumbers": [
   485  		  {
   486  			"type": "home",
   487  			"number": "212 555-1234"
   488  		  },
   489  		  {
   490  			"type": "office",
   491  			"number": "646 555-4567"
   492  		  },
   493  		  {
   494  			"type": "mobile",
   495  			"number": "123 456-7890"
   496  		  }
   497  		],
   498  		"children": [],
   499  		"spouse": null
   500  	  }`
   501  
   502  	var expected = `/address
   503  	  /address/city
   504  	  /address/postalCode
   505  	  /address/state
   506  	  /address/streetAddress
   507  	  /age
   508  	  /children
   509  	  /firstName
   510  	  /isAlive
   511  	  /lastName
   512  	  /phoneNumbers
   513  	  /phoneNumbers/0
   514  	  /phoneNumbers/0/number
   515  	  /phoneNumbers/0/type
   516  	  /phoneNumbers/1
   517  	  /phoneNumbers/1/number
   518  	  /phoneNumbers/1/type
   519  	  /phoneNumbers/2
   520  	  /phoneNumbers/2/number
   521  	  /phoneNumbers/2/type
   522  	  /spouse
   523    `
   524  
   525  	expected = strings.Replace(expected, "\t", "", -1)
   526  	expected = strings.Replace(expected, " ", "", -1)
   527  
   528  	tests := []test.MurexTest{
   529  		{
   530  			Block: `
   531  				tout json (` + input + `) -> struct-keys 200 -> format str -> msort
   532  			`,
   533  			ExitNum: 0,
   534  			Stdout:  expected,
   535  			Stderr:  ``,
   536  		},
   537  		{
   538  			Block: `
   539  				tout json (` + input + `) -> struct-keys -d 200 -> format str -> msort
   540  			`,
   541  			ExitNum: 0,
   542  			Stdout:  expected,
   543  			Stderr:  ``,
   544  		},
   545  		{
   546  			Block: `
   547  				tout json (` + input + `) -> struct-keys --depth 200 -> format str -> msort
   548  			`,
   549  			ExitNum: 0,
   550  			Stdout:  expected,
   551  			Stderr:  ``,
   552  		},
   553  	}
   554  
   555  	test.RunMurexTests(tests, t)
   556  }
   557  
   558  func TestStructKeysSeparator(t *testing.T) {
   559  	var input = `{
   560  		"firstName": "John",
   561  		"lastName": "Smith",
   562  		"isAlive": true,
   563  		"age": 27,
   564  		"address": {
   565  		  "streetAddress": "21 2nd Street",
   566  		  "city": "New York",
   567  		  "state": "NY",
   568  		  "postalCode": "10021-3100"
   569  		},
   570  		"phoneNumbers": [
   571  		  {
   572  			"type": "home",
   573  			"number": "212 555-1234"
   574  		  },
   575  		  {
   576  			"type": "office",
   577  			"number": "646 555-4567"
   578  		  },
   579  		  {
   580  			"type": "mobile",
   581  			"number": "123 456-7890"
   582  		  }
   583  		],
   584  		"children": [],
   585  		"spouse": null
   586  	  }`
   587  
   588  	var expected = `☺address
   589  	  ☺address☺city
   590  	  ☺address☺postalCode
   591  	  ☺address☺state
   592  	  ☺address☺streetAddress
   593  	  ☺age
   594  	  ☺children
   595  	  ☺firstName
   596  	  ☺isAlive
   597  	  ☺lastName
   598  	  ☺phoneNumbers
   599  	  ☺phoneNumbers☺0
   600  	  ☺phoneNumbers☺0☺number
   601  	  ☺phoneNumbers☺0☺type
   602  	  ☺phoneNumbers☺1
   603  	  ☺phoneNumbers☺1☺number
   604  	  ☺phoneNumbers☺1☺type
   605  	  ☺phoneNumbers☺2
   606  	  ☺phoneNumbers☺2☺number
   607  	  ☺phoneNumbers☺2☺type
   608  	  ☺spouse
   609    `
   610  
   611  	expected = strings.Replace(expected, "\t", "", -1)
   612  	expected = strings.Replace(expected, " ", "", -1)
   613  
   614  	tests := []test.MurexTest{
   615  		{
   616  			Block: `
   617  				tout json (` + input + `) -> struct-keys -s ☺ -> format str -> msort
   618  			`,
   619  			ExitNum: 0,
   620  			Stdout:  expected,
   621  			Stderr:  ``,
   622  		},
   623  		{
   624  			Block: `
   625  				tout json (` + input + `) -> struct-keys -s ☺ 200 -> format str -> msort
   626  			`,
   627  			ExitNum: 0,
   628  			Stdout:  expected,
   629  			Stderr:  ``,
   630  		},
   631  		{
   632  			Block: `
   633  				tout json (` + input + `) -> struct-keys -s ☺ -d 200 -> format str -> msort
   634  			`,
   635  			ExitNum: 0,
   636  			Stdout:  expected,
   637  			Stderr:  ``,
   638  		},
   639  		{
   640  			Block: `
   641  				tout json (` + input + `) -> struct-keys --separator ☺ --depth 200 -> format str -> msort
   642  			`,
   643  			ExitNum: 0,
   644  			Stdout:  expected,
   645  			Stderr:  ``,
   646  		},
   647  	}
   648  
   649  	test.RunMurexTests(tests, t)
   650  }