Use spectre-build for tests

Tests/Nodes/ForNodeSpec.swift

@@ -3,60 +3,62 @@ import Stencil
 import Foundation
 
 
-describe("ForNode") {
-  let context = Context(dictionary: [
-    "items": [1, 2, 3],
-    "emptyItems": [Int](),
-  ])
+func testForNode() {
+  describe("ForNode") {
+    let context = Context(dictionary: [
+      "items": [1, 2, 3],
+      "emptyItems": [Int](),
+    ])
 
-  $0.it("renders the given nodes for each item") {
-    let nodes: [NodeType] = [VariableNode(variable: "item")]
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(context)) == "123"
-  }
+    $0.it("renders the given nodes for each item") {
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "123"
+    }
 
-  $0.it("renders the given empty nodes when no items found item") {
-    let nodes: [NodeType] = [VariableNode(variable: "item")]
-    let emptyNodes: [NodeType] = [TextNode(text: "empty")]
-    let node = ForNode(variable: "emptyItems", loopVariable: "item", nodes: nodes, emptyNodes: emptyNodes)
-    try expect(try node.render(context)) == "empty"
-  }
+    $0.it("renders the given empty nodes when no items found item") {
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let emptyNodes: [NodeType] = [TextNode(text: "empty")]
+      let node = ForNode(variable: "emptyItems", loopVariable: "item", nodes: nodes, emptyNodes: emptyNodes)
+      try expect(try node.render(context)) == "empty"
+    }
 
-  $0.it("renders a context variable of type Array<Any>") {
-    let any_context = Context(dictionary: [
+    $0.it("renders a context variable of type Array<Any>") {
+      let any_context = Context(dictionary: [
         "items": ([1, 2, 3] as [Any])
       ])
 
-    let nodes: [NodeType] = [VariableNode(variable: "item")]
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(any_context)) == "123" 
-  }
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(any_context)) == "123" 
+    }
 
-  $0.it("renders a context variable of type NSArray") {
-    let nsarray_context = Context(dictionary: [
+    $0.it("renders a context variable of type NSArray") {
+      let nsarray_context = Context(dictionary: [
         "items": NSArray(array: [1, 2, 3])
       ])
 
-    let nodes: [NodeType] = [VariableNode(variable: "item")]
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(nsarray_context)) == "123" 
-  }
+      let nodes: [NodeType] = [VariableNode(variable: "item")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(nsarray_context)) == "123" 
+    }
 
-  $0.it("renders the given nodes while providing if the item is first in the context") {
-    let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.first")]
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(context)) == "1true2false3false"
-  }
+    $0.it("renders the given nodes while providing if the item is first in the context") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.first")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "1true2false3false"
+    }
 
-  $0.it("renders the given nodes while providing if the item is last in the context") {
-    let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.last")]
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(context)) == "1false2false3true"
-  }
+    $0.it("renders the given nodes while providing if the item is last in the context") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.last")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "1false2false3true"
+    }
 
-  $0.it("renders the given nodes while providing item counter") {
-    let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")]
-    let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
-    try expect(try node.render(context)) == "112233"
+    $0.it("renders the given nodes while providing item counter") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")]
+      let node = ForNode(variable: "items", loopVariable: "item", nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "112233"
+    }
   }
 }

Tests/Nodes/IfNodeSpec.swift

@@ -1,113 +1,116 @@
 import Spectre
 import Stencil
 
