mtg-playerinfo 1.2.2 → 1.3.0

package/test/data/untapped.json

@@ -0,0 +1,104 @@
+[
+  {
+    "short_id": "ZcCUi2BJ7g5ubNrREqKS3C",
+    "match_start": 1770848945000,
+    "season_ordinal": 86,
+    "event_name": "Traditional_Ladder",
+    "super_format": 2,
+    "match_win_condition": 2,
+    "games": [
+      {
+        "game_number": 1,
+        "game_duration_seconds": 587,
+        "active_player_id": 1,
+        "winning_team_id": 2,
+        "friendly_deckstring": "AAQAAQqMBQHz1C2kAxkD1vkHqPQChuwHlrgBBbzrAd_rM7j6ApWaCeEEBIdk4JwsCofsFAe16wHuUMuQL5sEr50Qf5k6AAIJ_uIC6_EW1qsTosgL4-4HgQSjsAF2_AIDlxCMwzWO1QwAAAAA",
+        "player_opening_hands": [
+          "AAQAAQe16wEH51DOxCrMXNn5B736AgAAAAAA"
+        ],
+        "player_mulligan_put_on_bottom": null,
+        "opponent_revealed_colors": [
+          11
+        ],
+        "opponent_revealed_archetype": {
+          "AAQAAQmMBaINvlHE7gbaiSagAZw317sKwNsIB64a_F7QSqKZLL_1B7UE9N8KA6v-LNvSBJP7BgAAAA": null
+        },
+        "opponent_revealed_deckstrings": [
+          "AAQAAQmMBaINvlHE7gbaiSagAZw317sKwNsIB64a_F7QSqKZLL_1B7UE9N8KA6v-LNvSBJP7BgAAAA"
+        ]
+      },
+      {
+        "game_number": 2,
+        "game_duration_seconds": 335,
+        "active_player_id": 1,
+        "winning_team_id": 1,
+        "friendly_deckstring": "AAQAAQyMBQHx3QLBnSrBWaQDGQPW-QfL8QLdAqChCQeXEKXbAd_rM7j6AvHlB4W5Aeg3Aodk6pwsB7XrAe5Qy5AvmwSvnRB_mToAAgLp1Bnc5iYCo9M1t5wMA-eALYHrFJABAAAA",
+        "player_opening_hands": [
+          "AAQAAQWXEJ7bAYqVK6_MBPP7BgGjvAIAAAAA"
+        ],
+        "player_mulligan_put_on_bottom": null,
+        "opponent_revealed_colors": [
+          11
+        ],
+        "opponent_revealed_archetype": {
+          "AAQAAQqMBaIV_F7QSpCYLKABsfUHrgSQ9QK_AQGQ1zUAAAAA": null
+        },
+        "opponent_revealed_deckstrings": [
+          "AAQAAQqMBaIV_F7QSpCYLKABsfUHrgSQ9QK_AQGQ1zUAAAAA"
+        ]
+      },
+      {
+        "game_number": 3,
+        "game_duration_seconds": 190,
+        "active_player_id": 2,
+        "winning_team_id": 1,
+        "friendly_deckstring": "AAQAAQyMBQHx3QLBnSrBWaQDGQPW-QfL8QLdAqChCQeXEKXbAd_rM7j6AvHlB4W5Aeg3Aodk6pwsB7XrAe5Qy5AvmwSvnRB_mToAAgLp1Bnc5iYCo9M1t5wMA-eALYHrFJABAAAA",
+        "player_opening_hands": [
+          "AAQAAQWHZJzYAc7EKqrWCJbRDAG370EAAAAA"
+        ],
+        "player_mulligan_put_on_bottom": null,
+        "opponent_revealed_colors": [
+          3
+        ],
+        "opponent_revealed_archetype": {
+          "AAQAAQeuEoAIvkm-FZBy1Oor-4AIAYS3QAAAAAA": null
+        },
+        "opponent_revealed_deckstrings": [
+          "AAQAAQeuEoAIvkm-FZBy1Oor-4AIAYS3QAAAAAA"
+        ]
+      }
+    ],
+    "winning_team_id": 1,
+    "active_player_id": 1,
+    "friendly_deckstring": "AAQAAQqMBQHz1C2kAxkD1vkHqPQChuwHlrgBBbzrAd_rM7j6ApWaCeEEBIdk4JwsCofsFAe16wHuUMuQL5sEr50Qf5k6AAIJ_uIC6_EW1qsTosgL4-4HgQSjsAF2_AIDlxCMwzWO1QwAAAAA",
+    "friendly_deck_name": "Sultai Combo v2",
+    "friendly_deck_id": "5e2004f0-e55c-4081-8284-22ca03db47c8",
+    "friendly_deck_colors": 22,
+    "friendly_deck_tile_id": 98497,
+    "friendly_deck_archetype": null,
+    "friendly_system_seat_id": 1,
+    "friendly_team_id": 1,
+    "friendly_ranking_class_before": "Platinum",
+    "friendly_ranking_tier_before": 4,
+    "friendly_ranking_tier_steps_before": 2,
+    "friendly_mythic_percentile_before": 0.0,
+    "friendly_mythic_leaderboard_place_before": 0,
+    "friendly_rating_before": null,
+    "friendly_rating_deviation_before": null,
+    "friendly_rating_volatility_before": null,
+    "friendly_rating_mythic_before": null,
+    "friendly_ranking_class_after": "Platinum",
+    "friendly_ranking_tier_after": 4,
+    "friendly_ranking_tier_steps_after": 4,
+    "friendly_mythic_percentile_after": 0.0,
+    "friendly_mythic_leaderboard_place_after": 0,
+    "friendly_course_wins_before": null,
+    "friendly_course_losses_before": null,
+    "opponents": [
+      {
+        "player_name": "MysticalMachineGun",
+        "team_id": 2
+      }
+    ]
+  }
+]

