public void WhenOrderIsOk_ThenResponseHasStatus201AndLocation()
{
var orderRepository = new Mock <IRepository <Order> >();
orderRepository
.Setup(or => or.MakePersistent(It.IsAny <Order[]>()))
.Callback <Order[]>(o => o.First().Id = 123);
var appProxy = CreateAppProxy(orderRepository.Object);
var expectedUriToTheNewOrder =
new ResourceLinker(Container.Resolve <IRouteCacheProvider>()).BuildUriString(appProxy.Get("/orders").Context, "ReadOrder", new { orderId = "123" });
var orderRepresentation = new OrderRepresentation()
{
Items = { new OrderItemRepresentation()
{
Name = "latte", Quantity = 1
} }
};
// act
var result = appProxy.Post("/orders/",
with =>
{
with.Header("Content-Type", "application/xml");
with.Body(orderRepresentation.ToXmlString());
});
result.StatusCode.Should().Be.EqualTo(HttpStatusCode.Created);
result.Headers["Location"].Should().Be.EqualTo(expectedUriToTheNewOrder);
}
public HalResourceWithPeopleTest()
{
resource = new OrganisationRepresentation(1, "Org Name");
var linker = new ResourceLinker();
linker.AddLinker(new OrganisationWithPeopleLinker());
linker.CreateLinks(resource);
}
public static OrderRepresentation Map(Order order, ResourceLinker resourceLinker, NancyContext context)
{
return(new OrderRepresentation(order)
{
Links = GetLinks(order, resourceLinker, context).ToList()
});
}
public static OrderRepresentation Map(Order order, ResourceLinker resourceLinker, NancyContext context)
{
return new OrderRepresentation(order)
{
Links = GetLinks(order, resourceLinker, context).ToList()
};
}
public void Link_generated_is_correct_when_base_uri_has_trailing_slash()
{
var resourceLinker = new ResourceLinker("http://localhost/");
var uriString = resourceLinker.BuildUriString("/foo", "", new {});
Assert.That(uriString, Is.EqualTo("http://localhost/foo"));
}
public void Link_generated_is_correct_with_bound_parameter()
{
var resourceLinker = new ResourceLinker("http://localhost");
var uriString = resourceLinker.BuildUriString("/foo", "/bar/{id}", new { id = 123 });
Assert.That(uriString, Is.EqualTo("http://localhost/foo/bar/123"));
}
public void Link_generated_is_correct_with_simple_template()
{
var resourceLinker = new ResourceLinker("http://localhost");
var uriString = resourceLinker.BuildUriString("/foo", "/bar", new {});
Assert.That(uriString, Is.EqualTo("http://localhost/foo/bar"));
}
public TrashModule(IRepository<Order> orderRepository, ResourceLinker linker)
: base(path)
{
this.orderRepository = orderRepository;
this.linker = linker;
this.routeCacheProvider = routeCacheProvider;
Get["ReadCancelledOrder", GetCancelledPath] = parameters => GetCanceled((int) parameters.orderId);
}
public OrdersResourceModule(IRepository <Product> productRepository, IRepository <Order> orderRepository, ResourceLinker linker)
: base("/orders")
{
this.productRepository = productRepository;
this.orderRepository = orderRepository;
this.linker = linker;
Post["/"] = _ => HandlePost(this.Bind <OrderRepresentation>());
}
public OrdersResourceModule(IRepository<Product> productRepository, IRepository<Order> orderRepository, ResourceLinker linker)
: base("/orders")
{
this.productRepository = productRepository;
this.orderRepository = orderRepository;
this.linker = linker;
Post["/"] = _ => HandlePost(this.Bind<OrderRepresentation>());
}
public TrashModule(IRepository <Order> orderRepository, ResourceLinker linker)
: base(path)
{
this.orderRepository = orderRepository;
this.linker = linker;
this.routeCacheProvider = routeCacheProvider;
Get["ReadCancelledOrder", GetCancelledPath] = parameters => GetCanceled((int)parameters.orderId);
}
private Response Created(Order order)
{
var uri = new ResourceLinker(Request.BaseUri()).BuildUriString(
OrderResourceModule.Path,
OrderResourceModule.SlashOrderId,
new { orderId = order.Id });
return(Response.Created(uri));
}
private Response Created(Order order)
{
var uri = new ResourceLinker(Request.BaseUri()).BuildUriString(
OrderResourceModule.Path,
OrderResourceModule.SlashOrderId,
new {orderId = order.Id});
return Response.Created(uri);
}
private static IEnumerable<Link> GetLinks(Order order, string baseAddress)
{
var baseUri = new UriSegment(baseAddress);
var linker = new ResourceLinker(baseAddress);
var get = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.SlashOrderId,
new {orderId = order.Id}),
baseUri + "docs/order-get.htm",
MediaTypes.Default);
var update = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.SlashOrderId,
new {orderId = order.Id}),
baseUri + "docs/order-update.htm",
MediaTypes.Default);
var cancel = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.SlashOrderId,
new {orderId = order.Id}),
baseUri + "docs/order-cancel.htm",
MediaTypes.Default);
var pay = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.PaymentPath,
new {orderId = order.Id}),
baseUri + "docs/order-pay.htm",
MediaTypes.Default);
var receipt = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.ReceiptPath,
new {orderId = order.Id}),
baseUri + "docs/receipt-coffee.htm",
MediaTypes.Default);
switch (order.Status)
{
case OrderStatus.Unpaid:
yield return get;
yield return update;
yield return cancel;
yield return pay;
break;
case OrderStatus.Paid:
case OrderStatus.Delivered:
yield return get;
break;
case OrderStatus.Ready:
yield return receipt;
break;
case OrderStatus.Canceled:
yield break;
default:
yield break;
}
}
public void Argument_exception_is_thrown_if_parameter_from_template_cannot_be_bound()
{
var resourceLinker = new ResourceLinker("http://localhost");
var exception = Assert.Throws <ArgumentException>(() => resourceLinker.BuildUriString("/foo", "/bar/{id}", new {}));
Assert.That(exception.Message,
Is.EqualTo(
"The path variable 'ID' in the UriTemplate must be bound to a non-empty string value.\r\nParameter name: parameters"));
}
public OrderResourceModule(IRepository <Order> orderRepository, ResourceLinker linker)
: base(Path)
{
this.orderRepository = orderRepository;
this.linker = linker;
Get["ReadOrder", SlashOrderId] = parameters => GetHandler((int)parameters.orderId);
Put["UpdateOrder", SlashOrderId] = parameters => Update((int)parameters.orderId, this.Bind <OrderRepresentation>());
Delete["CancelOrder", SlashOrderId] = parameters => Cancel((int)parameters.orderId);
Post["PayOrder", PaymentPath] = parameters => Pay((int)parameters.orderId, FromXmlStream <PaymentRepresentation>(Request.Body));
}
public void PrepareLinker()
{
var mock = new Mock <IResourceGraph>();
mock.Setup(g => g.Get(It.IsAny <long>())).Returns <long>(id => _graph.ContainsKey(id) ? _graph[id].Target : null);
_linker = new ResourceLinker
{
Graph = mock.Object,
Logger = new DummyLogger()
};
}
public HalResourceListTests()
{
resourceLinker = new ResourceLinker();
resourceLinker.AddLinker(new OrganisationListLinker());
resourceLinker.AddLinker(new OrganisationLinker());
resource = new ResourceList<OrganisationRepresentation>(
new List<OrganisationRepresentation>
{
new OrganisationRepresentation(1, "Org1"),
new OrganisationRepresentation(2, "Org2")
});
resourceLinker.CreateLinks(resource);
}
private static IEnumerable <Link> GetLinks(Order order, ResourceLinker linker, NancyContext context)
{
var get = new Link(
linker.BuildUriString(context, "ReadOrder", new { orderId = order.Id }),
context.Request.BaseUri() + "/docs/order-get.htm",
MediaTypes.Default);
var update = new Link(
linker.BuildUriString(context, "UpdateOrder", new { orderId = order.Id }),
context.Request.BaseUri() + "/docs/order-update.htm",
MediaTypes.Default);
var cancel = new Link(
linker.BuildUriString(context, "CancelOrder", new { orderId = order.Id }),
context.Request.BaseUri() + "/docs/order-cancel.htm",
MediaTypes.Default);
var pay = new Link(linker.BuildUriString(context, "PayOrder", new { orderId = order.Id }),
context.Request.BaseUri() + "/docs/order-pay.htm",
MediaTypes.Default);
switch (order.Status)
{
case OrderStatus.Unpaid:
yield return(get);
yield return(update);
yield return(cancel);
yield return(pay);
break;
case OrderStatus.Paid:
case OrderStatus.Delivered:
yield return(get);
break;
case OrderStatus.Ready:
break;
case OrderStatus.Canceled:
yield break;
default:
yield break;
}
}
public void throws_meaningful_exception_when_cannot_find_linker()
{
// arrange
var resourceLinker = new ResourceLinker();
Exception exception = null;
// act
try
{
resourceLinker.CreateLinks(new List<Resource>());
}
catch (ArgumentException ex)
{
exception = ex;
}
// assert
Approvals.Verify(exception.Message);
}
private static IEnumerable<Link> GetLinks(Order order, ResourceLinker linker, NancyContext context)
{
var get = new Link(
linker.BuildUriString(context, "ReadOrder", new {orderId = order.Id}),
context.Request.BaseUri() + "/docs/order-get.htm",
MediaTypes.Default);
var update = new Link(
linker.BuildUriString(context, "UpdateOrder", new { orderId = order.Id}),
context.Request.BaseUri() + "/docs/order-update.htm",
MediaTypes.Default);
var cancel = new Link(
linker.BuildUriString(context, "CancelOrder", new { orderId = order.Id}),
context.Request.BaseUri() + "/docs/order-cancel.htm",
MediaTypes.Default);
var pay = new Link(linker.BuildUriString(context, "PayOrder", new {orderId = order.Id}),
context.Request.BaseUri() + "/docs/order-pay.htm",
MediaTypes.Default);
switch (order.Status)
{
case OrderStatus.Unpaid:
yield return get;
yield return update;
yield return cancel;
yield return pay;
break;
case OrderStatus.Paid:
case OrderStatus.Delivered:
yield return get;
break;
case OrderStatus.Ready:
break;
case OrderStatus.Canceled:
yield break;
default:
yield break;
}
}
private static IEnumerable <Link> GetLinks(Order order, string baseAddress)
{
var baseUri = new UriSegment(baseAddress);
var linker = new ResourceLinker(baseAddress);
var get = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.SlashOrderId,
new { orderId = order.Id }),
baseUri + "docs/order-get.htm",
MediaTypes.Default);
var update = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.SlashOrderId,
new { orderId = order.Id }),
baseUri + "docs/order-update.htm",
MediaTypes.Default);
var cancel = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.SlashOrderId,
new { orderId = order.Id }),
baseUri + "docs/order-cancel.htm",
MediaTypes.Default);
var pay = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.PaymentPath,
new { orderId = order.Id }),
baseUri + "docs/order-pay.htm",
MediaTypes.Default);
var receipt = new Link(linker.BuildUriString(OrderResourceHandler.Path,
OrderResourceHandler.ReceiptPath,
new { orderId = order.Id }),
baseUri + "docs/receipt-coffee.htm",
MediaTypes.Default);
switch (order.Status)
{
case OrderStatus.Unpaid:
yield return(get);
yield return(update);
yield return(cancel);
yield return(pay);
break;
case OrderStatus.Paid:
case OrderStatus.Delivered:
yield return(get);
break;
case OrderStatus.Ready:
yield return(receipt);
break;
case OrderStatus.Canceled:
yield break;
default:
yield break;
}
}
/// <summary>
/// Binds the specified effect data to this instance.
/// </summary>
/// <param name="effectDataArg">The effect data arg.</param>
/// <param name="cloneFromEffect">The clone from effect.</param>
/// <exception cref="System.InvalidOperationException">If no techniques found in this effect.</exception>
/// <exception cref="System.ArgumentException">If unable to find effect [effectName] from the EffectPool.</exception>
internal void InitializeFrom(EffectData.Effect effectDataArg, Effect cloneFromEffect)
{
RawEffectData = effectDataArg;
// Clean any previously allocated resources
if (DisposeCollector != null)
{
DisposeCollector.DisposeAndClear();
}
ConstantBuffers.Clear();
Parameters.Clear();
Techniques.Clear();
ResourceLinker = ToDispose(new EffectResourceLinker());
if (effectConstantBuffersCache != null)
{
effectConstantBuffersCache.Clear();
}
// Copy data
IsSupportingDynamicCompilation = RawEffectData.Arguments != null;
ShareConstantBuffers = RawEffectData.ShareConstantBuffers;
// Create the local effect constant buffers cache
if (!ShareConstantBuffers)
{
effectConstantBuffersCache = new Dictionary <EffectConstantBufferKey, EffectConstantBuffer>();
}
var logger = new Logger();
int techniqueIndex = 0;
int totalPassCount = 0;
EffectPass parentPass = null;
foreach (var techniqueRaw in RawEffectData.Techniques)
{
var name = techniqueRaw.Name;
if (string.IsNullOrEmpty(name))
{
name = string.Format("${0}", techniqueIndex++);
}
var technique = new EffectTechnique(this, name);
Techniques.Add(technique);
int passIndex = 0;
foreach (var passRaw in techniqueRaw.Passes)
{
name = passRaw.Name;
if (string.IsNullOrEmpty(name))
{
name = string.Format("${0}", passIndex++);
}
var pass = new EffectPass(logger, this, technique, passRaw, name);
pass.Initialize(logger);
// If this is a subpass, add it to the parent pass
if (passRaw.IsSubPass)
{
if (parentPass == null)
{
logger.Error("Pass [{0}] is declared as a subpass but has no parent.");
}
else
{
parentPass.SubPasses.Add(pass);
}
}
else
{
technique.Passes.Add(pass);
parentPass = pass;
}
}
// Count the number of passes
totalPassCount += technique.Passes.Count;
}
if (totalPassCount == 0)
{
throw new InvalidOperationException("No passes found in this effect.");
}
// Log all the exception in a single throw
if (logger.HasErrors)
{
throw new InvalidOperationException(Utilities.Join("\n", logger.Messages));
}
// Initialize the resource linker when we are done with all pass/parameters
ResourceLinker.Initialize();
//// Sort all parameters by their resource types
//// in order to achieve better local cache coherency in resource linker
Parameters.Items.Sort((left, right) =>
{
// First, order first all value types, then resource type
var comparison = left.IsValueType != right.IsValueType ? left.IsValueType ? -1 : 1 : 0;
// If same type
if (comparison == 0)
{
// Order by resource type
comparison = ((int)left.ResourceType).CompareTo((int)right.ResourceType);
// If same, order by resource index
if (comparison == 0)
{
comparison = left.Offset.CompareTo(right.Offset);
}
}
return(comparison);
});
// Prelink constant buffers
int resourceIndex = 0;
foreach (var parameter in Parameters)
{
// Recalculate parameter resource index
if (!parameter.IsValueType)
{
parameter.Offset = resourceIndex;
resourceIndex += parameter.ElementCount;
}
// Set the default values
parameter.SetDefaultValue();
if (parameter.ResourceType == EffectResourceType.ConstantBuffer)
{
parameter.SetResource(ConstantBuffers[parameter.Name]);
}
}
// Compute slot links
foreach (var technique in Techniques)
{
foreach (var pass in technique.Passes)
{
foreach (var subPass in pass.SubPasses)
{
subPass.ComputeSlotLinks();
}
pass.ComputeSlotLinks();
}
}
// Setup the first Current Technique.
CurrentTechnique = this.Techniques[0];
// Initialize predefined parameters used by Model.Draw (to speedup things internally)
DefaultParameters = new EffectDefaultParameters(this);
// If this is a clone, we need to
if (cloneFromEffect != null)
{
// Copy the content of the constant buffers to the new instance.
for (int i = 0; i < ConstantBuffers.Count; i++)
{
cloneFromEffect.ConstantBuffers[i].CopyTo(ConstantBuffers[i]);
}
// Copy back all bound resources except constant buffers
// that are already initialized with InitializeFrom method.
for (int i = 0; i < cloneFromEffect.ResourceLinker.Count; i++)
{
if (cloneFromEffect.ResourceLinker.BoundResources[i] is EffectConstantBuffer)
{
continue;
}
ResourceLinker.BoundResources[i] = cloneFromEffect.ResourceLinker.BoundResources[i];
unsafe
{
ResourceLinker.Pointers[i] = cloneFromEffect.ResourceLinker.Pointers[i];
}
}
// If everything was fine, then we can register it into the pool
Pool.AddEffect(this);
}
// Allow subclasses to complete initialization.
Initialize();
OnInitialized();
}
