Add and update tests

intitni · intitni · commit 00305e532f68 · 2024-04-15T19:22:59.000+08:00
diff --git a/Core/Package.swift b/Core/Package.swift
@@ -66,6 +66,10 @@ let package = Package(
             ]
         ),
 
+        .testTarget(
+            name: "CodeCompletionServiceTests",
+            dependencies: ["CodeCompletionService"]
+        ),
         .testTarget(
             name: "FundamentalTests",
             dependencies: ["Fundamental"]
diff --git a/Core/Tests/CodeCompletionServiceTests/OpeningTagBasedStreamStopStrategyTests.swift b/Core/Tests/CodeCompletionServiceTests/OpeningTagBasedStreamStopStrategyTests.swift
@@ -0,0 +1,106 @@
+import Foundation
+import XCTest
+
+@testable import CodeCompletionService
+
+class OpeningTagBasedStreamStopStrategyTests: XCTestCase {
+    func test_no_opening_tag_found_and_not_hitting_limit() {
+        let strategy = OpeningTagBasedStreamStopStrategy(
+            openingTag: "<Code>",
+            toleranceIfNoOpeningTagFound: 3
+        )
+        let limiter = StreamLineLimiter(lineLimit: 1, strategy: strategy)
+        let content = """
+        Hello World
+        My Friend
+        """
+        for character in content {
+            let result = limiter.push(String(character))
+            XCTAssertEqual(result, .continue)
+        }
+        XCTAssertEqual(limiter.result, content)
+    }
+    
+    func test_no_opening_tag_found_hitting_limit() {
+        let strategy = OpeningTagBasedStreamStopStrategy(
+            openingTag: "<Code>",
+            toleranceIfNoOpeningTagFound: 3
+        )
+        let limiter = StreamLineLimiter(lineLimit: 1, strategy: strategy)
+        let content = """
+        Hello World
+        My Friend
+        How Are You
+        I Am Fine
+        Thank You
+        """
+        
+        let expected = """
+        Hello World
+        My Friend
+        How Are You
+        I Am Fine
+        
+        """
+        
+        for character in content {
+            let result = limiter.push(String(character))
+            if result == .finish(expected) {
+                XCTAssertEqual(limiter.result, expected)
+                return
+            }
+        }
+        XCTFail("Should return in the loop\n\n\(limiter.result)")
+    }
+    
+    func test_opening_tag_found_not_hitting_limit() {
+        let strategy = OpeningTagBasedStreamStopStrategy(
+            openingTag: "<Code>",
+            toleranceIfNoOpeningTagFound: 3
+        )
+        let limiter = StreamLineLimiter(lineLimit: 2, strategy: strategy)
+        let content = """
+        Hello World
+        <Code>
+        How Are You
+        """
+        for character in content {
+            let result = limiter.push(String(character))
+            XCTAssertEqual(result, .continue)
+        }
+        XCTAssertEqual(limiter.result, content)
+    }
+    
+    func test_opening_tag_found_hitting_limit() {
+        let strategy = OpeningTagBasedStreamStopStrategy(
+            openingTag: "<Code>",
+            toleranceIfNoOpeningTagFound: 3
+        )
+        let limiter = StreamLineLimiter(lineLimit: 2, strategy: strategy)
+        let content = """
+        Hello World
+        <Code>
+        How Are You
+        I Am Fine
+        Thank You
+        """
+        
+        let expected = """
+        Hello World
+        <Code>
+        How Are You
+        I Am Fine
+        
+        """
+        
+        for character in content {
+            let result = limiter.push(String(character))
+            if result == .finish(expected) {
+                XCTAssertEqual(limiter.result, expected)
+                return
+            }
+        }
+        XCTFail("Should return in the loop\n\n\(limiter.result)")
+    }
+}
+
diff --git a/Core/Tests/CodeCompletionServiceTests/StreamLineLimiterTests.swift b/Core/Tests/CodeCompletionServiceTests/StreamLineLimiterTests.swift
@@ -0,0 +1,69 @@
+import Foundation
+import XCTest
+
+@testable import CodeCompletionService
+
+class StreamLineLimiterTests: XCTestCase {
+    func test_pushing_characters_without_hitting_limit() {
+        let limiter = StreamLineLimiter(lineLimit: 2, strategy: DefaultStreamStopStrategy())
+        let content = "hello world\n"
+        for character in content {
+            let result = limiter.push(String(character))
+            XCTAssertEqual(result, .continue)
+        }
+        XCTAssertEqual(limiter.result, content)
+    }
+
+    func test_pushing_characters_hitting_limit() {
+        let limiter = StreamLineLimiter(lineLimit: 2, strategy: DefaultStreamStopStrategy())
+        let content = "hello world\nhello world\nhello world"
+        for character in content {
+            let result = limiter.push(String(character))
+            if result == .finish("hello world\nhello world\n") {
+                XCTAssertEqual(limiter.result, "hello world\nhello world\n")
+                return
+            }
+        }
+        XCTFail("Should return in the loop\n\(limiter.result)")
+    }
+
+    func test_pushing_characters_with_early_exit_strategy() {
+        struct Strategy: StreamStopStrategy {
+            func shouldStop(
+                existedLines: [String],
+                currentLine: String,
+                proposedLineLimit: Int
+            ) -> StreamStopStrategyResult {
+                let hasPrefixP = currentLine.hasPrefix("p")
+                let hasNewLine = existedLines.first?.hasSuffix("\n") ?? false
+                if hasPrefixP && hasNewLine {
+                    return .stop(appendingNewContent: false)
+                }
+                return .continue
+            }
+        }
+
+        let limiter = StreamLineLimiter(lineLimit: 10, strategy: Strategy())
+        let content = "hello world\npikachu\n"
+        for character in content {
+            let result = limiter.push(String(character))
+            if result == .finish("hello world\n") {
+                XCTAssertEqual(limiter.result, "hello world\n")
+                return
+            }
+        }
+        XCTFail("Should return in the loop\n\(limiter.result)")
+    }
+
+    func test_receiving_multiple_line_ending_as_a_single_token() {
+        let limiter = StreamLineLimiter(lineLimit: 4, strategy: DefaultStreamStopStrategy())
+        let content = "hello world"
+        for character in content {
+            let result = limiter.push(String(character))
+            XCTAssertEqual(result, .continue)
+        }
+        XCTAssertEqual(limiter.push("\n\n\n"), .continue)
+        XCTAssertEqual(limiter.push("\n"), .finish("hello world\n\n\n\n"))
+    }
+}
+
diff --git a/Core/Tests/SuggestionServiceTests/DefaultRawSuggestionPostProcessingStrategyTests.swift b/Core/Tests/SuggestionServiceTests/DefaultRawSuggestionPostProcessingStrategyTests.swift
@@ -6,8 +6,7 @@ import XCTest
 class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
     func test_whenSuggestionHasCodeTagAtTheFirstLine_shouldExtractCodeInside() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -21,8 +20,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
     func test_whenSuggestionHasCodeTagAtTheFirstLine_closingTagInOtherLines_shouldExtractCodeInside(
     ) {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -36,8 +34,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenSuggestionHasCodeTag_butNoClosingTag_shouldExtractCodeAfterTheTag() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -51,8 +48,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenMultipleOpeningTagFound_shouldTreatTheNextOneAsClosing() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -64,8 +60,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenMarkdownCodeBlockFound_shouldExtractCodeInside() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -80,8 +75,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenOnlyLinebreaksOrSpacesBeforeMarkdownCodeBlock_shouldExtractCodeInside() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -120,8 +114,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenMarkdownCodeBlockAndCodeTagFound_firstlyExtractCodeTag_thenCodeTag() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -137,8 +130,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
     func test_whenMarkdownCodeBlockAndCodeTagFound_butNoClosingTag_firstlyExtractCodeTag_thenCodeTag(
     ) {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -153,8 +145,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenSuggestionHasTheSamePrefix_removeThePrefix() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: "suggestion"
@@ -165,8 +156,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenSuggestionLooksLikeAMessage_parseItCorrectly() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.extractSuggestion(
             from: """
@@ -182,8 +172,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenSuggestionHasTheSamePrefix_inTags_removeThePrefix() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         var suggestion = "prefix suggestion"
         strategy.removePrefix(from: &suggestion, infillPrefix: "prefix")
@@ -193,8 +182,7 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
     func test_whenSuggestionHasTheSameSuffix_removeTheSuffix() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         var suggestion = "suggestion\na\nb"
         strategy.removeSuffix(from: &suggestion, suffix: [
@@ -214,11 +202,10 @@ class DefaultRawSuggestionPostProcessingStrategyTests: XCTestCase {
 
         XCTAssertEqual(suggestion3, "suggestion\na\n")
     }
-    
+
     func test_case_1() {
         let strategy = DefaultRawSuggestionPostProcessingStrategy(
-            openingCodeTag: "<Code>",
-            closingCodeTag: "</Code>"
+            codeWrappingTags: ("<Code>", "</Code>")
         )
         let result = strategy.postProcess(
             rawSuggestion: """
diff --git a/TestPlan.xctestplan b/TestPlan.xctestplan
@@ -15,8 +15,8 @@
     {
       "target" : {
         "containerPath" : "container:Core",
-        "identifier" : "SuggestionServiceTests",
-        "name" : "SuggestionServiceTests"
+        "identifier" : "CodeCompletionServiceTests",
+        "name" : "CodeCompletionServiceTests"
       }
     },
     {
@@ -25,6 +25,13 @@
         "identifier" : "FundamentalTests",
         "name" : "FundamentalTests"
       }
+    },
+    {
+      "target" : {
+        "containerPath" : "container:Core",
+        "identifier" : "SuggestionServiceTests",
+        "name" : "SuggestionServiceTests"
+      }
     }
   ],
   "version" : 1

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,8 @@`
`15`	`15`	`{`
`16`	`16`	`"target" : {`
`17`	`17`	`"containerPath" : "container:Core",`
`18`		`- "identifier" : "SuggestionServiceTests",`
`19`		`- "name" : "SuggestionServiceTests"`
	`18`	`+ "identifier" : "CodeCompletionServiceTests",`
	`19`	`+ "name" : "CodeCompletionServiceTests"`
`20`	`20`	`}`
`21`	`21`	`},`
`22`	`22`	`{`
`@@ -25,6 +25,13 @@`
`25`	`25`	`"identifier" : "FundamentalTests",`
`26`	`26`	`"name" : "FundamentalTests"`
`27`	`27`	`}`
	`28`	`+ },`
	`29`	`+ {`
	`30`	`+ "target" : {`
	`31`	`+ "containerPath" : "container:Core",`
	`32`	`+ "identifier" : "SuggestionServiceTests",`
	`33`	`+ "name" : "SuggestionServiceTests"`
	`34`	`+ }`
`28`	`35`	`}`
`29`	`36`	`],`
`30`	`37`	`"version" : 1`