package/test/edgeCases.test.js

@@ -0,0 +1,128 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const PlayerInfoManager = require('../src')
+
+test('PlayerInfoManager: getPlayerInfo handles all null results gracefully', async () => {
+  const manager = new PlayerInfoManager()
+
+  manager.fetchers.unity.fetchById = async () => null
+  manager.fetchers.mtgelo.fetchById = async () => null
+  manager.fetchers.melee.fetchById = async () => null
+  manager.fetchers.topdeck.fetchById = async () => null
+
+  const result = await manager.getPlayerInfo({
+    unityId: '123',
+    mtgeloId: '456',
+    meleeUser: 'test',
+    topdeckHandle: 'test'
+  })
+
+  assert.deepEqual(result.general, {}, 'General should be empty object')
+  assert.deepEqual(result.sources, {}, 'Sources should be empty object')
+  assert.ok(!result.general['win rate'], 'Should not have win rate with no valid results')
+})
+
+test('PlayerInfoManager: getPlayerInfo handles partial null results', async () => {
+  const manager = new PlayerInfoManager()
+
+  manager.fetchers.unity.fetchById = async () => ({
+    source: 'Unity League',
+    url: 'http://unity.test',
+    name: 'Test Player'
+  })
+  manager.fetchers.mtgelo.fetchById = async () => null
+  manager.fetchers.melee.fetchById = async () => null
+  manager.fetchers.topdeck.fetchById = async () => null
+
+  const result = await manager.getPlayerInfo({
+    unityId: '123',
+    mtgeloId: '456',
+    meleeUser: 'test',
+    topdeckHandle: 'test'
+  })
+
+  assert.equal(result.general.name, 'Test Player', 'Should have data from Unity League')
+  assert.equal(Object.keys(result.sources).length, 1, 'Should have only one source')
+  assert.ok(result.sources['Unity League'], 'Should have Unity League in sources')
+})
+
+test('PlayerInfoManager: mergeData handles records without draws (W-L format)', async () => {
+  const manager = new PlayerInfoManager()
+
+  const results = [
+    {
+      source: 'Test Source',
+      url: 'http://test.com',
+      name: 'Test Player',
+      record: '10-5'
+    }
+  ]
+
+  const merged = manager.mergeData(results, false)
+
+  assert.equal(merged.general['win rate'], '66.67%', 'Should calculate win rate correctly for W-L format')
+})
+
+test('PlayerInfoManager: mergeData handles invalid win rate strings gracefully', async () => {
+  const manager = new PlayerInfoManager()
+
+  const results = [
+    {
+      source: 'Test1',
+      url: 'http://test1.com',
+      name: 'Test',
+      winRate: 'invalid%'
+    },
+    {
+      source: 'Test2',
+      url: 'http://test2.com',
+      name: 'Test',
+      'win rate': 'N/A'
+    },
+    {
+      source: 'Test3',
+      url: 'http://test3.com',
+      name: 'Test',
+      record: '10-5-0'
+    }
+  ]
+
+  const merged = manager.mergeData(results, false)
+
+  // Should not crash, should calculate from record only
+  assert.ok(merged, 'Should not crash on invalid win rate strings')
+  assert.equal(merged.general['win rate'], '66.67%', 'Should calculate from valid record')
+})
+
+test('PlayerInfoManager: mergeData returns no win rate when insufficient data', async () => {
+  const manager = new PlayerInfoManager()
+
+  const results = [
+    {
+      source: 'Test',
+      url: 'http://test.com',
+      name: 'Test Player'
+    }
+  ]
+
+  const merged = manager.mergeData(results, false)
+
+  assert.ok(!merged.general['win rate'], 'Should not calculate win rate without data')
+})
+
+test('PlayerInfoManager: mergeData handles record with all zeros', async () => {
+  const manager = new PlayerInfoManager()
+
+  const results = [
+    {
+      source: 'Test',
+      url: 'http://test.com',
+      name: 'Test Player',
+      record: '0-0-0'
+    }
+  ]
+
+  const merged = manager.mergeData(results, false)
+
+  assert.ok(!merged.general['win rate'], 'Should not calculate win rate when no games played')
+})

