swiftstencil/swiftpm-stencil
1
0
Fork 0
Code Issues Pull Requests Actions 5 Packages Projects Releases Wiki Activity

[Project] Use 2 spaces for indentation

Browse Source
This commit is contained in:
Kyle Fuller
2015-06-29 16:40:15 -07:00
parent 59bab00c97
commit 53d5a4f8c3
20 changed files with 1047 additions and 1045 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
StencilTests/ContextTests.swift
View File

@@ -3,63 +3,63 @@ import XCTest
import Stencil
class ContextTests: XCTestCase {
var context:Context!
var context:Context!
override func setUp() {
context = Context(dictionary: ["name": "Kyle"])
}
override func setUp() {
context = Context(dictionary: ["name": "Kyle"])
}
func testItAllowsYouToRetrieveAValue() {
let name = context["name"] as! String
XCTAssertEqual(name, "Kyle")
}
func testItAllowsYouToRetrieveAValue() {
let name = context["name"] as! String
XCTAssertEqual(name, "Kyle")
}
func testItAllowsYouToSetValue() {
context["name"] = "Katie"
func testItAllowsYouToSetValue() {
context["name"] = "Katie"
let name = context["name"] as! String
XCTAssertEqual(name, "Katie")
}
let name = context["name"] as! String
XCTAssertEqual(name, "Katie")
}
func testItAllowsYouToRemoveAValue() {
context["name"] = nil
XCTAssertNil(context["name"])
}
func testItAllowsYouToRemoveAValue() {
context["name"] = nil
XCTAssertNil(context["name"])
}
func testItAllowsYouToRetrieveAValueFromParent() {
context.push()
func testItAllowsYouToRetrieveAValueFromParent() {
context.push()
let name = context["name"] as! String
XCTAssertEqual(name, "Kyle")
}
let name = context["name"] as! String
XCTAssertEqual(name, "Kyle")
}
func testItAllowsYouToOverideAParentVariable() {
context.push()
context["name"] = "Katie"
func testItAllowsYouToOverideAParentVariable() {
context.push()
context["name"] = "Katie"
let name = context["name"] as! String
XCTAssertEqual(name, "Katie")
}
let name = context["name"] as! String
XCTAssertEqual(name, "Katie")
}
func testShowAllowYouToPopVariablesRestoringPreviousState() {
context.push()
context["name"] = "Katie"
context.pop()
func testShowAllowYouToPopVariablesRestoringPreviousState() {
context.push()
context["name"] = "Katie"
context.pop()
let name = context["name"] as! String
XCTAssertEqual(name, "Kyle")
}
let name = context["name"] as! String
XCTAssertEqual(name, "Kyle")
}
func testItAllowsYouToPushADictionaryToTheStack() {
context.push(["name": "Katie"])
func testItAllowsYouToPushADictionaryToTheStack() {
context.push(["name": "Katie"])
let name = context["name"] as! String
XCTAssertEqual(name, "Katie")
}
let name = context["name"] as! String
XCTAssertEqual(name, "Katie")
}
func testItAllowsYouToCompareTwoContextsForEquality() {
let otherContext = Context(dictionary: ["name": "Kyle"])
func testItAllowsYouToCompareTwoContextsForEquality() {
let otherContext = Context(dictionary: ["name": "Kyle"])
XCTAssertEqual(otherContext, context)
}
XCTAssertEqual(otherContext, context)
}
}

66
StencilTests/LexerTests.swift
View File

