github.com/TrueBlocks/trueblocks-core/src/apps/chifra@v0.0.0-20241022031540-b362680128f7/pkg/output/json_writer_test.go (about)

     1  package output
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"fmt"
     7  	"strconv"
     8  	"testing"
     9  
    10  	"github.com/TrueBlocks/trueblocks-core/src/apps/chifra/pkg/types"
    11  )
    12  
    13  func helperReportStringMismatch(t *testing.T, expected, result string) {
    14  	for i, ch := range expected {
    15  		if result[i] != byte(ch) {
    16  			fmt.Printf("<<%s>>", string(result[:i]))
    17  			t.Fatalf("mismatch at %d, expected %s, got %s", i, strconv.QuoteRune(ch), strconv.Quote(string(result[i])))
    18  		}
    19  	}
    20  }
    21  
    22  func TestJsonWriter_EmptyRoot(t *testing.T) {
    23  	expected := `{}`
    24  
    25  	b := make([]byte, 0, 1024)
    26  	buf := bytes.NewBuffer(b)
    27  	w := NewJsonWriter(buf)
    28  	w.Close()
    29  
    30  	result := buf.String()
    31  	if result != expected {
    32  		helperReportStringMismatch(t, expected, result)
    33  	}
    34  }
    35  
    36  func TestJsonWriter_EmptyField(t *testing.T) {
    37  	expected := `{
    38    "data": []
    39  }`
    40  
    41  	b := make([]byte, 0, 1024)
    42  	buf := bytes.NewBuffer(b)
    43  	w := NewJsonWriter(buf)
    44  	w.OpenField("data", FieldArray)
    45  	w.CloseField(FieldArray)
    46  	w.Close()
    47  
    48  	result := buf.String()
    49  
    50  	if result != expected {
    51  		helperReportStringMismatch(t, expected, result)
    52  	}
    53  }
    54  
    55  func TestJsonWriter_EmptySubField(t *testing.T) {
    56  	expected := `{
    57    "data": [
    58      {}
    59    ]
    60  }`
    61  
    62  	b := make([]byte, 0, 1024)
    63  	buf := bytes.NewBuffer(b)
    64  	w := NewJsonWriter(buf)
    65  	w.OpenField("data", FieldArray)
    66  	w.OpenField("", FieldObject)
    67  	w.CloseField(FieldObject)
    68  	w.CloseField(FieldArray)
    69  	w.Close()
    70  
    71  	result := buf.String()
    72  
    73  	if result != expected {
    74  		helperReportStringMismatch(t, expected, result)
    75  	}
    76  }
    77  
    78  func TestJsonWriter_SingleKey(t *testing.T) {
    79  	expected := `{
    80    "data": [
    81      {
    82        "key": true
    83      }
    84    ]
    85  }`
    86  
    87  	b := make([]byte, 0, 1024)
    88  	buf := bytes.NewBuffer(b)
    89  	w := NewJsonWriter(buf)
    90  	w.OpenField("data", FieldArray)
    91  	w.OpenField("", FieldObject)
    92  	w.Write([]byte(`"key": true`))
    93  	w.CloseField(FieldObject)
    94  	w.CloseField(FieldArray)
    95  	w.Close()
    96  
    97  	result := buf.String()
    98  
    99  	if result != expected {
   100  		helperReportStringMismatch(t, expected, result)
   101  	}
   102  }
   103  
   104  func TestJsonWriter_SingleEmptySubkey(t *testing.T) {
   105  	expected := `{
   106    "data": [
   107      {
   108        "subkey": {}
   109      }
   110    ]
   111  }`
   112  
   113  	b := make([]byte, 0, 1024)
   114  	buf := bytes.NewBuffer(b)
   115  	w := NewJsonWriter(buf)
   116  	w.OpenField("data", FieldArray)
   117  	w.OpenField("", FieldObject)
   118  	w.OpenField("subkey", FieldObject)
   119  	w.CloseField(FieldObject)
   120  	w.CloseField(FieldObject)
   121  	w.CloseField(FieldArray)
   122  	w.Close()
   123  
   124  	result := buf.String()
   125  
   126  	if result != expected {
   127  		helperReportStringMismatch(t, expected, result)
   128  	}
   129  }
   130  
   131  func TestJsonWriter_SingleNonEmptySubkey(t *testing.T) {
   132  	expected := `{
   133    "data": [
   134      {
   135        "subkey": {
   136          "key": true
   137        }
   138      }
   139    ]
   140  }`
   141  
   142  	b := make([]byte, 0, 1024)
   143  	buf := bytes.NewBuffer(b)
   144  	w := NewJsonWriter(buf)
   145  	w.OpenField("data", FieldArray)
   146  	w.OpenField("", FieldObject)
   147  	w.OpenField("subkey", FieldObject)
   148  	w.Write([]byte(`"key": true`))
   149  	w.CloseField(FieldObject)
   150  	w.CloseField(FieldObject)
   151  	w.CloseField(FieldArray)
   152  	w.Close()
   153  
   154  	result := buf.String()
   155  
   156  	if result != expected {
   157  		helperReportStringMismatch(t, expected, result)
   158  	}
   159  }
   160  
   161  func TestJsonWriter_SingleNonEmptySubkeyMultipleChildren(t *testing.T) {
   162  	expected := `{
   163    "data": [
   164      {
   165        "subkey": {
   166          "key1": true,
   167          "key2": false
   168        }
   169      }
   170    ]
   171  }`
   172  
   173  	b := make([]byte, 0, 1024)
   174  	buf := bytes.NewBuffer(b)
   175  	w := NewJsonWriter(buf)
   176  	w.OpenField("data", FieldArray)
   177  	w.OpenField("", FieldObject)
   178  	w.OpenField("subkey", FieldObject)
   179  	w.Write([]byte(`"key1": true`))
   180  	w.Write([]byte(`"key2": false`))
   181  	w.CloseField(FieldObject)
   182  	w.CloseField(FieldObject)
   183  	w.CloseField(FieldArray)
   184  	w.Close()
   185  
   186  	result := buf.String()
   187  
   188  	if result != expected {
   189  		helperReportStringMismatch(t, expected, result)
   190  	}
   191  }
   192  
   193  func TestJsonWriter_MultipleItems(t *testing.T) {
   194  	expected := `{
   195    "first": 1,
   196    "second": 2
   197  }`
   198  	b := make([]byte, 0, 1024)
   199  	buf := bytes.NewBuffer(b)
   200  	w := NewJsonWriter(buf)
   201  	_, err := w.Write([]byte(`"first": 1`))
   202  	if err != nil {
   203  		t.Fatal("first write:", err)
   204  	}
   205  	_, err = w.Write([]byte(`"second": 2`))
   206  	if err != nil {
   207  		t.Fatal("second write:", err)
   208  	}
   209  	w.Close()
   210  	result := buf.String()
   211  
   212  	if result != expected {
   213  		helperReportStringMismatch(t, expected, result)
   214  	}
   215  }
   216  
   217  func TestJsonWriter_MultipleItemsWithSubitems(t *testing.T) {
   218  	expected := `{
   219    "data": [
   220      {
   221        "item": true
   222      }
   223    ],
   224    "errors": [],
   225    "meta": {}
   226  }`
   227  	b := make([]byte, 0, 1024)
   228  	buf := bytes.NewBuffer(b)
   229  	w := NewJsonWriter(buf)
   230  	_, err := w.OpenField("data", FieldArray)
   231  	if err != nil {
   232  		t.Fatal(err)
   233  	}
   234  	_, err = w.OpenField("", FieldObject)
   235  	if err != nil {
   236  		t.Fatal(err)
   237  	}
   238  	_, err = w.Write([]byte(`"item": true`))
   239  	if err != nil {
   240  		t.Fatal(err)
   241  	}
   242  	w.CloseField(FieldObject)
   243  	w.CloseField(FieldArray)
   244  
   245  	w.OpenField("errors", FieldArray)
   246  	w.CloseField(FieldArray)
   247  
   248  	w.OpenField("meta", FieldObject)
   249  	w.CloseField(FieldObject)
   250  
   251  	w.Close()
   252  
   253  	result := buf.String()
   254  
   255  	if result != expected {
   256  		helperReportStringMismatch(t, expected, result)
   257  	}
   258  }
   259  
   260  func TestJsonWriter_openRoot(t *testing.T) {
   261  	expected := `{`
   262  
   263  	b := make([]byte, 0, 1024)
   264  	buf := bytes.NewBuffer(b)
   265  	w := NewJsonWriter(buf)
   266  	w.Write([]byte(""))
   267  
   268  	result := buf.String()
   269  
   270  	if result != expected {
   271  		helperReportStringMismatch(t, expected, result)
   272  	}
   273  }
   274  
   275  func TestJsonWriter_CloseApiResponse(t *testing.T) {
   276  	expected := `{
   277    "data": [
   278      {
   279        "item": true
   280      }
   281    ],
   282    "meta": {
   283      "client": 0,
   284      "finalized": 0,
   285      "staging": 0,
   286      "ripe": 0,
   287      "unripe": 0
   288    },
   289    "errors": [
   290      "error1",
   291      "error2"
   292    ]
   293  }`
   294  	b := make([]byte, 0, 1024)
   295  	buf := bytes.NewBuffer(b)
   296  	w := NewJsonWriter(buf)
   297  	w.GetMeta = func() (*types.MetaData, error) {
   298  		return &types.MetaData{}, nil
   299  	}
   300  	w.ShouldWriteMeta = true
   301  
   302  	_, err := w.OpenField("data", FieldArray)
   303  	if err != nil {
   304  		t.Fatal(err)
   305  	}
   306  	_, err = w.OpenField("", FieldObject)
   307  	if err != nil {
   308  		t.Fatal(err)
   309  	}
   310  	_, err = w.Write([]byte(`"item": true`))
   311  	if err != nil {
   312  		t.Fatal(err)
   313  	}
   314  	w.CloseField(FieldObject)
   315  	w.CloseField(FieldArray)
   316  
   317  	w.WriteError(errors.New("error1"))
   318  	w.WriteError(errors.New("error2"))
   319  
   320  	w.Close()
   321  
   322  	result := buf.String()
   323  	if result != expected {
   324  		helperReportStringMismatch(t, expected, result)
   325  	}
   326  }
   327  
   328  func TestJsonWriter_WriteCompound(t *testing.T) {
   329  	expected := `{
   330    "data": [
   331      {
   332        "key": true
   333      }
   334    ]
   335  }`
   336  
   337  	b := make([]byte, 0, 1024)
   338  	buf := bytes.NewBuffer(b)
   339  	w := NewJsonWriter(buf)
   340  	w.DefaultField = DefaultField{
   341  		Key:       "data",
   342  		FieldType: FieldArray,
   343  	}
   344  	w.WriteCompoundItem("", map[string]bool{"key": true})
   345  	w.Close()
   346  
   347  	result := buf.String()
   348  	if result != expected {
   349  		helperReportStringMismatch(t, expected, result)
   350  	}
   351  }
   352  
   353  func TestJsonWriter_WriteCompoundTwice(t *testing.T) {
   354  	expected := `{
   355    "data": [
   356      {
   357        "first": true
   358      },
   359      {
   360        "second": true
   361      }
   362    ]
   363  }`
   364  
   365  	b := make([]byte, 0, 1024)
   366  	buf := bytes.NewBuffer(b)
   367  	w := NewJsonWriter(buf)
   368  	w.DefaultField = DefaultField{
   369  		Key:       "data",
   370  		FieldType: FieldArray,
   371  	}
   372  	w.WriteCompoundItem("", map[string]bool{"first": true})
   373  	w.WriteCompoundItem("", map[string]bool{"second": true})
   374  	w.Close()
   375  
   376  	result := buf.String()
   377  	if result != expected {
   378  		helperReportStringMismatch(t, expected, result)
   379  	}
   380  }
   381  
   382  func TestJsonWriter_DefaultField(t *testing.T) {
   383  	expected := `{
   384    "data": [
   385      {
   386        "subkey": {}
   387      }
   388    ]
   389  }`
   390  
   391  	b := make([]byte, 0, 1024)
   392  	buf := bytes.NewBuffer(b)
   393  	w := NewJsonWriter(buf)
   394  	w.DefaultField = DefaultField{
   395  		Key:       "data",
   396  		FieldType: FieldArray,
   397  	}
   398  	w.OpenField("", FieldObject)
   399  	w.OpenField("subkey", FieldObject)
   400  	w.CloseField(FieldObject)
   401  	w.CloseField(FieldObject)
   402  	w.Close()
   403  
   404  	result := buf.String()
   405  	if result != expected {
   406  		helperReportStringMismatch(t, expected, result)
   407  	}
   408  }
   409  
   410  func TestJsonWriter_DefaultFieldEmpty(t *testing.T) {
   411  	expected := `{
   412    "data": []
   413  }`
   414  
   415  	b := make([]byte, 0, 1024)
   416  	buf := bytes.NewBuffer(b)
   417  	w := NewJsonWriter(buf)
   418  	w.DefaultField = DefaultField{
   419  		Key:       "data",
   420  		FieldType: FieldArray,
   421  	}
   422  	w.Close()
   423  
   424  	result := buf.String()
   425  	if result != expected {
   426  		helperReportStringMismatch(t, expected, result)
   427  	}
   428  }
   429  
   430  func TestJsonWriter_DefaultFieldCompound(t *testing.T) {
   431  	expected := `{
   432    "data": [
   433      {}
   434    ]
   435  }`
   436  
   437  	b := make([]byte, 0, 1024)
   438  	buf := bytes.NewBuffer(b)
   439  	w := NewJsonWriter(buf)
   440  	w.DefaultField = DefaultField{
   441  		Key:       "data",
   442  		FieldType: FieldArray,
   443  	}
   444  	w.WriteCompoundItem("", map[string]string{})
   445  	w.Close()
   446  
   447  	result := buf.String()
   448  
   449  	if result != expected {
   450  		helperReportStringMismatch(t, expected, result)
   451  	}
   452  }