Rename 'PredbRelease' to 'Pre' and label parsed releases simply as releases for the sake of clarity.

dailyreleases/generation.py

@@ -9,7 +9,7 @@ from typing import Set
 
 from . import util, reddit, predbs, parsing
 from .config import CONFIG, DATA_DIR
-from .parsing import ParsedReleases, Release, ReleaseType
+from .parsing import Releases, Release, ReleaseType
 
 logger = logging.getLogger(__name__)
 
@@ -46,7 +46,7 @@ def row(release: Release):
     return name, release.group, stores, reviews
 
 
-def generate_post(releases: ParsedReleases) -> str:
+def generate_post(releases: Releases) -> str:
     post = []
     for platform, platform_releases in releases.items():
         # Skip if platform doesn't contain any releases in any of the three release type categories
@@ -109,18 +109,16 @@ def generate(post=False, pm_recipients=None) -> None:
     logger.info("-------------------------------------------------------------------------------------------------")
     start_time = time.time()
 
-    already_posted = load_already_posted()
+    processed = load_processed()
-
+    pres = predbs.get_pres()
-    releases = predbs.get_releases()
+    releases = parsing.parse_pres(pre
-    # Remove old releases from already_posted to save space
+                                  for pre in pres
-    already_posted.intersection_update(r.dirname for r in releases)
+                                  if pre.dirname not in processed)
-
-    parsed_releases = parsing.parse_releases(releases, already_posted)
 
     # The date of the post changes at midday instead of midnight to allow calling script after 00:00
     title = f"Daily Releases ({(datetime.today() - timedelta(hours=12)).strftime('%B %-d, %Y')})"
 
-    generated_post = generate_post(parsed_releases)
+    generated_post = generate_post(releases)
     generated_post_src = textwrap.indent(generated_post, "    ")
 
     if post:
@@ -133,7 +131,8 @@ def generate(post=False, pm_recipients=None) -> None:
         reddit_src_post.mod.approve()
         reddit_post.mod.approve()
 
