Create test modules under technology root warnings

The two test created are testModuleUnderAncestorOfTechnologyRoot, and
testModuleUnderTechnologyRoot. These test verify that technology roots,
nor ancestors of technology roots generate errors when linking to a
module.

testCrawlDiagnostics() already verifies that regular articles generate
an error when linking to modules. So creating that testcase is not needed.

Issue: 735

Author: Anthony Eid

Sources/SwiftDocC/Infrastructure/DocumentationCurator.swift

@@ -232,11 +232,13 @@ struct DocumentationCurator {
 
 
                 // If a module has a path with a manual technology root there shouldn't
-                // be an error messsage. Using an if statement allows fallthrough behavior 
-                // in that specific case
+                // be an error messsage. This is an if statement instead of a guard because
+                // when there's no warning we still curate the node
                 if childDocumentationNode.kind == .module {
 
-                    let hasTechnologyRoot = context.pathsTo(nodeReference).contains { path in
+                    var hasTechnologyRoot = documentationNode.kind.isSymbol == false
+
+                    hasTechnologyRoot = hasTechnologyRoot || context.pathsTo(nodeReference).contains { path in
                         if path.count == 0 {
                             return false
                         }
@@ -246,7 +248,7 @@ struct DocumentationCurator {
                     }
 
                     if !hasTechnologyRoot {
-                    problems.append(Problem(diagnostic: Diagnostic(source: source(), severity: .warning, range: range(), identifier: "org.swift.docc.ModuleCuration", summary: "Linking to \((link.destination ?? "").singleQuoted) from a Topics group in \(nodeReference.absoluteString.singleQuoted) isn't allowed", explanation: "The former is a module, and modules only exist at the root"), possibleSolutions: []))
+                    problems.append(Problem(diagnostic: Diagnostic(source: source(), severity: .warning, range: range(), identifier: "org.swift.docc.ModuleCuration", summary: "Linking to \((link.destination ?? "").singleQuoted) from a Topics group in \(nodeReference.absoluteString.singleQuoted) isn't allowed", explanation: "The former is a module test, and modules only exist at the root"), possibleSolutions: []))
                     continue
                     }
 

Tests/SwiftDocCTests/Infrastructure/DocumentationCuratorTests.swift

@@ -145,6 +145,96 @@ class DocumentationCuratorTests: XCTestCase {
         )
     }
 
+    func testModuleUnderTechnologyRoot() throws {
+        let (_, bundle, context) = try testBundleAndContext(copying: "ModuleUnderTechnologyRoot") { url in
+            try """
+            # Another Awesome Project
+            
+            Technology Root
+            
+            @Metadata {
+               @TechnologyRoot
+            }
+            
+            ## Overview
+            
+            This shouldn't create a warning because it's a technologyRoot
+            
+            ## Topics
+            
+            ### Code Reference
+            - ``MyAwesomeApp``
+            
+            """.write(to: url.appendingPathComponent("Root.md"), atomically: true, encoding: .utf8)
+        }
+        
+        var crawler = DocumentationCurator.init(in: context, bundle: bundle)
+        XCTAssert(context.problems.isEmpty, "Expected no problems. Found: \(context.problems.map(\.diagnostic.summary))")
+        
+        for node in context.rootModules {
+            XCTAssertNoThrow(try crawler.crawlChildren(of: node, prepareForCuration: { _ in }, relateNodes: { _, _ in }))
+        }
+        
+        XCTAssertEqual(crawler.problems.count, 0)
+            
+    }
+        
+    func testModuleUnderAncestorOfTechnologyRoot() throws {
+        let (_, bundle, context) = try testBundleAndContext(copying: "ModuleUnderTechnologyRoot") { url in
+            try """
+            # Another Awesome Project
+            
+            Technology Root
+            
+            @Metadata {
+               @TechnologyRoot
+            }
+            
+            ## Overview
+            
+            This shouldn't create a warning because it's a technologyRoot
+            
+            ## Topics
+            - <doc:Ancestor>
+            
+            ### Code Reference
+            
+            """.write(to: url.appendingPathComponent("Root.md"), atomically: true, encoding: .utf8)
+            
+            try """
+            # MyAwesomeApp Project
+            
+            Random summary
+
+            ## Overview
+
+            This is a project to test that no errors are created when a technology root refers to a
+            module.
+            
+            This should create a warning because it links to a module without being a technology root
+
+            ## Topics
+
+
+            ### Code Reference
+
+            - ``MyAwesomeApp``
+
+            """.write(to: url.appendingPathComponent("Ancestor.md"), atomically: true, encoding: .utf8)
+        }
+        
+        var crawler = DocumentationCurator.init(in: context, bundle: bundle)
+        XCTAssert(context.problems.isEmpty, "Expected no problems. Found: \(context.problems.map(\.diagnostic.summary))")
+        
+        for node in context.rootModules {
+            XCTAssertNoThrow(try crawler.crawlChildren(of: node, prepareForCuration: { _ in }, relateNodes: { _, _ in }))
+        }
+        
+       
+        XCTAssertEqual(crawler.problems.count, 0)
+    }
+
+
     func testSymbolLinkResolving() throws {
         let workspace = DocumentationWorkspace()
         let context = try DocumentationContext(dataProvider: workspace)