feat: Working on node builder

Tests/CliDocTests/CliDocTests.swift

@@ -1,70 +1,99 @@
 @_spi(Internal) import CliDoc
+@preconcurrency import Rainbow
 import Testing
+import XCTest
 
-@Test
-func testNodeBuilder() {
-  let node = AnyNode {
-    Text("foo").color(.green).style(.bold)
-    NewLine()
-    Text("bar").repeating(2)
+final class CliDocTests: XCTestCase {
+
+  override func setUp() {
+    super.setUp()
+    Rainbow.outputTarget = .console
+    Rainbow.enabled = true
   }
-  let expected = """
-  \("foo".green.bold)
-  barbar
-  """
-  #expect(node.render() == expected)
-}
 
-@Test(
-  arguments: [
-    (true, "foo bar"),
-    (false, """
-    foo
-    bar
-    """)
-  ]
-)
-func testSection(
-  inline: Bool,
-  expected: String
-) {
-  let node = AnyNode {
-    Section(
-      header: "foo",
-      separator: inline ? Space().eraseToAnyNode() : NewLine().eraseToAnyNode()
-    ) {
-      Text("bar")
+  func testStringChecks() {
+    let expected = "Foo".green.bold
+    let notexpected = "Foo"
+
+    XCTAssert("Foo".green.bold == expected)
+    XCTAssert("Foo".green.bold != notexpected)
+  }
+
+  func testRepeatingModifier() {
+    let node = AnyNode {
+      Text("foo").color(.green).style(.bold)
+      "\n".repeating(2)
+      Text("bar").repeating(2, separator: " ")
+    }
+    let expected = """
+    \("foo".green.bold)
+
+    bar bar
+    """
+    XCTAssert(node.render() == expected)
+  }
+
+  func testGroup1() {
+    let arguments = [
+      (true, "foo bar"),
+      (false, """
+      foo
+      bar
+      """)
+    ]
+
+    for (inline, expected) in arguments {
+      let node = AnyNode {
+        Group(separator: inline ? " " : "\n") {
+          Text("foo")
+          Text("bar")
+        }
+      }
+      XCTAssert(node.render() == expected)
     }
   }
 
-  print(node.render())
-  #expect(node.render() == expected)
-}
+  func testHeader() {
+    let header = Header("Foo")
+    let expected = "\("Foo".yellow.bold)"
+    XCTAssert(header.render() == expected)
 
-@Test
-func testHeader() {
-  let header = Header("Foo")
-  let expected = "\("Foo".yellow.bold)"
-  #expect(header.render() == expected)
-}
-
-@Test
-func testGroup() {
-  let group = Group {
-    Text("foo")
-    Text("bar")
+    let header2 = Header {
+      "Foo".yellow.bold
+    }
+    XCTAssert(header2.render() == expected)
   }
 
-  print(group.render())
-  #expect(group.render() == "foo bar")
+  func testGroup() {
+    let group = Group {
+      Text("foo")
+      Text("bar")
+    }
 
-  let group2 = Group(separator: .newLine()) {
-    Text("foo")
-    Text("bar")
+    XCTAssert(group.render() == "foo bar")
+
+    let group2 = Group(separator: "\n") {
+      Text("foo")
+      Text("bar")
+    }
+    let expected = """
+    foo
+    bar
+    """
+    XCTAssert(group2.render() == expected)
+  }
+
+  func testLabeledContent() {
+    let node = LabeledContent("Foo") {
+      Text("Bar")
+    }
+    .labelStyle(.green)
+    .labelStyle(.bold)
+
+    let expected = """
+    \("Foo".green.bold)
+    Bar
+    """
+    XCTAssert(node.render() == expected)
   }
-  let expected = """
-  foo
-  bar
-  """
-  #expect(group2.render() == expected)
 }