From b4ba12bbdee78c7c1c64a4a2cc25329470dc4f6d Mon Sep 17 00:00:00 2001 From: Kyle Fuller Date: Tue, 2 Feb 2016 12:16:43 +0000 Subject: [PATCH] Use spectre-build for tests --- .swift-version | 2 +- .travis.yml | 8 + Makefile | 7 + Package.swift | 11 +- README.md | 2 +- Tests/ContextSpec.swift | 106 +++++------ Tests/FilterSpec.swift | 105 +++++------ Tests/LexerSpec.swift | 68 +++---- Tests/Nodes/ForNodeSpec.swift | 86 ++++----- Tests/Nodes/IfNodeSpec.swift | 197 +++++++++++---------- Tests/Nodes/NodeSpec.swift | 76 ++++---- Tests/Nodes/NowNodeSpec.swift | 54 +++--- Tests/ParserSpec.swift | 80 +++++---- Tests/StencilSpec.swift | 82 ++++----- Tests/TemplateLoader/IncludeSpec.swift | 82 ++++----- Tests/TemplateLoader/InheritenceSpec.swift | 16 +- Tests/TemplateLoaderSpec.swift | 26 +-- Tests/TemplateSpec.swift | 14 +- Tests/TokenSpec.swift | 44 ++--- Tests/VariableSpec.swift | 98 +++++----- Tests/main.swift | 15 ++ circle.yml | 21 --- 22 files changed, 621 insertions(+), 579 deletions(-) create mode 100644 .travis.yml create mode 100644 Makefile create mode 100644 Tests/main.swift delete mode 100644 circle.yml diff --git a/.swift-version b/.swift-version index c78c4ff..b1b7b7c 100644 --- a/.swift-version +++ b/.swift-version @@ -1 +1 @@ -2.2-dev +DEVELOPMENT-SNAPSHOT-2016-01-25-a diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..0d109c3 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,8 @@ +os: +- osx +osx_image: xcode7.2 +install: +- curl -sL https://gist.github.com/kylef/5c0475ff02b7c7671d2a/raw/621ef9b29bbb852fdfd2e10ed147b321d792c1e4/swiftenv-install.sh | bash +script: +- . ~/.swiftenv/init +- make test diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..c95da49 --- /dev/null +++ b/Makefile @@ -0,0 +1,7 @@ +stencil: + @echo "Building Stencil" + @swift build + +test: stencil + @echo "Running Tests" + @.build/debug/spectre-build diff --git a/Package.swift b/Package.swift index f9bf298..2c970d1 100644 --- a/Package.swift +++ b/Package.swift @@ -1,8 +1,11 @@ import PackageDescription let package = Package( - name: "Stencil", - dependencies: [ - .Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 6), - ] + name: "Stencil", + dependencies: [ + .Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 6), + ], + testDependencies: [ + .Package(url: "https://github.com/kylef/spectre-build", majorVersion: 0), + ] ) diff --git a/README.md b/README.md index 9a6b356..e906e2d 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Stencil -[![Build Status](http://img.shields.io/circleci/project/kylef/Stencil/master.svg)](https://circleci.com/gh/kylef/Stencil) +[![Build Status](https://travis-ci.org/kylef/Stencil.svg?branch=master)](https://travis-ci.org/kylef/Stencil) Stencil is a simple and powerful template language for Swift. It provides a syntax similar to Django and Mustache. If you're familiar with these, you will diff --git a/Tests/ContextSpec.swift b/Tests/ContextSpec.swift index 20e81f7..f9ff19d 100644 --- a/Tests/ContextSpec.swift +++ b/Tests/ContextSpec.swift @@ -2,64 +2,66 @@ import Spectre import Stencil -describe("Context") { - var context: Context! +func testContext() { + describe("Context") { + var context: Context! - $0.before { - context = Context(dictionary: ["name": "Kyle"]) - } + $0.before { + context = Context(dictionary: ["name": "Kyle"]) + } - $0.it("allows you to get a value via subscripting") { - try expect(context["name"] as? String) == "Kyle" - } + $0.it("allows you to get a value via subscripting") { + try expect(context["name"] as? String) == "Kyle" + } - $0.it("allows you to set a value via subscripting") { - context["name"] = "Katie" + $0.it("allows you to set a value via subscripting") { + context["name"] = "Katie" - try expect(context["name"] as? String) == "Katie" - } - - $0.it("allows you to remove a value via subscripting") { - context["name"] = nil - - try expect(context["name"]).to.beNil() - } - - $0.it("allows you to retrieve a value from a parent") { - context.push() - - try expect(context["name"] as? String) == "Kyle" - } - - $0.it("allows you to override a parent's value") { - context.push() - context["name"] = "Katie" - - try expect(context["name"] as? String) == "Katie" - } - - $0.it("allows you to pop to restore previous state") { - context.push() - context["name"] = "Katie" - context.pop() - - try expect(context["name"] as? String) == "Kyle" - } - - $0.it("allows you to push a dictionary onto the stack") { - context.push(["name": "Katie"]) - try expect(context["name"] as? String) == "Katie" - } - - $0.it("allows you to push a dictionary and run a closure then restoring previous state") { - var didRun = false - - try context.push(["name": "Katie"]) { - didRun = true try expect(context["name"] as? String) == "Katie" } - try expect(didRun).to.beTrue() - try expect(context["name"] as? String) == "Kyle" + $0.it("allows you to remove a value via subscripting") { + context["name"] = nil + + try expect(context["name"]).to.beNil() + } + + $0.it("allows you to retrieve a value from a parent") { + context.push() + + try expect(context["name"] as? String) == "Kyle" + } + + $0.it("allows you to override a parent's value") { + context.push() + context["name"] = "Katie" + + try expect(context["name"] as? String) == "Katie" + } + + $0.it("allows you to pop to restore previous state") { + context.push() + context["name"] = "Katie" + context.pop() + + try expect(context["name"] as? String) == "Kyle" + } + + $0.it("allows you to push a dictionary onto the stack") { + context.push(["name": "Katie"]) + try expect(context["name"] as? String) == "Katie" + } + + $0.it("allows you to push a dictionary and run a closure then restoring previous state") { + var didRun = false + + try context.push(["name": "Katie"]) { + didRun = true + try expect(context["name"] as? String) == "Katie" + } + + try expect(didRun).to.beTrue() + try expect(context["name"] as? String) == "Kyle" + } } } diff --git a/Tests/FilterSpec.swift b/Tests/FilterSpec.swift index 419007a..70d77e7 100644 --- a/Tests/FilterSpec.swift +++ b/Tests/FilterSpec.swift @@ -2,68 +2,69 @@ import Spectre import Stencil -describe("template filters") { - let context = Context(dictionary: ["name": "Kyle"]) +func testFilter() { + describe("template filters") { + let context = Context(dictionary: ["name": "Kyle"]) - $0.it("allows you to register a custom filter") { - let template = Template(templateString: "{{ name|repeat }}") + $0.it("allows you to register a custom filter") { + let template = Template(templateString: "{{ name|repeat }}") - let namespace = Namespace() - namespace.registerFilter("repeat") { value in - if let value = value as? String { - return "\(value) \(value)" + let namespace = Namespace() + namespace.registerFilter("repeat") { value in + if let value = value as? String { + return "\(value) \(value)" + } + + return nil } - return nil + let result = try template.render(context, namespace: namespace) + try expect(result) == "Kyle Kyle" } - let result = try template.render(context, namespace: namespace) - try expect(result) == "Kyle Kyle" - } + $0.it("allows you to register a custom which throws") { + let template = Template(templateString: "{{ name|repeat }}") + let namespace = Namespace() + namespace.registerFilter("repeat") { value in + throw TemplateSyntaxError("No Repeat") + } - $0.it("allows you to register a custom filter") { - let template = Template(templateString: "{{ name|repeat }}") - let namespace = Namespace() - namespace.registerFilter("repeat") { value in - throw TemplateSyntaxError("No Repeat") + try expect(try template.render(context, namespace: namespace)).toThrow(TemplateSyntaxError("No Repeat")) } - try expect(try template.render(context, namespace: namespace)).toThrow(TemplateSyntaxError("No Repeat")) + $0.it("allows whitespace in expression") { + let template = Template(templateString: "{{ name | uppercase }}") + let result = try template.render(Context(dictionary: ["name": "kyle"])) + try expect(result) == "KYLE" + } } - $0.it("allows whitespace in expression") { - let template = Template(templateString: "{{ name | uppercase }}") - let result = try template.render(Context(dictionary: ["name": "kyle"])) - try expect(result) == "KYLE" - } -} - - -describe("capitalize filter") { - let template = Template(templateString: "{{ name|capitalize }}") - - $0.it("capitalizes a string") { - let result = try template.render(Context(dictionary: ["name": "kyle"])) - try expect(result) == "Kyle" - } -} - - -describe("uppercase filter") { - let template = Template(templateString: "{{ name|uppercase }}") - - $0.it("transforms a string to be uppercase") { - let result = try template.render(Context(dictionary: ["name": "kyle"])) - try expect(result) == "KYLE" - } -} - - -describe("lowercase filter") { - let template = Template(templateString: "{{ name|lowercase }}") - - $0.it("transforms a string to be lowercase") { - let result = try template.render(Context(dictionary: ["name": "Kyle"])) - try expect(result) == "kyle" + + describe("capitalize filter") { + let template = Template(templateString: "{{ name|capitalize }}") + + $0.it("capitalizes a string") { + let result = try template.render(Context(dictionary: ["name": "kyle"])) + try expect(result) == "Kyle" + } + } + + + describe("uppercase filter") { + let template = Template(templateString: "{{ name|uppercase }}") + + $0.it("transforms a string to be uppercase") { + let result = try template.render(Context(dictionary: ["name": "kyle"])) + try expect(result) == "KYLE" + } + } + + describe("lowercase filter") { + let template = Template(templateString: "{{ name|lowercase }}") + + $0.it("transforms a string to be lowercase") { + let result = try template.render(Context(dictionary: ["name": "Kyle"])) + try expect(result) == "kyle" + } } } diff --git a/Tests/LexerSpec.swift b/Tests/LexerSpec.swift index c31f876..a5f6f79 100644 --- a/Tests/LexerSpec.swift +++ b/Tests/LexerSpec.swift @@ -2,47 +2,49 @@ import Spectre import Stencil -describe("Lexer") { - $0.it("can tokenize text") { - let lexer = Lexer(templateString: "Hello World") - let tokens = lexer.tokenize() +func testLexer() { + describe("Lexer") { + $0.it("can tokenize text") { + let lexer = Lexer(templateString: "Hello World") + let tokens = lexer.tokenize() - try expect(tokens.count) == 1 - try expect(tokens.first) == Token.Text(value: "Hello World") - } + try expect(tokens.count) == 1 + try expect(tokens.first) == Token.Text(value: "Hello World") + } - $0.it("can tokenize a comment") { - let lexer = Lexer(templateString: "{# Comment #}") - let tokens = lexer.tokenize() + $0.it("can tokenize a comment") { + let lexer = Lexer(templateString: "{# Comment #}") + let tokens = lexer.tokenize() - try expect(tokens.count) == (1) - try expect(tokens.first) == Token.Comment(value: "Comment") - } + try expect(tokens.count) == (1) + try expect(tokens.first) == Token.Comment(value: "Comment") + } - $0.it("can tokenize a variable") { - let lexer = Lexer(templateString: "{{ Variable }}") - let tokens = lexer.tokenize() + $0.it("can tokenize a variable") { + let lexer = Lexer(templateString: "{{ Variable }}") + let tokens = lexer.tokenize() - try expect(tokens.count) == 1 - try expect(tokens.first) == Token.Variable(value: "Variable") - } + try expect(tokens.count) == 1 + try expect(tokens.first) == Token.Variable(value: "Variable") + } - $0.it("can tokenize a mixture of content") { - let lexer = Lexer(templateString: "My name is {{ name }}.") - let tokens = lexer.tokenize() + $0.it("can tokenize a mixture of content") { + let lexer = Lexer(templateString: "My name is {{ name }}.") + let tokens = lexer.tokenize() - try expect(tokens.count) == 3 - try expect(tokens[0]) == Token.Text(value: "My name is ") - try expect(tokens[1]) == Token.Variable(value: "name") - try expect(tokens[2]) == Token.Text(value: ".") - } + try expect(tokens.count) == 3 + try expect(tokens[0]) == Token.Text(value: "My name is ") + try expect(tokens[1]) == Token.Variable(value: "name") + try expect(tokens[2]) == Token.Text(value: ".") + } - $0.it("can tokenize two variables without being greedy") { - let lexer = Lexer(templateString: "{{ thing }}{{ name }}") - let tokens = lexer.tokenize() + $0.it("can tokenize two variables without being greedy") { + let lexer = Lexer(templateString: "{{ thing }}{{ name }}") + let tokens = lexer.tokenize() - try expect(tokens.count) == 2 - try expect(tokens[0]) == Token.Variable(value: "thing") - try expect(tokens[1]) == Token.Variable(value: "name") + try expect(tokens.count) == 2 + try expect(tokens[0]) == Token.Variable(value: "thing") + try expect(tokens[1]) == Token.Variable(value: "name") + } } } diff --git a/Tests/Nodes/ForNodeSpec.swift b/Tests/Nodes/ForNodeSpec.swift index 585b9c5..856035a 100644 --- a/Tests/Nodes/ForNodeSpec.swift +++ b/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") { - let any_context = Context(dictionary: [ + $0.it("renders a context variable of type Array") { + 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" + } } } diff --git a/Tests/Nodes/IfNodeSpec.swift b/Tests/Nodes/IfNodeSpec.swift index 77f56e6..49f563a 100644 --- a/Tests/Nodes/IfNodeSpec.swift +++ b/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 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 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" + } } } } diff --git a/Tests/Nodes/NodeSpec.swift b/Tests/Nodes/NodeSpec.swift index 558b2d3..c951e57 100644 --- a/Tests/Nodes/NodeSpec.swift +++ b/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")) + } } } } diff --git a/Tests/Nodes/NowNodeSpec.swift b/Tests/Nodes/NowNodeSpec.swift index d6d9049..e0d9451 100644 --- a/Tests/Nodes/NowNodeSpec.swift +++ b/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 + } } } } diff --git a/Tests/ParserSpec.swift b/Tests/ParserSpec.swift index 399937e..5e4495c 100644 --- a/Tests/ParserSpec.swift +++ b/Tests/ParserSpec.swift @@ -2,54 +2,56 @@ import Spectre import Stencil -describe("TokenParser") { - $0.it("can parse a text token") { - let parser = TokenParser(tokens: [ - Token.Text(value: "Hello World") - ], namespace: Namespace()) +func testTokenParser() { + describe("TokenParser") { + $0.it("can parse a text token") { + let parser = TokenParser(tokens: [ + Token.Text(value: "Hello World") + ], namespace: Namespace()) - let nodes = try parser.parse() - let node = nodes.first as? TextNode + let nodes = try parser.parse() + let node = nodes.first as? TextNode - try expect(nodes.count) == 1 - try expect(node?.text) == "Hello World" - } + try expect(nodes.count) == 1 + try expect(node?.text) == "Hello World" + } - $0.it("can parse a variable token") { - let parser = TokenParser(tokens: [ - Token.Variable(value: "'name'") - ], namespace: Namespace()) + $0.it("can parse a variable token") { + let parser = TokenParser(tokens: [ + Token.Variable(value: "'name'") + ], namespace: Namespace()) - let nodes = try parser.parse() - let node = nodes.first as? VariableNode - try expect(nodes.count) == 1 - let result = try node?.render(Context()) - try expect(result) == "name" - } + let nodes = try parser.parse() + let node = nodes.first as? VariableNode + try expect(nodes.count) == 1 + let result = try node?.render(Context()) + try expect(result) == "name" + } - $0.it("can parse a comment token") { - let parser = TokenParser(tokens: [ - Token.Comment(value: "Secret stuff!") - ], namespace: Namespace()) + $0.it("can parse a comment token") { + let parser = TokenParser(tokens: [ + Token.Comment(value: "Secret stuff!") + ], namespace: Namespace()) - let nodes = try parser.parse() - try expect(nodes.count) == 0 - } + let nodes = try parser.parse() + try expect(nodes.count) == 0 + } - $0.it("can parse a tag token") { - let parser = TokenParser(tokens: [ - Token.Block(value: "now"), - ], namespace: Namespace()) + $0.it("can parse a tag token") { + let parser = TokenParser(tokens: [ + Token.Block(value: "now"), + ], namespace: Namespace()) - let nodes = try parser.parse() - try expect(nodes.count) == 1 - } + let nodes = try parser.parse() + try expect(nodes.count) == 1 + } - $0.it("errors when parsing an unknown tag") { - let parser = TokenParser(tokens: [ - Token.Block(value: "unknown"), - ], namespace: Namespace()) + $0.it("errors when parsing an unknown tag") { + let parser = TokenParser(tokens: [ + Token.Block(value: "unknown"), + ], namespace: Namespace()) - try expect(try parser.parse()).toThrow(TemplateSyntaxError("Unknown template tag 'unknown'")) + try expect(try parser.parse()).toThrow(TemplateSyntaxError("Unknown template tag 'unknown'")) + } } } diff --git a/Tests/StencilSpec.swift b/Tests/StencilSpec.swift index 6124071..1434c82 100644 --- a/Tests/StencilSpec.swift +++ b/Tests/StencilSpec.swift @@ -9,55 +9,57 @@ class CustomNode : NodeType { } -describe("Stencil") { - $0.it("can render the README example") { - let templateString = "There are {{ articles.count }} articles.\n" + - "\n" + - "{% for article in articles %}" + - " - {{ article.title }} by {{ article.author }}.\n" + - "{% endfor %}\n" +func testStencil() { + describe("Stencil") { + $0.it("can render the README example") { + 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 = try template.render(context) + let template = Template(templateString: templateString) + let result = try 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" - try expect(result) == fixture - } - - $0.it("can render a custom template tag") { - let templateString = "{% custom %}" - let template = Template(templateString: templateString) - - let namespace = Namespace() - namespace.registerTag("custom") { parser, token in - return CustomNode() + try expect(result) == fixture } - let result = try template.render(namespace: namespace) - try expect(result) == "Hello World" - } + $0.it("can render a custom template tag") { + let templateString = "{% custom %}" + let template = Template(templateString: templateString) - $0.it("can render a simple custom tag") { - let templateString = "{% custom %}" - let template = Template(templateString: templateString) + let namespace = Namespace() + namespace.registerTag("custom") { parser, token in + return CustomNode() + } - let namespace = Namespace() - namespace.registerSimpleTag("custom") { context in - return "Hello World" + let result = try template.render(namespace: namespace) + try expect(result) == "Hello World" } - try expect(try template.render(namespace: namespace)) == "Hello World" + $0.it("can render a simple custom tag") { + let templateString = "{% custom %}" + let template = Template(templateString: templateString) + + let namespace = Namespace() + namespace.registerSimpleTag("custom") { context in + return "Hello World" + } + + try expect(try template.render(namespace: namespace)) == "Hello World" + } } } diff --git a/Tests/TemplateLoader/IncludeSpec.swift b/Tests/TemplateLoader/IncludeSpec.swift index 797d3a1..1e94fa1 100644 --- a/Tests/TemplateLoader/IncludeSpec.swift +++ b/Tests/TemplateLoader/IncludeSpec.swift @@ -3,56 +3,58 @@ import Stencil import PathKit -describe("Include") { - let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures" - let loader = TemplateLoader(paths: [path]) +func testInclude() { + describe("Include") { + let path = Path(__FILE__) + ".." + ".." + "fixtures" + let loader = TemplateLoader(paths: [path]) - $0.describe("parsing") { - $0.it("throws an error when no template is given") { - let tokens = [ Token.Block(value: "include") ] - let parser = TokenParser(tokens: tokens, namespace: Namespace()) + $0.describe("parsing") { + $0.it("throws an error when no template is given") { + let tokens = [ Token.Block(value: "include") ] + let parser = TokenParser(tokens: tokens, namespace: Namespace()) - let error = TemplateSyntaxError("'include' tag takes one argument, the template file to be included") - try expect(try parser.parse()).toThrow(error) - } + let error = TemplateSyntaxError("'include' tag takes one argument, the template file to be included") + try expect(try parser.parse()).toThrow(error) + } - $0.it("can parse a valid include block") { - let tokens = [ Token.Block(value: "include \"test.html\"") ] - let parser = TokenParser(tokens: tokens, namespace: Namespace()) + $0.it("can parse a valid include block") { + let tokens = [ Token.Block(value: "include \"test.html\"") ] + let parser = TokenParser(tokens: tokens, namespace: Namespace()) - let nodes = try parser.parse() - let node = nodes.first as? IncludeNode - try expect(nodes.count) == 1 - try expect(node?.templateName) == Variable("\"test.html\"") - } - } - - $0.describe("rendering") { - $0.it("throws an error when rendering without a loader") { - let node = IncludeNode(templateName: Variable("\"test.html\"")) - - do { - try node.render(Context()) - } catch { - try expect("\(error)") == "Template loader not in context" + let nodes = try parser.parse() + let node = nodes.first as? IncludeNode + try expect(nodes.count) == 1 + try expect(node?.templateName) == Variable("\"test.html\"") } } - $0.it("throws an error when it cannot find the included template") { - let node = IncludeNode(templateName: Variable("\"unknown.html\"")) + $0.describe("rendering") { + $0.it("throws an error when rendering without a loader") { + let node = IncludeNode(templateName: Variable("\"test.html\"")) - do { - try node.render(Context(dictionary: ["loader": loader])) - } catch { - try expect("\(error)".hasPrefix("'unknown.html' template not found")).to.beTrue() + do { + try node.render(Context()) + } catch { + try expect("\(error)") == "Template loader not in context" + } } - } - $0.it("successfully renders a found included template") { - let node = IncludeNode(templateName: Variable("\"test.html\"")) - let context = Context(dictionary: ["loader":loader, "target": "World"]) - let value = try node.render(context) - try expect(value) == "Hello World!" + $0.it("throws an error when it cannot find the included template") { + let node = IncludeNode(templateName: Variable("\"unknown.html\"")) + + do { + try node.render(Context(dictionary: ["loader": loader])) + } catch { + try expect("\(error)".hasPrefix("'unknown.html' template not found")).to.beTrue() + } + } + + $0.it("successfully renders a found included template") { + let node = IncludeNode(templateName: Variable("\"test.html\"")) + let context = Context(dictionary: ["loader":loader, "target": "World"]) + let value = try node.render(context) + try expect(value) == "Hello World!" + } } } } diff --git a/Tests/TemplateLoader/InheritenceSpec.swift b/Tests/TemplateLoader/InheritenceSpec.swift index c74c00b..ba2d0ca 100644 --- a/Tests/TemplateLoader/InheritenceSpec.swift +++ b/Tests/TemplateLoader/InheritenceSpec.swift @@ -3,13 +3,15 @@ import Stencil import PathKit -describe("Inheritence") { - let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures" - let loader = TemplateLoader(paths: [path]) +func testInheritence() { + describe("Inheritence") { + let path = Path(__FILE__) + ".." + ".." + "fixtures" + let loader = TemplateLoader(paths: [path]) - $0.it("can inherit from another template") { - let context = Context(dictionary: ["loader": loader]) - let template = loader.loadTemplate("child.html") - try expect(try template?.render(context)) == "Header\nChild" + $0.it("can inherit from another template") { + let context = Context(dictionary: ["loader": loader]) + let template = loader.loadTemplate("child.html") + try expect(try template?.render(context)) == "Header\nChild" + } } } diff --git a/Tests/TemplateLoaderSpec.swift b/Tests/TemplateLoaderSpec.swift index 2a8d7e9..1f207de 100644 --- a/Tests/TemplateLoaderSpec.swift +++ b/Tests/TemplateLoaderSpec.swift @@ -3,21 +3,23 @@ import Stencil import PathKit -describe("TemplateLoader") { - let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures" - let loader = TemplateLoader(paths: [path]) +func testTemplateLoader() { + describe("TemplateLoader") { + let path = Path(__FILE__) + ".." + ".." + "Tests" + "fixtures" + let loader = TemplateLoader(paths: [path]) - $0.it("returns nil when a template cannot be found") { - try expect(loader.loadTemplate("unknown.html")).to.beNil() - } + $0.it("returns nil when a template cannot be found") { + try expect(loader.loadTemplate("unknown.html")).to.beNil() + } - $0.it("returns nil when an array of templates cannot be found") { - try expect(loader.loadTemplate(["unknown.html", "unknown2.html"])).to.beNil() - } + $0.it("returns nil when an array of templates cannot be found") { + try expect(loader.loadTemplate(["unknown.html", "unknown2.html"])).to.beNil() + } - $0.it("can load a template from a file") { - if loader.loadTemplate("test.html") == nil { - throw failure("didn't find the template") + $0.it("can load a template from a file") { + if loader.loadTemplate("test.html") == nil { + throw failure("didn't find the template") + } } } } diff --git a/Tests/TemplateSpec.swift b/Tests/TemplateSpec.swift index 30ce57f..a06f1bd 100644 --- a/Tests/TemplateSpec.swift +++ b/Tests/TemplateSpec.swift @@ -2,11 +2,13 @@ import Spectre import Stencil -describe("Template") { - $0.it("can render a template from a string") { - let context = Context(dictionary: [ "name": "Kyle" ]) - let template = Template(templateString: "Hello World") - let result = try template.render(context) - try expect(result) == "Hello World" +func testTemplate() { + describe("Template") { + $0.it("can render a template from a string") { + let context = Context(dictionary: [ "name": "Kyle" ]) + let template = Template(templateString: "Hello World") + let result = try template.render(context) + try expect(result) == "Hello World" + } } } diff --git a/Tests/TokenSpec.swift b/Tests/TokenSpec.swift index d9ea125..c084c57 100644 --- a/Tests/TokenSpec.swift +++ b/Tests/TokenSpec.swift @@ -2,31 +2,33 @@ import Spectre import Stencil -describe("Token") { - $0.it("can split the contents into components") { - let token = Token.Text(value: "hello world") - let components = token.components() +func testToken() { + describe("Token") { + $0.it("can split the contents into components") { + let token = Token.Text(value: "hello world") + let components = token.components() - try expect(components.count) == 2 - try expect(components[0]) == "hello" - try expect(components[1]) == "world" - } + try expect(components.count) == 2 + try expect(components[0]) == "hello" + try expect(components[1]) == "world" + } - $0.it("can split the contents into components with single quoted strings") { - let token = Token.Text(value: "hello 'kyle fuller'") - let components = token.components() + $0.it("can split the contents into components with single quoted strings") { + let token = Token.Text(value: "hello 'kyle fuller'") + let components = token.components() - try expect(components.count) == 2 - try expect(components[0]) == "hello" - try expect(components[1]) == "'kyle fuller'" - } + try expect(components.count) == 2 + try expect(components[0]) == "hello" + try expect(components[1]) == "'kyle fuller'" + } - $0.it("can split the contents into components with double quoted strings") { - let token = Token.Text(value: "hello \"kyle fuller\"") - let components = token.components() + $0.it("can split the contents into components with double quoted strings") { + let token = Token.Text(value: "hello \"kyle fuller\"") + let components = token.components() - try expect(components.count) == 2 - try expect(components[0]) == "hello" - try expect(components[1]) == "\"kyle fuller\"" + try expect(components.count) == 2 + try expect(components[0]) == "hello" + try expect(components[1]) == "\"kyle fuller\"" + } } } diff --git a/Tests/VariableSpec.swift b/Tests/VariableSpec.swift index f021d90..1b1c36c 100644 --- a/Tests/VariableSpec.swift +++ b/Tests/VariableSpec.swift @@ -8,61 +8,63 @@ import Stencil } -describe("Variable") { - let context = Context(dictionary: [ - "name": "Kyle", - "contacts": ["Katie", "Carlton"], - "profiles": [ - "github": "kylef", - ], - "object": Object(), - ]) +func testVariable() { + describe("Variable") { + let context = Context(dictionary: [ + "name": "Kyle", + "contacts": ["Katie", "Carlton"], + "profiles": [ + "github": "kylef", + ], + "object": Object(), + ]) - $0.it("can resolve a string literal with double quotes") { - let variable = Variable("\"name\"") - let result = try variable.resolve(context) as? String - try expect(result) == "name" - } + $0.it("can resolve a string literal with double quotes") { + let variable = Variable("\"name\"") + let result = try variable.resolve(context) as? String + try expect(result) == "name" + } - $0.it("can resolve a string literal with single quotes") { - let variable = Variable("'name'") - let result = try variable.resolve(context) as? String - try expect(result) == "name" - } + $0.it("can resolve a string literal with single quotes") { + let variable = Variable("'name'") + let result = try variable.resolve(context) as? String + try expect(result) == "name" + } - $0.it("can resolve a string variable") { - let variable = Variable("name") - let result = try variable.resolve(context) as? String - try expect(result) == "Kyle" - } + $0.it("can resolve a string variable") { + let variable = Variable("name") + let result = try variable.resolve(context) as? String + try expect(result) == "Kyle" + } - $0.it("can resolve an item from a dictionary") { - let variable = Variable("profiles.github") - let result = try variable.resolve(context) as? String - try expect(result) == "kylef" - } + $0.it("can resolve an item from a dictionary") { + let variable = Variable("profiles.github") + let result = try variable.resolve(context) as? String + try expect(result) == "kylef" + } - $0.it("can resolve an item from an array via it's index") { - let variable = Variable("contacts.0") - let result = try variable.resolve(context) as? String - try expect(result) == "Katie" - } + $0.it("can resolve an item from an array via it's index") { + let variable = Variable("contacts.0") + let result = try variable.resolve(context) as? String + try expect(result) == "Katie" + } - $0.it("can resolve the first item from an array") { - let variable = Variable("contacts.first") - let result = try variable.resolve(context) as? String - try expect(result) == "Katie" - } + $0.it("can resolve the first item from an array") { + let variable = Variable("contacts.first") + let result = try variable.resolve(context) as? String + try expect(result) == "Katie" + } - $0.it("can resolve the last item from an array") { - let variable = Variable("contacts.last") - let result = try variable.resolve(context) as? String - try expect(result) == "Carlton" - } + $0.it("can resolve the last item from an array") { + let variable = Variable("contacts.last") + let result = try variable.resolve(context) as? String + try expect(result) == "Carlton" + } - $0.it("can resolve a value via KVO") { - let variable = Variable("object.title") - let result = try variable.resolve(context) as? String - try expect(result) == "Hello World" + $0.it("can resolve a value via KVO") { + let variable = Variable("object.title") + let result = try variable.resolve(context) as? String + try expect(result) == "Hello World" + } } } diff --git a/Tests/main.swift b/Tests/main.swift new file mode 100644 index 0000000..421d40c --- /dev/null +++ b/Tests/main.swift @@ -0,0 +1,15 @@ +testContext() +testFilter() +testLexer() +testToken() +testTokenParser() +testTemplateLoader() +testTemplate() +testVariable() +testNode() +testForNode() +testIfNode() +testNowNode() +testInclude() +testInheritence() +testStencil() diff --git a/circle.yml b/circle.yml deleted file mode 100644 index df52107..0000000 --- a/circle.yml +++ /dev/null @@ -1,21 +0,0 @@ -machine: - xcode: - version: "7.0" - environment: - XCODE_SCHEME: NONE - XCODE_PROJECT: NONE - -dependencies: - post: - - brew install --HEAD kylef/formulae/conche - -test: - override: - - conche test - -deployment: - release: - tag: /.*/ - commands: - - pod trunk push -