public static IEnumerable <ISirenLink> LinksByType(
this ISirenEntity @this,
string type
)
{
return(@this.Links.Where(link => link.Type.Equals(type)));
}
public void SirenEntity_Equality_DifferentTitle_ShouldNotBeEqual()
{
ISirenEntity entity = TestHelpers.GetEntity();
ISirenEntity other = TestHelpers.GetEntity("different-title");
TestHelpers.BidirectionalEquality(entity, other, false);
}
public void SirenEntity_Equality_SameEntity_ShouldBeEqual()
{
ISirenEntity entity = TestHelpers.GetEntity();
ISirenEntity other = TestHelpers.GetEntity();
TestHelpers.BidirectionalEquality(entity, other, true);
}
public static IEnumerable <ISirenLink> LinksByRel(
this ISirenEntity @this,
string rel
)
{
return(@this.Links.Where(link => link.Rel.Contains(rel)));
}
public void SirenEntity_Equality_MissingAttributes_ShouldNotBeEqual()
{
ISirenEntity entity = TestHelpers.GetEntity();
ISirenEntity other = new SirenEntity();
TestHelpers.BidirectionalEquality(entity, other, false);
}
public static IEnumerable <ISirenEntity> SubEntitiesByClass(
this ISirenEntity @this,
string @class
)
{
return(@this.Entities.Where(entity => entity.Class.Contains(@class)));
}
public static IEnumerable <ISirenEntity> SubEntitiesByRel(
this ISirenEntity @this,
string rel
)
{
return(@this.Entities.Where(entity => entity.Rel.Contains(rel)));
}
public void SirenEntity_DeserializesCorrectly()
{
ISirenEntity sirenEntity = new SirenEntity(
properties: new {
foo = "bar"
},
links: new[] {
new SirenLink(rel: new[] { "self" }, href: new Uri("http://example.com"), @class: new[] { "class" })
},
rel: new[] { "organization" },
@class: new[] { "some-class" },
entities: new[] {
new SirenEntity()
},
actions: new[] {
new SirenAction(name: "action-name", href: new Uri("http://example.com"), @class: new[] { "class" })
},
title: "Entity title",
href: new Uri("http://example.com/3"),
type: "text/html"
);
string serialized = JsonConvert.SerializeObject(sirenEntity);
ISirenEntity entity = JsonConvert.DeserializeObject <SirenEntity>(serialized);
Assert.AreEqual("bar", (string)entity.Properties.foo);
Assert.AreEqual(1, entity.Links.ToList().Count);
Assert.Contains("organization", entity.Rel);
Assert.Contains("some-class", entity.Class);
Assert.AreEqual(1, entity.Entities.ToList().Count);
Assert.AreEqual(1, entity.Actions.ToList().Count);
Assert.AreEqual("Entity title", entity.Title);
Assert.AreEqual("http://example.com/3", entity.Href.ToString());
Assert.AreEqual("text/html", entity.Type);
}
public static IEnumerable <ISirenLink> LinksByClass(
this ISirenEntity @this,
string @class
)
{
return(@this.Links.Where(link => link.Class.Contains(@class)));
}
public static IEnumerable <ISirenEntity> SubEntitiesByType(
this ISirenEntity @this,
string type
)
{
return(@this.Entities.Where(entity => entity.Type.Equals(type)));
}
public static IEnumerable <ISirenAction> ActionsByClass(
this ISirenEntity @this,
string @class
)
{
return(@this.Actions.Where(action => action.Class.Contains(@class)));
}
public override bool Equals(object obj)
{
ISirenEntity entity = obj as ISirenEntity;
ISirenEntity @this = this;
return(entity != null && @this.Equals(entity));
}
public static bool TryGetSubEntityByType(
this ISirenEntity @this,
string type,
out ISirenEntity entity
)
{
entity = @this.SubEntitiesByType(type).FirstOrDefault();
return(entity != default(ISirenEntity));
}
public static bool TryGetLinkByClass(
this ISirenEntity @this,
string @class,
out ISirenLink link
)
{
link = @this.LinksByClass(@class).FirstOrDefault();
return(link != default(ISirenLink));
}
public static bool TryGetLinkByType(
this ISirenEntity @this,
string type,
out ISirenLink link
)
{
link = @this.LinksByType(type).FirstOrDefault();
return(link != default(ISirenLink));
}
public static bool TryGetActionByName(
this ISirenEntity @this,
string name,
out ISirenAction action
)
{
action = @this.Actions.FirstOrDefault(a => a.Name.Equals(name));
return(action != default(ISirenAction));
}
public static bool TryGetSubEntityByRel(
this ISirenEntity @this,
string rel,
out ISirenEntity entity
)
{
entity = @this.SubEntitiesByRel(rel).FirstOrDefault();
return(entity != default(ISirenEntity));
}
public static bool TryGetLinkByRel(
this ISirenEntity @this,
string rel,
out ISirenLink link
)
{
link = @this.LinksByRel(rel).FirstOrDefault();
return(link != default(ISirenLink));
}
int IComparable <ISirenEntity> .CompareTo(ISirenEntity other)
{
if (other == null)
{
return(1);
}
return(string.CompareOrdinal(m_title, other.Title));
}
public static bool TryGetActionByClass(
this ISirenEntity @this,
string @class,
out ISirenAction action
)
{
action = @this.ActionsByClass(@class).FirstOrDefault();
return(action != default(ISirenAction));
}
public static bool TryGetSubEntityByClass(
this ISirenEntity @this,
string @class,
out ISirenEntity entity
)
{
entity = @this.SubEntitiesByClass(@class).FirstOrDefault();
return(entity != default(ISirenEntity));
}
public SirenEntityBuilder AddEntity(ISirenEntity entity)
{
if (m_entities == null)
{
m_entities = new List <ISirenEntity>();
}
m_entities.Add(entity);
return(this);
}
public void SirenEntityBuilder_AddProperty_NullProperty_ExpectEntityWithNullProperty()
{
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddProperty("testNullProperty", null);
ISirenEntity entity = builder.Build();
Assert.IsNotNull(entity.Properties);
Assert.IsNull(entity.Properties.testNullProperty);
}
public void MatchingHelpers_ThrowsWhenGivenProperties()
{
ISirenEntity expected = new SirenEntity(
properties: new {
foo = "bar"
}
);
ISirenEntity actual = expected;
Assert.Throws <ArgumentException>(() => SirenMatchers.Matches(expected, actual, out string _));
}
internal static JObject UnparseDocument(ISirenEntity entity)
{
var result = new JObject();
UnparseClasses(result, entity.Classes);
UnparseTitle(result, entity.Title);
UnparseProperties(result, entity.Properties);
UnparseActions(result, entity.Actions);
UnparseLinks(result, entity.Links);
UnparseEntities(result, entity.EmbeddedLinks, entity.EmbeddedRepresentations);
return result;
}
public static bool Matches(ISirenEntity expected, ISirenEntity actual, out string message)
{
return(Matches(expected.Rel, actual.Rel, out message) &&
Matches(expected.Class, actual.Class, out message)
// Need to figure out a good way to match dynamics - considering moving away from dynamic for Properties
//&& Matches( expected.Properties, actual.Properties, out message )
&& Matches(expected.Entities, actual.Entities, out message) &&
Matches(expected.Links, actual.Links, out message) &&
Matches(expected.Actions, actual.Actions, out message) &&
Matches(expected.Href, actual.Href, out message) &&
Matches(expected.Title, actual.Title, out message) &&
Matches(expected.Type, actual.Type, out message));
}
internal static JObject UnparseDocument(ISirenEntity entity)
{
var result = new JObject();
UnparseClasses(result, entity.Classes);
UnparseTitle(result, entity.Title);
UnparseProperties(result, entity.Properties);
UnparseActions(result, entity.Actions);
UnparseLinks(result, entity.Links);
UnparseEntities(result, entity.EmbeddedLinks, entity.EmbeddedRepresentations);
return(result);
}
public void SirenEntityBuilder_Build_WithParams_ExpectEntityWithParams()
{
string expectedTitle = "test-title";
Uri expectedHref = TestHref;
string expectedType = "test-type";
SirenEntityBuilder builder = new SirenEntityBuilder();
ISirenEntity entity = builder.Build(expectedTitle, expectedHref, expectedType);
Assert.AreEqual(expectedTitle, entity.Title);
Assert.AreEqual(expectedHref, entity.Href);
Assert.AreEqual(expectedType, entity.Type);
}
public void SirenEntityBuilder_AddRel_Single_ExpectEntityWithRels()
{
string expectedRel1 = "first-rel";
string expectedRel2 = "second-rel";
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddRel(expectedRel1);
builder.AddRel(expectedRel2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Rel.Length);
Assert.Contains(expectedRel1, entity.Rel);
Assert.Contains(expectedRel2, entity.Rel);
}
public void SirenEntityBuilder_AddAction_ExpectEntityWithActions()
{
ISirenAction expectedAction1 = TestHelpers.GetAction("action-1");
ISirenAction expectedAction2 = TestHelpers.GetAction("action-2");
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddAction(expectedAction1);
builder.AddAction(expectedAction2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Actions.Count());
CollectionAssert.Contains(entity.Actions, expectedAction1);
CollectionAssert.Contains(entity.Actions, expectedAction2);
}
public void SirenEntityBuilder_AddClass_Single_ExpectEntityWithClasses()
{
string expectedClass1 = "first-class";
string expectedClass2 = "second-class";
SirenEntityBuilder builder = new SirenEntityBuilder();
builder.AddClass(expectedClass1);
builder.AddClass(expectedClass2);
ISirenEntity entity = builder.Build();
Assert.AreEqual(2, entity.Class.Length);
Assert.Contains(expectedClass1, entity.Class);
Assert.Contains(expectedClass2, entity.Class);
}
/// <summary>
/// Validates that the structure of <paramref name="entity"/> matches that of the spec sample JSON.
/// </summary>
/// <param name="entity">The Siren Entity to compare to the spec sample.</param>
public static void AssertIsSpecSample(ISirenEntity entity)
{
Assert.Equal("order", entity.Classes.Single());
var properties = entity.Properties;
Assert.Equal(3, properties.Count);
Assert.Equal("42", properties["orderNumber"].ToString());
Assert.Equal("3", properties["itemCount"].ToString());
Assert.Equal("pending", properties["status"].ToString());
Assert.Equal(1, entity.EmbeddedLinks.Count());
Assert.Equal(1, entity.EmbeddedRepresentations.Count());
var link = entity.EmbeddedLinks.Single();
Assert.NotNull(link);
Assert.Equal(2, link.Classes.Count);
Assert.Contains("items", link.Classes);
Assert.Contains("collection", link.Classes);
Assert.Equal("http://x.io/rels/order-items", link.Rel.Single());
Assert.Equal("http://api.x.io/orders/42/items", link.Href);
var rep = entity.EmbeddedRepresentations.Single();
Assert.NotNull(rep);
Assert.Equal(2, rep.Classes.Count);
Assert.Contains("info", rep.Classes);
Assert.Contains("customer", rep.Classes);
Assert.Equal("http://x.io/rels/customer", rep.Rel.Single());
var repProperties = rep.Properties;
Assert.Equal(2, repProperties.Count);
Assert.Equal("pj123", repProperties["customerId"].ToString());
Assert.Equal("Peter Joseph", repProperties["name"].ToString());
var repLink = rep.Links.Single();
Assert.Equal("self", repLink.Rel.Single());
Assert.Equal("http://api.x.io/customers/pj123", repLink.Href);
Assert.Equal("CustomerUri", repLink.Title);
var action = entity.Actions.Single();
Assert.Equal("add-item", action.Name);
Assert.Equal("Add Item", action.Title);
Assert.Equal("POST", action.Method.Method);
Assert.Equal("http://api.x.io/orders/42/items", action.Href);
Assert.Equal("application/x-www-form-urlencoded", action.Type.MediaType);
var fields = action.Fields;
Assert.Equal(3, fields.Count);
var orderNumber = fields.Single(x => x.Name == "orderNumber");
Assert.Equal(FieldType.Hidden, orderNumber.Type);
Assert.Equal("42", orderNumber.Value);
var productType = fields.Single(x => x.Name == "productCode");
Assert.Equal(FieldType.Text, productType.Type);
var quantity = fields.Single(x => x.Name == "quantity");
Assert.Equal(FieldType.Number, quantity.Type);
var links = entity.Links;
Assert.Equal(3, links.Count);
var self = links.Single(x => x.Rel.Single() == "self");
Assert.Equal("http://api.x.io/orders/42", self.Href);
var prev = links.Single(x => x.Rel.Single() == "previous");
Assert.Equal("http://api.x.io/orders/41", prev.Href);
var next = links.Single(x => x.Rel.Single() == "next");
Assert.Equal("http://api.x.io/orders/43", next.Href);
}
public static JObject Unparse(ISirenEntity entity)
{
return Unparser.UnparseDocument(entity);
}
