summaryrefslogtreecommitdiff
path: root/tests/Hakyll/Web/Template/Tests.hs
blob: a73b92d552b31f0c4741cd76068494dbf3e50bb8 (plain)
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
--------------------------------------------------------------------------------
{-# 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           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>\n"
    cleanTestEnv
  where
    item = Item "item1" "Hello, world"