Initial project import

tools/v/vlib/json/tests/json_test.v

@@ -0,0 +1,604 @@
+import json
+import time
+
+enum JobTitle {
+	manager
+	executive
+	worker
+}
+
+struct Employee {
+	name   string
+	age    int
+	salary f32
+	title  JobTitle
+}
+
+fn test_simple() {
+	x := Employee{'Peter', 28, 95000.5, .worker}
+	s := json.encode(x)
+	// eprintln('Employee x: ${s}')
+	assert s == '{"name":"Peter","age":28,"salary":95000.5,"title":"worker"}'
+	y := json.decode(Employee, s)!
+	// eprintln('Employee y: ${y}')
+	assert y.name == 'Peter'
+	assert y.age == 28
+	assert y.salary == 95000.5
+	assert y.title == .worker
+}
+
+const currency_id = 'cconst'
+
+struct Price {
+	net         f64
+	currency_id string = currency_id @[json: currencyId]
+}
+
+fn test_field_with_default_expr() {
+	data := '[{"net":1},{"net":2,"currencyId":"cjson"}]'
+	prices := json.decode([]Price, data)!
+	assert prices == [Price{
+		net:         1
+		currency_id: 'cconst'
+	}, Price{
+		net:         2
+		currency_id: 'cjson'
+	}]
+}
+
+fn test_decode_top_level_array() {
+	s := '[{"name":"Peter", "age": 29}, {"name":"Bob", "age":31}]'
+	x := json.decode([]Employee, s) or { panic(err) }
+	assert x.len == 2
+	assert x[0].name == 'Peter'
+	assert x[0].age == 29
+	assert x[1].name == 'Bob'
+	assert x[1].age == 31
+}
+
+struct Human {
+	name string
+}
+
+struct Item {
+	tag string
+}
+
+enum Animal {
+	dog // Will be encoded as `0`
+	cat
+}
+
+type Entity = Animal | Human | Item | string | time.Time
+
+struct SomeGame {
+	title  string
+	player Entity
+	other  []Entity
+}
+
+fn test_encode_decode_sumtype() {
+	t := time.now()
+	game := SomeGame{
+		title:  'Super Mega Game'
+		player: Human{'Monke'}
+		other:  [
+			Entity(Item{'Pen'}),
+			Item{'Cookie'},
+			Animal.cat,
+			'Stool',
+			t,
+		]
+	}
+	// eprintln('Game: ${game}')
+
+	enc := json.encode(game)
+	// eprintln('Encoded Game: ${enc}')
+
+	assert enc == '{"title":"Super Mega Game","player":{"name":"Monke","_type":"Human"},"other":[{"tag":"Pen","_type":"Item"},{"tag":"Cookie","_type":"Item"},"cat","Stool",{"_type":"Time","value":${t.unix()}}]}'
+
+	dec := json.decode(SomeGame, enc)!
+	// eprintln('Decoded Game: ${dec}')
+
+	assert game.title == dec.title
+	assert game.player == dec.player
+	assert (game.other[2] as Animal) == .cat
+	assert dec.other[2] == Entity('cat')
+	assert (game.other[4] as time.Time).unix() == (dec.other[4] as time.Time).unix()
+}
+
+fn bar[T](payload string) !Bar { // ?T doesn't work currently
+	result := json.decode(T, payload)!
+	return result
+}
+
+struct Bar {
+	x string
+}
+
+fn test_generic() {
+	result := bar[Bar]('{"x":"test"}') or { Bar{} }
+	assert result.x == 'test'
+}
+
+struct User2 {
+	age      int
+	nums     []int
+	reg_date time.Time
+}
+
+struct User {
+	age           int
+	nums          []int
+	last_name     string @[json: lastName]
+	is_registered bool   @[json: IsRegistered]
+	typ           int    @[json: 'type']
+	pets          string @[json: 'pet_animals'; raw]
+}
+
+fn test_parse_user() {
+	s := '{"age": 10, "nums": [1,2,3], "type": 1, "lastName": "Johnson", "IsRegistered": true, "pet_animals": {"name": "Bob", "animal": "Dog"}}'
+	u2 := json.decode(User2, s)!
+	// println(u2)
+	u := json.decode(User, s)!
+	// println(u)
+	assert u.age == 10
+	assert u.last_name == 'Johnson'
+	assert u.is_registered == true
+	assert u.nums.len == 3
+	assert u.nums[0] == 1
+	assert u.nums[1] == 2
+	assert u.nums[2] == 3
+	assert u.typ == 1
+	assert u.pets == '{"name":"Bob","animal":"Dog"}'
+}
+
+fn test_encode_decode_time() {
+	user := User2{
+		age:      25
+		reg_date: time.new(year: 2020, month: 12, day: 22, hour: 7, minute: 23)
+	}
+	s := json.encode(user)
+	// println(s)
+	assert s.contains('"reg_date":1608621780')
+	user2 := json.decode(User2, s)!
+	assert user2.reg_date.str() == '2020-12-22 07:23:00'
+	// println(user2)
+	// println(user2.reg_date)
+}
+
+fn test_decode_time_string_into_struct_field() {
+	user := json.decode(User2, '{"age": 25, "reg_date": "2001-01-01"}')!
+	assert user.reg_date.str() == '2001-01-01 00:00:00'
+}
+
+fn (mut u User) foo() string {
+	return json.encode(u)
+}
+
+fn test_encode_user() {
+	mut usr := User{
+		age:           10
+		nums:          [1, 2, 3]
+		last_name:     'Johnson'
+		is_registered: true
+		typ:           0
+		pets:          'foo'
+	}
+	expected := '{"age":10,"nums":[1,2,3],"lastName":"Johnson","IsRegistered":true,"type":0,"pet_animals":"foo"}'
+	out := json.encode(usr)
+	// println(out)
+	assert out == expected
+	// Test json.encode on mutable pointers
+	assert usr.foo() == expected
+}
+
+struct Color {
+	space string
+	point string @[raw]
+}
+
+fn test_raw_json_field() {
+	color := json.decode(Color, '{"space": "YCbCr", "point": {"Y": 123}}') or {
+		// println('text')
+		return
+	}
+	assert color.point == '{"Y":123}'
+	assert color.space == 'YCbCr'
+}
+
+fn test_bad_raw_json_field() {
+	color := json.decode(Color, '{"space": "YCbCr"}') or {
+		// println('text')
+		return
+	}
+	assert color.point == ''
+	assert color.space == 'YCbCr'
+}
+
+struct City {
+	name string
+}
+
+struct Country {
+	cities []City
+	name   string
+}
+
+fn test_struct_in_struct() {
+	country := json.decode(Country,
+		'{ "name": "UK", "cities": [{"name":"London"}, {"name":"Manchester"}]}')!
+	assert country.name == 'UK'
+	assert country.cities.len == 2
+	assert country.cities[0].name == 'London'
+	assert country.cities[1].name == 'Manchester'
+	// println(country.cities)
+}
+
+fn test_encode_map() {
+	expected := '{"one":1,"two":2,"three":3,"four":4}'
+	numbers := {
+		'one':   1
+		'two':   2
+		'three': 3
+		'four':  4
+	}
+	out := json.encode(numbers)
+	// println(out)
+	assert out == expected
+	assert json.encode_pretty(numbers) == '{
+	"one":	1,
+	"two":	2,
+	"three":	3,
+	"four":	4
+}'
+}
+
+fn test_parse_map() {
+	expected := {
+		'one':   1
+		'two':   2
+		'three': 3
+		'four':  4
+	}
+	out := json.decode(map[string]int, '{"one":1,"two":2,"three":3,"four":4}')!
+	// println(out)
+	assert out == expected
+}
+
+struct Data {
+	countries []Country
+	users     map[string]User
+	extra     map[string]map[string]int
+}
+
+fn test_nested_type() {
+	data_expected := '{"countries":[{"cities":[{"name":"London"},{"name":"Manchester"}],"name":"UK"},{"cities":[{"name":"Donlon"},{"name":"Termanches"}],"name":"KU"}],"users":{"Foo":{"age":10,"nums":[1,2,3],"lastName":"Johnson","IsRegistered":true,"type":0,"pet_animals":"little foo"},"Boo":{"age":20,"nums":[5,3,1],"lastName":"Smith","IsRegistered":false,"type":4,"pet_animals":"little boo"}},"extra":{"2":{"n1":2,"n2":4,"n3":8,"n4":16},"3":{"n1":3,"n2":9,"n3":27,"n4":81}}}'
+	data := Data{
+		countries: [
+			Country{
+				name:   'UK'
+				cities: [City{'London'}, City{'Manchester'}]
+			},
+			Country{
+				name:   'KU'
+				cities: [City{'Donlon'}, City{'Termanches'}]
+			},
+		]
+		users:     {
+			'Foo': User{
+				age:           10
+				nums:          [1, 2, 3]
+				last_name:     'Johnson'
+				is_registered: true
+				typ:           0
+				pets:          'little foo'
+			}
+			'Boo': User{
+				age:           20
+				nums:          [5, 3, 1]
+				last_name:     'Smith'
+				is_registered: false
+				typ:           4
+				pets:          'little boo'
+			}
+		}
+		extra:     {
+			'2': {
+				'n1': 2
+				'n2': 4
+				'n3': 8
+				'n4': 16
+			}
+			'3': {
+				'n1': 3
+				'n2': 9
+				'n3': 27
+				'n4': 81
+			}
+		}
+	}
+	out := json.encode(data)
+	// println(out)
+	assert out == data_expected
+	data2 := json.decode(Data, data_expected)!
+	assert data2.countries.len == data.countries.len
+	for i in 0 .. 1 {
+		assert data2.countries[i].name == data.countries[i].name
+		assert data2.countries[i].cities.len == data.countries[i].cities.len
+		for j in 0 .. 1 {
+			assert data2.countries[i].cities[j].name == data.countries[i].cities[j].name
+		}
+	}
+	for key, user in data.users {
+		assert data2.users[key].age == user.age
+		assert data2.users[key].nums == user.nums
+		assert data2.users[key].last_name == user.last_name
+		assert data2.users[key].is_registered == user.is_registered
+		assert data2.users[key].typ == user.typ
+		// assert data2.users[key].pets == user.pets // TODO: FIX
+	}
+	for k, v in data.extra {
+		for k2, v2 in v {
+			assert data2.extra[k][k2] == v2
+		}
+	}
+}
+
+struct Foo[T] {
+pub:
+	name string
+	data T
+}
+
+fn test_generic_struct() {
+	foo_int := Foo[int]{'bar', 12}
+	foo_enc := json.encode(foo_int)
+	assert foo_enc == '{"name":"bar","data":12}'
+	foo_dec := json.decode(Foo[int], foo_enc)!
+	assert foo_dec.name == 'bar'
+	assert foo_dec.data == 12
+}
+
+fn test_errors() {
+	invalid_array := fn () {
+		data := '{"countries":[{"cities":[{"name":"London"},{"name":"Manchester"}],"name":"UK"},{"cities":{"name":"Donlon"},"name":"KU"}],"users":{"Foo":{"age":10,"nums":[1,2,3],"lastName":"Johnson","IsRegistered":true,"type":0,"pet_animals":"little foo"},"Boo":{"age":20,"nums":[5,3,1],"lastName":"Smith","IsRegistered":false,"type":4,"pet_animals":"little boo"}},"extra":{"2":{"n1":2,"n2":4,"n3":8,"n4":16},"3":{"n1":3,"n2":9,"n3":27,"n4":81}}}'
+		json.decode(Data, data) or {
+			// println(err)
+			assert err.msg().starts_with('Json element is not an array:')
+			return
+		}
+		assert false
+	}
+	invalid_object := fn () {
+		data := '{"countries":[{"cities":[{"name":"London"},{"name":"Manchester"}],"name":"UK"},{"cities":[{"name":"Donlon"},{"name":"Termanches"}],"name":"KU"}],"users":[{"age":10,"nums":[1,2,3],"lastName":"Johnson","IsRegistered":true,"type":0,"pet_animals":"little foo"},{"age":20,"nums":[5,3,1],"lastName":"Smith","IsRegistered":false,"type":4,"pet_animals":"little boo"}],"extra":{"2":{"n1":2,"n2":4,"n3":8,"n4":16},"3":{"n1":3,"n2":9,"n3":27,"n4":81}}}'
+		json.decode(Data, data) or {
+			// println(err)
+			assert err.msg().starts_with('Json element is not an object:')
+			return
+		}
+		assert false
+	}
+	invalid_array()
+	invalid_object()
+}
+
+type ID = string
+type GG = int
+
+struct Message {
+	id ID
+	ij GG
+}
+
+fn test_decode_alias_struct() {
+	msg := json.decode(Message, '{"id": "118499178790780929"}')!
+	// hacky way of comparing aliased strings
+	assert msg.id.str() == '118499178790780929'
+	assert msg.ij.str() == '0'
+}
+
+fn test_encode_alias_struct() {
+	expected := '{"id":"118499178790780929","ij":999998888}'
+	msg := Message{'118499178790780929', 999998888}
+	out := json.encode(msg)
+	assert out == expected
+}
+
+struct List {
+	id    int
+	items []string
+}
+
+fn test_list() {
+	list := json.decode(List, '{"id": 1, "items": ["1", "2"]}')!
+	assert list.id == 1
+	assert list.items == ['1', '2']
+}
+
+fn test_list_no_id() {
+	list := json.decode(List, '{"items": ["1", "2"]}')!
+	assert list.id == 0
+	assert list.items == ['1', '2']
+}
+
+fn test_list_no_items() {
+	list := json.decode(List, '{"id": 1}')!
+	assert list.id == 1
+	assert list.items == []
+}
+
+struct Info {
+	id    int
+	items []string
+	maps  map[string]string
+}
+
+fn test_decode_null_object() {
+	info := json.decode(Info, '{"id": 22, "items": null, "maps": null}')!
+	assert info.id == 22
+	assert '${info.items}' == '[]'
+	assert '${info.maps}' == '{}'
+}
+
+fn test_decode_missing_maps_field() {
+	info := json.decode(Info, '{"id": 22, "items": null}')!
+	assert info.id == 22
+	assert '${info.items}' == '[]'
+	assert '${info.maps}' == '{}'
+}
+
+struct Foo2 {
+	name string
+}
+
+fn test_pretty() {
+	foo := Foo2{'Bob'}
+	assert json.encode_pretty(foo) == '{
+	"name":	"Bob"
+}'
+}
+
+struct Foo3 {
+	name string
+	age  int @[omitempty]
+}
+
+fn test_omit_empty() {
+	foo := Foo3{'Bob', 0}
+	assert json.encode_pretty(foo) == '{
+	"name":	"Bob"
+}'
+	// println('omitempty:')
+	// println(json.encode_pretty(foo))
+}
+
+fn test_encode_struct_expression() {
+	assert json.encode(Foo2{'Foo'}) == '{"name":"Foo"}'
+	assert json.encode_pretty(Foo2{'Bar'}) == '{
+	"name":	"Bar"
+}'
+}
+
+struct Asdasd {
+	data GamePacketData
+}
+
+type GamePacketData = GPEquipItem | GPScale
+
+struct GPScale {
+	value f32
+}
+
+struct GPEquipItem {
+	name string
+}
+
+fn create_game_packet(data &GamePacketData) string {
+	return json.encode(data)
+}
+
+fn test_encode_sumtype_defined_ahead() {
+	ret := create_game_packet(&GamePacketData(GPScale{}))
+	// println(ret)
+	assert ret == '{"value":0,"_type":"GPScale"}'
+}
+
+struct StByteArray {
+	ba []u8
+}
+
+fn test_byte_array() {
+	assert json.encode(StByteArray{ ba: [u8(1), 2, 3, 4, 5] }) == '{"ba":[1,2,3,4,5]}'
+}
+
+struct Aa {
+	sub AliasType
+}
+
+struct Bb {
+	a int
+}
+
+type AliasType = Bb
+
+fn test_encode_alias_field() {
+	s := json.encode(Aa{
+		sub: Bb{
+			a: 1
+		}
+	})
+	assert s == '{"sub":{"a":1}}'
+}
+
+struct APrice {}
+
+struct Association {
+	association &Association = unsafe { nil }
+	price       APrice
+}
+
+fn test_encoding_struct_with_pointers() {
+	value := Association{
+		association: &Association{
+			price: APrice{}
+		}
+		price:       APrice{}
+	}
+	assert json.encode(value) == '{"association":{"price":{}},"price":{}}'
+}
+
+struct ChildNullish {
+	name string
+}
+
+struct NullishStruct {
+	name     string
+	lastname string
+	age      int
+	salary   f32
+	child    ChildNullish
+}
+
+struct RequiredStruct {
+	name     string @[required]
+	lastname string
+}
+
+fn test_required() {
+	nullish_one := json.decode(NullishStruct,
+		'{"name":"Peter", "lastname":null, "age":28,"salary":95000.5,"title":"worker"}')!
+	assert nullish_one.name == 'Peter'
+	assert nullish_one.lastname == ''
+	assert nullish_one.age == 28
+	assert nullish_one.salary == 95000.5
+	assert nullish_one.child.name == ''
+
+	nullish_two := json.decode(NullishStruct,
+		'{"name":"Peter", "lastname": "Parker", "age":28,"salary":95000.5,"title":"worker"}')!
+	assert nullish_two.name == 'Peter'
+	assert nullish_two.lastname == 'Parker'
+	assert nullish_two.age == 28
+	assert nullish_two.salary == 95000.5
+	assert nullish_two.child.name == ''
+
+	nullish_third := json.decode(NullishStruct,
+		'{"name":"Peter", "age":28,"salary":95000.5,"title":"worker", "child": {"name":"Nullish"}}')!
+	assert nullish_third.name == 'Peter'
+	assert nullish_third.lastname == ''
+	assert nullish_third.age == 28
+	assert nullish_third.salary == 95000.5
+	assert nullish_third.child.name == 'Nullish'
+
+	required_struct := json.decode(RequiredStruct, '{"name":"Peter", "lastname": "Parker"}')!
+	assert required_struct.name == 'Peter'
+	assert required_struct.lastname == 'Parker'
+
+	required_struct_err := json.decode(RequiredStruct, '{"name": null, "lastname": "Parker"}') or {
+		assert err.msg() == "type mismatch for field 'name', expecting `string` type, got: null"
+		RequiredStruct{
+			name:     'Peter'
+			lastname: 'Parker'
+		}
+	}
+}