Format whole codebase with ruff

make tests run again after reformatting
raise TypeError of the type is wrong

pyproject.toml

@@ -177,6 +177,8 @@ extend-safe-fixes = [
     "T203",   # `pprint` found
     "RUF001", # String contains ambiguous character
     "SLF001", # Private member accessed
+    "N999",   # module name
+    "PT027",  # assertRaises
 ]
 "src/icalendar/prop.py" = [
     "N801",   # Class name should use CamelCase

src/icalendar/cal.py

@@ -59,7 +59,7 @@ def get_example(component_directory: str, example_name: str) -> bytes:
     if not example_file.is_file():
         raise ValueError(
             f"Example {example_name} for {component_directory} not found. "
-            f"You can use one of {', '.join(p.stem for p in examples.iterdir())}"
+            f"You can use one of {', '.join(p.name for p in examples.iterdir())}"
         )
     return Path(example_file).read_bytes()
 

src/icalendar/tests/prop/test_unit.py

@@ -8,105 +8,105 @@ class TestProp(unittest.TestCase):
     def test_prop_vFloat(self):
         from icalendar.prop import vFloat
 
-        self.assertEqual(vFloat(1.0).to_ical(), b"1.0")
-        self.assertEqual(vFloat.from_ical("42"), 42.0)
-        self.assertEqual(vFloat(42).to_ical(), b"42.0")
+        assert vFloat(1.0).to_ical() == b"1.0"
+        assert vFloat.from_ical("42") == 42.0
+        assert vFloat(42).to_ical() == b"42.0"
         self.assertRaises(ValueError, vFloat.from_ical, "1s3")
 
     def test_prop_vInt(self):
         from icalendar.prop import vInt
 
-        self.assertEqual(vInt(42).to_ical(), b"42")
-        self.assertEqual(vInt.from_ical("13"), 13)
+        assert vInt(42).to_ical() == b"42"
+        assert vInt.from_ical("13") == 13
         self.assertRaises(ValueError, vInt.from_ical, "1s3")
 
     def test_prop_vDDDLists(self):
         from icalendar.prop import vDDDLists
 
         dt_list = vDDDLists.from_ical("19960402T010000Z")
-        self.assertIsInstance(dt_list, list)
-        self.assertEqual(len(dt_list), 1)
-        self.assertIsInstance(dt_list[0], datetime)
-        self.assertEqual(str(dt_list[0]), "1996-04-02 01:00:00+00:00")
+        assert isinstance(dt_list, list)
+        assert len(dt_list) == 1
+        assert isinstance(dt_list[0], datetime)
+        assert str(dt_list[0]) == "1996-04-02 01:00:00+00:00"
 
         p = "19960402T010000Z,19960403T010000Z,19960404T010000Z"
         dt_list = vDDDLists.from_ical(p)
-        self.assertEqual(len(dt_list), 3)
-        self.assertEqual(str(dt_list[0]), "1996-04-02 01:00:00+00:00")
-        self.assertEqual(str(dt_list[2]), "1996-04-04 01:00:00+00:00")
+        assert len(dt_list) == 3
+        assert str(dt_list[0]) == "1996-04-02 01:00:00+00:00"
+        assert str(dt_list[2]) == "1996-04-04 01:00:00+00:00"
 
         dt_list = vDDDLists([])
-        self.assertEqual(dt_list.to_ical(), b"")
+        assert dt_list.to_ical() == b""
 
         dt_list = vDDDLists([datetime(2000, 1, 1)])
-        self.assertEqual(dt_list.to_ical(), b"20000101T000000")
+        assert dt_list.to_ical() == b"20000101T000000"
 
         dt_list = vDDDLists([datetime(2000, 1, 1), datetime(2000, 11, 11)])
-        self.assertEqual(dt_list.to_ical(), b"20000101T000000,20001111T000000")
+        assert dt_list.to_ical() == b"20000101T000000,20001111T000000"
 
         instance = vDDDLists([])
-        self.assertNotEqual(instance, "value")
+        assert instance != "value"
 
     def test_prop_vDate(self):
         from icalendar.prop import vDate
 
-        self.assertEqual(vDate(date(2001, 1, 1)).to_ical(), b"20010101")
-        self.assertEqual(vDate(date(1899, 1, 1)).to_ical(), b"18990101")
+        assert vDate(date(2001, 1, 1)).to_ical() == b"20010101"
+        assert vDate(date(1899, 1, 1)).to_ical() == b"18990101"
 
-        self.assertEqual(vDate.from_ical("20010102"), date(2001, 1, 2))
+        assert vDate.from_ical("20010102") == date(2001, 1, 2)
 
-        self.assertRaises(ValueError, vDate, "d")
+        self.assertRaises(TypeError, vDate, "d")
         self.assertRaises(ValueError, vDate.from_ical, "200102")
 
     def test_prop_vDuration(self):
         from icalendar.prop import vDuration
 
-        self.assertEqual(vDuration(timedelta(11)).to_ical(), b"P11D")
-        self.assertEqual(vDuration(timedelta(-14)).to_ical(), b"-P14D")
-        self.assertEqual(vDuration(timedelta(1, 7384)).to_ical(), b"P1DT2H3M4S")
-        self.assertEqual(vDuration(timedelta(1, 7380)).to_ical(), b"P1DT2H3M")
-        self.assertEqual(vDuration(timedelta(1, 7200)).to_ical(), b"P1DT2H")
-        self.assertEqual(vDuration(timedelta(0, 7200)).to_ical(), b"PT2H")
-        self.assertEqual(vDuration(timedelta(0, 7384)).to_ical(), b"PT2H3M4S")
-        self.assertEqual(vDuration(timedelta(0, 184)).to_ical(), b"PT3M4S")
-        self.assertEqual(vDuration(timedelta(0, 22)).to_ical(), b"PT22S")
-        self.assertEqual(vDuration(timedelta(0, 3622)).to_ical(), b"PT1H0M22S")
-        self.assertEqual(vDuration(timedelta(days=1, hours=5)).to_ical(), b"P1DT5H")
-        self.assertEqual(vDuration(timedelta(hours=-5)).to_ical(), b"-PT5H")
-        self.assertEqual(vDuration(timedelta(days=-1, hours=-5)).to_ical(), b"-P1DT5H")
+        assert vDuration(timedelta(11)).to_ical() == b"P11D"
+        assert vDuration(timedelta(-14)).to_ical() == b"-P14D"
+        assert vDuration(timedelta(1, 7384)).to_ical() == b"P1DT2H3M4S"
+        assert vDuration(timedelta(1, 7380)).to_ical() == b"P1DT2H3M"
+        assert vDuration(timedelta(1, 7200)).to_ical() == b"P1DT2H"
+        assert vDuration(timedelta(0, 7200)).to_ical() == b"PT2H"
+        assert vDuration(timedelta(0, 7384)).to_ical() == b"PT2H3M4S"
+        assert vDuration(timedelta(0, 184)).to_ical() == b"PT3M4S"
+        assert vDuration(timedelta(0, 22)).to_ical() == b"PT22S"
+        assert vDuration(timedelta(0, 3622)).to_ical() == b"PT1H0M22S"
+        assert vDuration(timedelta(days=1, hours=5)).to_ical() == b"P1DT5H"
+        assert vDuration(timedelta(hours=-5)).to_ical() == b"-PT5H"
+        assert vDuration(timedelta(days=-1, hours=-5)).to_ical() == b"-P1DT5H"
 
         # How does the parsing work?
-        self.assertEqual(vDuration.from_ical("PT1H0M22S"), timedelta(0, 3622))
+        assert vDuration.from_ical("PT1H0M22S") == timedelta(0, 3622)
 
         self.assertRaises(ValueError, vDuration.from_ical, "kox")
 
-        self.assertEqual(vDuration.from_ical("-P14D"), timedelta(-14))
+        assert vDuration.from_ical("-P14D") == timedelta(-14)
 
-        self.assertRaises(ValueError, vDuration, 11)
+        self.assertRaises(TypeError, vDuration, 11)
 
         # calling to_ical twice should result in same output
         duration = vDuration(timedelta(days=-1, hours=-5))
-        self.assertEqual(duration.to_ical(), b"-P1DT5H")
-        self.assertEqual(duration.to_ical(), b"-P1DT5H")
+        assert duration.to_ical() == b"-P1DT5H"
+        assert duration.to_ical() == b"-P1DT5H"
 
     def test_prop_vWeekday(self):
         from icalendar.prop import vWeekday
 
-        self.assertEqual(vWeekday("mo").to_ical(), b"MO")
+        assert vWeekday("mo").to_ical() == b"MO"
         self.assertRaises(ValueError, vWeekday, "erwer")
-        self.assertEqual(vWeekday.from_ical("mo"), "MO")
-        self.assertEqual(vWeekday.from_ical("+3mo"), "+3MO")
+        assert vWeekday.from_ical("mo") == "MO"
+        assert vWeekday.from_ical("+3mo") == "+3MO"
         self.assertRaises(ValueError, vWeekday.from_ical, "Saturday")
-        self.assertEqual(vWeekday("+mo").to_ical(), b"+MO")
-        self.assertEqual(vWeekday("+3mo").to_ical(), b"+3MO")
-        self.assertEqual(vWeekday("-tu").to_ical(), b"-TU")
+        assert vWeekday("+mo").to_ical() == b"+MO"
+        assert vWeekday("+3mo").to_ical() == b"+3MO"
+        assert vWeekday("-tu").to_ical() == b"-TU"
 
     def test_prop_vFrequency(self):
         from icalendar.prop import vFrequency
 
         self.assertRaises(ValueError, vFrequency, "bad test")
-        self.assertEqual(vFrequency("daily").to_ical(), b"DAILY")
-        self.assertEqual(vFrequency("daily").from_ical("MONTHLY"), "MONTHLY")
+        assert vFrequency("daily").to_ical() == b"DAILY"
+        assert vFrequency("daily").from_ical("MONTHLY") == "MONTHLY"
         self.assertRaises(ValueError, vFrequency.from_ical, 234)
 
     def test_prop_vRecur(self):
@@ -115,11 +115,11 @@ class TestProp(unittest.TestCase):
         # Let's see how close we can get to one from the rfc:
         # FREQ=YEARLY;INTERVAL=2;BYMONTH=1;BYDAY=SU;BYHOUR=8,9;BYMINUTE=30
 
-        r = dict({"freq": "yearly", "interval": 2})
+        r = {"freq": "yearly", "interval": 2}
         r.update({"bymonth": 1, "byday": "su", "byhour": [8, 9], "byminute": 30})
-        self.assertEqual(
-            vRecur(r).to_ical(),
-            b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=SU;BYMONTH=1",
+        assert (
+            vRecur(r).to_ical()
+            == b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=SU;BYMONTH=1"
         )
 
         r = vRecur(FREQ="yearly", INTERVAL=2)
@@ -131,60 +131,55 @@ class TestProp(unittest.TestCase):
                 "BYMINUTE": 30,
             }
         )
