1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
--------------------------------------------------------------------------------
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
module Hakyll.Web.Template.Tests
( tests
) where
--------------------------------------------------------------------------------
import Test.Tasty (TestTree, testGroup)
import Test.Tasty.HUnit (Assertion, assertBool, testCase,
(@=?), (@?=))
import Data.Either (isLeft)
import System.IO (nativeNewline, Newline(..))
--------------------------------------------------------------------------------
import Hakyll.Core.Compiler
import Hakyll.Core.Identifier
import Hakyll.Core.Item
import Hakyll.Core.Provider
import Hakyll.Web.Template
import Hakyll.Web.Template.Context
import Hakyll.Web.Template.Internal
import Hakyll.Web.Template.List
import TestSuite.Util
--------------------------------------------------------------------------------
tests :: TestTree
tests = testGroup "Hakyll.Web.Template.Tests" $ concat
[ [ testCase "case01" $ test ("template.html.out", "template.html", "example.md")
, testCase "case02" $ test ("strip.html.out", "strip.html", "example.md")
, testCase "case03" $ test ("just-meta.html.out", "just-meta.html", "example.md")
, testCase "applyJoinTemplateList" testApplyJoinTemplateList
]
, fromAssertions "parseTemplate"
[ Right [Chunk "Hello ", Expr (Call "guest" [])]
@=? parse "Hello $guest()$"
, Right [If (Call "a" [StringLiteral "bar"]) [Chunk "foo"] Nothing]
@=? parse "$if(a(\"bar\"))$foo$endif$"
-- 'If' trim check.
, Right [ TrimL
, If (Ident (TemplateKey "body"))
[ TrimR
, Chunk "\n"
, Expr (Ident (TemplateKey "body"))
, Chunk "\n"
, TrimL
]
(Just [ TrimR
, Chunk "\n"
, Expr (Ident (TemplateKey "body"))
, Chunk "\n"
, TrimL
])
, TrimR
]
@=? parse "$-if(body)-$\n$body$\n$-else-$\n$body$\n$-endif-$"
-- 'For' trim check.
, Right [ TrimL
, For (Ident (TemplateKey "authors"))
[TrimR, Chunk "\n body \n", TrimL]
Nothing
, TrimR
]
@=? parse "$-for(authors)-$\n body \n$-endfor-$"
-- 'Partial' trim check.
, Right [ TrimL
, Partial (StringLiteral "path")
, TrimR
]
@=? parse "$-partial(\"path\")-$"
-- 'Expr' trim check.
, Right [ TrimL
, Expr (Ident (TemplateKey "foo"))
, TrimR
]
@=? parse "$-foo-$"
-- fail on incomplete template.
, assertBool "did not yield error" $ isLeft $
parse "a$b"
-- fail on mismatched template syntax.
, assertBool "did not fail to parse" $ isLeft $
parse "$for(xs)$\n <p>foo</p>\n$endif$"
]
, [testCase "embeddedTemplate" testEmbeddedTemplate]
]
where
parse = parseTemplateElemsFile ""
--------------------------------------------------------------------------------
test :: (Identifier, Identifier, Identifier) -> Assertion
test (outf, tplf, itemf) = do
store <- newTestStore
provider <- newTestProvider store
out <- resourceString provider outf
tpl <- testCompilerDone store provider tplf templateBodyCompiler
item <- testCompilerDone store provider itemf $
getResourceBody
>>= renderParagraphs
>>= applyTemplate (itemBody tpl) testContext
out @=? itemBody item
cleanTestEnv
--------------------------------------------------------------------------------
testContext :: Context String
testContext = mconcat
[ defaultContext
, listField "authors" (bodyField "name") $ do
n1 <- makeItem "Jan"
n2 <- makeItem "Piet"
return [n1, n2]
, functionField "rev" $ \args _ -> return $ unwords $ map reverse args
]
--------------------------------------------------------------------------------
testApplyJoinTemplateList :: Assertion
testApplyJoinTemplateList = do
store <- newTestStore
provider <- newTestProvider store
tpl <- testCompilerDone store provider "tpl" $
compileTemplateItem (Item "tpl" "<b>$body$</b>")
str <- testCompilerDone store provider "item3" $
applyJoinTemplateList ", " tpl defaultContext [i1, i2]
str @?= "<b>Hello</b>, <b>World</b>"
cleanTestEnv
where
i1 = Item "item1" "Hello"
i2 = Item "item2" "World"
--------------------------------------------------------------------------------
embeddedTemplate :: Template
embeddedTemplate = $(embedTemplate "tests/data/embed.html")
--------------------------------------------------------------------------------
testEmbeddedTemplate :: Assertion
testEmbeddedTemplate = do
store <- newTestStore
provider <- newTestProvider store
str <- testCompilerDone store provider "item3" $
applyTemplate embeddedTemplate defaultContext item
itemBody str @?= ("<p>Hello, world</p>" ++ (newline nativeNewline))
cleanTestEnv
where
item = Item "item1" "Hello, world"
newline LF = "\n"
newline CRLF = "\r\n"
|