@@ -4,47 +4,47 @@ import Stencil
class LexerTests: XCTestCase {
func testTokenizeText() {
let lexer = Lexer(templateString:"Hello World")
let tokens = lexer.tokenize()
func testTokenizeText() {
let lexer = Lexer(templateString:"Hello World")
let tokens = lexer.tokenize()
XCTAssertEqual(tokens.count, 1)
XCTAssertEqual(tokens.first!, Token.Text(value: "Hello World"))
}
XCTAssertEqual(tokens.count, 1)
XCTAssertEqual(tokens.first!, Token.Text(value: "Hello World"))
}
func testTokenizeComment() {
let lexer = Lexer(templateString:"{# Comment #}")
let tokens = lexer.tokenize()
func testTokenizeComment() {
let lexer = Lexer(templateString:"{# Comment #}")
let tokens = lexer.tokenize()
XCTAssertEqual(tokens.count, 1)
XCTAssertEqual(tokens.first!, Token.Comment(value: "Comment"))
}
XCTAssertEqual(tokens.count, 1)
XCTAssertEqual(tokens.first!, Token.Comment(value: "Comment"))
}
func testTokenizeVariable() {
let lexer = Lexer(templateString:"{{ Variable }}")
let tokens = lexer.tokenize()
func testTokenizeVariable() {
let lexer = Lexer(templateString:"{{ Variable }}")
let tokens = lexer.tokenize()
XCTAssertEqual(tokens.count, 1)
XCTAssertEqual(tokens.first!, Token.Variable(value: "Variable"))
}
XCTAssertEqual(tokens.count, 1)
XCTAssertEqual(tokens.first!, Token.Variable(value: "Variable"))
}
func testTokenizeMixture() {
let lexer = Lexer(templateString:"My name is {{ name }}.")
let tokens = lexer.tokenize()
func testTokenizeMixture() {
let lexer = Lexer(templateString:"My name is {{ name }}.")
let tokens = lexer.tokenize()
XCTAssertEqual(tokens.count, 3)
XCTAssertEqual(tokens[0], Token.Text(value: "My name is "))
XCTAssertEqual(tokens[1], Token.Variable(value: "name"))
XCTAssertEqual(tokens[2], Token.Text(value: "."))
}
XCTAssertEqual(tokens.count, 3)
XCTAssertEqual(tokens[0], Token.Text(value: "My name is "))
XCTAssertEqual(tokens[1], Token.Variable(value: "name"))
XCTAssertEqual(tokens[2], Token.Text(value: "."))
}
func testTokenizeTwoVariables() { // Don't be greedy
let lexer = Lexer(templateString:"{{ thing }}{{ name }}")
let tokens = lexer.tokenize()
func testTokenizeTwoVariables() { // Don't be greedy
let lexer = Lexer(templateString:"{{ thing }}{{ name }}")
let tokens = lexer.tokenize()
XCTAssertEqual(tokens.count, 2)
XCTAssertEqual(tokens[0], Token.Variable(value: "thing"))
XCTAssertEqual(tokens[1], Token.Variable(value: "name"))
}
XCTAssertEqual(tokens.count, 2)
XCTAssertEqual(tokens[0], Token.Variable(value: "thing"))
XCTAssertEqual(tokens[1], Token.Variable(value: "name"))
}
}

350
StencilTests/NodeTests.swift
View File