-        self.assertEqual(
-            r.to_ical(),
-            b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=SU;BYMONTH=1",
+        assert (
+            r.to_ical()
+            == b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=SU;BYMONTH=1"
         )
 
         r = vRecur(freq="DAILY", count=10)
         r["bysecond"] = [0, 15, 30, 45]
-        self.assertEqual(r.to_ical(), b"FREQ=DAILY;COUNT=10;BYSECOND=0,15,30,45")
+        assert r.to_ical() == b"FREQ=DAILY;COUNT=10;BYSECOND=0,15,30,45"
 
         r = vRecur(freq="DAILY", until=datetime(2005, 1, 1, 12, 0, 0))
-        self.assertEqual(r.to_ical(), b"FREQ=DAILY;UNTIL=20050101T120000")
+        assert r.to_ical() == b"FREQ=DAILY;UNTIL=20050101T120000"
 
         # How do we fare with regards to parsing?
         r = vRecur.from_ical("FREQ=DAILY;INTERVAL=2;COUNT=10")
-        self.assertEqual(r, {"COUNT": [10], "FREQ": ["DAILY"], "INTERVAL": [2]})
-        self.assertEqual(vRecur(r).to_ical(), b"FREQ=DAILY;COUNT=10;INTERVAL=2")
+        assert r == {"COUNT": [10], "FREQ": ["DAILY"], "INTERVAL": [2]}
+        assert vRecur(r).to_ical() == b"FREQ=DAILY;COUNT=10;INTERVAL=2"
 
         r = vRecur.from_ical(
             "FREQ=YEARLY;INTERVAL=2;BYMONTH=1;BYDAY=-SU;BYHOUR=8,9;BYMINUTE=30"
         )
-        self.assertEqual(
-            r,
-            {
-                "BYHOUR": [8, 9],
-                "BYDAY": ["-SU"],
-                "BYMINUTE": [30],
-                "BYMONTH": [1],
-                "FREQ": ["YEARLY"],
-                "INTERVAL": [2],
-            },
-        )
+        assert r == {
+            "BYHOUR": [8, 9],
+            "BYDAY": ["-SU"],
+            "BYMINUTE": [30],
+            "BYMONTH": [1],
+            "FREQ": ["YEARLY"],
+            "INTERVAL": [2],
+        }
 
-        self.assertEqual(
-            vRecur(r).to_ical(),
-            b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=-SU;BYMONTH=1",
+        assert (
+            vRecur(r).to_ical()
+            == b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=-SU;BYMONTH=1"
         )
 
         r = vRecur.from_ical("FREQ=WEEKLY;INTERVAL=1;BYWEEKDAY=TH")
 
-        self.assertEqual(r, {"FREQ": ["WEEKLY"], "INTERVAL": [1], "BYWEEKDAY": ["TH"]})
+        assert r == {"FREQ": ["WEEKLY"], "INTERVAL": [1], "BYWEEKDAY": ["TH"]}
 
-        self.assertEqual(vRecur(r).to_ical(), b"FREQ=WEEKLY;INTERVAL=1;BYWEEKDAY=TH")
+        assert vRecur(r).to_ical() == b"FREQ=WEEKLY;INTERVAL=1;BYWEEKDAY=TH"
 
         # Some examples from the spec
         r = vRecur.from_ical("FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1")
-        self.assertEqual(
-            vRecur(r).to_ical(), b"FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1"
-        )
+        assert vRecur(r).to_ical() == b"FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1"
 
         p = "FREQ=YEARLY;INTERVAL=2;BYMONTH=1;BYDAY=SU;BYHOUR=8,9;BYMINUTE=30"
         r = vRecur.from_ical(p)
-        self.assertEqual(
-            vRecur(r).to_ical(),
-            b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=SU;BYMONTH=1",
+        assert (
+            vRecur(r).to_ical()
+            == b"FREQ=YEARLY;INTERVAL=2;BYMINUTE=30;BYHOUR=8,9;BYDAY=SU;BYMONTH=1"
         )
 
         # and some errors
@@ -192,40 +187,41 @@ class TestProp(unittest.TestCase):
 
         # when key is not RFC-compliant, parse it as vText
         r = vRecur.from_ical("FREQ=MONTHLY;BYOTHER=TEXT;BYEASTER=-3")
-        self.assertEqual(vRecur(r).to_ical(), b"FREQ=MONTHLY;BYEASTER=-3;BYOTHER=TEXT")
+        assert vRecur(r).to_ical() == b"FREQ=MONTHLY;BYEASTER=-3;BYOTHER=TEXT"
 
     def test_prop_vText(self):
         from icalendar.prop import vText
 
-        self.assertEqual(vText("Simple text").to_ical(), b"Simple text")
+        assert vText("Simple text").to_ical() == b"Simple text"
 
         # Escaped text
         t = vText("Text ; with escaped, chars")
-        self.assertEqual(t.to_ical(), b"Text \\; with escaped\\, chars")
+        assert t.to_ical() == b"Text \\; with escaped\\, chars"
 
         # Escaped newlines
-        self.assertEqual(
-            vText("Text with escaped\\N chars").to_ical(), b"Text with escaped\\n chars"
+        assert (
+            vText("Text with escaped\\N chars").to_ical()
+            == b"Text with escaped\\n chars"
         )
 
         # If you pass a unicode object, it will be utf-8 encoded. As this is
         # the (only) standard that RFC 5545 support.
         t = vText("international chars \xe4\xf6\xfc")
-        self.assertEqual(t.to_ical(), b"international chars \xc3\xa4\xc3\xb6\xc3\xbc")
+        assert t.to_ical() == b"international chars \xc3\xa4\xc3\xb6\xc3\xbc"
 
         # and parsing?
-        self.assertEqual(
-            vText.from_ical("Text \\; with escaped\\, chars"),
-            "Text ; with escaped, chars",
+        assert (
+            vText.from_ical("Text \\; with escaped\\, chars")
+            == "Text ; with escaped, chars"
         )
 
         t = vText.from_ical("A string with\\; some\\\\ characters in\\it")
-        self.assertEqual(t, "A string with; some\\ characters in\\it")
+        assert t == "A string with; some\\ characters in\\it"
 
         # We are forgiving to utf-8 encoding errors:
         # We intentionally use a string with unexpected encoding
         #
-        self.assertEqual(vText.from_ical(b"Ol\xe9"), "Ol\ufffd")
+        assert vText.from_ical(b"Ol\xe9") == "Ol<EFBFBD>"
 
         # Notice how accented E character, encoded with latin-1, got replaced
         # with the official U+FFFD REPLACEMENT CHARACTER.
@@ -233,8 +229,8 @@ class TestProp(unittest.TestCase):
     def test_prop_vTime(self):
         from icalendar.prop import vTime
 
-        self.assertEqual(vTime(12, 30, 0).to_ical(), "123000")
-        self.assertEqual(vTime.from_ical("123000"), time(12, 30))
+        assert vTime(12, 30, 0).to_ical() == "123000"
+        assert vTime.from_ical("123000") == time(12, 30)
 
         # We should also fail, right?
         self.assertRaises(ValueError, vTime.from_ical, "263000")
@@ -244,26 +240,22 @@ class TestProp(unittest.TestCase):
     def test_prop_vUri(self):
         from icalendar.prop import vUri
 
-        self.assertEqual(
-            vUri("http://www.example.com/").to_ical(), b"http://www.example.com/"
-        )
-        self.assertEqual(
-            vUri.from_ical("http://www.example.com/"), "http://www.example.com/"
-        )
+        assert vUri("http://www.example.com/").to_ical() == b"http://www.example.com/"
+        assert vUri.from_ical("http://www.example.com/") == "http://www.example.com/"
 
     def test_prop_vGeo(self):
         from icalendar.prop import vGeo
 
         # Pass a list
-        self.assertEqual(vGeo([1.2, 3.0]).to_ical(), "1.2;3.0")
+        assert vGeo([1.2, 3.0]).to_ical() == "1.2;3.0"
 
         # Pass a tuple
-        self.assertEqual(vGeo((1.2, 3.0)).to_ical(), "1.2;3.0")
+        assert vGeo((1.2, 3.0)).to_ical() == "1.2;3.0"
 
         g = vGeo.from_ical("37.386013;-122.082932")
-        self.assertEqual(g, (float("37.386013"), float("-122.082932")))
+        assert g == (float("37.386013"), float("-122.082932"))
 
-        self.assertEqual(vGeo(g).to_ical(), "37.386013;-122.082932")
+        assert vGeo(g).to_ical() == "37.386013;-122.082932"
 
         self.assertRaises(ValueError, vGeo, "g")
         self.assertRaises(ValueError, vGeo.from_ical, "1s3;1s3")
@@ -271,50 +263,50 @@ class TestProp(unittest.TestCase):
     def test_prop_vUTCOffset(self):
         from icalendar.prop import vUTCOffset
 
-        self.assertEqual(vUTCOffset(timedelta(hours=2)).to_ical(), "+0200")
+        assert vUTCOffset(timedelta(hours=2)).to_ical() == "+0200"
 
-        self.assertEqual(vUTCOffset(timedelta(hours=-5)).to_ical(), "-0500")
+        assert vUTCOffset(timedelta(hours=-5)).to_ical() == "-0500"
 
-        self.assertEqual(vUTCOffset(timedelta()).to_ical(), "+0000")
+        assert vUTCOffset(timedelta()).to_ical() == "+0000"
 
-        self.assertEqual(vUTCOffset(timedelta(minutes=-30)).to_ical(), "-0030")
+        assert vUTCOffset(timedelta(minutes=-30)).to_ical() == "-0030"
 
-        self.assertEqual(vUTCOffset(timedelta(hours=2, minutes=-30)).to_ical(), "+0130")
+        assert vUTCOffset(timedelta(hours=2, minutes=-30)).to_ical() == "+0130"
 
-        self.assertEqual(vUTCOffset(timedelta(hours=1, minutes=30)).to_ical(), "+0130")
+        assert vUTCOffset(timedelta(hours=1, minutes=30)).to_ical() == "+0130"
 
         # Support seconds
-        self.assertEqual(
-            vUTCOffset(timedelta(hours=1, minutes=30, seconds=7)).to_ical(), "+013007"
+        assert (
+            vUTCOffset(timedelta(hours=1, minutes=30, seconds=7)).to_ical() == "+013007"
         )
 
         # Parsing
 
-        self.assertEqual(vUTCOffset.from_ical("0000"), timedelta(0))
-        self.assertEqual(vUTCOffset.from_ical("-0030"), timedelta(-1, 84600))
-        self.assertEqual(vUTCOffset.from_ical("+0200"), timedelta(0, 7200))
-        self.assertEqual(vUTCOffset.from_ical("+023040"), timedelta(0, 9040))
+        assert vUTCOffset.from_ical("0000") == timedelta(0)
+        assert vUTCOffset.from_ical("-0030") == timedelta(-1, 84600)
+        assert vUTCOffset.from_ical("+0200") == timedelta(0, 7200)
+        assert vUTCOffset.from_ical("+023040") == timedelta(0, 9040)
 
-        self.assertEqual(vUTCOffset(vUTCOffset.from_ical("+0230")).to_ical(), "+0230")
+        assert vUTCOffset(vUTCOffset.from_ical("+0230")).to_ical() == "+0230"
 
         # And a few failures
         self.assertRaises(ValueError, vUTCOffset.from_ical, "+323k")
 
         self.assertRaises(ValueError, vUTCOffset.from_ical, "+2400")
 
-        self.assertRaises(ValueError, vUTCOffset, "0:00:00")
+        self.assertRaises(TypeError, vUTCOffset, "0:00:00")
 
     def test_prop_vInline(self):
         from icalendar.prop import vInline
 
-        self.assertEqual(vInline("Some text"), "Some text")
-        self.assertEqual(vInline("Some text").to_ical(), b"Some text")
-        self.assertEqual(vInline.from_ical("Some text"), "Some text")
+        assert vInline("Some text") == "Some text"
+        assert vInline("Some text").to_ical() == b"Some text"
+        assert vInline.from_ical("Some text") == "Some text"
 
         t2 = vInline("other text")
         t2.params["cn"] = "Test Osterone"
-        self.assertIsInstance(t2.params, Parameters)
-        self.assertEqual(t2.params, {"CN": "Test Osterone"})
+        assert isinstance(t2.params, Parameters)
+        assert t2.params == {"CN": "Test Osterone"}
 
     def test_prop_vCategory(self):
         from icalendar.prop import vCategory
@@ -322,8 +314,8 @@ class TestProp(unittest.TestCase):
         catz = ["cat 1", "cat 2", "cat 3"]
         v_cat = vCategory(catz)
 
-        self.assertEqual(v_cat.to_ical(), b"cat 1,cat 2,cat 3")
-        self.assertEqual(vCategory.from_ical(v_cat.to_ical()), catz)
+        assert v_cat.to_ical() == b"cat 1,cat 2,cat 3"
+        assert vCategory.from_ical(v_cat.to_ical()) == catz
         c = vCategory(vCategory.from_ical("APPOINTMENT,EDUCATION"))
         cats = list(c)
         assert cats == ["APPOINTMENT", "EDUCATION"]
@@ -334,30 +326,27 @@ class TestProp(unittest.TestCase):
         # To get a type you can use it like this.
         factory = TypesFactory()
         datetime_parser = factory["date-time"]
-        self.assertEqual(
-            datetime_parser(datetime(2001, 1, 1)).to_ical(), b"20010101T000000"
-        )
+        assert datetime_parser(datetime(2001, 1, 1)).to_ical() == b"20010101T000000"
 
         # A typical use is when the parser tries to find a content type and use
         # text as the default
         value = "20050101T123000"
         value_type = "date-time"
-        self.assertEqual(
-            factory.get(value_type, "text").from_ical(value),
-            datetime(2005, 1, 1, 12, 30),
+        assert factory.get(value_type, "text").from_ical(value) == datetime(
+            2005, 1, 1, 12, 30
         )
 
         # It can also be used to directly encode property and parameter values
-        self.assertEqual(
-            factory.to_ical("comment", "by Rasmussen, Max M\xfcller"),
-            b"by Rasmussen\\, Max M\xc3\xbcller",
+        assert (
+            factory.to_ical("comment", "by Rasmussen, Max Müller")
+            == b"by Rasmussen\\, Max M\xc3\xbcller"
         )
-        self.assertEqual(factory.to_ical("priority", 1), b"1")
-        self.assertEqual(
-            factory.to_ical("cn", "Rasmussen, Max M\xfcller"),
-            b"Rasmussen\\, Max M\xc3\xbcller",
+        assert factory.to_ical("priority", 1) == b"1"
+        assert (
+            factory.to_ical("cn", "Rasmussen, Max Müller")
+            == b"Rasmussen\\, Max M\xc3\xbcller"
         )
-        self.assertEqual(
-            factory.from_ical("cn", b"Rasmussen\\, Max M\xc3\xb8ller"),
-            "Rasmussen, Max M\xf8ller",
+        assert (
+            factory.from_ical("cn", b"Rasmussen\\, Max M\xc3\xb8ller")
+            == "Rasmussen, Max Møller"
         )

src/icalendar/tests/prop/test_vDDDTypes.py

@@ -22,7 +22,7 @@ def test_timedelta():
 
 
 def test_bad_input():
-    with pytest.raises(ValueError):
+    with pytest.raises(TypeError):
         vDDDTypes(42)
 
 

src/icalendar/tests/prop/test_vPeriod.py

@@ -10,24 +10,24 @@ class TestProp(unittest.TestCase):
     def test_one_day(self):
         # One day in exact datetimes
         per = (datetime(2000, 1, 1), datetime(2000, 1, 2))
-        self.assertEqual(vPeriod(per).to_ical(), b"20000101T000000/20000102T000000")
+        assert vPeriod(per).to_ical() == b"20000101T000000/20000102T000000"
 
         per = (datetime(2000, 1, 1), timedelta(days=31))
-        self.assertEqual(vPeriod(per).to_ical(), b"20000101T000000/P31D")
+        assert vPeriod(per).to_ical() == b"20000101T000000/P31D"
 
     def test_roundtrip(self):
         p = vPeriod.from_ical("20000101T000000/20000102T000000")
-        self.assertEqual(p, (datetime(2000, 1, 1, 0, 0), datetime(2000, 1, 2, 0, 0)))
-        self.assertEqual(vPeriod(p).to_ical(), b"20000101T000000/20000102T000000")
+        assert p == (datetime(2000, 1, 1, 0, 0), datetime(2000, 1, 2, 0, 0))
+        assert vPeriod(p).to_ical() == b"20000101T000000/20000102T000000"
 
-        self.assertEqual(
-            vPeriod.from_ical("20000101T000000/P31D"),
-            (datetime(2000, 1, 1, 0, 0), timedelta(31)),
+        assert vPeriod.from_ical("20000101T000000/P31D") == (
+            datetime(2000, 1, 1, 0, 0),
+            timedelta(31),
         )
 
     def test_round_trip_with_absolute_time(self):
         p = vPeriod.from_ical("20000101T000000Z/20000102T000000Z")
-        self.assertEqual(vPeriod(p).to_ical(), b"20000101T000000Z/20000102T000000Z")
+        assert vPeriod(p).to_ical() == b"20000101T000000Z/20000102T000000Z"
 
     def test_bad_input(self):
         self.assertRaises(ValueError, vPeriod.from_ical, "20000101T000000/Psd31D")
@@ -59,5 +59,5 @@ def test_timezoned_with_timedelta(tzp):
 )
 def test_invalid_parameters(params):
     """The parameters are of wrong type or of wrong order."""
-    with pytest.raises(ValueError):
+    with pytest.raises(TypeError):
         vPeriod(params)

src/icalendar/tests/test_icalendar.py

@@ -26,7 +26,8 @@ class IcalendarTestCase(unittest.TestCase):
             c.to_ical()
             == b"BEGIN:VEVENT\r\n123456789 123456789 123456789 123456789 "  # noqa: ISC003
             + b"123456789 123456789 123456789 1234\r\n 56789 123456789 "
-        ), "123456789 \r\n"
+            + b"123456789 \r\n"
+        )
 
         # from doctests
         # Notice that there is an extra empty string in the end of the content
@@ -69,7 +70,7 @@ class IcalendarTestCase(unittest.TestCase):
         # N or a LATIN CAPITAL LETTER N, that is "\n" or "\N".
 
         # Newlines are not allowed in content lines
-        self.assertRaises(AssertionError, Contentline, b"1234\r\n\r\n1234")  # noqa: PT027
+        self.assertRaises(AssertionError, Contentline, b"1234\r\n\r\n1234")
 
         assert Contentline("1234\\n\\n1234").to_ical() == b"1234\\n\\n1234"
 
@@ -232,7 +233,7 @@ class IcalendarTestCase(unittest.TestCase):
         assert foldline("foo") == "foo"
         assert (
             foldline(
-                "Lorem ipsum dolor sit amet, consectetur adipiscing ",
+                "Lorem ipsum dolor sit amet, consectetur adipiscing "
                 "elit. Vestibulum convallis imperdiet dui posuere.",
             )
             == "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
@@ -248,7 +249,7 @@ class IcalendarTestCase(unittest.TestCase):
         assert foldline("foobar", limit=4) == "foo\r\n bar"
         assert (
             foldline(
-                "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
+                "Lorem ipsum dolor sit amet, consectetur adipiscing elit"
                 ". Vestibulum convallis imperdiet dui posuere.",
             )
             == "Lorem ipsum dolor sit amet, consectetur adipiscing elit."  # noqa: ISC003