From 4b2d6d556aa5cfe3e38fa03a6787f151e1f7638c Mon Sep 17 00:00:00 2001 From: Oliver Schrenk Date: Sun, 19 Jan 2025 12:03:42 +0100 Subject: [PATCH] :white_check_mark: Move to Testing framework --- Tests/CalendarFilterTest.swift | 64 +++++++++++++++++----------------- Tests/EventFilterTest.swift | 60 +++++++++++++++---------------- Tests/LegendTests.swift | 16 ++++----- Tests/ObjectTests.swift | 26 +++++--------- Tests/ParserTests.swift | 19 +++++----- Tests/ServiceTests.swift | 12 +++---- 6 files changed, 95 insertions(+), 102 deletions(-) diff --git a/Tests/CalendarFilterTest.swift b/Tests/CalendarFilterTest.swift index e9031e7..5c52a75 100644 --- a/Tests/CalendarFilterTest.swift +++ b/Tests/CalendarFilterTest.swift @@ -1,132 +1,132 @@ import EventKit +import Testing @testable import plan -import XCTest -final class CalendarFilterTests: XCTestCase { - func testAlwaysAccept() { +@Suite final class CalendarFilterTests { + @Test func testAlwaysAccept() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.Accept().accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was not accepted") + #expect(actual == expected, "The calendar was not accepted") } - func testSelectCalendarsMatching() { + @Test func testSelectCalendarsMatching() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.Select(uuids: [calendar.id]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was not accepted") + #expect(actual == expected, "The calendar was not accepted") } - func testSelectCalendarsEmptyArray() { + @Test func testSelectCalendarsEmptyArray() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.Select(uuids: []).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was not accepted") + #expect(actual == expected, "The calendar was not accepted") } - func testIgnoreCalendarsMatching() { + @Test func testIgnoreCalendarsMatching() { let calendar = PlanCalendar.generate() let expected = false let actual = CalendarFilter.Ignore(uuids: [calendar.id]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was accepted") + #expect(actual == expected, "The calendar was accepted") } - func testIgnoreCalendarsEmptyArray() { + @Test func testIgnoreCalendarsEmptyArray() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.Ignore(uuids: []).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was not accepted") + #expect(actual == expected, "The calendar was not accepted") } - func testIgnoreCalendarSourcesMatching() { + @Test func testIgnoreCalendarSourcesMatching() { let source = "Personal" let calendar = PlanCalendar.generate(source: source) let expected = false let actual = CalendarFilter.IgnoreSources(sources: [source]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was accepted") + #expect(actual == expected, "The calendar was accepted") } - func testIgnoreCalendarSourcesEmptyArray() { + @Test func testIgnoreCalendarSourcesEmptyArray() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.IgnoreSources(sources: []).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was rejected") + #expect(actual == expected, "The calendar was rejected") } - func testSelectCalendarSourcesMatching() { + @Test func testSelectCalendarSourcesMatching() { let source = "Personal" let calendar = PlanCalendar.generate(source: source) let expected = true let actual = CalendarFilter.SelectSources(sources: [source]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was rejected") + #expect(actual == expected, "The calendar was rejected") } - func testSelectCalendarSourcesNotMatching() { + @Test func testSelectCalendarSourcesNotMatching() { let source = "Personal" let calendar = PlanCalendar.generate(source: source) let expected = false let actual = CalendarFilter.SelectSources(sources: ["not-existing"]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was accepted") + #expect(actual == expected, "The calendar was accepted") } - func testSelectCalendarSourcesEmptyArray() { + @Test func testSelectCalendarSourcesEmptyArray() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.SelectSources(sources: []).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was rejected") + #expect(actual == expected, "The calendar was rejected") } - func testIgnoreCalendarTypesMatching() { + @Test func testIgnoreCalendarTypesMatching() { let type = EKCalendarType.birthday let calendar = PlanCalendar.generate(type: type) let expected = false let actual = CalendarFilter.IgnoreTypes(types: [type]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was accepted") + #expect(actual == expected, "The calendar was accepted") } - func testIgnoreCalendarTypesEmptyArray() { + @Test func testIgnoreCalendarTypesEmptyArray() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.IgnoreTypes(types: []).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was rejected") + #expect(actual == expected, "The calendar was rejected") } - func testSelectCalendarTypesMatching() { + @Test func testSelectCalendarTypesMatching() { let type = EKCalendarType.birthday let calendar = PlanCalendar.generate(type: type) let expected = true let actual = CalendarFilter.SelectTypes(types: [type]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was rejected") + #expect(actual == expected, "The calendar was rejected") } - func testSelectCalendarTypesNotMatching() { + @Test func testSelectCalendarTypesNotMatching() { let type = EKCalendarType.calDAV let calendar = PlanCalendar.generate(type: type) let expected = false let actual = CalendarFilter.SelectTypes(types: [EKCalendarType.birthday]).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was accepted") + #expect(actual == expected, "The calendar was accepted") } - func testSelectCalendarTypesEmptyArray() { + @Test func testSelectCalendarTypesEmptyArray() { let calendar = PlanCalendar.generate() let expected = true let actual = CalendarFilter.SelectTypes(types: []).accept(calendar) - XCTAssertEqual(actual, expected, "The calendar was rejected") + #expect(actual == expected, "The calendar was rejected") } } diff --git a/Tests/EventFilterTest.swift b/Tests/EventFilterTest.swift index 1b5e04e..c85747a 100644 --- a/Tests/EventFilterTest.swift +++ b/Tests/EventFilterTest.swift @@ -1,104 +1,104 @@ @testable import plan -import XCTest +import Testing -final class EventFilterTests: XCTestCase { - func testAlwaysAccept() { +@Suite final class EventFilterTests { + @Test func testAlwaysAccept() { let event = Event.generate() let expected = true let actual = EventFilter.Accept().accept(event) - XCTAssertEqual(actual, expected, "The event was not accepted") + #expect(actual == expected) } - func testIgnoreTagsNoTags() { + @Test func testIgnoreTagsNoTags() { let event = Event.generate(tags: ["timeblock"]) let expected = true let actual = EventFilter.IgnoreTags(tags: []).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely accepted") + #expect(actual == expected) } - func testIgnoreTagsMatchingTags() { + @Test func testIgnoreTagsMatchingTags() { let event = Event.generate(tags: ["timeblock"]) let expected = false let actual = EventFilter.IgnoreTags(tags: ["timeblock"]).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely accepted") + #expect(actual == expected) } - func testIgnoreTagsNotMatchingTags() { + @Test func testIgnoreTagsNotMatchingTags() { let event = Event.generate(tags: ["foo"]) let expected = true let actual = EventFilter.IgnoreTags(tags: ["timeblock"]).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely ignored") + #expect(actual == expected) } - func testIgnoreAnAllDayEvent() { + @Test func testIgnoreAnAllDayEvent() { let event = Event.generate(allDay: true) let expected = false let actual = EventFilter.IgnoreAllDay().accept(event) - XCTAssertEqual(actual, expected, "The event was falsely accepted") + #expect(actual == expected) } - func testAcceptAnNonAllDayEvent() { + @Test func testAcceptAnNonAllDayEvent() { let event = Event.generate(allDay: false) let expected = true let actual = EventFilter.IgnoreAllDay().accept(event) - XCTAssertEqual(actual, expected, "The event was falsely ignored") + #expect(actual == expected) } - func testIgnoringEventMatchingTitle() { + @Test func testIgnoringEventMatchingTitle() { let event = Event.generate(title: "foo matching") let expected = false let actual = EventFilter.IgnorePatternTitle(pattern: "foo").accept(event) - XCTAssertEqual(actual, expected, "The event was falsely accepted") + #expect(actual == expected) } - func testAcceptingEventNotMatchingTitle() { + @Test func testAcceptingEventNotMatchingTitle() { let event = Event.generate(title: "foo matching") let expected = true let actual = EventFilter.IgnorePatternTitle(pattern: "bar").accept(event) - XCTAssertEqual(actual, expected, "The event was falsely ignored") + #expect(actual == expected) } - func testAcceptingEventWithAtLeastTwoAttendees() { + @Test func testAcceptingEventWithAtLeastTwoAttendees() { let event = Event.generate(attendees: ["personA", "personB"]) let expected = true let actual = EventFilter.MinNumAttendees(count: 2).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely ignored") + #expect(actual == expected) } - func testAcceptingEventWithTooFewAttendees() { + @Test func testAcceptingEventWithTooFewAttendees() { let event = Event.generate(attendees: ["personA", "personB"]) let expected = false let actual = EventFilter.MinNumAttendees(count: 3).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely accepted") + #expect(actual == expected) } - func testAcceptingEventWithFewAttendees() { + @Test func testAcceptingEventWithFewAttendees() { let event = Event.generate(attendees: ["personA", "personB"]) let expected = true let actual = EventFilter.MaxNumAttendees(count: 3).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely ignored") + #expect(actual == expected) } - func testAcceptingEventWithTooManyAttendees() { + @Test func testAcceptingEventWithTooManyAttendees() { let event = Event.generate(attendees: ["personA", "personB", "personC"]) let expected = false let actual = EventFilter.MaxNumAttendees(count: 2).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely accepted") + #expect(actual == expected) } - func testAcceptCombinedFilter() { + @Test func testAcceptCombinedFilter() { let event = Event.generate(attendees: ["personA", "personB", "personC"]) let expected = true let min = EventFilter.MinNumAttendees(count: 2) @@ -106,10 +106,10 @@ final class EventFilterTests: XCTestCase { let actual = EventFilter.Combined(filters: [min, max]).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely ignored") + #expect(actual == expected) } - func testRejectCombinedFilter() { + @Test func testRejectCombinedFilter() { let event = Event.generate(attendees: ["personA", "personB", "personC"]) let expected = false let min = EventFilter.MinNumAttendees(count: 4) @@ -117,6 +117,6 @@ final class EventFilterTests: XCTestCase { let actual = EventFilter.Combined(filters: [min, max]).accept(event) - XCTAssertEqual(actual, expected, "The event was falsely accepted") + #expect(actual == expected) } } diff --git a/Tests/LegendTests.swift b/Tests/LegendTests.swift index 1618920..01a2686 100644 --- a/Tests/LegendTests.swift +++ b/Tests/LegendTests.swift @@ -1,29 +1,29 @@ @testable import plan -import XCTest +import Testing -final class LegendTests: XCTestCase { - func testWithoutEmoji() { +@Suite final class LegendTests { + @Test func testWithoutEmoji() { let input = "Banana" let expected = Legend(description: "Banana", icon: "") let output = input.asLegend() - XCTAssertEqual(output, expected, "The emoji was not correctly extracted") + #expect(output == expected) } - func testLeadingSimpleEmoji() { + @Test func testLeadingSimpleEmoji() { let input = "🍌 Banana" let expected = Legend(description: "Banana", icon: "🍌") let output = input.asLegend() - XCTAssertEqual(output, expected, "The emoji was not correctly extracted") + #expect(output == expected) } - func testLeadingCombinedEmoji() { + @Test func testLeadingCombinedEmoji() { // 'Thumbs up' with 'Emoji Modifier Fitzpatrick Type-4': let input = "👍🏽 Thumb" let expected = Legend(description: "Thumb", icon: "👍🏽") let output = input.asLegend() - XCTAssertEqual(output, expected, "The emoji was not correctly extracted") + #expect(output == expected) } } diff --git a/Tests/ObjectTests.swift b/Tests/ObjectTests.swift index 81d7620..4cf8336 100644 --- a/Tests/ObjectTests.swift +++ b/Tests/ObjectTests.swift @@ -1,30 +1,22 @@ @testable import plan -import XCTest +import Testing -final class ObjectTests: XCTestCase { - func testKeyPathOnKeywords() { +@Suite final class ObjectTests { + @Test func testKeyPathOnKeywords() { let event = Event.generate(title: "test") - do { + + #expect(throws: Never.self) { let expected = try Object.valueForKeyPath(event, "schedule.start.in") as? Int ?? -1 let output = 0 - XCTAssertEqual(output, expected, "The fields were not the same") - } catch { - XCTFail("Expected no error, but got \(error)") + #expect(output == expected) } } - func testNotComparable() { + @Test func testNotComparable() { let event = Event.generate(title: "test") - do { - XCTAssertThrowsError(try Object.valueForKeyPath(event, "schedule.start")) { error in - XCTAssertTrue( - error is Object.PathError, - "Unexpected error type: \(type(of: error))" - ) - - XCTAssertEqual(error as? Object.PathError, .notComparable) - } + #expect(throws: Object.PathError.self) { + try Object.valueForKeyPath(event, "schedule.start") } } } diff --git a/Tests/ParserTests.swift b/Tests/ParserTests.swift index 607ff9d..fca1a45 100644 --- a/Tests/ParserTests.swift +++ b/Tests/ParserTests.swift @@ -1,8 +1,9 @@ +import Foundation @testable import plan -import XCTest +import Testing -final class ParserTests: XCTestCase { - func testParseWithLeadingDash() { +@Suite final class ParserTests { + @Test func testParseWithLeadingDash() { let input = "- 10:00 - 12:00 🥗 Lunch" let expected = AddEvent( title: "🥗 Lunch", @@ -12,10 +13,10 @@ final class ParserTests: XCTestCase { ) let output = Parser.parse(text: input)! - XCTAssertEqual(output.title, expected.title, "The title was not correct") + #expect(output.title == expected.title) } - func testParseWithoutLeadingDash() { + @Test func testParseWithoutLeadingDash() { let input = "10:00 - 12:00 🥗 Lunch" let expected = AddEvent( title: "🥗 Lunch", @@ -25,10 +26,10 @@ final class ParserTests: XCTestCase { ) let output = Parser.parse(text: input)! - XCTAssertEqual(output.title, expected.title, "The title was not correct") + #expect(output.title == expected.title) } - func testParseTag() { + @Test func testParseTag() { let input = "10:00 - 12:00 🥗 Lunch #calendar/foo" let expected = AddEvent( title: "🥗 Lunch", @@ -38,7 +39,7 @@ final class ParserTests: XCTestCase { ) let output = Parser.parse(text: input)! - XCTAssertEqual(output.title, expected.title, "The title was not correct") - XCTAssertEqual(output.tag, expected.tag, "The title was not correct") + #expect(output.title == expected.title) + #expect(output.tag == expected.tag) } } diff --git a/Tests/ServiceTests.swift b/Tests/ServiceTests.swift index ff73c7a..9cec001 100644 --- a/Tests/ServiceTests.swift +++ b/Tests/ServiceTests.swift @@ -1,20 +1,20 @@ @testable import plan -import XCTest +import Testing -final class ServiceTests: XCTestCase { - func testEmptyNotes() { +@Suite final class ServiceTests { + @Test func testEmptyNotes() { let input = "" let expected = Service.fromNotes(notes: input) let output: [Service: String] = [:] - XCTAssertEqual(output, expected, "The notes were not empty") + #expect(output == expected) } - func testMeetNotes() { + @Test func testMeetNotes() { let input = "https://meet.google.com/ped-jqsa-fkv" let expected = Service.fromNotes(notes: input) let output: [Service: String] = [Service.meet: input] - XCTAssertEqual(output, expected, "The notes did not match") + #expect(output == expected) } }