updated tests

Author: tib

README.md

@@ -1,3 +1,218 @@
 # SwiftHttp
 
-A description of this package.
+An awesome Swift HTTP library to rapidly setup the communication layer with API endpoints. 
+
+```swift
+import SwiftHttp
+
+print(html)
+```
+
+
+## Install
+
+You can simply use `SwiftHtml` as a dependency via the Swift Package Manager:
+
+```swift
+.package(url: "https://github.com/binarybirds/swift-html", from: "1.6.0"),
+```
+
+Add the `SwiftHtml` product from the `swift-html` package as a dependency to your target:
+
+```swift
+.product(name: "SwiftHtml", package: "swift-html"),
+```
+
+Import the framework:
+
+```swift
+import SwiftHtml
+```
+
+That's it.
+
+
+## Creating custom tags
+
+You can define your own custom tags by subclassing the `Tag` or `EmptyTag` class. 
+
+You can follow the same pattern if you take a look at the core tags.
+
+```swift
+open class Div: Tag {
+
+}
+
+// <div></div> - standard tag
+
+open class Br: EmptyTag {
+    
+}
+// <br> - no closing tag
+
+```
+
+By default the name of the tag is automatically derived from the class name (lowercased), but you can also create your own tag type & name by overriding the `createNode()` class function.
+
+```swift
+open class LastBuildDate: Tag {
+
+    open override class func createNode() -> Node {
+        Node(type: .standard, name: "lastBuildDate")
+    }
+}
+
+// <lastBuildDate></lastBuildDate> - standard tag with custom name
+```
+
+It is also possible to create tags with altered content or default attributes.
+
+```swift
+open class Description: Tag {
+    
+    public init(_ contents: String) {
+        super.init()
+        setContents("<![CDATA[" + contents + "]]>")
+    }
+}
+// <description><![CDATA[lorem ipsum]]></description> - content wrapped in CDATA
+
+open class Rss: Tag {
+    
+    public init(@TagBuilder _ builder: () -> [Tag]) {
+        super.init(builder())
+        setAttributes([
+            .init(key: "version", value: "2.0"),
+        ])
+    }
+}
+// <rss version="2.0">...</rss> - tag with a default attribute
+```
+
+## Attribute management
+
+You can set, add or delete the attributes of a given tag.
+
+```swift
+Leaf("example")
+    // set (override) the current attributes
+    .setAttributes([
+        .init(key: "a", value: "foo"),
+        .init(key: "b", value: "bar"),
+        .init(key: "c", value: "baz"),
+    ])
+    // add a new attribute using a key & value 
+    .attribute("foo", "example")
+    // add a new flag attribute (without a value)
+    .flagAttribute("bar")
+    // delete an attribute by using a key
+    .deleteAttribute("b")
+    
+// <leaf a="foo" c="baz" foo="example" bar></leaf>
+```
+
+You can also manage the class atrribute through helper methods.
+
+```swift
+Span("foo")
+    // set (override) class values 
+    .class("a", "b", "c")
+    // add new class values   
+    .class(add: ["d", "e", "f"])
+    // add new class value if the condition is true
+    .class(add: "b", true)
+    /// remove multiple class values
+    .class(remove: ["b", "c", "d"])
+    /// remove a class value if the condition is true
+    .class(remove: "e", true)
+
+// <span class="a f"></span>
+```
+
+You can create your own attribute modifier via an extension.
+
+```swift
+public extension Guid {
+    
+    func isPermalink(_ value: Bool = true) -> Self {
+        attribute("isPermalink", String(value))
+    }
+}
+```
+
+There are other built-in type-safe attribute modifiers available on tags.
+
+ 
+## Composing tags
+
+You can come up with your own `Tag` composition system by introducing a new protocol.
+
+```swift
+protocol TagRepresentable {
+
+    func build() -> Tag
+}
+
+struct ListComponent: TagRepresentable {
+
+    let items: [String]
+    
+    init(_ items: [String]) {
+        self.items = items
+    }
+
+    @TagBuilder
+    func build() -> Tag {
+        Ul {
+            items.map { Li($0) }
+        }
+    }
+}
+
+let tag = ListComponent(["a", "b", "c"]).build()
+```
+
+This way it is also possible to extend the `TagBuilder` to support the new protocol.
+
+```swift
+extension TagBuilder {
+
+    static func buildExpression(_ expression: TagRepresentable) -> Tag {
+        expression.build()
+    }
+    
+    static func buildExpression(_ expression: TagRepresentable) -> [Tag] {
+        [expression.build()]
+    }
+
+    static func buildExpression(_ expression: [TagRepresentable]) -> [Tag] {
+        expression.map { $0.build() }
+    }
+
+    static func buildExpression(_ expression: [TagRepresentable]) -> Tag {
+        GroupTag {
+            expression.map { $0.build() }
+        }
+    }
+}
+```
+
+Sometimes you'll need extra parameters for the build function, so you have to call the build method by hand.
+
+In those cases it is recommended to introduce a `render` function instead of using build.
+
+```swift
+
+let tag = WebIndexTemplate(ctx) {
+    ListComponent(["a", "b", "c"])
+        .render(req)
+}
+.render(req)
+```
+
+If you want to create a lightweight template engine for the [Vapor](https://vapor.codes/) web framework using SwiftHtml, you can see a working example inside the [Feather CMS core](https://github.com/FeatherCMS/feather-core) repository. 
+
+
+## Credits & references
+
+- [HTML Reference](https://www.w3schools.com/tags/default.asp)

Tests/SwiftHttpTests/Helpers/CustomDecoder.swift

@@ -0,0 +1,32 @@
+//
+//  CustomDecoder.swift
+//  SwiftHttpTests
+//
+//  Created by Tibor Bodecs on 2022. 03. 11..
+//
+
+import Foundation
+import SwiftHttp
+
+public extension HttpResponseDecoder {
+    
+    static func custom() -> HttpResponseDecoder {
+        .init(decoder: CustomDataDecoder(), validators: [
+            HttpHeaderValidator(.key(.contentType)) {
+                $0.contains("application/json")
+            },
+        ])
+    }
+}
+
+/// custom data decoder that transforms from a wrong object to a nice object...
+struct CustomDataDecoder: HttpDataDecoder {
+    struct WrongPost: Codable {
+        let id: Int
+    }
+    
+    func decode<T>(_ type: T.Type, from data: Data) throws -> T where T : Decodable {
+        let wrongPost = try JSONDecoder().decode(WrongPost.self, from: data)
+        return Post(userId: 1, id: wrongPost.id, title: "lorem", body: "ipsum") as! T
+    }
+}

Tests/SwiftHttpTests/Helpers/FeatherApi.swift

@@ -0,0 +1,42 @@
+//
+//  File.swift
+//  
+//
+//  Created by Tibor Bodecs on 2022. 03. 11..
+//
+
+import Foundation
+import SwiftHttp
+
+struct FeatherError: Codable {
+    let message: String
+}
+
+struct FeatherApi {
+
+    let client = UrlSessionHttpClient(log: true)
+    let apiBaseUrl = HttpUrl(scheme: "http", host: "test.binarybirds.com")
+     
+    func test() async throws -> [Post] {
+        let pipeline = HttpDecodablePipeline<[Post]>(url: apiBaseUrl.path("api", "test"),
+                                                     method: .get,
+                                                     validators: [
+                                                        HttpStatusCodeValidator(.ok)
+                                                     ],
+                                                     decoder: .json())
+        return try await pipeline.execute(client.dataTask)
+    }
+    
+    func testQueryParams() async throws -> String? {
+        let pipeline = HttpRawPipeline(url: apiBaseUrl
+                                            .path("api", "status")
+                                            .query([
+                                                "foo": "bar"
+                                            ]),
+                                        method: .get,
+                                        validators: [
+                                            HttpStatusCodeValidator(.ok)
+                                        ])
+        return try await pipeline.execute(client.dataTask).utf8String
+    }
+}

Tests/SwiftHttpTests/Helpers/PostsApi.swift renamed to Tests/SwiftHttpTests/Helpers/PostApi.swift

@@ -8,8 +8,7 @@
 import Foundation
 import SwiftHttp
 
-
-struct PostsApi: HttpCodablePipelineCollection {
+struct PostApi: HttpCodablePipelineCollection {
 
     let client: HttpClient = UrlSessionHttpClient(log: true)
     let apiBaseUrl = HttpUrl(host: "jsonplaceholder.typicode.com")

Tests/SwiftHttpTests/Helpers/Todo.swift

@@ -0,0 +1,14 @@
+//
+//  File.swift
+//  
+//
+//  Created by Tibor Bodecs on 2022. 03. 11..
+//
+
+import Foundation
+
+struct Todo: Codable {
+    let id: Int
+    let title: String
+    let completed: Bool
+}

Tests/SwiftHttpTests/Helpers/TodoApi.swift

@@ -0,0 +1,22 @@
+//
+//  File.swift
+//  
+//
+//  Created by Tibor Bodecs on 2022. 03. 11..
+//
+
+import Foundation
+import SwiftHttp
+
+struct TodoApi: HttpCodablePipelineCollection {
+
+    let client: HttpClient = UrlSessionHttpClient(log: true)
+    let apiBaseUrl = HttpUrl(host: "jsonplaceholder.typicode.com")
+
+    
+    func list() async throws -> [Todo] {
+        try await decodableRequest(executor: client.dataTask,
+                                   url: apiBaseUrl.path("todos"),
+                                   method: .get)
+    }    
+}

Tests/SwiftHttpTests/PostTests.swift

@@ -0,0 +1,49 @@
+//
+//  PostTests.swift
+//  SwiftHttpTests
+//
+//  Created by Tibor Bodecs on 2022. 03. 11..
+//
+
+import XCTest
+@testable import SwiftHttp
+
+final class PostTests: XCTestCase {
+        
+    let api = PostApi()
+    
+    func testList() async throws {
+        let posts = try await api.listPosts()
+        XCTAssertEqual(posts.count, 100)
+    }
+    
+    func testGet() async throws {
+        let post = try await api.getPost(1)
+        XCTAssertEqual(post.id, 1)
+    }
+    
+    func testCreate() async throws {
+        let object = Post(userId: 1, id: 1, title: "lorem ipsum", body: "dolor sit amet")
+        let post = try await api.createPost(object)
+        XCTAssertEqual(post.id, 101)
+    }
+    
+    func testUpdate() async throws {
+        let object = Post.Update(userId: 1, title: "lorem ipsum", body: "dolor sit amet")
+        let post = try await api.updatePost(1, object)
+        XCTAssertEqual(post.id, 1)
+    }
+    
+    func testPatch() async throws {
+        let object = Post.Update(userId: 1, title: "lorem ipsum", body: "dolor sit amet")
+        let post = try await api.patchPost(1, object)
+        XCTAssertEqual(post.id, 1)
+    }
+    
+    func testDelete() async throws {
+        let res = try await api.deletePost(1)
+        XCTAssertEqual(res.statusCode, .ok)
+    }
+
+}
+