mtg-playerinfo 1.4.0 → 1.4.2

package/test/untapped.test.js

@@ -1,15 +1,10 @@
 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')
+const httpClient = require('../src/utils/httpClient')
+const { readFixture, withMutedConsole } = require('./helpers')
 
-function readFixture (name) {
-  return fs.readFileSync(path.join(__dirname, 'data', name), 'utf8')
-}
-
-test('UntappedFetcher: parses most recent match and extracts MTGA rank', () => {
+test('UntappedFetcher: parseMatches extracts MTGA rank from fixture', () => {
   const fetcher = new UntappedFetcher()
   const fixtureJson = readFixture('untapped.json')
   const matches = JSON.parse(fixtureJson)
@@ -19,83 +14,99 @@ test('UntappedFetcher: parses most recent match and extracts MTGA rank', () => {
 
   assert.strictEqual(result.source, 'Untapped.gg')
   assert.strictEqual(result.url, url)
-
   assert.strictEqual(typeof result.mtga_rank, 'object')
 
-  // Format is either "Rank Tier" (e.g. "Diamond 2") or "Mythic #Place" or "Mythic Percentile%" (e.g. "Mythic #123" or "Mythic 98.67%")
-  if (result.mtga_rank.constructed !== undefined) {
-    assert.match(result.mtga_rank.constructed, /^(Bronze|Silver|Gold|Platinum|Diamond|Mythic)(\s\d+|\s#\d+|\s\d+(\.\d+)?%)$/)
+  const rankRegex = /^(Bronze|Silver|Gold|Platinum|Diamond|Mythic)(\s\d+|\s#\d+|\s\d+(\.\d+)?%)$/
+  if (result.mtga_rank.constructed) {
+    assert.match(result.mtga_rank.constructed, rankRegex)
   }
-  if (result.mtga_rank.limited !== undefined) {
-    assert.match(result.mtga_rank.limited, /^(Bronze|Silver|Gold|Platinum|Diamond|Mythic)(\s\d+|\s#\d+|\s\d+(\.\d+)?%)$/)
+  if (result.mtga_rank.limited) {
+    assert.match(result.mtga_rank.limited, rankRegex)
   }
 })
 
-test('UntappedFetcher: handles missing rank data', () => {
+test('UntappedFetcher: formats Mythic rank correctly', () => {
   const fetcher = new UntappedFetcher()
-  const testMatches = [
+  const testCases = [
     {
-      super_format: 2,
-      friendly_ranking_class_after: null,
-      friendly_ranking_tier_after: null,
-      match_start: 1000
+      label: 'leaderboard place',
+      match: { super_format: 2, friendly_ranking_class_after: 'Mythic', friendly_mythic_leaderboard_place_after: 123, match_start: 1000 },
+      expected: 'Mythic #123'
     },
     {
-      super_format: 1,
-      friendly_ranking_class_after: null,
-      friendly_ranking_tier_after: null,
-      match_start: 2000
+      label: 'percentile',
+      match: { super_format: 1, friendly_ranking_class_after: 'Mythic', friendly_mythic_percentile_after: 98.789, match_start: 2000 },
+      expected: 'Mythic 98%'
     }
   ]
 
-  const url = 'https://mtga.untapped.gg/profile/test-user/test-code'
-  const result = fetcher.parseMatches(testMatches, url)
-
-  assert.strictEqual('constructed' in result.mtga_rank, false)
-  assert.strictEqual('limited' in result.mtga_rank, false)
+  for (const { label, match, expected } of testCases) {
+    const result = fetcher.parseMatches([match], 'url')
+    const rank = match.super_format === 2 ? result.mtga_rank.constructed : result.mtga_rank.limited
+    assert.strictEqual(rank, expected, `Failed for ${label}`)
+  }
 })
 
-test('UntappedFetcher: formats Mythic rank with leaderboard place or percentile', () => {
+test('UntappedFetcher: handles missing or incomplete rank data', () => {
   const fetcher = new UntappedFetcher()
-  const testMatches = [
-    {
-      super_format: 2,
-      friendly_ranking_class_after: 'Mythic',
-      friendly_ranking_tier_after: null,
-      friendly_mythic_leaderboard_place_after: 123,
-      friendly_mythic_percentile_after: 101.5,
-      match_start: 1000
-    },
-    {
-      super_format: 1,
-      friendly_ranking_class_after: 'Mythic',
-      friendly_ranking_tier_after: null,
-      friendly_mythic_leaderboard_place_after: null,
-      friendly_mythic_percentile_after: 98.789,
-      match_start: 2000
-    }
+  const cases = [
+    { label: 'null class', match: { super_format: 2, friendly_ranking_class_after: null } },
+    { label: 'Mythic no data', match: { super_format: 2, friendly_ranking_class_after: 'Mythic', friendly_mythic_leaderboard_place_after: null, friendly_mythic_percentile_after: null } },
+    { label: 'missing tier', match: { super_format: 2, friendly_ranking_class_after: 'Gold', friendly_ranking_tier_after: null } }
   ]
 
-  const url = 'https://mtga.untapped.gg/profile/test-user/test-code'
-  const result = fetcher.parseMatches(testMatches, url)
-
-  assert.strictEqual(result.mtga_rank.constructed, 'Mythic #123')
-  assert.strictEqual(result.mtga_rank.limited, 'Mythic 98%')
+  for (const { label, match } of cases) {
+    const result = fetcher.parseMatches([match], 'url')
+    assert.ok(!result.mtga_rank.constructed, `Should not have rank for ${label}`)
+  }
 })
 
-test('UntappedFetcher: constructs correct API URL from two-part ID', () => {
-  const userId = '7de50700-c3f6-48e4-a38d-2add5b0d9b71'
-  const playerCode = '76DCDWCZS5FX5PIEEMUVY6GV74'
-  const id = `${userId}/${playerCode}`
+test('UntappedFetcher: findMostRecentByFormat picks latest match', () => {
+  const fetcher = new UntappedFetcher()
+  const testMatches = [
+    { super_format: 2, friendly_ranking_class_after: 'Gold', friendly_ranking_tier_after: 4, match_start: 1000 },
+    { super_format: 2, friendly_ranking_class_after: 'Gold', friendly_ranking_tier_after: 1, match_start: 5000 },
+    { super_format: 2, friendly_ranking_class_after: 'Gold', friendly_ranking_tier_after: 2, match_start: 3000 }
+  ]
 
-  const parts = id.split('/')
-  assert.strictEqual(parts.length, 2)
-  assert.strictEqual(parts[0], userId)
-  assert.strictEqual(parts[1], playerCode)
+  const result = fetcher.parseMatches(testMatches, 'url')
+  assert.strictEqual(result.mtga_rank.constructed, 'Gold 1')
+})
 
-  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')
+test('UntappedFetcher: fetchById handles various ID and response scenarios', async (t) => {
+  const fetcher = new UntappedFetcher()
 
-  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')
+  await t.test('invalid ID format', async () => {
+    await withMutedConsole(async () => {
+      const result = await fetcher.fetchById('invalid-id')
+      assert.strictEqual(result, null)
+    })
+  })
+
+  await t.test('network error', async () => {
+    const mockRequest = t.mock.method(httpClient, 'request', () => { throw new Error('Network Error') })
+    await withMutedConsole(async () => {
+      const result = await fetcher.fetchById('user/code')
+      assert.strictEqual(result, null)
+    })
+    mockRequest.mock.restore()
+  })
+
+  await t.test('empty matches array', async () => {
+    const mockRequest = t.mock.method(httpClient, 'request', async () => ({ data: [] }))
+    await withMutedConsole(async () => {
+      const result = await fetcher.fetchById('user/code')
+      assert.strictEqual(result, null)
+    })
+    mockRequest.mock.restore()
+  })
+
+  await t.test('non-array data', async () => {
+    const mockRequest = t.mock.method(httpClient, 'request', async () => ({ data: {} }))
+    await withMutedConsole(async () => {
+      const result = await fetcher.fetchById('user/code')
+      assert.strictEqual(result, null)
+    })
+    mockRequest.mock.restore()
+  })
 })

package/test/edgeCases.test.js

@@ -1,128 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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/unityLeagueEdgeCases.test.js

@@ -1,123 +0,0 @@
-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')
-})