package/test/meleeEdgeCases.test.js

@@ -0,0 +1,53 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const MeleeFetcher = require('../src/fetchers/melee')
+
+test('MeleeFetcher: parseHtml uses username when name not found in HTML', () => {
+  const fetcher = new MeleeFetcher()
+  const html = '<html><body></body></html>'
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'fallbackname')
+
+  assert.equal(result.name, 'fallbackname', 'Should use username as fallback')
+  assert.equal(result.source, 'Melee')
+  assert.equal(result.url, 'http://test.com')
+})
+
+test('MeleeFetcher: parseHtml handles invalid social link URLs gracefully', () => {
+  const fetcher = new MeleeFetcher()
+  const html = `
+    <html>
+      <body>
+        <span style="font-size: xx-large">Test Name</span>
+        <a class="social-link" href="not-a-valid-url">Invalid</a>
+        <a class="social-link" href="https://twitter.com/validuser">Valid</a>
+      </body>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'testuser')
+
+  assert.equal(result.name, 'Test Name')
+  assert.equal(result.twitter, 'validuser', 'Should parse valid URL')
+  // Should not crash on invalid URL
+})
+
+test('MeleeFetcher: parseHtml extracts multiple social links correctly', () => {
+  const fetcher = new MeleeFetcher()
+  const html = `
+    <html>
+      <body>
+        <span style="font-size: xx-large">Test Player</span>
+        <a class="social-link" href="https://twitter.com/testtwitter">Twitter</a>
+        <a class="social-link" href="https://www.facebook.com/testfacebook">Facebook</a>
+        <a class="social-link" href="https://twitch.tv/testtwitch">Twitch</a>
+      </body>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'testuser')
+
+  assert.equal(result.twitter, 'testtwitter')
+  assert.equal(result.facebook, 'testfacebook')
+  assert.equal(result.twitch, 'testtwitch')
+})

package/test/mtgEloEdgeCases.test.js