-        save_already_posted(already_posted)
+        # We only need to save the latest pres since older ones will never show up again
+        save_processed(p.dirname for p in pres)
 
         if pm_recipients is not None:
             msg = inspect.cleandoc(
@@ -149,15 +148,15 @@ def generate(post=False, pm_recipients=None) -> None:
     logger.info("-------------------------------------------------------------------------------------------------")
 
 
-def load_already_posted() -> Set[str]:
+def load_processed() -> Set[str]:
     try:
-        with DATA_DIR.joinpath("already_posted").open() as file:
+        with DATA_DIR.joinpath("processed").open() as file:
             return {line.rstrip() for line in file}
     except FileNotFoundError:
         return set()
 
 
-def save_already_posted(already_posted) -> None:
+def save_processed(processed) -> None:
     logger.info("Saving already posted to file")
-    with DATA_DIR.joinpath("already_posted").open("w") as file:
+    with DATA_DIR.joinpath("processed").open("w") as file:
-        file.writelines(f"{dirname}\n" for dirname in already_posted)
+        file.writelines(f"{dirname}\n" for dirname in processed)

dailyreleases/parsing.py

@@ -4,10 +4,10 @@ import string
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from enum import Enum
-from typing import Optional, List, Set, Dict, Iterable
+from typing import List, Dict, Iterable
 
 from . import stores
-from .predbs import PredbRelease
+from .predbs import Pre
 from .stores import steam
 
 logger = logging.getLogger(__name__)
@@ -34,12 +34,13 @@ class Platform(str, Enum):
 @dataclass
 class Release:
     dirname: str
+    nfo_link: str
+    timestamp: datetime
     rls_name: str  # dirname without group
     group: str
     game_name: str
     type: ReleaseType
     platform: Platform
-    nfo_link: str
     store_links: Dict[str, str] = field(default_factory=dict)
     tags: List[str] = field(default_factory=list)
     highlights: List[str] = field(default_factory=list)
@@ -47,6 +48,10 @@ class Release:
     num_reviews: int = -1
 
 
+class ParseError(Exception):
+    pass
+
+
 STOPWORDS = (
     "update",
     "v[0-9]+",
@@ -119,12 +124,18 @@ BLACKLISTED = (
 )
 
 
-def parse_dirname(dirname: str, nfo_link: str) -> Optional[Release]:
+def parse_pre(pre: Pre) -> Release:
+    if re.search("|".join(BLACKLISTED), pre.dirname, flags=re.IGNORECASE):
+        raise ParseError("Contains blacklisted word")
+
+    if pre.timestamp < datetime.now() - timedelta(hours=48):
+        raise ParseError("Older than 48 hours")
+
     logger.info("---")
-    logger.info("Parsing: %s", dirname)
+    logger.info("Parsing: %s", pre.dirname)
 
     # Extract group name
-    rls_name, group = dirname.rsplit("-", maxsplit=1)
+    rls_name, group = pre.dirname.rsplit("-", maxsplit=1)
 
     # Find game name by matching until one of the stopwords
     game_name, *stopwords = re.split("[._-]({})".format("|".join(STOPWORDS + TAGS + HIGHLIGHTS)),
@@ -170,17 +181,17 @@ def parse_dirname(dirname: str, nfo_link: str) -> Optional[Release]:
 
     # No store link? Probably software and not a game
     if not store_links:
-        logger.info("Skipping %s: no store link (probably software)", dirname)
+        raise ParseError("No store link: probably software")
-        return None
 
     release = Release(
-        dirname=dirname,
+        dirname=pre.dirname,
+        nfo_link=pre.nfo_link,
+        timestamp=pre.timestamp,
         rls_name=rls_name,
         group=group,
         game_name=game_name,
         type=rls_type,
         platform=platform,
-        nfo_link=nfo_link,
         store_links=store_links,
         tags=tags,
         highlights=highlights
@@ -199,33 +210,17 @@ def parse_dirname(dirname: str, nfo_link: str) -> Optional[Release]:
     return release
 
 
-ParsedReleases = Dict[Platform, Dict[ReleaseType, List[Release]]]
+Releases = Dict[Platform, Dict[ReleaseType, List[Release]]]  # {Windows: {Game: [..], DLC: [..], ..}, Linux: ...}
 
 
-def parse_releases(releases: Iterable[PredbRelease], already_posted: Set[str]) -> ParsedReleases:
+def parse_pres(pres: Iterable[Pre]) -> Releases:
-    parsed_releases = {platform: {release_type: [] for release_type in ReleaseType}
+    releases = {platform: {release_type: [] for release_type in ReleaseType} for platform in Platform}
-                       for platform in Platform}  # {Windows: {Game: [..], DLC: [..], ..}, Linux: ...}
+    for pre in pres:
+        try:
+            release = parse_pre(pre)
+            releases[release.platform][release.type].append(release)
+        except ParseError as e:
+            logger.info("Skipping %s: %s", pre.dirname, e)
 
-    for release in releases:
+    logger.debug("Parsed releases: %s", releases)
-        if release.dirname in already_posted:
+    return releases
-            logger.info("Skipping %s: dirname in already posted", release.dirname)
-            continue
-
-        if re.search("|".join(BLACKLISTED), release.dirname, flags=re.IGNORECASE):
-            logger.info("Skipping %s: contains blacklisted word", release.dirname)
-            continue
-
-        if release.timestamp < datetime.now() - timedelta(hours=48):
-            logger.info("Skipping %s: older than 48 hours (but not in already_posted!?)", release.dirname)
-            continue
-
-        release = parse_dirname(release.dirname, release.nfo_link)
-        if not release:
-            continue  # skip if there is no data about the release (e.g. if it is deemed a non-game by parse_dirname)
-
-        # Add release to dict of parsed releases by platform and type
-        parsed_releases[release.platform][release.type].append(release)
-        already_posted.add(release.dirname)
-
-    logger.debug("Parsed releases: %s", parsed_releases)
-    return parsed_releases

dailyreleases/predbs.py

@@ -10,28 +10,28 @@ from . import cache
 logger = logging.getLogger(__name__)
 
 
-class PredbRelease(NamedTuple):
+class Pre(NamedTuple):
     dirname: str
     nfo_link: str
     timestamp: datetime
 
 
-def get_releases() -> List[PredbRelease]:
+def get_pres() -> List[Pre]:
-    logger.info("Getting releases from predbs")
+    logger.info("Getting pres from predbs")
 
-    releases = {}
+    pres = {}
-    for db_releases in (get_predbme, get_xrel):  # in reverse order of preference
+    for get in (get_predbme, get_xrel):  # in reverse order of preference
         try:
-            releases.update((r.dirname, r) for r in db_releases())  # override duplicate dirnames in later iterations
+            pres.update((p.dirname, p) for p in get())  # override duplicate dirnames in later iterations
         except HTTPError as e:
             logger.error(e)
             logger.warning("Connection to predb failed, skipping..")
 
-    return list(releases.values())
+    return list(pres.values())
 
 
-def get_xrel(categories=("CRACKED", "UPDATE"), num_pages=2) -> List[PredbRelease]:
+def get_xrel(categories=("CRACKED", "UPDATE"), num_pages=2) -> List[Pre]:
-    logger.debug("Getting releases from xrel.to")
+    logger.debug("Getting pres from xrel.to")
 
     def get_releases_in_category(category, page):
         r = cache.get("https://api.xrel.to/v2/release/browse_category.json", params={
@@ -42,23 +42,23 @@ def get_xrel(categories=("CRACKED", "UPDATE"), num_pages=2) -> List[PredbRelease
         })
         return r.json["list"]
 
-    return [PredbRelease(rls["dirname"],
+    return [Pre(rls["dirname"],
-                         rls["link_href"],
+                rls["link_href"],
-                         datetime.fromtimestamp(rls["time"]))
+                datetime.fromtimestamp(rls["time"]))
             for category in categories
             for page in range(1, num_pages)
             for rls in get_releases_in_category(category, page)]
 
 
-def get_predbme() -> List[PredbRelease]:
+def get_predbme() -> List[Pre]:
-    logger.debug("Getting releases from predb.me")
+    logger.debug("Getting pres from predb.me")
 
     rss = cache.get("https://predb.me/?cats=games-pc&rss=1")
     soup = BeautifulSoup(rss.text, "html.parser").find_all("item")
 
     # Predb.me doesn't show timestamps in the RSS-feed, but the feed is so short it only shows ~72 hours worth of
     # releases anyway, so we just set timestamp to now.
-    return [PredbRelease(item.find("title").text,
+    return [Pre(item.find("title").text,
-                         item.find("guid").text,
+                item.find("guid").text,
-                         datetime.utcnow())
+                datetime.utcnow())
             for item in soup]

tests/test_parse_dirname.py

@@ -1,12 +1,15 @@
 import unittest
+from datetime import datetime, timedelta
 
 from dailyreleases import parsing
-from dailyreleases.parsing import ReleaseType, Platform
+from dailyreleases.parsing import ReleaseType, Platform, ParseError
+from dailyreleases.predbs import Pre
 
 
 class ParseDirnameTestCase(unittest.TestCase):
     def test_single_word_release(self):
-        p = parsing.parse_dirname("Aztez-DARKSiDERS", "nfo_link")
+        pre = Pre("Aztez-DARKSiDERS", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
 
         self.assertEqual("Aztez-DARKSiDERS", p.dirname)
         self.assertEqual("Aztez", p.rls_name)
@@ -18,111 +21,142 @@ class ParseDirnameTestCase(unittest.TestCase):
         self.assertEqual([], p.tags)
         self.assertEqual([], p.highlights)
 
+    def test_error_on_blacklisted_word(self):
+        pre = Pre("Anthemion.Software.DialogBlocks.v5.15.LINUX.Incl.Keygen-AMPED", "nfo_link", datetime.now())
+        with self.assertRaisesRegex(ParseError, "Contains blacklisted word"):
+            parsing.parse_pre(pre)
+
+    def test_error_on_old(self):
+        pre = Pre("Aztez-DARKSiDERS", "nfo_link", datetime.now() - timedelta(hours=50))
+        with self.assertRaisesRegex(ParseError, "Older than 48 hours"):
+            parsing.parse_pre(pre)
+
+    def test_error_on_software(self):
+        pre = Pre("Tecplot.RS.2017.R1.v1.2.85254.X64-AMPED", "nfo_link", datetime.now())
+        with self.assertRaisesRegex(ParseError, "No store link: probably software"):
+            parsing.parse_pre(pre)
+
     def test_nuked_release(self):
         # TODO: Actual nuke handling?
-        p = parsing.parse_dirname("Battlefield.1-CPY", "nfo_link")
+        pre = Pre("Battlefield.1-CPY", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual("Battlefield.1-CPY", p.dirname)
 
     def test_update(self):
-        p = parsing.parse_dirname("Car.Mechanic.Simulator.2018.Plymouth.Update.v1.5.1.Hotfix-PLAZA", "nfo_link")
+        pre = Pre("Car.Mechanic.Simulator.2018.Plymouth.Update.v1.5.1.Hotfix-PLAZA", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(ReleaseType.UPDATE, p.type)
         self.assertIn("store.steampowered.com/app/754920", p.store_links["Steam"])
 
     def test_proper_highlight(self):
-        p = parsing.parse_dirname("Death.Coming.PROPER-SiMPLEX", "nfo_link")
+        pre = Pre("Death.Coming.PROPER-SiMPLEX", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(["PROPER"], p.highlights)
         self.assertIn("store.steampowered.com/app/705120", p.store_links["Steam"])
 
     def test_macos_release(self):
-        p = parsing.parse_dirname("The_Fall_Part_2_Unbound_MacOS-Razor1911", "nfo_link")
+        pre = Pre("The_Fall_Part_2_Unbound_MacOS-Razor1911", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(Platform.OSX, p.platform)
         self.assertEqual(ReleaseType.GAME, p.type)
         self.assertIn("store.steampowered.com/app/510490", p.store_links["Steam"])
         self.assertIn("gog.com/game/the_fall_part_2_unbound", p.store_links["GOG"])
 
     def test_macosx_update(self):
-        p = parsing.parse_dirname("Man_O_War_Corsair_Warhammer_Naval_Battles_v1.3.2_MacOSX-Razor1911", "nfo_link")
+        pre = Pre("Man_O_War_Corsair_Warhammer_Naval_Battles_v1.3.2_MacOSX-Razor1911", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(Platform.OSX, p.platform)
         self.assertEqual(ReleaseType.UPDATE, p.type)
         self.assertIn("store.steampowered.com/app/344240", p.store_links["Steam"])
         self.assertIn("gog.com/game/man_o_war_corsair", p.store_links["GOG"])
 
     def test_linux_release(self):
-        p = parsing.parse_dirname("Sphinx_And_The_Cursed_Mummy_Linux-Razor1911", "nfo_link")
+        pre = Pre("Sphinx_And_The_Cursed_Mummy_Linux-Razor1911", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(Platform.LINUX, p.platform)
         self.assertEqual(ReleaseType.GAME, p.type)
         self.assertIn("store.steampowered.com/app/606710", p.store_links["Steam"])
         self.assertIn("gog.com/game/sphinx_and_the_cursed_mummy", p.store_links["GOG"])
 
     def test_dlc_explicit(self):
-        p = parsing.parse_dirname("Fallout.4.Far.Harbor.DLC-CODEX", "nfo_link")
+        pre = Pre("Fallout.4.Far.Harbor.DLC-CODEX", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertIn("store.steampowered.com/app/435881", p.store_links["Steam"])
         self.assertEqual(ReleaseType.DLC, p.type)
 
     def test_dlc_implicit(self):
-        p = parsing.parse_dirname("Euro.Truck.Simulator.2.Italia-CODEX", "nfo_link")
+        pre = Pre("Euro.Truck.Simulator.2.Italia-CODEX", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(ReleaseType.DLC, p.type)
         self.assertIn("store.steampowered.com/app/558244", p.store_links["Steam"])
 
     def test_incl_dlc_update(self):
-        p = parsing.parse_dirname("Wolfenstein.II.The.New.Colossus.Update.5.incl.DLC-CODEX", "nfo_link")
+        pre = Pre("Wolfenstein.II.The.New.Colossus.Update.5.incl.DLC-CODEX", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(ReleaseType.UPDATE, p.type)
         self.assertIn("store.steampowered.com/app/612880", p.store_links["Steam"])
 
     def test_incl_dlc_release(self):
-        p = parsing.parse_dirname("Mutiny.Incl.DLC-DARKSiDERS", "nfo_link")
+        pre = Pre("Mutiny.Incl.DLC-DARKSiDERS", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(ReleaseType.GAME, p.type)
 
     def test_score_steam(self):
-        p1 = parsing.parse_dirname("BioShock_Infinite-FLT", "nfo_link")
+        pre = Pre("BioShock_Infinite-FLT", "nfo_link", datetime.now())
+        p1 = parsing.parse_pre(pre)
         self.assertIn("store.steampowered.com/app/8870", p1.store_links["Steam"])
-        p2 = parsing.parse_dirname("Duke.Nukem.Forever.Complete-PLAZA", "nfo_link")
+        pre = Pre("Duke.Nukem.Forever.Complete-PLAZA", "nfo_link", datetime.now())
+        p2 = parsing.parse_pre(pre)
         self.assertIn("store.steampowered.com/app/57900", p2.store_links["Steam"])
         self.assertGreater(p1.score, p2.score)
 
     def test_non_steam(self):
-        p = parsing.parse_dirname("Battlefield.1.REPACK-CPY", "nfo_link")
+        pre = Pre("Battlefield.1.REPACK-CPY", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertIn("www.origin.com/usa/en-us/store/battlefield/battlefield-1", p.store_links["Origin"])
         self.assertEqual(-1, p.score)
         self.assertEqual(-1, p.num_reviews)
 
     def test_gog_exclusive(self):
         # TODO: Actually use GOG API (gog.update_info)
-        p = parsing.parse_dirname("Dungeons.and.Dragons.Dragonshard.v2.0.0.10.Multilingual-DELiGHT", "nfo_link")
+        pre = Pre("Dungeons.and.Dragons.Dragonshard.v2.0.0.10.Multilingual-DELiGHT", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertIn("gog.com/game/dungeons_dragons_dragonshard", p.store_links["GOG"])
         self.assertEqual(-1, p.score)
 
     def test_gog_exclusive2(self):
-        p = parsing.parse_dirname("Diablo.GOG.Classic-KaliMaaShaktiDe", "nfo_link")
+        pre = Pre("Diablo.GOG.Classic-KaliMaaShaktiDe", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertIn("gog.com/game/diablo", p.store_links["GOG"])
 
     def test_score_non_steam(self):
-        p = parsing.parse_dirname("Ode.RIP.MULTI12-SiMPLEX", "nfo_link")
+        pre = Pre("Ode.RIP.MULTI12-SiMPLEX", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(-1, p.score)
 
     def test_tags(self):
-        p = parsing.parse_dirname("The.Curious.Expedition.v1.3.7.1.MULTI.7.RIP-Unleashed", "nfo_link")
+        pre = Pre("The.Curious.Expedition.v1.3.7.1.MULTI.7.RIP-Unleashed", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertIn("gog.com/game/curious_expedition_the", p.store_links["GOG"])
         self.assertEqual(["MULTI.7", "RIP"], p.tags)
 
-    def test_skip_software(self):
-        p = parsing.parse_dirname("Tecplot.RS.2017.R1.v1.2.85254.X64-AMPED", "nfo_link")
-        self.assertIsNone(p)
-
     def test_steam_package(self):
-        p = parsing.parse_dirname("Farming.Simulator.17.Platinum.Edition.Update.v1.5.3-BAT", "nfo_link")
+        pre = Pre("Farming.Simulator.17.Platinum.Edition.Update.v1.5.3-BAT", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual("Farming Simulator 17 - Platinum Edition", p.game_name)
         self.assertEqual(ReleaseType.UPDATE, p.type)
         self.assertIn("store.steampowered.com/sub/202103", p.store_links["Steam"])
 
     def test_steam_package_with_dlc_first(self):
-        p = parsing.parse_dirname("The.Witcher.3.Wild.Hunt.Game.of.The.Year.Edition-RELOADED", "nfo_link")
+        pre = Pre("The.Witcher.3.Wild.Hunt.Game.of.The.Year.Edition-RELOADED", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual("The Witcher 3: Wild Hunt - Game of the Year Edition", p.game_name)
         self.assertEqual(ReleaseType.GAME, p.type)
         self.assertIn("store.steampowered.com/sub/124923", p.store_links["Steam"])
 
     def test_steam_bundle(self):
-        p = parsing.parse_dirname("Valve.Complete.Pack-FAKE", "nfo_link")
+        pre = Pre("Valve.Complete.Pack-FAKE", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual("Valve.Complete.Pack-FAKE", p.dirname)
         self.assertEqual("Valve Complete Pack", p.game_name)
         self.assertEqual("Windows", p.platform)
@@ -131,29 +165,35 @@ class ParseDirnameTestCase(unittest.TestCase):
 
     def test_steam_denuvo(self):
         # "denuvo" occurs in the Steam EULA
-        p = parsing.parse_dirname("Deus.Ex.Mankind.Divided-CPY", "nfo_link")
+        pre = Pre("Deus.Ex.Mankind.Divided-CPY", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(["DENUVO"], p.highlights)
 
         # "denuvo" occurs in the Steam DRM notice
-        p = parsing.parse_dirname("Yakuza.0-FAKE", "nfo_link")
+        pre = Pre("Yakuza.0-FAKE", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(["DENUVO"], p.highlights)
 
     def test_episode_release(self):
-        p = parsing.parse_dirname("Life.is.Strange.Before.the.Storm.Episode.3-CODEX", "nfo_link")
+        pre = Pre("Life.is.Strange.Before.the.Storm.Episode.3-CODEX", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual("Life is Strange: Before the Storm Episode 3", p.game_name)
         self.assertEqual(ReleaseType.DLC, p.type)
         self.assertIn("store.steampowered.com/app/704740", p.store_links["Steam"])
 
     def test_season_and_episode_release(self):
-        p = parsing.parse_dirname("Minecraft.Story.Mode.Season.Two.Episode.5.MacOSX-RELOADED", "nfo_link")
+        pre = Pre("Minecraft.Story.Mode.Season.Two.Episode.5.MacOSX-RELOADED", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual("Minecraft Story Mode Season Two Episode 5", p.game_name)
 
     def test_build_is_update(self):
-        p = parsing.parse_dirname("DUSK.Episode.1.Build.2.6-SKIDROW", "nfo_link")
+        pre = Pre("DUSK.Episode.1.Build.2.6-SKIDROW", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertEqual(ReleaseType.UPDATE, p.type)
 
     def test_prefer_steam_to_microsoft_store(self):
-        p = parsing.parse_dirname("Forgiveness-PLAZA", "nfo_link")
+        pre = Pre("Forgiveness-PLAZA", "nfo_link", datetime.now())
+        p = parsing.parse_pre(pre)
         self.assertIn("store.steampowered.com/app/971120", p.store_links["Steam"])
 
 

tests/test_parse_releases.py

@@ -1,58 +0,0 @@
-import unittest
-from datetime import datetime, timedelta
-
-from dailyreleases import parsing
-from dailyreleases.parsing import Platform, ReleaseType
-from dailyreleases.predbs import PredbRelease
-
-
-class ParseReleasesTestCase(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        cls.empty_releases = {platform: {release_type: [] for release_type in ReleaseType}
-                              for platform in Platform}
-
-    def test_dont_skip(self):
-        already_posted = set()
-        releases = [
-            PredbRelease("Aztez-DARKSiDERS", "nfo_link", datetime.now())
-        ]
-        parsed_releases = parsing.parse_releases(releases, already_posted)
-        self.assertEqual(parsed_releases[Platform.WINDOWS][ReleaseType.GAME][0].game_name, "Aztez")
-
-    def test_skip_already_posted(self):
-        already_posted = {"Aztez-DARKSiDERS"}
-        releases = [
-            PredbRelease("Aztez-DARKSiDERS", "nfo_link", datetime.now())
-        ]
-        parsed_releases = parsing.parse_releases(releases, already_posted)
-        self.assertDictEqual(parsed_releases, self.empty_releases)
-
-    def test_skip_blacklisted_word(self):
-        already_posted = set()
-        releases = [
-            PredbRelease("Anthemion.Software.DialogBlocks.v5.15.LINUX.Incl.Keygen-AMPED", "nfo_link", datetime.now())
-        ]
-        parsed_releases = parsing.parse_releases(releases, already_posted)
-        self.assertDictEqual(parsed_releases, self.empty_releases)
-
-    def test_skip_older_than_48hr(self):
-        already_posted = set()
-        releases = [
-            PredbRelease("Aztez-DARKSiDERS", "nfo_link", datetime.now() - timedelta(hours=50))
-        ]
-        parsed_releases = parsing.parse_releases(releases, already_posted)
-        self.assertDictEqual(parsed_releases, self.empty_releases)
-
-    def test_skip_no_data_for_software(self):
-        already_posted = set()
-        releases = [
-            PredbRelease("Tecplot.RS.2017.R1.v1.2.85254.X64-AMPED", "nfo_link", datetime.now())
-        ]
-        parsed_releases = parsing.parse_releases(releases, already_posted)
-        self.assertDictEqual(parsed_releases, self.empty_releases)
-
-
-if __name__ == '__main__':
-    unittest.main()