schema_test.gno

  1package datastore
  2
  3import (
  4	"testing"
  5
  6	"gno.land/p/demo/uassert"
  7	"gno.land/p/demo/urequire"
  8)
  9
 10func TestSchemaNew(t *testing.T) {
 11	cases := []struct {
 12		name    string
 13		options []SchemaOption
 14		fields  []string
 15		strict  bool
 16	}{
 17		{
 18			name: "default",
 19		},
 20		{
 21			name:    "strict",
 22			options: []SchemaOption{Strict()},
 23			strict:  true,
 24		},
 25		{
 26			name: "with fields",
 27			options: []SchemaOption{
 28				WithField("foo"),
 29				WithField("bar"),
 30				WithDefaultField("baz", 42),
 31			},
 32			fields: []string{"foo", "bar", "baz"},
 33		},
 34	}
 35
 36	for _, tc := range cases {
 37		t.Run(tc.name, func(t *testing.T) {
 38			s := NewSchema("Foo", tc.options...)
 39
 40			uassert.Equal(t, "Foo", s.Name())
 41			uassert.Equal(t, tc.strict, s.IsStrict())
 42			urequire.Equal(t, len(tc.fields), s.Size(), "field count")
 43
 44			for i, name := range s.Fields() {
 45				uassert.Equal(t, tc.fields[i], name)
 46				uassert.True(t, s.HasField(name))
 47			}
 48		})
 49	}
 50}
 51
 52func TestSchemaAddField(t *testing.T) {
 53	cases := []struct {
 54		name       string
 55		options    []SchemaOption
 56		fieldName  string
 57		fieldIndex int
 58		fields     []string
 59		success    bool
 60	}{
 61		{
 62			name:       "new only field",
 63			fieldName:  "foo",
 64			fieldIndex: 0,
 65			fields:     []string{"foo"},
 66			success:    true,
 67		},
 68		{
 69			name: "new existing fields",
 70			options: []SchemaOption{
 71				WithField("foo"),
 72				WithField("bar"),
 73			},
 74			fieldName:  "baz",
 75			fieldIndex: 2,
 76			fields:     []string{"foo", "bar", "baz"},
 77			success:    true,
 78		},
 79		{
 80			name:       "duplicated field",
 81			options:    []SchemaOption{WithField("foo")},
 82			fieldName:  "foo",
 83			fieldIndex: -1,
 84			fields:     []string{"foo"},
 85		},
 86	}
 87
 88	for _, tc := range cases {
 89		t.Run(tc.name, func(t *testing.T) {
 90			s := NewSchema("Foo", tc.options...)
 91
 92			index, added := s.AddField(tc.fieldName, nil)
 93
 94			if tc.success {
 95				uassert.Equal(t, tc.fieldIndex, index)
 96				uassert.True(t, added)
 97			} else {
 98				uassert.Equal(t, -1, index)
 99				uassert.False(t, added)
100			}
101
102			urequire.Equal(t, len(tc.fields), s.Size(), "field count")
103
104			for i, name := range s.Fields() {
105				uassert.Equal(t, tc.fields[i], name)
106				uassert.True(t, s.HasField(name))
107			}
108		})
109	}
110}
111
112func TestSchemaGetFieldIndex(t *testing.T) {
113	s := NewSchema("Foo")
114	s.AddField("foo", nil)
115	s.AddField("bar", nil)
116	s.AddField("baz", nil)
117
118	uassert.Equal(t, 0, s.GetFieldIndex("foo"))
119	uassert.Equal(t, 1, s.GetFieldIndex("bar"))
120	uassert.Equal(t, 2, s.GetFieldIndex("baz"))
121
122	uassert.Equal(t, -1, s.GetFieldIndex(""))
123	uassert.Equal(t, -1, s.GetFieldIndex("unknown"))
124}
125
126func TestSchemaGetFieldName(t *testing.T) {
127	s := NewSchema("Foo")
128	s.AddField("foo", nil)
129	s.AddField("bar", nil)
130	s.AddField("baz", nil)
131
132	name, found := s.GetFieldName(0)
133	uassert.Equal(t, "foo", name)
134	uassert.True(t, found)
135
136	name, found = s.GetFieldName(1)
137	uassert.Equal(t, "bar", name)
138	uassert.True(t, found)
139
140	name, found = s.GetFieldName(2)
141	uassert.Equal(t, "baz", name)
142	uassert.True(t, found)
143
144	name, found = s.GetFieldName(404)
145	uassert.Equal(t, "", name)
146	uassert.False(t, found)
147}
148
149func TestSchemaGetDefault(t *testing.T) {
150	s := NewSchema("Foo")
151	s.AddField("foo", nil)
152	s.AddField("bar", 42)
153
154	_, found := s.GetDefault("foo")
155	uassert.False(t, found)
156
157	v, found := s.GetDefault("bar")
158	uassert.True(t, found)
159
160	got, ok := v.(int)
161	urequire.True(t, ok, "default field value")
162	uassert.Equal(t, 42, got)
163}
164
165func TestSchemaGetDefaultByIndex(t *testing.T) {
166	s := NewSchema("Foo")
167	s.AddField("foo", nil)
168	s.AddField("bar", 42)
169
170	_, found := s.GetDefaultByIndex(0)
171	uassert.False(t, found)
172
173	_, found = s.GetDefaultByIndex(404)
174	uassert.False(t, found)
175
176	v, found := s.GetDefaultByIndex(1)
177	uassert.True(t, found)
178
179	got, ok := v.(int)
180	urequire.True(t, ok, "default field value")
181	uassert.Equal(t, 42, got)
182}
183
184func TestSchemaRenameField(t *testing.T) {
185	s := NewSchema("Foo")
186	s.AddField("foo", nil)
187	s.AddField("bar", nil)
188
189	renamed := s.RenameField("foo", "bar")
190	uassert.False(t, renamed)
191
192	renamed = s.RenameField("", "baz")
193	uassert.False(t, renamed)
194
195	renamed = s.RenameField("foo", "")
196	uassert.True(t, renamed)
197
198	renamed = s.RenameField("", "foo")
199	uassert.True(t, renamed)
200
201	renamed = s.RenameField("foo", "foobar")
202	uassert.True(t, renamed)
203
204	urequire.Equal(t, 2, s.Size(), "field count")
205	fields := []string{"foobar", "bar"}
206	for i, name := range s.Fields() {
207		uassert.Equal(t, fields[i], name)
208		uassert.True(t, s.HasField(name))
209	}
210}