// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
|
// for details. All rights reserved. Use of this source code is governed by a
|
// BSD-style license that can be found in the LICENSE file.
|
|
import 'package:json_annotation/json_annotation.dart';
|
import 'package:test/test.dart';
|
import 'package:yaml/yaml.dart';
|
|
import '../test_utils.dart';
|
import 'kitchen_sink.dart' as nullable
|
show testFactory, testFromJson, JsonConverterTestClass;
|
import 'kitchen_sink.non_nullable.checked.dart' as checked
|
show testFactory, testFromJson;
|
import 'kitchen_sink.non_nullable.dart' as nn
|
show testFactory, testFromJson, JsonConverterTestClass;
|
import 'kitchen_sink.non_nullable.wrapped.dart' as nnwrapped
|
show testFactory, testFromJson;
|
import 'kitchen_sink.wrapped.dart' as wrapped show testFactory, testFromJson;
|
import 'kitchen_sink_interface.dart';
|
import 'strict_keys_object.dart';
|
|
// copied and renamed as private from /lib/src/constants.dart
|
const _generatedLocalVarName = 'val';
|
const _toJsonMapHelperName = 'writeNotNull';
|
|
final _isATypeError = const TypeMatcher<TypeError>();
|
|
Matcher _isAUnrecognizedKeysEexception(expectedMessage) =>
|
const TypeMatcher<UnrecognizedKeysException>()
|
.having((e) => e.message, 'message', expectedMessage);
|
|
Matcher _isMissingKeyException(expectedMessage) =>
|
const TypeMatcher<MissingRequiredKeysException>()
|
.having((e) => e.message, 'message', expectedMessage);
|
|
void main() {
|
test('valid values covers all keys', () {
|
expect(_invalidValueTypes.keys, orderedEquals(_validValues.keys));
|
});
|
|
test('required keys', () {
|
expect(
|
() => StrictKeysObject.fromJson({}),
|
throwsA(_isMissingKeyException(
|
'Required keys are missing: value, custom_field.')));
|
});
|
|
group('nullable', () {
|
group('unwrapped', () {
|
_nullableTests(nullable.testFactory, nullable.testFromJson);
|
});
|
|
group('wrapped', () {
|
_nullableTests(wrapped.testFactory, wrapped.testFromJson);
|
});
|
});
|
|
group('non-nullable', () {
|
group('checked', () {
|
_nonNullableTests(checked.testFactory, checked.testFromJson,
|
isChecked: true);
|
});
|
|
group('unwrapped', () {
|
_nonNullableTests(nn.testFactory, nn.testFromJson);
|
});
|
|
group('wrapped', () {
|
_nonNullableTests(nnwrapped.testFactory, nnwrapped.testFromJson);
|
});
|
});
|
|
group('JsonConverterTestClass', () {
|
final validValues = {
|
'duration': 5,
|
'durationList': [5],
|
'bigInt': '5',
|
'bigIntMap': {'vaule': '5'},
|
'numberSilly': 5,
|
'numberSillySet': [5],
|
'dateTime': 5
|
};
|
|
test('nullable values are allowed in the nullable version', () {
|
final instance = nullable.JsonConverterTestClass();
|
final json = instance.toJson();
|
expect(json.values, everyElement(isNull));
|
expect(json.keys, unorderedEquals(validValues.keys));
|
|
final instance2 = nullable.JsonConverterTestClass.fromJson(json);
|
expect(instance2.toJson(), json);
|
});
|
|
test('nullable values are not allowed in non-nullable version', () {
|
var instance = nn.JsonConverterTestClass();
|
expect(() => instance.toJson(), throwsNoSuchMethodError,
|
reason: 'Trying to call `map` on a null list');
|
|
instance = nn.JsonConverterTestClass.fromJson(validValues);
|
final json = instance.toJson();
|
expect(json, validValues);
|
expect(json.values, everyElement(isNotNull));
|
|
final instance2 = nn.JsonConverterTestClass.fromJson(json);
|
expect(instance2.toJson(), json);
|
});
|
});
|
}
|
|
typedef KitchenSink KitchenSinkCtor(
|
{int ctorValidatedNo42,
|
Iterable iterable,
|
Iterable<dynamic> dynamicIterable,
|
Iterable<Object> objectIterable,
|
Iterable<int> intIterable,
|
Iterable<DateTime> dateTimeIterable});
|
|
void _nonNullableTests(KitchenSinkCtor ctor, KitchenSink fromJson(Map json),
|
{bool isChecked = false}) {
|
test('with null values fails serialization', () {
|
expect(() => (ctor()..objectDateTimeMap = null).toJson(),
|
throwsNoSuchMethodError);
|
});
|
|
test('with empty json fails deserialization', () {
|
if (isChecked) {
|
expect(() => fromJson({}), throwsA(_checkedMatcher('intIterable')));
|
} else {
|
expect(() => fromJson({}), throwsNoSuchMethodError);
|
}
|
});
|
_sharedTests(ctor, fromJson, isChecked: isChecked);
|
}
|
|
void _nullableTests(KitchenSinkCtor ctor, KitchenSink fromJson(Map json)) {
|
void roundTripItem(KitchenSink p) {
|
roundTripObject(p, (json) => fromJson(json));
|
}
|
|
test('Fields with `!includeIfNull` should not be included when null', () {
|
final item = ctor();
|
|
final expectedDefaultKeys = _validValues.keys.toSet()
|
..removeAll(_excludeIfNullKeys);
|
|
final encoded = item.toJson();
|
|
expect(encoded.keys, orderedEquals(expectedDefaultKeys));
|
|
for (final key in expectedDefaultKeys) {
|
expect(encoded, containsPair(key, isNull));
|
}
|
});
|
|
test('list and map of DateTime', () {
|
final now = DateTime.now();
|
final item = ctor(dateTimeIterable: <DateTime>[now])
|
..dateTimeList = <DateTime>[now, null]
|
..objectDateTimeMap = <Object, DateTime>{'value': now, 'null': null};
|
|
roundTripItem(item);
|
});
|
|
test('complex nested type', () {
|
final item = ctor()
|
..crazyComplex = [
|
null,
|
{},
|
{
|
'null': null,
|
'empty': {},
|
'items': {
|
'null': null,
|
'empty': [],
|
'items': [
|
null,
|
[],
|
[DateTime.now()]
|
]
|
}
|
}
|
];
|
roundTripItem(item);
|
});
|
|
_sharedTests(ctor, fromJson);
|
}
|
|
void _sharedTests(KitchenSinkCtor ctor, KitchenSink fromJson(Map json),
|
{bool isChecked = false}) {
|
void roundTripSink(KitchenSink p) {
|
roundTripObject(p, fromJson);
|
}
|
|
test('empty', () {
|
final item = ctor();
|
roundTripSink(item);
|
});
|
|
test('list and map of DateTime - not null', () {
|
final now = DateTime.now();
|
final item = ctor(dateTimeIterable: <DateTime>[now])
|
..dateTimeList = <DateTime>[now, now]
|
..objectDateTimeMap = <Object, DateTime>{'value': now};
|
|
roundTripSink(item);
|
});
|
|
test('complex nested type - not null', () {
|
final item = ctor()
|
..crazyComplex = [
|
{},
|
{
|
'empty': {},
|
'items': {
|
'empty': [],
|
'items': [
|
[],
|
[DateTime.now()]
|
]
|
}
|
}
|
];
|
roundTripSink(item);
|
});
|
|
test('JSON keys should be defined in field/property order', () {
|
/// Explicitly setting values from [_excludeIfNullKeys] to ensure
|
/// they exist for KitchenSink where they are excluded when null
|
final item = ctor(iterable: [])
|
..dateTime = DateTime.now()
|
..dateTimeList = []
|
..crazyComplex = []
|
..val = {};
|
|
final json = item.toJson();
|
expect(json.keys, orderedEquals(_validValues.keys));
|
});
|
|
test('valid values round-trip - json', () {
|
expect(loudEncode(_validValues), loudEncode(fromJson(_validValues)));
|
});
|
|
test('valid values round-trip - yaml', () {
|
final jsonEncoded = loudEncode(_validValues);
|
final yaml = loadYaml(jsonEncoded, sourceUrl: 'input.yaml');
|
expect(jsonEncoded, loudEncode(fromJson(yaml as YamlMap)));
|
});
|
|
group('a bad value for', () {
|
for (final e in _invalidValueTypes.entries) {
|
_testBadValue(isChecked, e.key, e.value, fromJson, false);
|
}
|
for (final e in _invalidCheckedValues.entries) {
|
_testBadValue(isChecked, e.key, e.value, fromJson, true);
|
}
|
});
|
}
|
|
void _testBadValue(bool isChecked, String key, Object badValue,
|
KitchenSink fromJson(Map json), bool checkedAssignment) {
|
final matcher = _getMatcher(isChecked, key, checkedAssignment);
|
|
for (final isJson in [true, false]) {
|
test('`$key` fails with value `$badValue`- ${isJson ? 'json' : 'yaml'}',
|
() {
|
var copy = Map.from(_validValues);
|
copy[key] = badValue;
|
|
if (!isJson) {
|
copy = loadYaml(loudEncode(copy)) as YamlMap;
|
}
|
|
expect(() => fromJson(copy), matcher);
|
});
|
}
|
}
|
|
Matcher _checkedMatcher(String expectedKey) =>
|
const TypeMatcher<CheckedFromJsonException>()
|
.having((e) => e.className, 'className', 'KitchenSink')
|
.having((e) => e.key, 'key', expectedKey);
|
|
Matcher _getMatcher(bool checked, String expectedKey, bool checkedAssignment) {
|
Matcher innerMatcher;
|
|
if (checked) {
|
if (checkedAssignment &&
|
const ['intIterable', 'datetime-iterable'].contains(expectedKey)) {
|
expectedKey = null;
|
}
|
|
innerMatcher = _checkedMatcher(expectedKey);
|
} else {
|
innerMatcher = anyOf(
|
isCastError,
|
_isATypeError,
|
_isAUnrecognizedKeysEexception(
|
'Unrecognized keys: [invalid_key]; supported keys: [value, custom_field]'));
|
|
if (checkedAssignment) {
|
switch (expectedKey) {
|
case 'validatedPropertyNo42':
|
innerMatcher = isStateError;
|
break;
|
case 'no-42':
|
innerMatcher = isArgumentError;
|
break;
|
case 'strictKeysObject':
|
innerMatcher = _isAUnrecognizedKeysEexception('bob');
|
break;
|
case 'intIterable':
|
case 'datetime-iterable':
|
innerMatcher = isCastError;
|
break;
|
default:
|
throw StateError('Not expected! - $expectedKey');
|
}
|
}
|
}
|
|
return throwsA(innerMatcher);
|
}
|
|
final _validValues = const {
|
'no-42': 0,
|
'dateTime': '2018-05-10T14:20:58.927',
|
'iterable': [],
|
'dynamicIterable': [],
|
'objectIterable': [],
|
'intIterable': [],
|
'set': [],
|
'dynamicSet': [],
|
'objectSet': [],
|
'intSet': [],
|
'dateTimeSet': [],
|
'datetime-iterable': [],
|
'list': [],
|
'dynamicList': [],
|
'objectList': [],
|
'intList': [],
|
'dateTimeList': [],
|
'map': <String, dynamic>{},
|
'stringStringMap': {},
|
'dynamicIntMap': {},
|
'objectDateTimeMap': <String, dynamic>{},
|
'crazyComplex': [],
|
_generatedLocalVarName: {},
|
_toJsonMapHelperName: null,
|
r'$string': null,
|
'simpleObject': {'value': 42},
|
'strictKeysObject': {'value': 10, 'custom_field': 'cool'},
|
'validatedPropertyNo42': 0
|
};
|
|
final _invalidValueTypes = const {
|
'no-42': true,
|
'dateTime': true,
|
'iterable': true,
|
'dynamicIterable': true,
|
'objectIterable': true,
|
'intIterable': true,
|
'set': true,
|
'dynamicSet': true,
|
'objectSet': true,
|
'intSet': true,
|
'dateTimeSet': true,
|
'datetime-iterable': true,
|
'list': true,
|
'dynamicList': true,
|
'objectList': true,
|
'intList': [true],
|
'dateTimeList': [true],
|
'map': true,
|
'stringStringMap': {'key': 42},
|
'dynamicIntMap': {'key': 'value'},
|
'objectDateTimeMap': {'key': 42},
|
'crazyComplex': [true],
|
_generatedLocalVarName: {'key': 42},
|
_toJsonMapHelperName: 42,
|
r'$string': true,
|
'simpleObject': 42,
|
'strictKeysObject': {
|
'value': 10,
|
'invalid_key': true,
|
},
|
'validatedPropertyNo42': true
|
};
|
|
/// Invalid values that are found after the property set or ctor call
|
final _invalidCheckedValues = const {
|
'no-42': 42,
|
'validatedPropertyNo42': 42,
|
'intIterable': [true],
|
'datetime-iterable': [true],
|
};
|
|
final _excludeIfNullKeys = const [
|
'dateTime',
|
'iterable',
|
'dateTimeList',
|
'crazyComplex',
|
_generatedLocalVarName
|
];
|