-describe("IfNode") {
-  $0.describe("parsing") {
-    $0.it("can parse an if block") {
-      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, namespace: Namespace())
-      let nodes = try parser.parse()
-      let node = nodes.first as? IfNode
-      let trueNode = node?.trueNodes.first as? TextNode
-      let falseNode = node?.falseNodes.first as? TextNode
+func testIfNode() {
+  describe("IfNode") {
+    $0.describe("parsing") {
+      $0.it("can parse an if block") {
+        let tokens = [
+          Token.Block(value: "if value"),
+          Token.Text(value: "true"),
+          Token.Block(value: "else"),
+          Token.Text(value: "false"),
+          Token.Block(value: "endif")
+        ]
 
-      try expect(nodes.count) == 1
-      try expect(node?.variable.variable) == "value"
-      try expect(node?.trueNodes.count) == 1
-      try expect(trueNode?.text) == "true"
-      try expect(node?.falseNodes.count) == 1
-      try expect(falseNode?.text) == "false"
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let nodes = try parser.parse()
+        let node = nodes.first as? IfNode
+        let trueNode = node?.trueNodes.first as? TextNode
+        let falseNode = node?.falseNodes.first as? TextNode
+
+        try expect(nodes.count) == 1
+        try expect(node?.variable.variable) == "value"
+        try expect(node?.trueNodes.count) == 1
+        try expect(trueNode?.text) == "true"
+        try expect(node?.falseNodes.count) == 1
+        try expect(falseNode?.text) == "false"
+      }
+
+      $0.it("can parse an ifnot block") {
+        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, namespace: Namespace())
+        let nodes = try parser.parse()
+        let node = nodes.first as? IfNode
+        let trueNode = node?.trueNodes.first as? TextNode
+        let falseNode = node?.falseNodes.first as? TextNode
+
+        try expect(nodes.count) == 1
+        try expect(node?.variable.variable) == "value"
+        try expect(node?.trueNodes.count) == 1
+        try expect(trueNode?.text) == "true"
+        try expect(node?.falseNodes.count) == 1
+        try expect(falseNode?.text) == "false"
+      }
+
+      $0.it("throws an error when parsing an if block without an endif") {
+        let tokens = [
+          Token.Block(value: "if value"),
+        ]
+
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let error = TemplateSyntaxError("`endif` was not found.")
+        try expect(try parser.parse()).toThrow(error)
+      }
+
+      $0.it("throws an error when parsing an ifnot without an endif") {
+        let tokens = [
+          Token.Block(value: "ifnot value"),
+        ]
+
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let error = TemplateSyntaxError("`endif` was not found.")
+        try expect(try parser.parse()).toThrow(error)
+      }
     }
 
-    $0.it("can parse an ifnot block") {
-      let tokens = [
-        Token.Block(value: "ifnot value"),
-        Token.Text(value: "false"),
-        Token.Block(value: "else"),
-        Token.Text(value: "true"),
-        Token.Block(value: "endif")
-      ]
+    $0.describe("rendering") {
+      let context = Context(dictionary: ["items": true])
 
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let nodes = try parser.parse()
-      let node = nodes.first as? IfNode
-      let trueNode = node?.trueNodes.first as? TextNode
-      let falseNode = node?.falseNodes.first as? TextNode
+      $0.it("renders the truth when expression evaluates to true") {
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(context)) == "true"
+      }
 
-      try expect(nodes.count) == 1
-      try expect(node?.variable.variable) == "value"
-      try expect(node?.trueNodes.count) == 1
-      try expect(trueNode?.text) == "true"
-      try expect(node?.falseNodes.count) == 1
-      try expect(falseNode?.text) == "false"
-    }
+      $0.it("renders the false when expression evaluates to false") {
+        let node = IfNode(variable: "unknown", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(context)) == "false"
+      }
 
-    $0.it("throws an error when parsing an if block without an endif") {
-      let tokens = [
-        Token.Block(value: "if value"),
-      ]
+      $0.it("renders the truth when array expression is not empty") {
+        let items: Array<[String:AnyObject]> = [["key":"key1","value":42],["key":"key2","value":1337]]
+        let arrayContext = Context(dictionary: ["items": [items]])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "true"
+      }
 
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let error = TemplateSyntaxError("`endif` was not found.")
-      try expect(try parser.parse()).toThrow(error)
-    }
+      $0.it("renders the false when array expression is empty") {
+        let emptyItems = Array<[String:AnyObject]>()
+        let arrayContext = Context(dictionary: ["items": emptyItems])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "false"
+      }
 
-    $0.it("throws an error when parsing an ifnot without an endif") {
-      let tokens = [
-        Token.Block(value: "ifnot value"),
-      ]
+      $0.it("renders the false when dictionary expression is empty") {
+        let emptyItems = [String:AnyObject]()
+        let arrayContext = Context(dictionary: ["items": emptyItems])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "false"
+      }
 
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let error = TemplateSyntaxError("`endif` was not found.")
-      try expect(try parser.parse()).toThrow(error)
-    }
-  }
-
-  $0.describe("rendering") {
-    let context = Context(dictionary: ["items": true])
-
-    $0.it("renders the truth when expression evaluates to true") {
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(context)) == "true"
-    }
-
-    $0.it("renders the false when expression evaluates to false") {
-      let node = IfNode(variable: "unknown", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(context)) == "false"
-    }
-
-    $0.it("renders the truth when array expression is not empty") {
-      let items: Array<[String:AnyObject]> = [["key":"key1","value":42],["key":"key2","value":1337]]
-      let arrayContext = Context(dictionary: ["items": [items]])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "true"
-    }
-
-    $0.it("renders the false when array expression is empty") {
-      let emptyItems = Array<[String:AnyObject]>()
-      let arrayContext = Context(dictionary: ["items": emptyItems])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "false"
-    }
-
-    $0.it("renders the false when dictionary expression is empty") {
-      let emptyItems = [String:AnyObject]()
-      let arrayContext = Context(dictionary: ["items": emptyItems])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "false"
-    }
-
-    $0.it("renders the false when Array<Any> variable is empty") {
-      let arrayContext = Context(dictionary: ["items": ([] as [Any])])
-      let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
-      try expect(try node.render(arrayContext)) == "false"
+      $0.it("renders the false when Array<Any> variable is empty") {
+        let arrayContext = Context(dictionary: ["items": ([] as [Any])])
+        let node = IfNode(variable: "items", trueNodes: [TextNode(text: "true")], falseNodes: [TextNode(text: "false")])
+        try expect(try node.render(arrayContext)) == "false"
+      }
     }
   }
 }

Tests/Nodes/NodeSpec.swift

