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

     1  package avro_test
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"testing"
     7  
     8  	"github.com/hamba/avro/v2"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func TestDecoder_EnumInvalidType(t *testing.T) {
    14  	defer ConfigTeardown()
    15  
    16  	data := []byte{0xE2, 0xA2, 0xF3, 0xAD, 0xAD, 0xAD}
    17  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    18  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    19  	require.NoError(t, err)
    20  
    21  	var got int
    22  	err = dec.Decode(&got)
    23  
    24  	assert.Error(t, err)
    25  }
    26  
    27  func TestDecoder_Enum(t *testing.T) {
    28  	defer ConfigTeardown()
    29  
    30  	data := []byte{0x02}
    31  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    32  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    33  
    34  	var got string
    35  	err := dec.Decode(&got)
    36  
    37  	require.NoError(t, err)
    38  	assert.Equal(t, "bar", got)
    39  }
    40  
    41  func TestDecoder_EnumInvalidSymbol(t *testing.T) {
    42  	defer ConfigTeardown()
    43  
    44  	data := []byte{0x04}
    45  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    46  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    47  
    48  	var got string
    49  	err := dec.Decode(&got)
    50  
    51  	assert.Error(t, err)
    52  }
    53  
    54  func TestDecoder_EnumError(t *testing.T) {
    55  	defer ConfigTeardown()
    56  
    57  	data := []byte{0xE2, 0xA2, 0xF3, 0xAD, 0xAD, 0xAD}
    58  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    59  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
    60  	require.NoError(t, err)
    61  
    62  	var got string
    63  	err = dec.Decode(&got)
    64  
    65  	assert.Error(t, err)
    66  }
    67  
    68  func TestDecoder_EnumTextUnmarshaler(t *testing.T) {
    69  	defer ConfigTeardown()
    70  
    71  	data := []byte{0x02}
    72  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    73  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    74  
    75  	var got *testEnumTextUnmarshaler
    76  	err := dec.Decode(&got)
    77  
    78  	require.NoError(t, err)
    79  	require.NotNil(t, got)
    80  	assert.Equal(t, testEnumTextUnmarshaler(1), *got)
    81  }
    82  
    83  func TestDecoder_EnumTextUnmarshalerNonPtr(t *testing.T) {
    84  	defer ConfigTeardown()
    85  
    86  	data := []byte{0x02}
    87  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    88  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
    89  
    90  	var got testEnumTextUnmarshaler
    91  	err := dec.Decode(&got)
    92  
    93  	require.NoError(t, err)
    94  	require.NotNil(t, got)
    95  	assert.Equal(t, testEnumTextUnmarshaler(1), got)
    96  }
    97  
    98  func TestDecoder_EnumTextUnmarshalerObj(t *testing.T) {
    99  	defer ConfigTeardown()
   100  
   101  	data := []byte{0x02}
   102  	schema := `{
   103  	"type": "record",
   104  	"name": "test",
   105  	"fields" : [
   106  		{"name": "a", "type": {"type":"enum", "name": "test1", "symbols": ["foo", "bar"]}}
   107      ]
   108  }`
   109  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   110  	require.NoError(t, err)
   111  
   112  	var got testEnumUnmarshalerObj
   113  	err = dec.Decode(&got)
   114  
   115  	require.NoError(t, err)
   116  	require.NotNil(t, got)
   117  	assert.Equal(t, testEnumUnmarshalerObj{A: testEnumTextUnmarshaler(1)}, got)
   118  }
   119  
   120  func TestDecoder_EnumTextUnmarshalerInvalidSymbol(t *testing.T) {
   121  	defer ConfigTeardown()
   122  
   123  	data := []byte{0x04}
   124  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
   125  	dec, _ := avro.NewDecoder(schema, bytes.NewReader(data))
   126  
   127  	var got *testEnumTextUnmarshaler
   128  	err := dec.Decode(&got)
   129  
   130  	assert.Error(t, err)
   131  }
   132  
   133  func TestDecoder_EnumTextUnmarshalerEnumError(t *testing.T) {
   134  	defer ConfigTeardown()
   135  
   136  	data := []byte{0xE2, 0xA2, 0xF3, 0xAD, 0xAD, 0xAD}
   137  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
   138  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   139  	require.NoError(t, err)
   140  
   141  	var got *testEnumTextUnmarshaler
   142  	err = dec.Decode(&got)
   143  
   144  	assert.Error(t, err)
   145  }
   146  
   147  func TestDecoder_EnumTextUnmarshalerError(t *testing.T) {
   148  	defer ConfigTeardown()
   149  
   150  	data := []byte{0x04}
   151  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar", "baz"]}`
   152  	dec, err := avro.NewDecoder(schema, bytes.NewReader(data))
   153  	require.NoError(t, err)
   154  
   155  	var got *testEnumTextUnmarshaler
   156  	err = dec.Decode(&got)
   157  
   158  	assert.Error(t, err)
   159  }
   160  
   161  type testEnumUnmarshalerObj struct {
   162  	A testEnumTextUnmarshaler `avro:"a"`
   163  }
   164  
   165  type testEnumTextUnmarshaler int
   166  
   167  func (m *testEnumTextUnmarshaler) UnmarshalText(data []byte) error {
   168  	switch string(data) {
   169  	case "foo":
   170  		*m = 0
   171  		return nil
   172  	case "bar":
   173  		*m = 1
   174  		return nil
   175  	default:
   176  		return errors.New("unknown symbol")
   177  	}
   178  }