github.com/hamba/avro/v2@v2.22.1-0.20240518180522-aff3955acf7d/encoder_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 TestEncoder_EnumInvalidType(t *testing.T) {
    14  	defer ConfigTeardown()
    15  
    16  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    17  	buf := bytes.NewBuffer([]byte{})
    18  	enc, err := avro.NewEncoder(schema, buf)
    19  	require.NoError(t, err)
    20  
    21  	err = enc.Encode(27)
    22  
    23  	assert.Error(t, err)
    24  }
    25  
    26  func TestEncoder_Enum(t *testing.T) {
    27  	defer ConfigTeardown()
    28  
    29  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    30  	buf := bytes.NewBuffer([]byte{})
    31  	enc, err := avro.NewEncoder(schema, buf)
    32  	require.NoError(t, err)
    33  
    34  	err = enc.Encode("bar")
    35  
    36  	require.NoError(t, err)
    37  	assert.Equal(t, []byte{0x02}, buf.Bytes())
    38  }
    39  
    40  func TestEncoder_EnumInvalidSymbol(t *testing.T) {
    41  	defer ConfigTeardown()
    42  
    43  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    44  	buf := bytes.NewBuffer([]byte{})
    45  	enc, err := avro.NewEncoder(schema, buf)
    46  	require.NoError(t, err)
    47  
    48  	err = enc.Encode("baz")
    49  
    50  	assert.Error(t, err)
    51  }
    52  
    53  func TestEncoder_EnumTextMarshaler(t *testing.T) {
    54  	defer ConfigTeardown()
    55  
    56  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    57  	buf := bytes.NewBuffer([]byte{})
    58  	enc, err := avro.NewEncoder(schema, buf)
    59  	require.NoError(t, err)
    60  
    61  	m := testEnumTextMarshaler(1)
    62  	err = enc.Encode(m)
    63  
    64  	require.NoError(t, err)
    65  	assert.Equal(t, []byte{0x02}, buf.Bytes())
    66  }
    67  
    68  func TestEncoder_EnumTextMarshalerPtr(t *testing.T) {
    69  	defer ConfigTeardown()
    70  
    71  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
    72  	buf := bytes.NewBuffer([]byte{})
    73  	enc, err := avro.NewEncoder(schema, buf)
    74  	require.NoError(t, err)
    75  
    76  	m := testEnumTextMarshaler(1)
    77  	err = enc.Encode(&m)
    78  
    79  	require.NoError(t, err)
    80  	assert.Equal(t, []byte{0x02}, buf.Bytes())
    81  }
    82  
    83  func TestEncoder_EnumTextMarshalerObj(t *testing.T) {
    84  	defer ConfigTeardown()
    85  
    86  	schema := `{
    87  	"type": "record",
    88  	"name": "test",
    89  	"fields" : [
    90  		{"name": "a", "type": {"type":"enum", "name": "test1", "symbols": ["foo", "bar"]}}
    91      ]
    92  }`
    93  	buf := bytes.NewBuffer([]byte{})
    94  	enc, err := avro.NewEncoder(schema, buf)
    95  	require.NoError(t, err)
    96  
    97  	m := testEnumMarshlaerObj{A: testEnumTextMarshaler(1)}
    98  	err = enc.Encode(&m)
    99  
   100  	require.NoError(t, err)
   101  	assert.Equal(t, []byte{0x02}, buf.Bytes())
   102  }
   103  
   104  func TestEncoder_EnumTextMarshalerInvalidSymbol(t *testing.T) {
   105  	defer ConfigTeardown()
   106  
   107  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
   108  	buf := bytes.NewBuffer([]byte{})
   109  	enc, err := avro.NewEncoder(schema, buf)
   110  	require.NoError(t, err)
   111  
   112  	m := testEnumTextMarshaler(2)
   113  	err = enc.Encode(m)
   114  
   115  	assert.Error(t, err)
   116  }
   117  
   118  func TestEncoder_EnumTextMarshalerNil(t *testing.T) {
   119  	defer ConfigTeardown()
   120  
   121  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
   122  	buf := bytes.NewBuffer([]byte{})
   123  	enc, err := avro.NewEncoder(schema, buf)
   124  	require.NoError(t, err)
   125  
   126  	var m *testEnumTextMarshaler
   127  	err = enc.Encode(m)
   128  
   129  	assert.Error(t, err)
   130  }
   131  
   132  func TestEncoder_EnumTextMarshalerError(t *testing.T) {
   133  	defer ConfigTeardown()
   134  
   135  	schema := `{"type":"enum", "name": "test", "symbols": ["foo", "bar"]}`
   136  	buf := bytes.NewBuffer([]byte{})
   137  	enc, err := avro.NewEncoder(schema, buf)
   138  	require.NoError(t, err)
   139  
   140  	m := testEnumTextMarshaler(3)
   141  	err = enc.Encode(m)
   142  
   143  	assert.Error(t, err)
   144  }
   145  
   146  type testEnumMarshlaerObj struct {
   147  	A testEnumTextMarshaler `avro:"a"`
   148  }
   149  
   150  type testEnumTextMarshaler int
   151  
   152  func (m *testEnumTextMarshaler) MarshalText() ([]byte, error) {
   153  	switch *m {
   154  	case 0:
   155  		return []byte("foo"), nil
   156  	case 1:
   157  		return []byte("bar"), nil
   158  	case 2:
   159  		return []byte("baz"), nil
   160  	default:
   161  		return nil, errors.New("unknown symbol")
   162  	}
   163  }