@@ -9,50 +9,52 @@ class ErrorNode : NodeType {
 }
 
 
-describe("Node") {
-  let context = Context(dictionary: [
-    "name": "Kyle",
-    "age": 27,
-    "items": [1, 2, 3],
-  ])
+func testNode() {
+  describe("Node") {
+    let context = Context(dictionary: [
+      "name": "Kyle",
+      "age": 27,
+      "items": [1, 2, 3],
+    ])
 
-  $0.describe("TextNode") {
-    $0.it("renders the given text") {
-      let node = TextNode(text: "Hello World")
-      try expect(try node.render(context)) == "Hello World"
-    }
-  }
-
-  $0.describe("VariableNode") {
-    $0.it("resolves and renders the variable") {
-      let node = VariableNode(variable: Variable("name"))
-      try expect(try node.render(context)) == "Kyle"
+    $0.describe("TextNode") {
+      $0.it("renders the given text") {
+        let node = TextNode(text: "Hello World")
+        try expect(try node.render(context)) == "Hello World"
+      }
     }
 
-    $0.it("resolves and renders a non string variable") {
-      let node = VariableNode(variable: Variable("age"))
-      try expect(try node.render(context)) == "27"
-    }
-  }
+    $0.describe("VariableNode") {
+      $0.it("resolves and renders the variable") {
+        let node = VariableNode(variable: Variable("name"))
+        try expect(try node.render(context)) == "Kyle"
+      }
 
-  $0.describe("rendering nodes") {
-    $0.it("renders the nodes") {
-      let nodes: [NodeType] = [
-        TextNode(text:"Hello "),
-        VariableNode(variable: "name"),
-      ]
-
-      try expect(try renderNodes(nodes, context)) == "Hello Kyle"
+      $0.it("resolves and renders a non string variable") {
+        let node = VariableNode(variable: Variable("age"))
+        try expect(try node.render(context)) == "27"
+      }
     }
 
-    $0.it("correctly throws a nodes failure") {
-      let nodes: [NodeType] = [
-        TextNode(text:"Hello "),
-        VariableNode(variable: "name"),
-        ErrorNode(),
-      ]
+    $0.describe("rendering nodes") {
+      $0.it("renders the nodes") {
+        let nodes: [NodeType] = [
+          TextNode(text:"Hello "),
+          VariableNode(variable: "name"),
+        ]
 
-      try expect(try renderNodes(nodes, context)).toThrow(TemplateSyntaxError("Custom Error"))
+        try expect(try renderNodes(nodes, context)) == "Hello Kyle"
+      }
+
+      $0.it("correctly throws a nodes failure") {
+        let nodes: [NodeType] = [
+          TextNode(text:"Hello "),
+          VariableNode(variable: "name"),
+          ErrorNode(),
+        ]
+
+        try expect(try renderNodes(nodes, context)).toThrow(TemplateSyntaxError("Custom Error"))
+      }
     }
   }
 }

Tests/Nodes/NowNodeSpec.swift

@@ -3,37 +3,39 @@ import Spectre
 import Stencil
 
 
-describe("NowNode") {
-  $0.describe("parsing") {
-    $0.it("parses default format without any now arguments") {
-      let tokens = [ Token.Block(value: "now") ]
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
+func testNowNode() {
+  describe("NowNode") {
+    $0.describe("parsing") {
+      $0.it("parses default format without any now arguments") {
+        let tokens = [ Token.Block(value: "now") ]
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
 
-      let nodes = try parser.parse()
-      let node = nodes.first as? NowNode
-      try expect(nodes.count) == 1
-      try expect(node?.format.variable) == "\"yyyy-MM-dd 'at' HH:mm\""
+        let nodes = try parser.parse()
+        let node = nodes.first as? NowNode
+        try expect(nodes.count) == 1
+        try expect(node?.format.variable) == "\"yyyy-MM-dd 'at' HH:mm\""
+      }
+
+      $0.it("parses now with a format") {
+        let tokens = [ Token.Block(value: "now \"HH:mm\"") ]
+        let parser = TokenParser(tokens: tokens, namespace: Namespace())
+        let nodes = try parser.parse()
+        let node = nodes.first as? NowNode
+        try expect(nodes.count) == 1
+        try expect(node?.format.variable) == "\"HH:mm\""
+      }
     }
 
-    $0.it("parses now with a format") {
-      let tokens = [ Token.Block(value: "now \"HH:mm\"") ]
-      let parser = TokenParser(tokens: tokens, namespace: Namespace())
-      let nodes = try parser.parse()
-      let node = nodes.first as? NowNode
-      try expect(nodes.count) == 1
-      try expect(node?.format.variable) == "\"HH:mm\""
-    }
-  }
+    $0.describe("rendering") {
+      $0.it("renders the date") {
+        let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
 
-  $0.describe("rendering") {
-    $0.it("renders the date") {
-      let node = NowNode(format: Variable("\"yyyy-MM-dd\""))
+        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())
-
-      try expect(try node.render(Context())) == date
+        try expect(try node.render(Context())) == date
+      }
     }
   }
 }