JsonHelpersTests.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using Bleroy;

namespace Bleroy.Tests
{
    [TestClass]
    public class JsonHelpersTests
    {
        const string Json = @"{
    foo: ""fou"",
    bar: ""barre"",
    obj: {
        baz: ""base"",
        arr: [1, 4, 8]
    },
    after: ""apres"",
    number: 42,
    end: ""fin""
}";

        [TestMethod]
        public void CanAdvanceToPropertyName()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            var found = reader.AdvanceTo("bar");

            Assert.IsTrue(found);
            Assert.AreEqual("barre", reader.Value);
        }

        [TestMethod]
        public void CanAdvanceToDeepPropertyName()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            var found = reader.AdvanceTo("baz");

            Assert.IsTrue(found);
            Assert.AreEqual("base", reader.Value);
        }

        [TestMethod]
        public void ReadsTheWholeDocumentIfAdvanceToDoesntFindTheNode()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            var found = reader.AdvanceTo("bat");

            Assert.IsFalse(found);
            Assert.AreEqual(JsonToken.None, reader.TokenType);
        }

        [TestMethod]
        public void CanAdvanceToChildPropertyName()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("obj");
            var found = reader.AdvanceTo("baz");

            Assert.IsTrue(found);
            Assert.AreEqual("base", reader.Value);
        }

        [TestMethod]
        public void IfChildPropertyDoesntExistAdvanceToSkipsTheCurrentNode()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("obj");
            var found = reader.AdvanceTo("end");

            Assert.IsFalse(found);
            Assert.AreEqual("after", reader.Value);
        }

        [TestMethod]
        public void CanAdvanceToNodeType()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            var found = reader.AdvanceTo(JsonToken.String);

            Assert.IsTrue(found);
            Assert.AreEqual("fou", reader.Value);
        }

        [TestMethod]
        public void CanAdvanceToDeepNodeType()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            var found = reader.AdvanceTo(JsonToken.Integer);

            Assert.IsTrue(found);
            Assert.AreEqual(1L, reader.Value);
        }

        [TestMethod]
        public void ReadsTheWholeDocumentIfAdvanceToDoesntFindTheNodeType()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            var found = reader.AdvanceTo(JsonToken.Date);

            Assert.IsFalse(found);
            Assert.AreEqual(JsonToken.None, reader.TokenType);
        }

        [TestMethod]
        public void CanAdvanceToChildNodeType()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("obj");
            var found = reader.AdvanceTo(JsonToken.String);

            Assert.IsTrue(found);
            Assert.AreEqual("base", reader.Value);
        }

        [TestMethod]
        public void IfChildNodeTypeIsntFoundAdvanceToSkipsTheCurrentNode()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("obj");
            var found = reader.AdvanceTo(JsonToken.Date);

            Assert.IsFalse(found);
            Assert.AreEqual("after", reader.Value);
        }

        [TestMethod]
        public void CanEnumerateObjects()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("obj");
            var results = new List<Tuple<string, JsonToken>>();

            foreach(var propertyName in reader.Children())
            {
                results.Add(new Tuple<string, JsonToken>(propertyName, reader.TokenType));
            }
            Assert.AreEqual(JsonToken.EndObject, reader.TokenType);
            Assert.AreEqual(2, results.Count);
            Assert.AreEqual("baz", results[0].Item1);
            Assert.AreEqual(JsonToken.String, results[0].Item2);
            Assert.AreEqual("arr", results[1].Item1);
            Assert.AreEqual(JsonToken.StartArray, results[1].Item2);
        }

        [TestMethod]
        public void CanEnumerateArrays()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("arr");
            var results = new List<Tuple<string, long>>();

            foreach (var propertyName in reader.Children())
            {
                results.Add(new Tuple<string, long>(propertyName, (long)reader.Value));
            }
            Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
            Assert.AreEqual(3, results.Count);
            Assert.AreEqual(null, results[0].Item1);
            Assert.AreEqual(1L, results[0].Item2);
            Assert.AreEqual(null, results[1].Item1);
            Assert.AreEqual(4L, results[1].Item2);
            Assert.AreEqual(null, results[2].Item1);
            Assert.AreEqual(8L, results[2].Item2);
        }

        [TestMethod]
        public void EnumeratingAStringJustSkipsIt()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("foo");

            foreach(var propertyName in reader.Children())
            {
                Assert.Fail("This should never happen.");
            }
            Assert.AreEqual("bar", reader.Value);
        }

        [TestMethod]
        public void CanReadWholeDocuments()
        {
            var reader = new JsonTextReader(new StringReader(Json));
            reader.AdvanceTo("foo");
            Assert.AreEqual("fou", reader.Value);
            reader.AdvanceTo("bar");
            Assert.AreEqual("barre", reader.Value);
            reader.AdvanceTo("obj");
            var enumerator = reader.Children().GetEnumerator();
            enumerator.MoveNext();
            Assert.AreEqual("baz", enumerator.Current);
            Assert.AreEqual("base", reader.Value);
            enumerator.MoveNext();
            Assert.AreEqual("arr", enumerator.Current);
            var arrayValues = new List<long>();
            foreach(var shouldBeNull in reader.Children())
            {
                Assert.IsNull(shouldBeNull);
                arrayValues.Add((long)reader.Value);
            }
            Assert.AreEqual(1, arrayValues[0]);
            Assert.AreEqual(4, arrayValues[1]);
            Assert.AreEqual(8, arrayValues[2]);
            Assert.IsFalse(enumerator.MoveNext());
            reader.AdvanceTo("after");
            Assert.AreEqual("apres", reader.Value);
            reader.AdvanceTo("number");
            Assert.AreEqual(42L, reader.Value);
            reader.AdvanceTo("end");
            Assert.AreEqual("fin", reader.Value);
        }
    }
}