public void TestDiffFalseVsTrue()
{
var diffMessages = JsonStrings.Diff("false", "true");
var diffMessage = diffMessages.Single();
Assert.Equal("Boolean value mismatch at $.\nExpected true but was false.", diffMessage);
}
public void ShouldHaveCorrectErrorString()
{
var subjectUnderTest = new JsonProtocolWriterFormat();
Assert.That(subjectUnderTest.LogError("ERROR!!!!!!").TrimStuffForCompare(),
Is.EqualTo(JsonStrings.CommandErrorOut().TrimStuffForCompare()));
}
public void ShouldHaveCorrectLogString()
{
var subjectUnderTest = new JsonProtocolWriterFormat();
Assert.That(subjectUnderTest.LogInfo("hello world!").TrimStuffForCompare(),
Is.EqualTo(JsonStrings.CommandLogOut().TrimStuffForCompare()));
}
public void ShouldHaveCorrectAcknowledgeString()
{
var subjectUnderTest = new JsonProtocolWriterFormat();
Assert.That(subjectUnderTest.Acknowledge(1231231).TrimStuffForCompare(),
Is.EqualTo(JsonStrings.CommandAckOut().TrimStuffForCompare()));
}
public void TestDiffFalseVsNull()
{
var diffMessages = JsonStrings.Diff("false", "null");
var diffMessage = diffMessages.Single();
Assert.Equal("Kind mismatch at $.\nExpected null but was the boolean false.", diffMessage);
}
public void TestTypeDiff()
{
var str1 = "true";
var str2 = "\"true\"";
var diff1 = JsonStrings.Diff(str1, str2).Single();
Assert.True(diff1.IsTypeDiff);
Assert.False(diff1.IsValueDiff);
Assert.False(diff1.IsArrayDiff);
Assert.False(diff1.IsObjectDiff);
var diff2 = new TypeDiff(
new DiffPoint("$",
JsonTrue.Instance,
new JsonString("true")));
Assert.True(diff2.IsTypeDiff);
Assert.False(diff2.IsValueDiff);
Assert.False(diff2.IsArrayDiff);
Assert.False(diff2.IsObjectDiff);
Assert.Equal(diff1, diff2);
Assert.Equal("TypeDiff { Path = $, Left = true, Right = true }", diff1.ToString());
}
public void TestBookExample()
{
var str1 = @"{
""books"": [{
""title"": ""Data and Reality"",
""author"": ""William Kent""
}, {
""title"": ""Thinking Forth"",
""author"": ""Leo Brodie""
}]
}";
var str2 = @"{
""books"": [{
""title"": ""Data and Reality"",
""author"": ""William Kent"",
""edition"": ""2nd""
}, {
""title"": ""Thinking Forth"",
""author"": ""Chuck Moore""
}]
}";
var textDiffs1 = JsonStrings.TextDiff(str1, str2);
var textDiffs2 = Dogfooding.TextDiff(str1, str2);
Assert.Equal(textDiffs1.Count, textDiffs2.Count);
foreach (var(textDiff1, textDiff2) in textDiffs1.Zip(textDiffs2))
{
Assert.Equal(textDiff1, textDiff2);
}
}
public void TestDiffOneVsTrue()
{
var diffMessages = JsonStrings.Verify("1", "true");
var diffMessage = diffMessages.Single();
Assert.Equal("Kind mismatch at $.\nExpected the boolean true but was the number 1.", diffMessage);
}
public void TestDiffNullVsFalse()
{
var diffMessages = JsonStrings.Verify("null", "false");
var diffMessage = diffMessages.Single();
Assert.Equal("Kind mismatch at $.\nExpected the boolean false but was null.", diffMessage);
}
public void TestDiffFalseVsZero()
{
var diffMessages = JsonStrings.Verify("false", "0");
var diffMessage = diffMessages.Single();
Assert.Equal("Kind mismatch at $.\nExpected the number 0 but was the boolean false.", diffMessage);
}
public void TestDiffNullVsFalse()
{
var diffs = JsonStrings.TextDiff("null", "false");
var diff = diffs.Single();
Assert.Equal("Type difference at $: null vs the boolean false.", diff);
}
public void ArrayExampleOrderMatters()
{
var actualDiffs = JsonStrings.Diff("[ 24, 12 ]", "[ 12, 24 ]");
var expectedDiffs = new List <Diff>
{
new ArrayDiff(new DiffPoint("$",
new JsonArray(new JsonValue []
{
new JsonNumber(24, "24"),
new JsonNumber(12, "12")
}),
new JsonArray(new JsonValue []
{
new JsonNumber(12, "12"),
new JsonNumber(24, "24")
})),
new ItemMismatch[]
{
new LeftOnlyItem(0, new JsonNumber(24, "24")),
new RightOnlyItem(1, new JsonNumber(24, "24"))
})
};
Assert.Equal(expectedDiffs.Count, actualDiffs.Count);
foreach (var(expected, actual) in expectedDiffs.Zip(actualDiffs))
{
Assert.Equal(expected, actual);
}
}
public void TestDiffTrueVsFalse()
{
var diffMessages = JsonStrings.Verify("true", "false");
var diffMessage = diffMessages.Single();
Assert.Equal("Boolean value mismatch at $.\nExpected false but was true.", diffMessage);
}
public void ShouldIndicateNotTaskIdArray()
{
var rawJsonData = JsonStrings.TupleIn().WithoutEnd().ToSingleString();
var subjectUnderTest = Subject();
Assert.That(subjectUnderTest.IsTaskIdList(rawJsonData), Is.False);
}
public void BookExample()
{
var str1 = @"{
""books"": [{
""title"": ""Data and Reality"",
""author"": ""William Kent""
}, {
""title"": ""Thinking Forth"",
""author"": ""Leo Brodie""
}]
}";
var str2 = @"{
""books"": [{
""title"": ""Data and Reality"",
""author"": ""William Kent"",
""edition"": ""2nd""
}, {
""title"": ""Thinking Forth"",
""author"": ""Chuck Moore""
}]
}";
var diffs = JsonStrings.TextDiff(str1, str2);
Assert.Equal("Object difference at $.books[0].\nRight only property: 'edition' (string).", diffs[0]);
Assert.Equal("String value difference at $.books[1].author: Leo Brodie vs Chuck Moore.", diffs[1]);
}
public void ShouldHaveCorrectPidString()
{
var subjectUnderTest = new JsonProtocolWriterFormat();
Assert.That(subjectUnderTest.ProcessId(1234).TrimStuffForCompare(),
Is.EqualTo(JsonStrings.PidOut().TrimStuffForCompare()));
}
public void TestDiffEmptyArrayVsOne()
{
var diffs = JsonStrings.TextDiff("[]", "1");
var diff = diffs.Single();
Assert.Equal("Type difference at $: an empty array vs the number 1.", diff);
}
public void TestDiffArrayOfOneElementVsOne()
{
var diffs = JsonStrings.TextDiff("[ 1 ]", "1");
var diff = diffs.Single();
Assert.Equal("Type difference at $: an array with 1 item vs the number 1.", diff);
}
public void TestDiffOneVsTrue()
{
var diffs = JsonStrings.TextDiff("1.42", "true");
var diff = diffs.Single();
Assert.Equal("Type difference at $: the number 1.42 vs the boolean true.", diff);
}
public void TestDiffFalseVsZero()
{
var diffs = JsonStrings.TextDiff("false", "0");
var diff = diffs.Single();
Assert.Equal("Type difference at $: the boolean false vs the number 0.", diff);
}
public void TestDiffFalseVsNull()
{
var diffs = JsonStrings.TextDiff("false", "null");
var diff = diffs.Single();
Assert.Equal("Type difference at $: the boolean false vs null.", diff);
}
public void TestDiffEmptyArrayVsOne()
{
var diffMessages = JsonStrings.Verify("[]", "1");
var diffMessage = diffMessages.Single();
Assert.Equal("Kind mismatch at $.\nExpected the number 1 but was an empty array.", diffMessage);
}
public void TestValueDiff()
{
var str1 = @"{
""title"": ""Thinking Forth"",
""author"": ""Leo Brodie""
}";
var str2 = @"{
""title"": ""Thinking Forth"",
""author"": ""Chuck Moore""
}";
var diff1 = JsonStrings.Diff(str1, str2).Single();
Assert.True(diff1.IsValueDiff);
Assert.False(diff1.IsTypeDiff);
Assert.False(diff1.IsArrayDiff);
Assert.False(diff1.IsObjectDiff);
var diff2 = new ValueDiff(
new DiffPoint("$.author",
new JsonString("Leo Brodie"),
new JsonString("Chuck Moore")));
Assert.True(diff2.IsValueDiff);
Assert.False(diff2.IsTypeDiff);
Assert.False(diff2.IsArrayDiff);
Assert.False(diff2.IsObjectDiff);
Assert.Equal(diff1, diff2);
Assert.Equal("ValueDiff { Path = $.author, Left = Leo Brodie, Right = Chuck Moore }", diff1.ToString());
}
public void TestDiffArrayOfOneElementVsOne()
{
var diffMessages = JsonStrings.Verify("[ 1 ]", "1");
var diffMessage = diffMessages.Single();
Assert.Equal("Kind mismatch at $.\nExpected the number 1 but was an array with 1 item.", diffMessage);
}
public void ArrayExampleNumberOfItems()
{
var actualDiffs = JsonStrings.Diff("[ 3 ]", "[ 3, 7 ]");
var expectedDiffs = new List <Diff>
{
new ArrayDiff(
new DiffPoint("$",
new JsonArray(
new JsonValue []
{
new JsonNumber(3, "3")
}),
new JsonArray(new JsonValue []
{
new JsonNumber(3, "3"),
new JsonNumber(7, "7")
})), new ItemMismatch[]
{
new RightOnlyItem(1, new JsonNumber(7, "7")),
})
};
Assert.Equal(expectedDiffs.Count, actualDiffs.Count);
foreach (var(expected, actual) in expectedDiffs.Zip(actualDiffs))
{
Assert.Equal(expected, actual);
}
}
public static IReadOnlyList <string> TextDiff(string leftJsonString, string rightJsonString)
{
var diffs = JsonStrings.Diff(leftJsonString, rightJsonString);
var textDiffs = diffs.Select(ToTextDiff);
return(textDiffs.ToList());
}
public void ShouldHaveCorrectSyncString()
{
var subjectUnderTest = new JsonProtocolWriterFormat();
Assert.That(subjectUnderTest.Sync().TrimStuffForCompare(),
Is.EqualTo(JsonStrings.CommandSyncOut().TrimStuffForCompare()));
}
public void TestDiffTrueVsEmptyString()
{
// Empty string is not valid JSON.
var ex = Assert.Throws <ArgumentException>(() => JsonStrings.Diff("true", ""));
Assert.Equal("rightJsonString", ex.ParamName);
Assert.IsAssignableFrom <JsonException>(ex.InnerException);
}
public void TestDiffFalseVsTrue()
{
// In JSON there is no boolean type, but we pretend there is to provide a better message.
var diffs = JsonStrings.TextDiff("false", "true");
var diff = diffs.Single();
Assert.Equal("Boolean value difference at $: false vs true.", diff);
}
public void ShouldReturnAStormNext()
{
var rawJsonData = JsonStrings.CommandNextIn().WithoutEnd().ToSingleString();
var subjectUnderTest = Subject();
Assert.That(
subjectUnderTest.Command(rawJsonData),
Is.TypeOf <StormNext>());
}