@@ -0,0 +1,92 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const MtgEloFetcher = require('../src/fetchers/mtgElo')
+
+test('MtgEloFetcher: parseHtml returns null when no name found', () => {
+  const fetcher = new MtgEloFetcher()
+  const html = '<html><body></body></html>'
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'test-id')
+
+  assert.equal(result, null, 'Should return null when name cannot be extracted')
+})
+
+test('MtgEloFetcher: parseHtml handles invalid JSON in astro-island gracefully', () => {
+  const fetcher = new MtgEloFetcher()
+  const html = `
+    <html>
+      <astro-island component-url="Profile" props='invalid json'></astro-island>
+      <div class="text-[22pt]">Fallback, Name</div>
+      <div class="text-[18pt]">Current rating: <span class="font-bold">1500</span></div>
+      <div class="text-[18pt]">Record: 10-5-2</div>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'test-id')
+
+  assert.equal(result.name, 'Name Fallback', 'Should use fallback parsing with flipped name')
+  assert.equal(result.current_rating, '1500')
+  assert.equal(result.record, '10-5-2')
+})
+
+test('MtgEloFetcher: parseHtml uses fallback selectors when astro-island missing', () => {
+  const fetcher = new MtgEloFetcher()
+  const html = `
+    <html>
+      <div class="text-[22pt]">Smith, John</div>
+      <div class="text-[18pt]">Current rating: <span class="font-bold">1600</span></div>
+      <div class="text-[18pt]">Record: 20-10-5</div>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'test-id')
+
+  assert.equal(result.name, 'John Smith', 'Should flip comma-separated name')
+  assert.equal(result.current_rating, '1600')
+  assert.equal(result.record, '20-10-5')
+  assert.equal(result['win rate'], '57.14%', 'Should calculate win rate from record')
+})
+
+test('MtgEloFetcher: parseHtml calculates win rate correctly with draws', () => {
+  const fetcher = new MtgEloFetcher()
+  const html = `
+    <html>
+      <div class="text-[22pt]">Test Player</div>
+      <div class="text-[18pt]">Record: 15-10-5</div>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'test-id')
+
+  assert.equal(result.record, '15-10-5')
+  assert.equal(result['win rate'], '50.00%')
+})
+
+test('MtgEloFetcher: parseHtml handles record without draws', () => {
+  const fetcher = new MtgEloFetcher()
+  const html = `
+    <html>
+      <div class="text-[22pt]">Test Player</div>
+      <div class="text-[18pt]">Record: 12-8</div>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'test-id')
+
+  assert.equal(result.record, '12-8')
+  assert.equal(result['win rate'], '60.00%')
+})
+
+test('MtgEloFetcher: parseHtml handles name without comma', () => {
+  const fetcher = new MtgEloFetcher()
+  const html = `
+    <html>
+      <div class="text-[22pt]">SingleName</div>
+      <div class="text-[18pt]">Record: 5-5-0</div>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com', 'test-id')
+
+  assert.equal(result.name, 'SingleName', 'Should handle single name without comma')
+})

package/test/{integration/playerInfoManager.test.js → playerInfoManager.test.js}

@@ -3,10 +3,10 @@ const assert = require('node:assert/strict')
 const fs = require('node:fs')
 const path = require('node:path')
 
-const PlayerInfoManager = require('../../src')
+const PlayerInfoManager = require('../src')
 
 function readFixture (name) {
-  return fs.readFileSync(path.join(__dirname, '..', 'data', name), 'utf8')
+  return fs.readFileSync(path.join(__dirname, 'data', name), 'utf8')
 }
 
 const fixtures = {

package/test/unityLeagueEdgeCases.test.js

@@ -0,0 +1,123 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const UnityLeagueFetcher = require('../src/fetchers/unityLeague')
+
+test('UnityLeagueFetcher: parseHtml ignores non-player_profile images', () => {
+  const fetcher = new UnityLeagueFetcher()
+  const html = `
+    <html>
+      <h1 class="d-inline">Test Player</h1>
+      <div class="card-body">
+        <img class="img-fluid" src="https://unityleague.gg/media/default_avatar.jpg" />
+      </div>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com')
+
+  assert.equal(result.photo, null, 'Should not use non-player_profile images')
+  assert.equal(result.name, 'Test Player')
+})
+
+test('UnityLeagueFetcher: parseHtml handles missing country data gracefully', () => {
+  const fetcher = new UnityLeagueFetcher()
+  const html = `
+    <html>
+      <h1 class="d-inline">Test Player</h1>
+      <dt class="small text-muted">Country:</dt>
+      <dd></dd>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com')
+
+  assert.ok(result, 'Should return result even with missing country')
+  assert.equal(result.name, 'Test Player')
+  assert.equal(result.country, '', 'Country should be empty string')
+})
+
+test('UnityLeagueFetcher: parseHtml handles country text without flag icon', () => {
+  const fetcher = new UnityLeagueFetcher()
+  const html = `
+    <html>
+      <h1 class="d-inline">Test Player</h1>
+      <dt class="small text-muted">Country:</dt>
+      <dd>Germany</dd>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com')
+
+  assert.equal(result.country, 'Germany', 'Should use text when no flag icon')
+})
+
+test('UnityLeagueFetcher: parseHtml handles missing bio element', () => {
+  const fetcher = new UnityLeagueFetcher()
+  const html = `
+    <html>
+      <h1 class="d-inline">Test Player</h1>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com')
+
+  assert.ok(!result.bio, 'Bio should be undefined when element missing')
+})
+
+test('UnityLeagueFetcher: parseHtml extracts country from header flag', () => {
+  const fetcher = new UnityLeagueFetcher()
+  const html = `
+    <html>
+      <h1 class="d-inline">Test Player</h1>
+      <div class="card-body">
+        <i class="fi fi-us"></i>
+      </div>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com')
+
+  assert.equal(result.country, 'us', 'Should extract country code from header flag')
+})
+
+test('UnityLeagueFetcher: parseHtml handles missing ranking table', () => {
+  const fetcher = new UnityLeagueFetcher()
+  const html = `
+    <html>
+      <h1 class="d-inline">Test Player</h1>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com')
+
+  assert.ok(result, 'Should handle missing ranking table')
+  assert.ok(!result['rank germany'], 'Should not have rank data')
+})
+
+test('UnityLeagueFetcher: parseHtml extracts ranking data with special characters', () => {
+  const fetcher = new UnityLeagueFetcher()
+  const html = `
+    <html>
+      <h1 class="d-inline">Test Player</h1>
+      <table class="table-sm">
+        <thead>
+          <tr>
+            <th>Germany</th>
+            <th>Europe</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td>#42</td>
+            <td>1st</td>
+          </tr>
+        </tbody>
+      </table>
+    </html>
+  `
+
+  const result = fetcher.parseHtml(html, 'http://test.com')
+
+  assert.equal(result['rank germany'], '42', 'Should extract numeric value from #42')
+  assert.equal(result['rank europe'], '1', 'Should extract numeric value from 1st')
+})

package/test/untapped.test.js

@@ -0,0 +1,58 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const path = require('node:path')
+
+const UntappedFetcher = require('../src/fetchers/untapped')
+
+function readFixture (name) {
+  return fs.readFileSync(path.join(__dirname, 'data', name), 'utf8')
+}
+
+test('UntappedFetcher: parses most recent match and extracts MTGA rank', () => {
+  const fetcher = new UntappedFetcher()
+  const fixtureJson = readFixture('untapped.json')
+  const matches = JSON.parse(fixtureJson)
+
+  const url = 'https://mtga.untapped.gg/profile/7de50700-c3f6-48e4-a38d-2add5b0d9b71/76DCDWCZS5FX5PIEEMUVY6GV74'
+  const result = fetcher.parseMatch(matches[0], url)
+
+  assert.strictEqual(result.source, 'Untapped.gg')
+  assert.strictEqual(result.url, url)
+
+  assert.match(result.mtga_rank, /^(Bronze|Silver|Gold|Platinum|Diamond|Mythic)\s\d+$/)
+})
+
+test('UntappedFetcher: handles missing rank data', () => {
+  const fetcher = new UntappedFetcher()
+  const testMatch = {
+    friendly_ranking_class_after: null,
+    friendly_ranking_tier_after: null
+  }
+
+  const url = 'https://mtga.untapped.gg/profile/test-user/test-code'
+  const result = fetcher.parseMatch(testMatch, url)
+
+  assert.strictEqual(result.mtga_rank, null)
+})
+
+test('UntappedFetcher: constructs correct API URL from two-part ID', () => {
+  const fetcher = new UntappedFetcher()
+  const userId = '7de50700-c3f6-48e4-a38d-2add5b0d9b71'
+  const playerCode = '76DCDWCZS5FX5PIEEMUVY6GV74'
+  const id = `${userId}/${playerCode}`
+
+  const parts = id.split('/')
+  assert.strictEqual(parts.length, 2)
+  assert.strictEqual(parts[0], userId)
+  assert.strictEqual(parts[1], playerCode)
+
+  const apiUrl = `https://api.mtga.untapped.gg/api/v1/games/users/${parts[0]}/players/${parts[1]}/?card_set=ECL`
+  assert.strictEqual(apiUrl, 'https://api.mtga.untapped.gg/api/v1/games/users/7de50700-c3f6-48e4-a38d-2add5b0d9b71/players/76DCDWCZS5FX5PIEEMUVY6GV74/?card_set=ECL')
+
+  const profileUrl = `https://mtga.untapped.gg/profile/${parts[0]}/${parts[1]}`
+  assert.strictEqual(profileUrl, 'https://mtga.untapped.gg/profile/7de50700-c3f6-48e4-a38d-2add5b0d9b71/76DCDWCZS5FX5PIEEMUVY6GV74')
+})
+
+
+