BasicStringSerializerTests.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using NUnit.Framework;
#if !IOS
using System.ComponentModel.DataAnnotations;
using Northwind.Common.ComplexModel;
using ServiceStack.Common.Tests.Models;
#endif
using ServiceStack.Text.Common;

namespace ServiceStack.Text.Tests
{
    [TestFixture]
    public class BasicStringSerializerTests
    {
        readonly char[] allCharsUsed = new[] {
            JsWriter.QuoteChar, JsWriter.ItemSeperator,
            JsWriter.MapStartChar, JsWriter.MapKeySeperator, JsWriter.MapEndChar,
            JsWriter.ListEndChar, JsWriter.ListEndChar,
        };

        readonly string fieldWithInvalidChars = string.Format("all {0} {1} {2} {3} {4} {5} {6} invalid chars",
            JsWriter.QuoteChar, JsWriter.ItemSeperator,
            JsWriter.MapStartChar, JsWriter.MapKeySeperator, JsWriter.MapEndChar,
            JsWriter.ListEndChar, JsWriter.ListEndChar);

        readonly int[] intValues = new[] { 1, 2, 3, 4, 5 };
        readonly double[] doubleValues = new[] { 1.0d, 2.0d, 3.0d, 4.0d, 5.0d };
        readonly string[] stringValues = new[] { "One", "Two", "Three", "Four", "Five" };
        readonly string[] stringValuesWithIllegalChar = new[] { "One", ",", "Three", "Four", "Five" };

        public enum TestEnum
        {
            EnumValue1,
            EnumValue2,
        }

        [Flags]
        public enum UnsignedFlags : uint
        {
            EnumValue1 = 0,
            EnumValue2 = 1,
        }

        [Test]
        public void Can_convert_comma_delimited_string_to_List_String()
        {
            Assert.That(TypeSerializer.CanCreateFromString(typeof(List<string>)), Is.True);

            var stringValueList = "[" + string.Join(",", stringValues) + "]";

            var convertedJsvValues = TypeSerializer.DeserializeFromString<List<string>>(stringValueList);
            Assert.That(convertedJsvValues, Is.EquivalentTo(stringValues));

            var convertedJsonValues = JsonSerializer.DeserializeFromString<List<string>>(stringValueList);
            Assert.That(convertedJsonValues, Is.EquivalentTo(stringValues));
        }

        [Test]
        public void Null_or_Empty_string_returns_null()
        {
            var convertedJsvValues = TypeSerializer.DeserializeFromString<List<string>>(null);
            Assert.That(convertedJsvValues, Is.EqualTo(null));

            convertedJsvValues = TypeSerializer.DeserializeFromString<List<string>>(string.Empty);
            Assert.That(convertedJsvValues, Is.EqualTo(null));
        }

        [Test]
        public void Empty_list_string_returns_empty_List()
        {
            var convertedStringValues = TypeSerializer.DeserializeFromString<List<string>>("[]");
            Assert.That(convertedStringValues, Is.EqualTo(new List<string>()));
        }

        [Test]
        public void Null_or_Empty_string_returns_null_Map()
        {
            var convertedStringValues = TypeSerializer.DeserializeFromString<Dictionary<string, string>>(null);
            Assert.That(convertedStringValues, Is.EqualTo(null));

            convertedStringValues = TypeSerializer.DeserializeFromString<Dictionary<string, string>>(string.Empty);
            Assert.That(convertedStringValues, Is.EqualTo(null));
        }

        [Test]
        public void Empty_map_string_returns_empty_List()
        {
            var convertedStringValues = TypeSerializer.DeserializeFromString<Dictionary<string, string>>("{}");
            Assert.That(convertedStringValues, Is.EqualTo(new Dictionary<string, string>()));
        }

