github.com/hamba/avro/v2@v2.22.1-0.20240518180522-aff3955acf7d/codec_skip_test.go (about)

     1  package avro_test
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/hamba/avro/v2"
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestDecoder_SkipBool(t *testing.T) {
    13  	defer ConfigTeardown()
    14  
    15  	data := []byte{0x01, 0x06, 0x66, 0x6f, 0x6f}
    16  	schema := `{
    17  	"type": "record",
    18  	"name": "test",
    19  	"fields" : [
    20  		{"name": "a", "type": "boolean"},
    21  	    {"name": "b", "type": "string"}
    22  	]
    23  }`
    24  
    25  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    26  	require.NoError(t, err)
    27  
    28  	var got TestPartialRecord
    29  	err = dec.Decode(&got)
    30  
    31  	require.NoError(t, err)
    32  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
    33  }
    34  
    35  func TestDecoder_SkipInt(t *testing.T) {
    36  	defer ConfigTeardown()
    37  
    38  	data := []byte{0x36, 0x06, 0x66, 0x6f, 0x6f}
    39  	schema := `{
    40  	"type": "record",
    41  	"name": "test",
    42  	"fields" : [
    43  		{"name": "a", "type": "int"},
    44  	    {"name": "b", "type": "string"}
    45  	]
    46  }`
    47  
    48  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    49  	require.NoError(t, err)
    50  
    51  	var got TestPartialRecord
    52  	err = dec.Decode(&got)
    53  
    54  	require.NoError(t, err)
    55  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
    56  }
    57  
    58  func TestDecoder_SkipLong(t *testing.T) {
    59  	defer ConfigTeardown()
    60  
    61  	data := []byte{0x36, 0x06, 0x66, 0x6f, 0x6f}
    62  	schema := `{
    63  	"type": "record",
    64  	"name": "test",
    65  	"fields" : [
    66  		{"name": "a", "type": "long"},
    67  	    {"name": "b", "type": "string"}
    68  	]
    69  }`
    70  
    71  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    72  	require.NoError(t, err)
    73  
    74  	var got TestPartialRecord
    75  	err = dec.Decode(&got)
    76  
    77  	require.NoError(t, err)
    78  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
    79  }
    80  
    81  func TestDecoder_SkipFloat(t *testing.T) {
    82  	data := []byte{0x0, 0x0, 0x0, 0x0, 0x06, 0x66, 0x6f, 0x6f}
    83  	schema := `{
    84  	"type": "record",
    85  	"name": "test",
    86  	"fields" : [
    87  		{"name": "a", "type": "float"},
    88  	    {"name": "b", "type": "string"}
    89  	]
    90  }`
    91  
    92  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    93  	require.NoError(t, err)
    94  
    95  	var got TestPartialRecord
    96  	err = dec.Decode(&got)
    97  
    98  	require.NoError(t, err)
    99  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   100  }
   101  
   102  func TestDecoder_SkipDouble(t *testing.T) {
   103  	defer ConfigTeardown()
   104  
   105  	data := []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x06, 0x66, 0x6f, 0x6f}
   106  	schema := `{
   107  	"type": "record",
   108  	"name": "test",
   109  	"fields" : [
   110  		{"name": "a", "type": "double"},
   111  	    {"name": "b", "type": "string"}
   112  	]
   113  }`
   114  
   115  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   116  	require.NoError(t, err)
   117  
   118  	var got TestPartialRecord
   119  	err = dec.Decode(&got)
   120  
   121  	require.NoError(t, err)
   122  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   123  }
   124  
   125  func TestDecoder_SkipBytes(t *testing.T) {
   126  	defer ConfigTeardown()
   127  
   128  	data := []byte{0x02, 0x36, 0x06, 0x66, 0x6f, 0x6f}
   129  	schema := `{
   130  	"type": "record",
   131  	"name": "test",
   132  	"fields" : [
   133  		{"name": "a", "type": "bytes"},
   134  	    {"name": "b", "type": "string"}
   135  	]
   136  }`
   137  
   138  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   139  	require.NoError(t, err)
   140  
   141  	var got TestPartialRecord
   142  	err = dec.Decode(&got)
   143  
   144  	require.NoError(t, err)
   145  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   146  }
   147  
   148  func TestDecoder_SkipString(t *testing.T) {
   149  	defer ConfigTeardown()
   150  
   151  	data := []byte{0x02, 0x66, 0x06, 0x66, 0x6f, 0x6f}
   152  	schema := `{
   153  	"type": "record",
   154  	"name": "test",
   155  	"fields" : [
   156  		{"name": "a", "type": "string"},
   157  	    {"name": "b", "type": "string"}
   158  	]
   159  }`
   160  
   161  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   162  	require.NoError(t, err)
   163  
   164  	var got TestPartialRecord
   165  	err = dec.Decode(&got)
   166  
   167  	require.NoError(t, err)
   168  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   169  }
   170  
   171  func TestDecoder_SkipRecord(t *testing.T) {
   172  	defer ConfigTeardown()
   173  
   174  	data := []byte{0x02, 0x66, 0x06, 0x66, 0x6f, 0x6f}
   175  	schema := `{
   176  	"type": "record",
   177  	"name": "test",
   178  	"fields" : [
   179  		{"name": "a", "type": {"type": "record", "name": "test2", "fields": [{"name": "c", "type": "string"}]}},
   180  	    {"name": "b", "type": "string"}
   181  	]
   182  }`
   183  
   184  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   185  	require.NoError(t, err)
   186  
   187  	var got TestPartialRecord
   188  	err = dec.Decode(&got)
   189  
   190  	require.NoError(t, err)
   191  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   192  }
   193  
   194  func TestDecoder_SkipRef(t *testing.T) {
   195  	defer ConfigTeardown()
   196  
   197  	data := []byte{0x02, 0x66, 0x06, 0x66, 0x6f, 0x6f, 0x02, 0x66}
   198  	schema := `{
   199  	"type": "record",
   200  	"name": "test",
   201  	"fields" : [
   202  		{"name": "a", "type": {"type": "record", "name": "test2", "fields": [{"name": "c", "type": "string"}]}},
   203  	    {"name": "b", "type": "string"},
   204  		{"name": "c", "type": "test2"}
   205  	]
   206  }`
   207  
   208  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   209  	require.NoError(t, err)
   210  
   211  	var got TestPartialRecord
   212  	err = dec.Decode(&got)
   213  
   214  	require.NoError(t, err)
   215  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   216  }
   217  
   218  func TestDecoder_SkipEnum(t *testing.T) {
   219  	defer ConfigTeardown()
   220  
   221  	data := []byte{0x02, 0x06, 0x66, 0x6f, 0x6f}
   222  	schema := `{
   223  	"type": "record",
   224  	"name": "test",
   225  	"fields" : [
   226  		{"name": "a", "type": {"type": "enum", "name": "test2", "symbols": ["sym1", "sym2"]}},
   227  	    {"name": "b", "type": "string"}
   228  	]
   229  }`
   230  
   231  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   232  	require.NoError(t, err)
   233  
   234  	var got TestPartialRecord
   235  	err = dec.Decode(&got)
   236  
   237  	require.NoError(t, err)
   238  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   239  }
   240  
   241  func TestDecoder_SkipArray(t *testing.T) {
   242  	defer ConfigTeardown()
   243  
   244  	data := []byte{0x04, 0x36, 0x36, 0x0, 0x06, 0x66, 0x6f, 0x6f}
   245  	schema := `{
   246  	"type": "record",
   247  	"name": "test",
   248  	"fields" : [
   249  		{"name": "a", "type": {"type": "array", "items": "int"}},
   250  	    {"name": "b", "type": "string"}
   251  	]
   252  }`
   253  
   254  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   255  	require.NoError(t, err)
   256  
   257  	var got TestPartialRecord
   258  	err = dec.Decode(&got)
   259  
   260  	require.NoError(t, err)
   261  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   262  }
   263  
   264  func TestDecoder_SkipArrayBlocks(t *testing.T) {
   265  	defer ConfigTeardown()
   266  
   267  	data := []byte{0x03, 0x04, 0x36, 0x36, 0x0, 0x06, 0x66, 0x6f, 0x6f}
   268  	schema := `{
   269  	"type": "record",
   270  	"name": "test",
   271  	"fields" : [
   272  		{"name": "a", "type": {"type": "array", "items": "int"}},
   273  	    {"name": "b", "type": "string"}
   274  	]
   275  }`
   276  
   277  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   278  	require.NoError(t, err)
   279  
   280  	var got TestPartialRecord
   281  	err = dec.Decode(&got)
   282  
   283  	require.NoError(t, err)
   284  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   285  }
   286  
   287  func TestDecoder_SkipMap(t *testing.T) {
   288  	defer ConfigTeardown()
   289  
   290  	data := []byte{0x04, 0x02, 0x66, 0x36, 0x02, 0x6f, 0x36, 0x0, 0x06, 0x66, 0x6f, 0x6f}
   291  	schema := `{
   292  	"type": "record",
   293  	"name": "test",
   294  	"fields" : [
   295  		{"name": "a", "type": {"type": "map", "values": "int"}},
   296  	    {"name": "b", "type": "string"}
   297  	]
   298  }`
   299  
   300  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   301  	require.NoError(t, err)
   302  
   303  	var got TestPartialRecord
   304  	err = dec.Decode(&got)
   305  
   306  	require.NoError(t, err)
   307  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   308  }
   309  
   310  func TestDecoder_SkipMapBlocks(t *testing.T) {
   311  	defer ConfigTeardown()
   312  
   313  	data := []byte{0x03, 0x0C, 0x02, 0x66, 0x36, 0x02, 0x6f, 0x36, 0x0, 0x06, 0x66, 0x6f, 0x6f}
   314  	schema := `{
   315  	"type": "record",
   316  	"name": "test",
   317  	"fields" : [
   318  		{"name": "a", "type": {"type": "map", "values": "int"}},
   319  	    {"name": "b", "type": "string"}
   320  	]
   321  }`
   322  
   323  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   324  	require.NoError(t, err)
   325  
   326  	var got TestPartialRecord
   327  	err = dec.Decode(&got)
   328  
   329  	require.NoError(t, err)
   330  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   331  }
   332  
   333  func TestDecoder_SkipUnion(t *testing.T) {
   334  	defer ConfigTeardown()
   335  
   336  	data := []byte{0x02, 0x02, 0x66, 0x06, 0x66, 0x6f, 0x6f}
   337  	schema := `{
   338  	"type": "record",
   339  	"name": "test",
   340  	"fields" : [
   341  		{"name": "a", "type": ["null", "string"]},
   342  	    {"name": "b", "type": "string"}
   343  	]
   344  }`
   345  
   346  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   347  	require.NoError(t, err)
   348  
   349  	var got TestPartialRecord
   350  	err = dec.Decode(&got)
   351  
   352  	require.NoError(t, err)
   353  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   354  }
   355  
   356  func TestDecoder_SkipUnionNull(t *testing.T) {
   357  	defer ConfigTeardown()
   358  
   359  	data := []byte{0x00, 0x06, 0x66, 0x6f, 0x6f}
   360  	schema := `{
   361  	"type": "record",
   362  	"name": "test",
   363  	"fields" : [
   364  		{"name": "a", "type": ["null", "string"]},
   365  	    {"name": "b", "type": "string"}
   366  	]
   367  }`
   368  
   369  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   370  	require.NoError(t, err)
   371  
   372  	var got TestPartialRecord
   373  	err = dec.Decode(&got)
   374  
   375  	require.NoError(t, err)
   376  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   377  }
   378  
   379  func TestDecoder_SkipUnionInvalidSchema(t *testing.T) {
   380  	defer ConfigTeardown()
   381  
   382  	data := []byte{0x03, 0x06, 0x66, 0x6f, 0x6f}
   383  	schema := `{
   384  	"type": "record",
   385  	"name": "test",
   386  	"fields" : [
   387  		{"name": "a", "type": ["null", "string"]},
   388  	    {"name": "b", "type": "string"}
   389  	]
   390  }`
   391  
   392  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   393  	require.NoError(t, err)
   394  
   395  	var got TestPartialRecord
   396  	err = dec.Decode(&got)
   397  
   398  	assert.Error(t, err)
   399  }
   400  
   401  func TestDecoder_SkipFixed(t *testing.T) {
   402  	defer ConfigTeardown()
   403  
   404  	data := []byte{0x04, 0x02, 0x66, 0x36, 0x02, 0x6f, 0x36, 0x06, 0x66, 0x6f, 0x6f}
   405  	schema := `{
   406  	"type": "record",
   407  	"name": "test",
   408  	"fields" : [
   409  		{"name": "a", "type": {"type": "fixed", "name": "test2", "size": 7}},
   410  	    {"name": "b", "type": "string"}
   411  	]
   412  }`
   413  
   414  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   415  	require.NoError(t, err)
   416  
   417  	var got TestPartialRecord
   418  	err = dec.Decode(&got)
   419  
   420  	require.NoError(t, err)
   421  	assert.Equal(t, TestPartialRecord{B: "foo"}, got)
   422  }