446 lines
24 KiB
FSharp
446 lines
24 KiB
FSharp
module Htmx
|
|
|
|
open System
|
|
open Expecto
|
|
open Giraffe.Htmx
|
|
open Microsoft.AspNetCore.Http
|
|
open NSubstitute
|
|
|
|
/// Tests for the IHeaderDictionary extension properties
|
|
let dictExtensions =
|
|
testList "IHeaderDictionaryExtensions" [
|
|
testList "HxBoosted" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxBoosted "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present and true" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Boosted", "true")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxBoosted "There should be a header present"
|
|
Expect.isTrue ctx.Request.Headers.HxBoosted.Value "The header value should have been true"
|
|
}
|
|
test "succeeds when the header is present and false" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Boosted", "false")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxBoosted "There should be a header present"
|
|
Expect.isFalse ctx.Request.Headers.HxBoosted.Value "The header value should have been false"
|
|
}
|
|
]
|
|
testList "HxCurrentUrl" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxCurrentUrl "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Current-URL", "http://localhost/test.htm")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxCurrentUrl "There should be a header present"
|
|
Expect.equal
|
|
ctx.Request.Headers.HxCurrentUrl.Value (Uri "http://localhost/test.htm")
|
|
"The header value was not correct"
|
|
}
|
|
]
|
|
testList "HxHistoryRestoreRequest" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxHistoryRestoreRequest "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present and true" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-History-Restore-Request", "true")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxHistoryRestoreRequest "There should be a header present"
|
|
Expect.isTrue ctx.Request.Headers.HxHistoryRestoreRequest.Value "The header value should have been true"
|
|
}
|
|
test "succeeds when the header is present and false" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-History-Restore-Request", "false")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxHistoryRestoreRequest "There should be a header present"
|
|
Expect.isFalse
|
|
ctx.Request.Headers.HxHistoryRestoreRequest.Value "The header should have been false"
|
|
}
|
|
]
|
|
testList "HxPreloaded" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxPreloaded "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present and true" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Preloaded", "true")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxPreloaded "There should be a header present"
|
|
Expect.isTrue ctx.Request.Headers.HxPreloaded.Value "The header should have been true"
|
|
}
|
|
// This is not a condition fired by the extension; the header will be either absent or true
|
|
test "succeeds when the header is present and false" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Preloaded", "false")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxPreloaded "There should be a header present"
|
|
Expect.isFalse ctx.Request.Headers.HxPreloaded.Value "The header should have been false"
|
|
}
|
|
]
|
|
testList "HxPrompt" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxPrompt "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Prompt", "of course")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxPrompt "There should be a header present"
|
|
Expect.equal ctx.Request.Headers.HxPrompt.Value "of course" "The header value was incorrect"
|
|
}
|
|
]
|
|
testList "HxRequest" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxRequest "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present and true" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request", "true")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxRequest "There should be a header present"
|
|
Expect.isTrue ctx.Request.Headers.HxRequest.Value "The header should have been true"
|
|
}
|
|
test "succeeds when the header is present and false" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request", "false")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxRequest "There should be a header present"
|
|
Expect.isFalse ctx.Request.Headers.HxRequest.Value "The header should have been false"
|
|
}
|
|
]
|
|
testList "HxRequestId" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxRequestId "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request-ID", "abcd1234")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxRequestId "There should be a header present"
|
|
Expect.equal ctx.Request.Headers.HxRequestId.Value "abcd1234" "The header value was incorrect"
|
|
}
|
|
]
|
|
testList "HxRequestType" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxRequestType "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is invalid" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request-Type", "relaxed")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxRequestType "There should not have been a header returned"
|
|
}
|
|
test "succeeds for a full request" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request-Type", "full")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxRequestType "There have been a header returned"
|
|
Expect.equal ctx.Request.Headers.HxRequestType.Value HxFullRequest "The header value is incorrect"
|
|
}
|
|
test "succeeds for a partial request" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request-Type", "partial")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isSome ctx.Request.Headers.HxRequestType "There have been a header returned"
|
|
Expect.equal ctx.Request.Headers.HxRequestType.Value HxPartialRequest "The header value is incorrect"
|
|
}
|
|
]
|
|
testList "HxSource" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxSource "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present and both parts exist" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Source", "button#theId")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let hdr = ctx.Request.Headers.HxSource
|
|
Expect.isSome hdr "There should be a header present"
|
|
Expect.equal (fst hdr.Value) "button" "The source tag was incorrect"
|
|
Expect.isSome (snd hdr.Value) "There should be a source ID present"
|
|
Expect.equal (snd hdr.Value).Value "theId" "The source ID was incorrect"
|
|
}
|
|
test "succeeds when the header is present and ID is blank" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Source", "a#")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let hdr = ctx.Request.Headers.HxSource
|
|
Expect.isSome hdr "There should be a header present"
|
|
Expect.equal (fst hdr.Value) "a" "The source tag was incorrect"
|
|
Expect.isNone (snd hdr.Value) "There should not be a source ID present"
|
|
}
|
|
test "succeeds when the header is present and ID is missing" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Source", "form")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let hdr = ctx.Request.Headers.HxSource
|
|
Expect.isSome hdr "There should be a header present"
|
|
Expect.equal (fst hdr.Value) "form" "The source tag was incorrect"
|
|
Expect.isNone (snd hdr.Value) "There should not be a source ID present"
|
|
}
|
|
]
|
|
testList "HxTarget" [
|
|
test "succeeds when the header is not present" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isNone ctx.Request.Headers.HxTarget "There should not have been a header returned"
|
|
}
|
|
test "succeeds when the header is present and both parts exist" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Target", "div#leItem")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let hdr = ctx.Request.Headers.HxTarget
|
|
Expect.isSome hdr "There should be a header present"
|
|
Expect.equal (fst hdr.Value) "div" "The target tag was incorrect"
|
|
Expect.isSome (snd hdr.Value) "There should be a target ID present"
|
|
Expect.equal (snd hdr.Value).Value "leItem" "The header value was incorrect"
|
|
}
|
|
test "succeeds when the header is present and ID is blank" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Target", "span#")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let hdr = ctx.Request.Headers.HxTarget
|
|
Expect.isSome hdr "There should be a header present"
|
|
Expect.equal (fst hdr.Value) "span" "The target tag was incorrect"
|
|
Expect.isNone (snd hdr.Value) "There should not be a target ID present"
|
|
}
|
|
test "succeeds when the header is present and ID is missing" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Target", "aside")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let hdr = ctx.Request.Headers.HxTarget
|
|
Expect.isSome hdr "There should be a header present"
|
|
Expect.equal (fst hdr.Value) "aside" "The target tag was incorrect"
|
|
Expect.isNone (snd hdr.Value) "There should not be a target ID present"
|
|
}
|
|
]
|
|
]
|
|
|
|
/// Tests for the HttpRequest extension properties
|
|
let reqExtensions =
|
|
testList "HttpRequestExtensions" [
|
|
testList "IsHtmx" [
|
|
test "succeeds when request is not from htmx" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isFalse ctx.Request.IsHtmx "The request should not be an htmx request"
|
|
}
|
|
test "succeeds when request is from htmx" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request", "true")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isTrue ctx.Request.IsHtmx "The request should have been an htmx request"
|
|
}
|
|
]
|
|
testList "IsHtmxRefresh" [
|
|
test "succeeds when request is not from htmx" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
ctx.Request.Headers.ReturnsForAnyArgs(HeaderDictionary()) |> ignore
|
|
Expect.isFalse ctx.Request.IsHtmxRefresh "The request should not have been an htmx refresh"
|
|
}
|
|
test "succeeds when request is from htmx, but not a refresh" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request", "true")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isFalse ctx.Request.IsHtmxRefresh "The request should not have been an htmx refresh"
|
|
}
|
|
test "IsHtmxRefresh succeeds when request is from htmx and is a refresh" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
dic.Add("HX-Request", "true")
|
|
dic.Add("HX-History-Restore-Request", "true")
|
|
ctx.Request.Headers.ReturnsForAnyArgs dic |> ignore
|
|
Expect.isTrue ctx.Request.IsHtmxRefresh "The request should have been an htmx refresh"
|
|
}
|
|
]
|
|
]
|
|
|
|
open System.Threading.Tasks
|
|
|
|
/// Dummy "next" parameter to get the pipeline to execute/terminate
|
|
let next (ctx: HttpContext) = Task.FromResult(Some ctx)
|
|
|
|
/// Tests for the HttpHandler functions provided in the Handlers module
|
|
let handlers =
|
|
testList "HandlerTests" [
|
|
testTask "withHxDownload succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxDownload "/files/stuff.pdf" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Download") "The HX-Download header should be present"
|
|
Expect.equal dic["HX-Download"].[0] "/files/stuff.pdf" "The HX-Download value was incorrect"
|
|
}
|
|
testTask "withHxLocation succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxLocation "/pagina-otro.html" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Location") "The HX-Location header should be present"
|
|
Expect.equal dic["HX-Location"].[0] "/pagina-otro.html" "The HX-Location value was incorrect"
|
|
}
|
|
testTask "withHxPushUrl succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxPushUrl "/a-new-url" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Push-Url") "The HX-Push-Url header should be present"
|
|
Expect.equal dic["HX-Push-Url"].[0] "/a-new-url" "The HX-Push-Url value was incorrect"
|
|
}
|
|
testTask "withHxNoPushUrl succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxNoPushUrl next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Push-Url") "The HX-Push-Url header should be present"
|
|
Expect.equal dic["HX-Push-Url"].[0] "false" "The HX-Push-Url value was incorrect"
|
|
}
|
|
testTask "withHxRedirect succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxRedirect "/somewhere-else" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Redirect") "The HX-Redirect header should be present"
|
|
Expect.equal dic["HX-Redirect"].[0] "/somewhere-else" "The HX-Redirect value was incorrect"
|
|
}
|
|
testList "withHxRefresh" [
|
|
testTask "succeeds when set to true" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxRefresh true next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Refresh") "The HX-Refresh header should be present"
|
|
Expect.equal dic["HX-Refresh"].[0] "true" "The HX-Refresh value was incorrect"
|
|
}
|
|
testTask "succeeds when set to false" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxRefresh false next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Refresh") "The HX-Refresh header should be present"
|
|
Expect.equal dic["HX-Refresh"].[0] "false" "The HX-Refresh value was incorrect"
|
|
}
|
|
]
|
|
testTask "withHxReplaceUrl succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxReplaceUrl "/a-substitute-url" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Replace-Url") "The HX-Replace-Url header should be present"
|
|
Expect.equal dic["HX-Replace-Url"].[0] "/a-substitute-url" "The HX-Replace-Url value was incorrect"
|
|
}
|
|
testTask "withHxNoReplaceUrl succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxNoReplaceUrl next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Replace-Url") "The HX-Replace-Url header should be present"
|
|
Expect.equal dic["HX-Replace-Url"].[0] "false" "The HX-Replace-Url value was incorrect"
|
|
}
|
|
testTask "withHxReselect succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxReselect "#test" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Reselect") "The HX-Reselect header should be present"
|
|
Expect.equal dic["HX-Reselect"].[0] "#test" "The HX-Reselect value was incorrect"
|
|
}
|
|
testTask "withHxReswap succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxReswap HxSwap.BeforeEnd next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Reswap") "The HX-Reswap header should be present"
|
|
Expect.equal dic["HX-Reswap"].[0] HxSwap.BeforeEnd "The HX-Reswap value was incorrect"
|
|
}
|
|
testTask "withHxRetarget succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxRetarget "#somewhereElse" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Retarget") "The HX-Retarget header should be present"
|
|
Expect.equal dic["HX-Retarget"].[0] "#somewhereElse" "The HX-Retarget value was incorrect"
|
|
}
|
|
testTask "withHxTrigger succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxTrigger "doSomething" next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Trigger") "The HX-Trigger header should be present"
|
|
Expect.equal dic["HX-Trigger"].[0] "doSomething" "The HX-Trigger value was incorrect"
|
|
}
|
|
testTask "withHxTriggerMany succeeds" {
|
|
let ctx = Substitute.For<HttpContext>()
|
|
let dic = HeaderDictionary()
|
|
ctx.Response.Headers.ReturnsForAnyArgs dic |> ignore
|
|
let! _ = withHxTriggerMany [ "blah", "foo"; "bleh", "bar" ] next ctx
|
|
Expect.isTrue (dic.ContainsKey "HX-Trigger") "The HX-Trigger header should be present"
|
|
Expect.equal
|
|
dic["HX-Trigger"].[0] """{ "blah": "foo", "bleh": "bar" }""" "The HX-Trigger value was incorrect"
|
|
}
|
|
]
|
|
|
|
/// Tests for the HtmxScript module
|
|
let script =
|
|
testList "HtmxScript" [
|
|
test "local generates correct link" {
|
|
Expect.equal
|
|
(string HtmxScript.local)
|
|
$"""<script src="/_content/Giraffe.Htmx.Common/htmx.min.js?ver={HtmxVersion}"></script>"""
|
|
"htmx script link is incorrect"
|
|
}
|
|
test "localMax generates correct link" {
|
|
Expect.equal
|
|
(string HtmxScript.localMax)
|
|
$"""<script src="/_content/Giraffe.Htmx.Common/htmax.min.js?ver={HtmxVersion}"></script>"""
|
|
"htmx script link is incorrect"
|
|
}
|
|
]
|
|
|
|
/// All tests for this module
|
|
let allTests = testList "Htmx" [ dictExtensions; reqExtensions; handlers; script ]
|