        [Test]
        public void Can_convert_string_collection()
        {
            Assert.That(TypeSerializer.CanCreateFromString(typeof(string[])), Is.True);

            var stringValue = TypeSerializer.SerializeToString(stringValues);
            var expectedString = "[" + string.Join(",", stringValues.ToArray()) + "]";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_enum()
        {
            var enumValue = TestEnum.EnumValue1;
            var stringValue = TypeSerializer.SerializeToString(enumValue);
            var expectedString = TestEnum.EnumValue1.ToString();
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_nullable_enum()
        {
            TestEnum? enumValue = TestEnum.EnumValue1;
            var stringValue = TypeSerializer.SerializeToString(enumValue);
            var expectedString = TestEnum.EnumValue1.ToString();
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_to_nullable_enum()
        {
            Assert.That(TypeSerializer.CanCreateFromString(typeof(TestEnum?)), Is.True);

            TestEnum? enumValue = TestEnum.EnumValue1;
            var actualValue = TypeSerializer.DeserializeFromString<TestEnum?>(enumValue.ToString());
            Assert.That(actualValue, Is.EqualTo(enumValue));
        }

        [Test]
        public void Can_convert_to_nullable_enum_with_null_value()
        {
            var enumValue = TypeSerializer.DeserializeFromString<TestEnum?>(null);
            Assert.That(enumValue, Is.Null);
        }

        [Test]
        public void Can_convert_nullable_enum_with_null_value()
        {
            TestEnum? enumValue = null;
            var stringValue = TypeSerializer.SerializeToString(enumValue);
            Assert.That(stringValue, Is.Null);
        }

        [Test]
        public void Can_convert_unsigned_flags_enum()
        {
            var enumValue = UnsignedFlags.EnumValue1;
            var stringValue = TypeSerializer.SerializeToString(enumValue);
            var expectedString = UnsignedFlags.EnumValue1.ToString("D");
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_Guid()
        {
            Assert.That(TypeSerializer.CanCreateFromString(typeof(Guid)), Is.True);

            var guidValue = Guid.NewGuid();
            var stringValue = TypeSerializer.SerializeToString(guidValue);
            var expectedString = guidValue.ToString("N");
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_datetime()
        {
            var dateValue = new DateTime(1979, 5, 9);
            var stringValue = TypeSerializer.SerializeToString(dateValue);
            var expectedString = "1979-05-09";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_to_datetime()
        {
            Assert.That(TypeSerializer.CanCreateFromString(typeof(DateTime)), Is.True);

            var dateValue = new DateTime(1979, 5, 9);
            var actualValue = TypeSerializer.DeserializeFromString<DateTime>("1979-05-09");
            Assert.That(actualValue, Is.EqualTo(dateValue));
        }

        [Test]
        public void Can_convert_nullable_datetime()
        {
            DateTime? dateValue = new DateTime(1979, 5, 9);
            var stringValue = TypeSerializer.SerializeToString(dateValue);
            var expectedString = "1979-05-09";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_to_nullable_datetime()
        {
            Assert.That(TypeSerializer.CanCreateFromString(typeof(DateTime?)), Is.True);

            DateTime? dateValue = new DateTime(1979, 5, 9);
            var actualValue = TypeSerializer.DeserializeFromString<DateTime?>("1979-05-09");
            Assert.That(actualValue, Is.EqualTo(dateValue));
        }

        [Test]
        public void Can_convert_string_List()
        {
            var stringValue = TypeSerializer.SerializeToString(stringValues.ToList());
            var expectedString = "[" + string.Join(",", stringValues.ToArray()) + "]";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_string_array()
        {
            var stringValue = TypeSerializer.SerializeToString(stringValues.ToArray());
            var expectedString = "[" + string.Join(",", stringValues.ToArray()) + "]";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_string_List_as_object()
        {
            var stringValue = TypeSerializer.SerializeToString((object)stringValues.ToList());
            var expectedString = "[" + string.Join(",", stringValues.ToArray()) + "]";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_empty_List()
        {
            var stringValue = TypeSerializer.SerializeToString(new List<string>());
            var expectedString = "[]";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_multidimensional_array()
        {
            var data = new double[,] { { 1, 0 }, { 0, 1 } };
            var result = TypeSerializer.SerializeToString(data);

            Assert.That(result, Is.EqualTo("[[1,0],[0,1]]"));

            var data2 = new double[,,] { { { 1, 0 }, { 1, 0 } }, { { 0, 1 }, { 0, 1 } } };
            result = TypeSerializer.SerializeToString(data2);

            Assert.That(result, Is.EqualTo("[[[1,0],[1,0]],[[0,1],[0,1]]]"));
        }

        [Test]
        public void Can_convert_empty_List_as_object()
        {
            var stringValue = TypeSerializer.SerializeToString((object)new List<string>());
            var expectedString = "[]";
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_string_dictionary()
        {
            var stringDictionary = new Dictionary<string, string>
                {
                    { "One", "1st" }, { "Two", "2nd" }, { "Three", "3rd" }
                };
            var expectedString = "{One:1st,Two:2nd,Three:3rd}";
            var stringValue = TypeSerializer.SerializeToString(stringDictionary);
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_parse_string_dictionary()
        {
            var stringDictionary = new Dictionary<string, string>
                {
                    { "One", "1st" }, { "Two", "2nd" }, { "Three", "3rd" }
                };
            const string mapValues = "{One:1st,Two:2nd,Three:3rd}";
            var parsedDictionary = TypeSerializer.DeserializeFromString(mapValues, stringDictionary.GetType());
            Assert.That(parsedDictionary, Is.EquivalentTo(stringDictionary));
        }

        [Test]
        public void Can_convert_string_dictionary_as_object()
        {
            var stringDictionary = new Dictionary<string, string> {
                                                                      { "One", "1st" }, { "Two", "2nd" }, { "Three", "3rd" }
                                                                  };
            var expectedString = "{One:1st,Two:2nd,Three:3rd}";
            var stringValue = TypeSerializer.SerializeToString((object)stringDictionary);
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_string_dictionary_with_special_chars_as_object()
        {
            var stringDictionary = new Dictionary<string, string>
                {
                    { "One", "\"1st" }, { "Two", "2:nd" }, { "Three", "3r,d" }, { "Four", "four%" }
                };
            var expectedString = "{One:\"\"\"1st\",Two:\"2:nd\",Three:\"3r,d\",Four:four%}";
            var stringValue = TypeSerializer.SerializeToString(stringDictionary);
            Assert.That(stringValue, Is.EqualTo(expectedString));

            Serialize(stringDictionary);
        }

        [Test]
        public void Can_parse_string_dictionary_with_special_chars_as_object()
        {
            var stringDictionary = new Dictionary<string, string>
                {
                    { "One", "\"1st" }, { "Two", "2:nd" }, { "Three", "3r,d" }
                };
            const string mapValues = "{One:\"\"\"1st\",Two:2:nd,Three:\"3r,d\"}";
            var parsedDictionary = TypeSerializer.DeserializeFromString(mapValues, stringDictionary.GetType());
            Assert.That(parsedDictionary, Is.EquivalentTo(stringDictionary));

            Serialize(stringDictionary);
        }

        [Test]
        public void Can_convert_string_list_with_special_chars_as_object()
        {
            var stringList = new List<string>
                {
                    "\"1st", "2:nd", "3r,d", "four%"
                };
            var expectedString = "[\"\"\"1st\",\"2:nd\",\"3r,d\",four%]";
            var stringValue = TypeSerializer.SerializeToString(stringList);
            Assert.That(stringValue, Is.EqualTo(expectedString));

            Serialize(stringList);
        }

        [Test]
        public void Can_parse_string_list_with_special_chars_as_object()
        {
            var stringList = new List<string>
                {
                    "\"1st", "2:nd", "3r,d", "four%"
                };
            const string listValues = "[\"\"\"1st\",2:nd,\"3r,d\",four%]";
            var parsedList = TypeSerializer.DeserializeFromString(listValues, stringList.GetType());
            Assert.That(parsedList, Is.EquivalentTo(stringList));

            Serialize(stringList);
        }

        [Test]
        public void Can_convert_Byte_array_with_JsonSerializer()
        {
            var byteArrayValue = new byte[] { 0, 65, 97, 255, };
            var stringValue = JsonSerializer.SerializeToString(byteArrayValue);
            var expectedString = Convert.ToBase64String(byteArrayValue);
            Assert.That(stringValue, Is.EqualTo('"' + expectedString + '"'));
        }

        [Test]
        public void Can_convert_Byte_array()
        {
            var byteArrayValue = new byte[] { 0, 65, 97, 255, };
            var stringValue = TypeSerializer.SerializeToString(byteArrayValue);
            var expectedString = Convert.ToBase64String(byteArrayValue);
            Assert.That(stringValue, Is.EqualTo(expectedString));
        }

        [Test]
        public void Can_convert_to_Byte_array()
        {
            Assert.That(TypeSerializer.CanCreateFromString(typeof(byte[])), Is.True);

            var byteArrayValue = new byte[] { 0, 65, 97, 255, };
            var byteArrayString = TypeSerializer.SerializeToString(byteArrayValue);
            var actualValue = TypeSerializer.DeserializeFromString<byte[]>(byteArrayString);
            Assert.That(actualValue, Is.EqualTo(byteArrayValue));
        }


        public T Serialize<T>(T model)
        {
            var jsvModel = TypeSerializer.SerializeToString(model);
            Console.WriteLine("Len: " + jsvModel.Length + ", " + jsvModel);
            var fromJsvModel = TypeSerializer.DeserializeFromString<T>(jsvModel);

            var jsonModel = JsonSerializer.SerializeToString(model);
            Console.WriteLine("Len: " + jsonModel.Length + ", " + jsonModel);
            var fromJsonModel = JsonSerializer.DeserializeFromString<T>(jsonModel);

            return fromJsonModel;
        }

#if !IOS
        public class TestClass
        {
            [Required]
            public string Member1 { get; set; }

            public string Member2 { get; set; }

            [Required]
            public string Member3 { get; set; }

            [StringLength(1)]
            public string Member4 { get; set; }
        }

        [Test]
        public void Can_convert_string_to_List()
        {
            var fromHashSet = stringValues;
            var toHashSet = Serialize(fromHashSet);

            Assert.That(toHashSet.EquivalentTo(fromHashSet), Is.True);
        }

        [Test]
        public void Can_convert_string_to_string_HashSet()
        {
            var fromHashSet = new HashSet<string>(stringValues);
            var toHashSet = Serialize(fromHashSet);

            Assert.That(toHashSet.EquivalentTo(fromHashSet), Is.True);
        }

        [Test]
        public void Can_convert_string_to_int_HashSet()
        {
            var fromHashSet = new HashSet<int>(intValues);
            var toHashSet = Serialize(fromHashSet);

            Assert.That(toHashSet.EquivalentTo(fromHashSet), Is.True);
        }

        [Test]
        public void Can_convert_string_to_double_HashSet()
        {
            var fromHashSet = new HashSet<double>(doubleValues);
            var toHashSet = Serialize(fromHashSet);

            Assert.That(toHashSet.EquivalentTo(fromHashSet), Is.True);
        }

        [Test]
        public void Can_convert_string_to_string_ReadOnlyCollection()
        {
            var fromCollection = new ReadOnlyCollection<string>(stringValues);
            var toCollection = Serialize(fromCollection);

            Assert.That(toCollection.EquivalentTo(fromCollection), Is.True);
        }

        [Test]
        public void Can_convert_string_to_int_ReadOnlyCollection()
        {
            var fromCollection = new ReadOnlyCollection<int>(intValues);
            var toCollection = Serialize(fromCollection);

            Assert.That(toCollection.EquivalentTo(fromCollection), Is.True);
        }

        [Test]
        public void Can_convert_string_to_double_ReadOnlyCollection()
        {
            var fromCollection = new ReadOnlyCollection<double>(doubleValues);
            var toCollection = Serialize(fromCollection);

            Assert.That(toCollection.EquivalentTo(fromCollection), Is.True);
        }

        [Test]
        public void Can_convert_ModelWithFieldsOfDifferentTypes()
        {
            var model = ModelWithFieldsOfDifferentTypes.Create(1);
            var toModel = Serialize(model);

            ModelWithFieldsOfDifferentTypes.AssertIsEqual(toModel, model);
        }

        [Test]
        public void Can_convert_ModelWithFieldsOfNullableTypes()
        {
            var model = ModelWithFieldsOfNullableTypes.Create(1);
            var toModel = Serialize(model);

            ModelWithFieldsOfNullableTypes.AssertIsEqual(toModel, model);
        }

        [Test]
        public void Can_convert_ModelWithFieldsOfNullableTypes_of_nullables()
        {
            var model = new ModelWithFieldsOfNullableTypes();
            var toModel = Serialize(model);

            ModelWithFieldsOfNullableTypes.AssertIsEqual(toModel, model);
        }

        [Ignore("Causing infinite recursion in TypeToString")]
        [Test]
        public void Can_convert_ModelWithComplexTypes()
        {
            var model = ModelWithComplexTypes.Create(1);
            var toModel = Serialize(model);

            ModelWithComplexTypes.AssertIsEqual(toModel, model);
        }

        [Test]
        public void Can_convert_model_with_TypeChar()
        {
            var model = new ModelWithIdAndName { Id = 1, Name = "in } valid" };
            var toModel = Serialize(model);

            ModelWithIdAndName.AssertIsEqual(toModel, model);
        }

        [Test]
        public void Can_convert_model_with_ListChar()
        {
            var model = new ModelWithIdAndName { Id = 1, Name = "in [ valid" };
            var toModel = Serialize(model);
            ModelWithIdAndName.AssertIsEqual(toModel, model);

            var model2 = new ModelWithIdAndName { Id = 1, Name = "in valid]" };
            var toModel2 = Serialize(model2);
            ModelWithIdAndName.AssertIsEqual(toModel2, model2);
        }

        [Test]
        public void Can_convert_ModelWithMapAndList_with_ListChar()
        {
            var model = new ModelWithMapAndList<ModelWithIdAndName>
            {
                Id = 1,
                Name = "in [ valid",
                List = new List<ModelWithIdAndName> {
                    new ModelWithIdAndName{Id = 1, Name = "field [in valid] has stuff"},
                    new ModelWithIdAndName{Id = 1, Name = "field [in valid] has stuff"},
                },
            };
            var toModel = Serialize(model);
            //ModelWithMapAndList.AssertIsEqual(toModel, model);
        }

        [Test]
        public void Can_convert_ArrayDtoWithOrders()
        {
            var model = DtoFactory.ArrayDtoWithOrders;
            var toModel = Serialize(model);

            Assert.That(model.Equals(toModel), Is.True);
        }

        [Test]
        public void Can_convert_Field_Map_or_List_with_invalid_chars()
        {
            var instance = new ModelWithMapAndList<string>
            {
                Id = 1,
                Name = fieldWithInvalidChars,
                List = new List<string> { fieldWithInvalidChars, fieldWithInvalidChars },
                Map = new Dictionary<string, string> { { fieldWithInvalidChars, fieldWithInvalidChars } },
            };

            Serialize(instance);
        }

        [Test]
        public void Can_convert_Field_Map_or_List_with_single_invalid_char()
        {
            foreach (var invalidChar in allCharsUsed)
            {
                var singleInvalidChar = string.Format("a {0} b", invalidChar);

                var instance = new ModelWithMapAndList<string>
                {
                    Id = 1,
                    Name = singleInvalidChar,
                    List = new List<string> { singleInvalidChar, singleInvalidChar },
                    Map = new Dictionary<string, string> { { singleInvalidChar, singleInvalidChar } },
                };

                Serialize(instance);
            }
        }

        [Test]
        public void Can_convert_CustomerDto()
        {
            var model = DtoFactory.CustomerDto;
            var toModel = Serialize(model);

            Assert.That(model.Equals(toModel), Is.True);
        }

        [Test]
        public void Can_convert_CustomerOrderListDto()
        {
            var model = DtoFactory.CustomerOrderListDto;
            var toModel = Serialize(model);

            Assert.That(model.Equals(toModel), Is.True);
        }

        [Test]
        public void Can_convert_List_Guid()
        {
            var model = new List<Guid> {
                Guid.NewGuid(),
                Guid.NewGuid(),
                Guid.NewGuid(),
            };

            var toModel = Serialize(model);

            Assert.That(toModel, Is.EquivalentTo(model));
        }
#endif
    }
}