@@ -3,248 +3,248 @@ import XCTest
import Stencil
class ErrorNodeError : Error {
var description: String {
return "Node Error"
}
var description: String {
return "Node Error"
}
}
class ErrorNode : Node {
func render(context: Context) -> Result {
func render(context: Context) -> Result {
return .Error(ErrorNodeError())
}
return .Error(ErrorNodeError())
}
}
class NodeTests: XCTestCase {
var context:Context!
var context:Context!
override func setUp() {
context = Context(dictionary: [
"name": "Kyle",
"age": 27,
"items": [1,2,3],
])
}
override func setUp() {
context = Context(dictionary: [
"name": "Kyle",
"age": 27,
"items": [1,2,3],
])
}
}
class TextNodeTests: NodeTests {
func testTextNodeResolvesText() {
let node = TextNode(text:"Hello World")
let result = node.render(context)
func testTextNodeResolvesText() {
let node = TextNode(text:"Hello World")
let result = node.render(context)
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "Hello World")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "Hello World")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
}
class VariableNodeTests: NodeTests {
func testVariableNodeResolvesVariable() {
let node = VariableNode(variable:Variable("name"))
let result = node.render(context)
func testVariableNodeResolvesVariable() {
let node = VariableNode(variable:Variable("name"))
let result = node.render(context)
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "Kyle")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "Kyle")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
func testVariableNodeResolvesNonStringVariable() {
let node = VariableNode(variable:Variable("age"))
let result = node.render(context)
func testVariableNodeResolvesNonStringVariable() {
let node = VariableNode(variable:Variable("age"))
let result = node.render(context)
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "27")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "27")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
}
class RenderNodeTests: NodeTests {
func testRenderingNodes() {
let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name")] as [Node]
switch renderNodes(nodes, context) {
case .Success(let result):
XCTAssertEqual(result, "Hello Kyle")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
func testRenderingNodes() {
let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name")] as [Node]
switch renderNodes(nodes, context) {
case .Success(let result):
XCTAssertEqual(result, "Hello Kyle")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
func testRenderingNodesWithFailure() {
let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name"), ErrorNode()] as [Node]
func testRenderingNodesWithFailure() {
let nodes = [TextNode(text:"Hello "), VariableNode(variable: "name"), ErrorNode()] as [Node]
switch renderNodes(nodes, context) {
case .Success(let result):
XCTAssert(false, "Unexpected success")
case .Error(let error):
XCTAssertEqual("\(error)", "Node Error")
}
switch renderNodes(nodes, context) {
case .Success(let result):
XCTAssert(false, "Unexpected success")
case .Error(let error):
XCTAssertEqual("\(error)", "Node Error")
}
}
}
class ForNodeTests: NodeTests {
func testForNodeRender() {
let node = ForNode(variable: "items", loopVariable: "item", nodes: [VariableNode(variable: "item")], emptyNodes:[])
let result = node.render(context)
func testForNodeRender() {
let node = ForNode(variable: "items", loopVariable: "item", nodes: [VariableNode(variable: "item")], emptyNodes:[])
let result = node.render(context)
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "123")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "123")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
}
class IfNodeTests: NodeTests {
// MARK: Parsing
// MARK: Parsing
func testParseIf() {
let tokens = [
Token.Block(value: "if value"),
Token.Text(value: "true"),
Token.Block(value: "else"),
Token.Text(value: "false"),
Token.Block(value: "endif")
]
func testParseIf() {
let tokens = [
Token.Block(value: "if value"),
Token.Text(value: "true"),
Token.Block(value: "else"),
Token.Text(value: "false"),
Token.Block(value: "endif")
]
let parser = TokenParser(tokens: tokens)
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! IfNode
let trueNode = node.trueNodes.first as! TextNode
let falseNode = node.falseNodes.first as! TextNode
let parser = TokenParser(tokens: tokens)
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! IfNode
let trueNode = node.trueNodes.first as! TextNode
let falseNode = node.falseNodes.first as! TextNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.variable.variable, "value")
XCTAssertEqual(node.trueNodes.count, 1)
XCTAssertEqual(trueNode.text, "true")
XCTAssertEqual(node.falseNodes.count, 1)
XCTAssertEqual(falseNode.text, "false")
}
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.variable.variable, "value")
XCTAssertEqual(node.trueNodes.count, 1)
XCTAssertEqual(trueNode.text, "true")
XCTAssertEqual(node.falseNodes.count, 1)
XCTAssertEqual(falseNode.text, "false")
}
}
func testParseIfNot() {
let tokens = [
Token.Block(value: "ifnot value"),
Token.Text(value: "false"),
Token.Block(value: "else"),
Token.Text(value: "true"),
Token.Block(value: "endif")
]
func testParseIfNot() {
let tokens = [
Token.Block(value: "ifnot value"),
Token.Text(value: "false"),
Token.Block(value: "else"),
Token.Text(value: "true"),
Token.Block(value: "endif")
]
let parser = TokenParser(tokens: tokens)
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! IfNode
let trueNode = node.trueNodes.first as! TextNode
let falseNode = node.falseNodes.first as! TextNode
let parser = TokenParser(tokens: tokens)
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! IfNode
let trueNode = node.trueNodes.first as! TextNode
let falseNode = node.falseNodes.first as! TextNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.variable.variable, "value")
XCTAssertEqual(node.trueNodes.count, 1)
XCTAssertEqual(trueNode.text, "true")
XCTAssertEqual(node.falseNodes.count, 1)
XCTAssertEqual(falseNode.text, "false")
}
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.variable.variable, "value")
XCTAssertEqual(node.trueNodes.count, 1)
XCTAssertEqual(trueNode.text, "true")
XCTAssertEqual(node.falseNodes.count, 1)
XCTAssertEqual(falseNode.text, "false")
}
}
func testParseIfWithoutEndIfError() {
let tokens = [
Token.Block(value: "if value"),
]
func testParseIfWithoutEndIfError() {
let tokens = [
Token.Block(value: "if value"),
]
let parser = TokenParser(tokens: tokens)
assertFailure(parser.parse(), "if: `endif` was not found.")
let parser = TokenParser(tokens: tokens)
assertFailure(parser.parse(), "if: `endif` was not found.")
}
func testParseIfNotWithoutEndIfError() {
let tokens = [
Token.Block(value: "ifnot value"),
]
let parser = TokenParser(tokens: tokens)
assertFailure(parser.parse(), "ifnot: `endif` was not found.")
}
// MARK: Rendering
func testIfNodeRenderTruth() {
let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
let result = node.render(context)
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "true")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
func testParseIfNotWithoutEndIfError() {
let tokens = [
Token.Block(value: "ifnot value"),
]
func testIfNodeRenderFalse() {
let node = IfNode(variable: "unknown", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
let result = node.render(context)
let parser = TokenParser(tokens: tokens)
assertFailure(parser.parse(), "ifnot: `endif` was not found.")
}
// MARK: Rendering
func testIfNodeRenderTruth() {
let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
let result = node.render(context)
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "true")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
func testIfNodeRenderFalse() {
let node = IfNode(variable: "unknown", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
let result = node.render(context)
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "false")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, "false")
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
}
class NowNodeTests: NodeTests {
// MARK: Parsing
// MARK: Parsing
func testParseDefaultNow() {
let tokens = [ Token.Block(value: "now") ]
let parser = TokenParser(tokens: tokens)
func testParseDefaultNow() {
let tokens = [ Token.Block(value: "now") ]
let parser = TokenParser(tokens: tokens)
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! NowNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.format.variable, "\"yyyy-MM-dd 'at' HH:mm\"")
}
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! NowNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.format.variable, "\"yyyy-MM-dd 'at' HH:mm\"")
}
}
func testParseNowWithFormat() {
let tokens = [ Token.Block(value: "now \"HH:mm\"") ]
let parser = TokenParser(tokens: tokens)
func testParseNowWithFormat() {
let tokens = [ Token.Block(value: "now \"HH:mm\"") ]
let parser = TokenParser(tokens: tokens)
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! NowNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.format.variable, "\"HH:mm\"")
}
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! NowNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.format.variable, "\"HH:mm\"")
}
}
// MARK: Rendering
// MARK: Rendering
func testRenderNowNode() {
let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
let result = node.render(context)
func testRenderNowNode() {
let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
let result = node.render(context)
let formatter = NSDateFormatter()
formatter.dateFormat = "yyyy-MM-dd"
let date = formatter.stringFromDate(NSDate())
let formatter = NSDateFormatter()
formatter.dateFormat = "yyyy-MM-dd"
let date = formatter.stringFromDate(NSDate())
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, date)
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
switch node.render(context) {
case .Success(let string):
XCTAssertEqual(string, date)
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
}

64
StencilTests/ParserTests.swift
View File

@@ -3,47 +3,47 @@ import XCTest
import Stencil
class TokenParserTests: XCTestCase {
func testParsingTextToken() {
let parser = TokenParser(tokens: [
Token.Text(value: "Hello World")
])
func testParsingTextToken() {
let parser = TokenParser(tokens: [
Token.Text(value: "Hello World")
])
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! TextNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.text, "Hello World")
}
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! TextNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.text, "Hello World")
}
}
func testParsingVariableToken() {
let parser = TokenParser(tokens: [
Token.Variable(value: "name")
])
func testParsingVariableToken() {
let parser = TokenParser(tokens: [
Token.Variable(value: "name")
])
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! VariableNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.variable, Variable("name"))
}
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! VariableNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.variable, Variable("name"))
}
}
func testParsingCommentToken() {
let parser = TokenParser(tokens: [
Token.Comment(value: "Secret stuff!")
])
func testParsingCommentToken() {
let parser = TokenParser(tokens: [
Token.Comment(value: "Secret stuff!")
])
assertSuccess(parser.parse()) { nodes in
XCTAssertEqual(nodes.count, 0)
}
assertSuccess(parser.parse()) { nodes in
XCTAssertEqual(nodes.count, 0)
}
}
func testParsingTagToken() {
let parser = TokenParser(tokens: [
Token.Block(value: "now"),
])
func testParsingTagToken() {
let parser = TokenParser(tokens: [
Token.Block(value: "now"),
])
assertSuccess(parser.parse()) { nodes in
XCTAssertEqual(nodes.count, 1)
}
assertSuccess(parser.parse()) { nodes in
XCTAssertEqual(nodes.count, 1)
}
}
}

108
StencilTests/StencilTests.swift
View File

@@ -3,77 +3,77 @@ import XCTest
import Stencil
func assertSuccess(result:TokenParser.Results, block:(([Node]) -> ())) {
switch result {
case .Success(let nodes):
block(nodes)
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
switch result {
case .Success(let nodes):
block(nodes)
case .Error(let error):
XCTAssert(false, "Unexpected error")
}
}
func assertFailure(result:TokenParser.Results, description:String) {
switch result {
case .Success(let nodes):
XCTAssert(false, "Unexpected error")
case .Error(let error):
XCTAssertEqual("\(error)", description)
}
switch result {
case .Success(let nodes):
XCTAssert(false, "Unexpected error")
case .Error(let error):
XCTAssertEqual("\(error)", description)
}
}
class CustomNode : Node {
func render(context:Context) -> Result {
return .Success("Hello World")
}
func render(context:Context) -> Result {
return .Success("Hello World")
}
}
class StencilTests: XCTestCase {
func testReadmeExample() {
let templateString = "There are {{ articles.count }} articles.\n" +
"\n" +
"{% for article in articles %}" +
" - {{ article.title }} by {{ article.author }}.\n" +
"{% endfor %}\n"
func testReadmeExample() {
let templateString = "There are {{ articles.count }} articles.\n" +
"\n" +
"{% for article in articles %}" +
" - {{ article.title }} by {{ article.author }}.\n" +
"{% endfor %}\n"
let context = Context(dictionary: [
"articles": [
[ "title": "Migrating from OCUnit to XCTest", "author": "Kyle Fuller" ],
[ "title": "Memory Management with ARC", "author": "Kyle Fuller" ],
]
])
let context = Context(dictionary: [
"articles": [
[ "title": "Migrating from OCUnit to XCTest", "author": "Kyle Fuller" ],
[ "title": "Memory Management with ARC", "author": "Kyle Fuller" ],
]
])
let template = Template(templateString:templateString)
let result = template.render(context)
let template = Template(templateString:templateString)
let result = template.render(context)
let fixture = "There are 2 articles.\n" +
"\n" +
" - Migrating from OCUnit to XCTest by Kyle Fuller.\n" +
" - Memory Management with ARC by Kyle Fuller.\n" +
"\n"
let fixture = "There are 2 articles.\n" +
"\n" +
" - Migrating from OCUnit to XCTest by Kyle Fuller.\n" +
" - Memory Management with ARC by Kyle Fuller.\n" +
"\n"
XCTAssertEqual(result, Result.Success(fixture))
XCTAssertEqual(result, Result.Success(fixture))
}
func testCustomTag() {
let templateString = "{% custom %}"
let template = Template(templateString:templateString)
template.parser.registerTag("custom") { parser, token in
return .Success(node:CustomNode())
}
func testCustomTag() {
let templateString = "{% custom %}"
let template = Template(templateString:templateString)
let result = template.render()
XCTAssertEqual(result, Result.Success("Hello World"))
}
template.parser.registerTag("custom") { parser, token in
return .Success(node:CustomNode())
}
func testSimpleCustomTag() {
let templateString = "{% custom %}"
let template = Template(templateString:templateString)
let result = template.render()
XCTAssertEqual(result, Result.Success("Hello World"))
template.parser.registerSimpleTag("custom") { context in
return .Success("Hello World")
}
func testSimpleCustomTag() {
let templateString = "{% custom %}"
let template = Template(templateString:templateString)
template.parser.registerSimpleTag("custom") { context in
return .Success("Hello World")
}
let result = template.render()
XCTAssertEqual(result, Result.Success("Hello World"))
}
let result = template.render()
XCTAssertEqual(result, Result.Success("Hello World"))
}
}

106
StencilTests/TemplateLoader/IncludeTests.swift
View File

@@ -5,71 +5,71 @@ import PathKit
class IncludeTests: NodeTests {
var loader:TemplateLoader!
var loader:TemplateLoader!
override func setUp() {
super.setUp()
override func setUp() {
super.setUp()
let path = (Path(__FILE__) + Path("../..")).absolute()
loader = TemplateLoader(paths: [path])
let path = (Path(__FILE__) + Path("../..")).absolute()
loader = TemplateLoader(paths: [path])
}
// MARK: Parsing
func testParseMissingTemplate() {
let tokens = [ Token.Block(value: "include") ]
let parser = TokenParser(tokens: tokens)
assertFailure(parser.parse(), "include: Tag takes one argument, the template file to be included")
}
func testParse() {
let tokens = [ Token.Block(value: "include \"test.html\"") ]
let parser = TokenParser(tokens: tokens)
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! IncludeNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.templateName, "test.html")
}
}
// MARK: Parsing
// MARK: Render
func testParseMissingTemplate() {
let tokens = [ Token.Block(value: "include") ]
let parser = TokenParser(tokens: tokens)
func testRenderWithoutLoader() {
let node = IncludeNode(templateName: "test.html")
let result = node.render(Context())
assertFailure(parser.parse(), "include: Tag takes one argument, the template file to be included")
switch result {
case .Success(let string):
XCTAssert(false, "Unexpected error")
case .Error(let error):
XCTAssertEqual("\(error)", "Template loader not in context")
}
}
func testParse() {
let tokens = [ Token.Block(value: "include \"test.html\"") ]
let parser = TokenParser(tokens: tokens)
func testRenderWithoutTemplateNamed() {
let node = IncludeNode(templateName: "unknown.html")
let result = node.render(Context(dictionary:["loader":loader]))
assertSuccess(parser.parse()) { nodes in
let node = nodes.first as! IncludeNode
XCTAssertEqual(nodes.count, 1)
XCTAssertEqual(node.templateName, "test.html")
}
switch result {
case .Success(let string):
XCTAssert(false, "Unexpected error")
case .Error(let error):
XCTAssertTrue("\(error)".hasPrefix("Template 'unknown.html' not found"))
}
}
// MARK: Render
func testRender() {
let node = IncludeNode(templateName: "test.html")
let result = node.render(Context(dictionary:["loader":loader, "target": "World"]))
func testRenderWithoutLoader() {
let node = IncludeNode(templateName: "test.html")
let result = node.render(Context())
switch result {
case .Success(let string):
XCTAssert(false, "Unexpected error")
case .Error(let error):
XCTAssertEqual("\(error)", "Template loader not in context")
}
}
func testRenderWithoutTemplateNamed() {
let node = IncludeNode(templateName: "unknown.html")
let result = node.render(Context(dictionary:["loader":loader]))
switch result {
case .Success(let string):
XCTAssert(false, "Unexpected error")
case .Error(let error):
XCTAssertTrue("\(error)".hasPrefix("Template 'unknown.html' not found"))
}
}
func testRender() {
let node = IncludeNode(templateName: "test.html")
let result = node.render(Context(dictionary:["loader":loader, "target": "World"]))
switch result {
case .Success(let string):
XCTAssertEqual(string, "Hello World!")
case .Error(let error):
XCTAssert(false, "Unexpected error: \(error)")
}
switch result {
case .Success(let string):
XCTAssertEqual(string, "Hello World!")
case .Error(let error):
XCTAssert(false, "Unexpected error: \(error)")
}
}
}

26
StencilTests/TemplateLoaderTests.swift
View File

@@ -5,20 +5,20 @@ import PathKit
class TemplateLoaderTests: XCTestCase {
func testLoadingUnknownTemplate() {
let loader = TemplateLoader(paths:[])
XCTAssertNil(loader.loadTemplate("unknown.html"))
}
func testLoadingUnknownTemplate() {
let loader = TemplateLoader(paths:[])
XCTAssertNil(loader.loadTemplate("unknown.html"))
}
func testLoadingUnknownTemplates() {
let loader = TemplateLoader(paths:[])
XCTAssertNil(loader.loadTemplate(["unknown.html", "unknown2.html"]))
}
func testLoadingUnknownTemplates() {
let loader = TemplateLoader(paths:[])
XCTAssertNil(loader.loadTemplate(["unknown.html", "unknown2.html"]))
}
func testLoadingTemplate() {
let path = (Path(__FILE__) + Path("..")).absolute()
let loader = TemplateLoader(paths: [path])
XCTAssertTrue(loader.loadTemplate("test.html") != nil)
}
func testLoadingTemplate() {
let path = (Path(__FILE__) + Path("..")).absolute()
let loader = TemplateLoader(paths: [path])
XCTAssertTrue(loader.loadTemplate("test.html") != nil)
}
}

12
StencilTests/TemplateTests.swift
View File

@@ -4,11 +4,11 @@ import Stencil
class TemplateTests: XCTestCase {
func testTemplate() {
let context = Context(dictionary: [ "name": "Kyle" ])
let template = Template(templateString: "Hello World")
let result = template.render(context)
XCTAssertEqual(result, Result.Success("Hello World"))
}
func testTemplate() {
let context = Context(dictionary: [ "name": "Kyle" ])
let template = Template(templateString: "Hello World")
let result = template.render(context)
XCTAssertEqual(result, Result.Success("Hello World"))
}
}

90
StencilTests/VariableTests.swift
View File

@@ -3,60 +3,60 @@ import XCTest
import Stencil
@objc class Object : NSObject {
let title = "Hello World"
let title = "Hello World"
}
class VariableTests: XCTestCase {
var context:Context!
var context:Context!
override func setUp() {
context = Context(dictionary: [
"name": "Kyle",
"contacts": [ "Katie", "Orta", ],
"profiles": [ "github": "kylef", ],
"object": Object(),
])
}
override func setUp() {
context = Context(dictionary: [
"name": "Kyle",
"contacts": [ "Katie", "Orta", ],
"profiles": [ "github": "kylef", ],
"object": Object(),
])
}
func testResolvingStringLiteral() {
let variable = Variable("\"name\"")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "name")
}
func testResolvingStringLiteral() {
let variable = Variable("\"name\"")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "name")
}
func testResolvingVariable() {
let variable = Variable("name")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Kyle")
}
func testResolvingVariable() {
let variable = Variable("name")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Kyle")
}
func testResolvingItemFromDictionary() {
let variable = Variable("profiles.github")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "kylef")
}
func testResolvingItemFromDictionary() {
let variable = Variable("profiles.github")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "kylef")
}
func testResolvingItemFromArrayWithIndex() {
let variable = Variable("contacts.0")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Katie")
}
func testResolvingItemFromArrayWithIndex() {
let variable = Variable("contacts.0")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Katie")
}
func testResolvingFirstItemFromArray() {
let variable = Variable("contacts.first")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Katie")
}
func testResolvingFirstItemFromArray() {
let variable = Variable("contacts.first")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Katie")
}
func testResolvingLastItemFromArray() {
let variable = Variable("contacts.last")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Orta")
}
func testResolvingLastItemFromArray() {
let variable = Variable("contacts.last")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Orta")
}
func testResolvingValueViaKVO() {
let variable = Variable("object.title")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Hello World")
}
func testResolvingValueViaKVO() {
let variable = Variable("object.title")
let result = variable.resolve(context) as! String
XCTAssertEqual(result, "Hello World")
}
}