public IDocumentBuilder SetJsonApiVersion(JsonApiVersion jsonApiVersion)
{
Contract.Requires(jsonApiVersion != null);
this.DomDocument.SetDomReadOnlyJsonApiVersion(jsonApiVersion);
return(this);
}
public static void Equal(JsonApiVersion expected, JToken actualJToken)
{
// Handle when 'expected' is null.
if (expected == null)
{
ClrObjectAssert.IsNull(actualJToken);
return;
}
// Handle when 'expected' is not null.
Assert.NotNull(actualJToken);
var actualJTokenType = actualJToken.Type;
Assert.Equal(JTokenType.Object, actualJTokenType);
var actualJObject = (JObject)actualJToken;
// Version
Assert.Equal(expected.Version, (string)actualJObject.SelectToken(Keywords.Version));
// Meta
var actualMetaJToken = actualJObject.SelectToken(Keywords.Meta);
MetaAssert.Equal(expected.Meta, actualMetaJToken);
}
// PUBLIC METHODS ///////////////////////////////////////////////////
#region Factory Methods
public static DomReadOnlyJsonApiVersion Create(JsonApiVersion jsonApiVersion)
{
Contract.Requires(jsonApiVersion != null);
var domReadOnlyJsonApiVersion = new DomReadOnlyJsonApiVersion(jsonApiVersion);
return(domReadOnlyJsonApiVersion);
}
// PUBLIC METHODS ///////////////////////////////////////////////////
#region Assert Methods
public static void Equal(JsonApiVersion expected, string actualJson)
{
Assert.NotNull(expected);
Assert.False(String.IsNullOrEmpty(actualJson));
var actualJToken = JToken.Parse(actualJson);
JsonApiVersionAssert.Equal(expected, actualJToken);
}
internal DomReadOnlyJsonApiVersion SetDomReadOnlyJsonApiVersion(JsonApiVersion jsonApiVersion)
{
Contract.Requires(jsonApiVersion != null);
// Validation
this.ValidateJsonApiVersionDoesNotExist();
// Add the one allowed DOM jsonapi version node to the DOM document node.
var domReadOnlyJsonApiVersion = this.CreateAndAddNode(() => DomReadOnlyJsonApiVersion.Create(jsonApiVersion));
return(domReadOnlyJsonApiVersion);
}
public void TestJsonApiVersionParse(string name, JsonApiVersion expected)
{
// Arrange
var json = expected.ToJson();
// Act
this.Output.WriteLine(json);
var actual = JsonObject.Parse <JsonApiVersion>(json);
// Assert
JsonApiVersionAssert.Equal(expected, actual);
}
public void TestJsonApiVersionToJson(string name, JsonApiVersion expected)
{
// Arrange
// Act
var actual = expected.ToJson();
this.Output.WriteLine(actual);
// Assert
JsonApiVersionAssert.Equal(expected, actual);
}
public static void Equal(JsonApiVersion expected, JsonApiVersion actual)
{
if (expected == null)
{
Assert.Null(actual);
return;
}
Assert.NotNull(actual);
// Version
Assert.Equal(expected.Version, actual.Version);
// Meta
MetaAssert.Equal(expected.Meta, actual.Meta);
}
// PUBLIC METHODS ///////////////////////////////////////////////////
#region Assert Methods
public static void Equal(JsonApiVersion expected, DomReadOnlyJsonApiVersion actual)
{
if (expected == null)
{
Assert.Null(actual);
return;
}
Assert.NotNull(actual);
Assert.Equal(DomNodeType.JsonApiVersion, actual.NodeType);
var actualJsonApiVersion = actual.JsonApiVersion;
JsonApiVersionAssert.Equal(expected, actualJsonApiVersion);
}
// PUBLIC METHODS ///////////////////////////////////////////////////
#region Assert Methods
public static void Equal(JsonApiVersion expected, DomNode actual)
{
if (expected == null)
{
Assert.Null(actual);
return;
}
Assert.NotNull(actual);
var actualType = actual.GetType();
if (actualType == typeof(DomReadOnlyJsonApiVersion))
{
var actualDomReadOnlyJsonApiVersion = (DomReadOnlyJsonApiVersion)actual;
DomReadOnlyJsonApiVersionAssert.Equal(expected, actualDomReadOnlyJsonApiVersion);
}
else
{
Assert.True(false, "Unknown actual node type [name={0}].".FormatWith(actualType.Name));
}
}
// PRIVATE CONSTRUCTORS /////////////////////////////////////////////
#region Constructors
private DomReadOnlyJsonApiVersion(JsonApiVersion jsonApiVersion)
{
Contract.Requires(jsonApiVersion != null);
this.JsonApiVersion = jsonApiVersion;
}
