public void LoadingData_WithDataContainingEmbeddedData_RemovesEmbeddedItemsFromProperties()
{
var validJson = "{ }";
IDictionary <string, object> dataBeingLoaded = new Dictionary <string, object>
{
{
"_embedded",
new Dictionary <string, object>
{
{
"some-EmbeddedItem",
new Dictionary <string, object>
{
{ "string-Property", "Some String" },
{ "integer-Property", 123 }
}
}
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(dataBeingLoaded);
var resource = new HalResource(loader.Object);
resource.Load(validJson);
Assert.False(resource.Properties.ContainsKey("_embedded"));
}
public void LoadingData_WithDataContainingOneRelWithOneLink_RemovesLinksFromProperties()
{
var validJson = "{ }";
IDictionary <string, object> dataBeingLoaded = new Dictionary <string, object>
{
{
"_links",
new Dictionary <string, object>
{
{
"self",
new Dictionary <string, object>
{
{ "href", "/api/categories" },
{ "title", "Some Title" }
}
}
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(dataBeingLoaded);
var resource = new HalResource(loader.Object);
resource.Load(validJson);
Assert.False(resource.Properties.ContainsKey("_links"));
}
public virtual int compare <T1, T2>(HalResource <T1> resource1, HalResource <T2> resource2)
{
string id1 = ((HalIdResource)resource1).Id;
string id2 = ((HalIdResource)resource2).Id;
return(id1.CompareTo(id2));
}
public void LoadingData_WithComplexPropertyProvidedAsReferenceType_ThrowsException()
{
var validJson = "{ }";
IDictionary <string, object> expectedLoaderData = new Dictionary <string, object>
{
{
"complex-Property",
new Fixtures.ComplexModel
{
Id = Guid.NewGuid(),
Date = DateTime.Now,
Name = "Some Name"
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(expectedLoaderData);
var resource = new HalResource(loader.Object);
Assert.Throws <RawDataInputException>(() =>
{
resource.Load(validJson);
});
}
public void GettingStringProperty_WithPropertyAskedForIsString_ReturnsStringValue()
{
string validJson = "{ }";
const string propertyName = "string-property";
const string propertyValue = "some string";
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson))
.Returns(new Dictionary <string, object> {
{ propertyName, propertyValue }
});
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
var retrievedValue = resource.CastSimplePropertyTo <string>(propertyName);
Assert.IsType <string>(retrievedValue);
Assert.Equal(expected: propertyValue, actual: retrievedValue);
}
public void GettingStringProperty_WhenCasingDiffers_ThrowsException()
{
string validJson = "{ }";
const string propertyNameWithCamelCasing = "string-Property";
const string propertyName = "string-property";
const string propertyValue = "some string";
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson))
.Returns(new Dictionary <string, object> {
{ propertyName, propertyValue }
});
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <KeyNotFoundException>(() =>
{
resource.CastSimplePropertyTo <string>(propertyNameWithCamelCasing);
});
}
public void LoadingData_WithOneDecomposedComplexProperty_SetsItToThePropertiesCollection()
{
var validJson = "{ }";
IDictionary <string, object> expectedLoaderData = new Dictionary <string, object>
{
{
"complex-Property",
new Dictionary <string, object>
{
{ "string-Property1", "Hello" },
{ "string-Property2", "World!" }
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(expectedLoaderData);
var resource = new HalResource(loader.Object);
resource.Load(validJson);
Assert.Equal(expected: expectedLoaderData, actual: resource.Properties);
}
public void GettingIntProperty_WithPropertyAskedForIsString_ThrowsException()
{
string validJson = "{ }";
const string propertyName = "string-property";
const string propertyValue = "some string";
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson))
.Returns(new Dictionary <string, object> {
{ propertyName, propertyValue }
});
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <InvalidCastException>(() =>
{
resource.CastSimplePropertyTo <int>(propertyName);
});
}
public void CastingComplexPropertyAsEntity_WhenPropertyDoesNotExist_ThrowsException()
{
string validJson = "{ }";
const string propertyName = "string-property";
const string propertyValue = "some string";
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson))
.Returns(new Dictionary <string, object> {
{ propertyName, propertyValue }
});
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <NoSuchPropertyException>(() =>
{
resource.CastComplexPropertyTo <ComplexModel>("non existent property");
});
}
public void CastingResourceAsEntity_WithNoMapperForTypeRegistered_ThrowsException()
{
string validJson = "{ }";
const string propertyName = "complex";
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(
new Dictionary <string, object>
{
{
propertyName,
new Dictionary <string, object>
{
{ "id", Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a") },
{ "full-name", "My Name" },
{ "date", new DateTime(2020, 7, 5) }
}
}
});
var mapperFactory = new Mock <IEntityMapperFactory>();
mapperFactory.Setup(factory => factory.GetMapper <ComplexModel>()).Returns(() => null);
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <TypeHasNoMapperException>(() =>
{
var retrievedValue = resource.CastResourceAs <ComplexModel>();
});
}
public void LoadingData_WithDataContainingOneEmbeddedItemSetWithTwoItems_ProcessesTheItem()
{
var validJson = "{ }";
IDictionary <string, object> dataBeingLoaded = new Dictionary <string, object>
{
{
"_embedded",
new Dictionary <string, object>
{
{
"some-EmbeddedItem",
new List <Dictionary <string, object> >
{
new Dictionary <string, object>
{
{ "string-Property", "Some String" },
{ "integer-Property", 123 }
},
new Dictionary <string, object>
{
{ "string-Property", "Some other String" },
{ "integer-Property", 999 }
}
}
}
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(dataBeingLoaded);
var resource = new HalResource(loader.Object);
resource.Load(validJson);
var expectedResult = new List <HalResource>
{
CreateMockedHalResource(
new Dictionary <string, object>
{
{ "string-Property", "Some String" },
{ "integer-Property", 123 }
}),
CreateMockedHalResource(
new Dictionary <string, object>
{
{ "string-Property", "Some other String" },
{ "integer-Property", 999 }
})
};
Assert.NotNull(resource.EmbeddedItems);
Assert.Single(resource.EmbeddedItems);
Assert.True(resource.EmbeddedItems["some-EmbeddedItem"].Count() == 2);
expectedResult.ShouldDeepEqual(resource.EmbeddedItems["some-EmbeddedItem"]);
}
public IActionResult GetPriceHistoryEvents(int listingId)
{
var historyResources = GetPricingHistory().Where(h => h.ListingId == listingId)
.Select(h => h.AsResource()).ToArray();
var resource = HalResource.New(r => r.EmbedResources(historyResources, "price-history"));
return(Ok(resource));
}
public IActionResult GetCompanyLocations(string id)
{
Company company = _companyRepo.ReadCompany(id);
var locationResources = company.Locations.Select(LocationModel.FromEntity)
.Select(m => m.AsResource());
var rootRes = HalResource.New(i => i.EmbedResources(locationResources.ToArray(), "locations"));
return(Ok(rootRes));
}
public void LoadingData_WithDataContainingOneRelWithTwoLinks_ProcessesLinks()
{
var validJson = "{ }";
var dataBeingLoaded = new Dictionary <string, object>
{
{
"_links",
new Dictionary <string, object>
{
{
"orders",
new List <Dictionary <string, object> >
{
{
new Dictionary <string, object>
{
{ "href", "/api/orders/123" },
{ "title", "Order" }
}
},
{
new Dictionary <string, object>
{
{ "href", "/api/orders/456" },
{ "title", "Order" }
}
}
}
}
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(dataBeingLoaded);
var resource = new HalResource(loader.Object);
resource.Load(validJson);
var expectedLinks = new List <Link>
{
new Link("/api/orders/123", "Order"),
new Link("/api/orders/456", "Order")
};
var relSet = (List <Link>)resource.Links["orders"];
Assert.NotNull(resource.Links);
Assert.Single(resource.Links);
Assert.True(relSet.Count == 2);
expectedLinks.ShouldDeepEqual(relSet);
}
public void LoadingData_WithNullRawResponseProvided_ThrowsException()
{
var loader = new Mock <IHalResponseLoader>();
var halResource = new HalResource(loader.Object);
Assert.Throws <ArgumentNullException>(() =>
{
halResource.Load(null);
});
}
private void ProcessSingularEmbededItem(
KeyValuePair <string, object> keyValuePair)
{
var embeddedItemHalReader = new HalResource((Dictionary <string, object>)keyValuePair.Value);
embedded.Add(
keyValuePair.Key,
new List <HalResource> {
embeddedItemHalReader
}
);
}
public IActionResult GetCompany(string id)
{
Company company = _companyRepo.ReadCompany(id);
if (company == null)
{
return(NotFound("Customer Not Found"));
}
HalResource <CompanyModel> companyRes = BuildCompanyResource(company);
return(Ok(companyRes));
}
public void CastEmbeddedItemAsEntity_WithValidMapperForTypeRegistered_ReturnsPopulatedEntity()
{
string validJson = "{ }";
const string keyName = "some-Key";
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(
new Dictionary <string, object>
{
{
"_embedded",
new Dictionary <string, object>
{
{
keyName,
new Dictionary <string, object>
{
{ "id", Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a") },
{ "full-name", "My Name" },
{ "date", new DateTime(2020, 7, 5) }
}
}
}
}
});
var expectedEmbeddedModel = new ComplexModel
{
Id = Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a"),
Name = "My Name",
Date = new DateTime(2020, 7, 5)
};
var mapper = new Mock <IEntityMapper <ComplexModel> >();
mapper.Setup(mapper => mapper.Map()).Returns(expectedEmbeddedModel);
var mapperFactory = new Mock <IEntityMapperFactory>();
mapperFactory.Setup(factory => factory.GetMapper <ComplexModel>()).Returns(mapper.Object);
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
var retrievedValue = resource.CastEmbeddedItemAs <ComplexModel>(keyName);
retrievedValue.ShouldDeepEqual(expectedEmbeddedModel);
}
private static HalResource CreateMockedHalResource(IDictionary <string, object> dataBeingLoaded)
{
var validJson = "{ }";
var expectedloader = new Mock <IHalResponseLoader>();
expectedloader.Setup(loader => loader.Load(validJson)).Returns(dataBeingLoaded);
var halResource = new HalResource(expectedloader.Object);
halResource.Load(validJson);
return(halResource);
}
public void LoadingData_WithEmptyRawResponseProvided_ResultsInEmptyHalResource()
{
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(string.Empty)).Returns(new Dictionary <string, object>());
var halResource = new HalResource(loader.Object);
halResource.Load(string.Empty);
Assert.Empty(halResource.Properties);
Assert.Empty(halResource.Links);
Assert.Empty(halResource.EmbeddedItems);
}
public void CastEmbeddedItemAsEntity_WithKeyProvidedForEmbeddedItemCollection_ThrowsException()
{
string validJson = "{ }";
const string keyName = "some-Key";
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(
new Dictionary <string, object>
{
{
"_embedded",
new Dictionary <string, object>
{
{
keyName,
new List <Dictionary <string, object> >
{
new Dictionary <string, object>
{
{ "id", Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a") },
{ "full-name", "My Name" },
{ "date", new DateTime(2020, 7, 5) }
},
new Dictionary <string, object>
{
{ "id", Guid.Parse("43a4d9f2-d4fc-4664-a1af-e6cdb1e42d6b") },
{ "full-name", "Your Name" },
{ "date", new DateTime(2020, 7, 19) }
}
}
}
}
}
});
var mapper = new Mock <IEntityMapper <ComplexModel> >();
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <EmbeddedItemIsCollectionException>(() =>
{
var retrievedValue = resource.CastEmbeddedItemAs <ComplexModel>(keyName);
});
}
public void LoadingData_WithDataContainingTwoRelsEachWithOneLink_ProcessesLinks()
{
var validJson = "{ }";
IDictionary <string, object> dataBeingLoaded = new Dictionary <string, object>
{
{
"_links",
new Dictionary <string, object>
{
{
"self",
new Dictionary <string, object>
{
{ "href", "/api/categories/123" },
{ "title", "Category" }
}
},
{
"parent",
new Dictionary <string, object>
{
{ "href", "/api/categories" },
{ "title", "Categories" }
}
}
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(dataBeingLoaded);
var resource = new HalResource(loader.Object);
resource.Load(validJson);
var expectedSelfLink = new Link("/api/categories/123", "Category");
var expectedParentLink = new Link("/api/categories", "Categories");
Assert.NotNull(resource.Links);
Assert.True(resource.Links.Count == 2);
Assert.Single(resource.Links["self"]);
Assert.Single(resource.Links["parent"]);
expectedSelfLink.ShouldDeepEqual(resource.Links["self"].First());
expectedParentLink.ShouldDeepEqual(resource.Links["parent"].First());
}
public void GettingProperty_WithEmptyPropertyNameProvided_ThrowsException()
{
string validJson = "{ }";
var loader = new Mock <IHalResponseLoader>();
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <ArgumentException>(() =>
{
resource.CastSimplePropertyTo <string>(string.Empty);
});
}
public void CastEmbeddedItemAsEntity_WithEmptyKeyProvided_ThrowsException()
{
string validJson = "{ }";
var loader = new Mock <IHalResponseLoader>();
var mapper = new Mock <IEntityMapper <ComplexModel> >();
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <ArgumentException>(() =>
{
var retrievedValue = resource.CastEmbeddedItemAs <ComplexModel>(string.Empty);
});
}
private void ProcessEmbeddedItemSet(KeyValuePair <string, object> keyValuePair)
{
var embededItemSetItems = (IEnumerable <Dictionary <string, object> >)keyValuePair.Value;
var embeddedItemSet = new List <HalResource>();
foreach (var embeddedItem in embededItemSetItems)
{
var embeddedItemHalReader = new HalResource(embeddedItem);
embeddedItemSet.Add(embeddedItemHalReader);
}
embedded.Add(
keyValuePair.Key,
new List <HalResource>(embeddedItemSet));
}
public void CastEmbeddedItemAsEntity_WithKeyProvidedForNonExistentEmbeddedItem_ThrowsException()
{
string validJson = "{ }";
var loader = new Mock <IHalResponseLoader>();
var mapper = new Mock <IEntityMapper <ComplexModel> >();
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <NoEmbeddedItemWithKeyException>(() =>
{
var retrievedValue = resource.CastEmbeddedItemAs <ComplexModel>("Key Does Not Exist");
});
}
public void LoadingData_WithDataContainingOneSingularEmbeddedItemWithOnlyProperties_ProcessesTheItem()
{
var validJson = "{ }";
IDictionary <string, object> dataBeingLoaded = new Dictionary <string, object>
{
{
"_embedded",
new Dictionary <string, object>
{
{
"some-EmbeddedItem",
new Dictionary <string, object>
{
{ "string-Property", "Some String" },
{ "integer-Property", 123 }
}
}
}
}
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(dataBeingLoaded);
var resource = new HalResource(loader.Object);
resource.Load(validJson);
HalResource expectedResult;
expectedResult =
CreateMockedHalResource(
new Dictionary <string, object>
{
{ "string-Property", "Some String" },
{ "integer-Property", 123 }
});
Assert.NotNull(resource.EmbeddedItems);
Assert.Single(resource.EmbeddedItems);
Assert.Single(resource.EmbeddedItems["some-EmbeddedItem"]);
expectedResult.ShouldDeepEqual(resource.EmbeddedItems["some-EmbeddedItem"].First());
}
public static void AssertLink(this HalResource resource,
string relName,
HttpMethod expectedMethod,
string expectedValue)
{
Assert.True(
resource.Links != null && resource.Links.Count > 0,
"Resource does not have associated links.");
Assert.True(resource.Links.ContainsKey(relName), $"Resource does not have link with relation name: {relName}");
var link = resource.Links[relName];
Assert.Equal(expectedValue, link.Href);
Assert.NotNull(link.Methods);
Assert.True(link.Methods.Length == 1, "One HTTP method expected.");
Assert.Equal(expectedMethod.Method, link.Methods.First());
}
public void CastingComplexPropertyAsEntity_QuickMappingExpectedPropertyToKeyValue_ReturnsComplexValue()
{
string validJson = "{ }";
const string propertyName = "complex";
var propertyValue =
new ComplexModel
{
Id = Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a"),
Name = "My Name",
Date = new DateTime(2020, 7, 5)
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(
new Dictionary <string, object>
{
{
propertyName,
new Dictionary <string, object>
{
{ "id", Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a") },
{ "full-name", "My Name" },
{ "date", new DateTime(2020, 7, 5) }
}
}
});
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
var retrievedValue =
resource.CastComplexPropertyTo <ComplexModel>(
propertyName,
QuickMap.Into <ComplexModel>(model => model.Name, "full-name"));
Assert.IsType <ComplexModel>(retrievedValue);
propertyValue.ShouldDeepEqual(retrievedValue);
}
public void CastingComplexPropertyAsEntity_QuickMappingIntoNonExistentExpectedProperty_ThrowsException()
{
string validJson = "{ }";
const string propertyName = "complex";
var propertyValue =
new ComplexModel
{
Id = Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a"),
Name = "My Name",
Date = new DateTime(2020, 7, 5)
};
var loader = new Mock <IHalResponseLoader>();
loader.Setup(loader => loader.Load(validJson)).Returns(
new Dictionary <string, object>
{
{
propertyName,
new Dictionary <string, object>
{
{ "id", Guid.Parse("3b947c60-dcf8-4199-95a1-7a70fd81d16a") },
{ "full-name", "My Name" },
{ "date", new DateTime(2020, 7, 5) }
}
}
});
var mapperFactory = new Mock <IEntityMapperFactory>();
var resource = new HalResource(loader.Object, mapperFactory.Object);
resource.Load(validJson);
Assert.Throws <KeyNotFoundException>(() =>
{
var retrievedValue =
resource.CastComplexPropertyTo <ComplexModel>(
propertyName,
new KeyValuePair <string, string>("NotAPropertyOfComplexModel", "full-name"));
});
}
