mtg-playerinfo 1.4.1 → 1.4.2

package/test/playerInfoManager.test.js

@@ -310,3 +310,368 @@ test('PlayerInfoManager: with sources in different order (Melee first, then Unit
   assert.ok(!result.general.bio.includes('Change the target of target spell or ability with a single target'),
     'Bio should not contain text from only Unity League profile')
 })
+
+// --- Consolidated subtest clusters from edgeCases.test.js, verboseLogging.test.js, winRatePrecision.test.js ---
+
+test.describe('PlayerInfoManager: Edge Cases', () => {
+  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')
+  })
+})
+
+test.describe('PlayerInfoManager: Verbose Logging', () => {
+  test('PlayerInfoManager: verbose mode logs promoted properties', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'http://source1.com',
+        name: 'Player Name'
+      }
+    ]
+
+    const capturedLogs = []
+    const originalLog = console.log
+    console.log = (msg) => { capturedLogs.push(msg) }
+
+    try {
+      const merged = manager.mergeData(results, true)
+      assert.equal(merged.general.name, 'Player Name')
+      assert.ok(capturedLogs.some(log => log.includes('⬆️') && log.includes('name') && log.includes('Source1')),
+        'Should log property promotion with ⬆️ emoji')
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('PlayerInfoManager: verbose mode logs matching property values', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'http://source1.com',
+        name: 'Player Name',
+        team: 'Team A'
+      },
+      {
+        source: 'Source2',
+        url: 'http://source2.com',
+        name: 'Player Name',
+        team: 'Team A'
+      }
+    ]
+
+    const capturedLogs = []
+    const originalLog = console.log
+    console.log = (msg) => { capturedLogs.push(msg) }
+
+    try {
+      manager.mergeData(results, true)
+      assert.ok(capturedLogs.some(log => log.includes('🆗') && log.includes('name') && log.includes('Source2')),
+        'Should log matching property with 🆗 emoji')
+      assert.ok(capturedLogs.some(log => log.includes('🆗') && log.includes('team') && log.includes('Source2')),
+        'Should log matching team property with 🆗 emoji')
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('PlayerInfoManager: verbose mode logs conflicting property values', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'http://source1.com',
+        name: 'Alice'
+      },
+      {
+        source: 'Source2',
+        url: 'http://source2.com',
+        name: 'Bob'
+      }
+    ]
+
+    const capturedLogs = []
+    const originalLog = console.log
+    console.log = (msg) => { capturedLogs.push(msg) }
+
+    try {
+      const merged = manager.mergeData(results, true)
+      assert.equal(merged.general.name, 'Alice', 'Should keep first value')
+      assert.ok(capturedLogs.some(log => log.includes('🆚') && log.includes('name') && log.includes('Source2') && log.includes('Bob') && log.includes('Alice')),
+        'Should log conflicting property with 🆚 emoji')
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('PlayerInfoManager: verbose mode uses photo emoji for photo conflicts', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'http://source1.com',
+        name: 'Player',
+        photo: 'http://photo1.jpg'
+      },
+      {
+        source: 'Source2',
+        url: 'http://source2.com',
+        name: 'Player',
+        photo: 'http://photo2.jpg'
+      }
+    ]
+
+    const capturedLogs = []
+    const originalLog = console.log
+    console.log = (msg) => { capturedLogs.push(msg) }
+
+    try {
+      manager.mergeData(results, true)
+      assert.ok(capturedLogs.some(log => log.includes('🆕') && log.includes('photo')),
+        'Should log photo conflict with 🆕 emoji instead of 🆚')
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('PlayerInfoManager: verbose mode logs with null/undefined properties', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'http://source1.com',
+        name: 'Player',
+        bio: null,
+        team: undefined
+      },
+      {
+        source: 'Source2',
+        url: 'http://source2.com',
+        name: 'Player',
+        bio: 'Test bio',
+        team: 'Team A'
+      }
+    ]
+
+    const capturedLogs = []
+    const originalLog = console.log
+    console.log = (msg) => { capturedLogs.push(msg) }
+
+    try {
+      manager.mergeData(results, true)
+      assert.ok(capturedLogs.some(log => log.includes('⬆️') && log.includes('bio') && log.includes('Source2')),
+        'Should promote bio from Source2 after Source1 had null')
+      assert.ok(capturedLogs.some(log => log.includes('⬆️') && log.includes('team') && log.includes('Source2')),
+        'Should promote team from Source2 after Source1 had undefined')
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('PlayerInfoManager: verbose mode is false by default and logs nothing', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'http://source1.com',
+        name: 'Player Name'
+      }
+    ]
+
+    const capturedLogs = []
+    const originalLog = console.log
+    console.log = (msg) => { capturedLogs.push(msg) }
+
+    try {
+      manager.mergeData(results, false)
+      assert.equal(capturedLogs.length, 0, 'Should not log when verbose is false')
+    } finally {
+      console.log = originalLog
+    }
+  })
+
+  test('PlayerInfoManager: verbose mode logs each property separately', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'http://source1.com',
+        name: 'Alice',
+        team: 'Team A',
+        bio: 'Bio 1',
+        photo: 'photo1.jpg',
+        pronouns: 'they/them'
+      }
+    ]
+
+    const capturedLogs = []
+    const originalLog = console.log
+    console.log = (msg) => { capturedLogs.push(msg) }
+
+    try {
+      manager.mergeData(results, true)
+      const promotedLogs = capturedLogs.filter(log => log.includes('⬆️'))
+      assert.ok(promotedLogs.length >= 5, `Should log 5+ promoted properties, got ${promotedLogs.length}`)
+      assert.ok(promotedLogs.some(log => log.includes('name')))
+      assert.ok(promotedLogs.some(log => log.includes('team')))
+      assert.ok(promotedLogs.some(log => log.includes('bio')))
+      assert.ok(promotedLogs.some(log => log.includes('photo')))
+      assert.ok(promotedLogs.some(log => log.includes('pronouns')))
+    } finally {
+      console.log = originalLog
+    }
+  })
+})
+
+test.describe('PlayerInfoManager: Win Rate Calculation', () => {
+  test('PlayerInfoManager: Win rate should be calculated from total of source W-L-D records', async () => {
+    const manager = new PlayerInfoManager()
+
+    const results = [
+      {
+        source: 'Source1',
+        url: 'url1',
+        record: '10-0-0',
+        'win rate': '100.00%'
+      },
+      {
+        source: 'Source2',
+        url: 'url2',
+        record: '0-90-10',
+        'win rate': '0.00%'
+      }
+    ]
+
+    const merged = manager.mergeData(results)
+    assert.strictEqual(merged.general['win rate'], '9.09%', 'Win rate should be calculated from total records')
+  })
+})

package/test/socialMediaExtractor.test.js

@@ -0,0 +1,31 @@
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { extractHandle, getPlatformName } = require('../src/utils/socialMediaExtractor')
+
+test('socialMediaExtractor: extractHandle extracts handle correctly', () => {
+  assert.strictEqual(extractHandle('https://twitter.com/user'), 'user')
+  assert.strictEqual(extractHandle('https://www.facebook.com/user/'), 'user')
+  assert.strictEqual(extractHandle('https://twitch.tv/user'), 'user')
+  assert.strictEqual(extractHandle('https://youtube.com/@user'), '@user')
+  assert.strictEqual(extractHandle('https://instagram.com/user?query=1'), 'user')
+})
+
+test('socialMediaExtractor: extractHandle handles null/empty/invalid input', () => {
+  assert.strictEqual(extractHandle(null), null)
+  assert.strictEqual(extractHandle(''), null)
+  assert.strictEqual(extractHandle('not-a-url'), null)
+})
+
+test('socialMediaExtractor: getPlatformName extracts platform name correctly', () => {
+  assert.strictEqual(getPlatformName('https://twitter.com/user'), 'twitter')
+  assert.strictEqual(getPlatformName('https://www.facebook.com/user'), 'facebook')
+  assert.strictEqual(getPlatformName('https://twitch.tv/user'), 'twitch')
+  assert.strictEqual(getPlatformName('https://youtube.com/@user'), 'youtube')
+  assert.strictEqual(extractHandle('https://twitter.com/'), null)
+})
+
+test('socialMediaExtractor: getPlatformName handles null/empty/invalid input', () => {
+  assert.strictEqual(getPlatformName(null), null)
+  assert.strictEqual(getPlatformName(''), null)
+  assert.strictEqual(getPlatformName('not-a-url'), null)
+})

package/test/topdeck.test.js

@@ -1,49 +1,85 @@
 const test = require('node:test')
 const assert = require('node:assert/strict')
-const fs = require('node:fs')
-const path = require('node:path')
-const { mock } = require('node:test')
-
-const httpClient = require('../src/utils/httpClient')
 const TopdeckFetcher = require('../src/fetchers/topdeck')
+const httpClient = require('../src/utils/httpClient')
+const { readFixture, withMutedConsole } = require('./helpers')
 
-function readFixture (name) {
-  return fs.readFileSync(path.join(__dirname, 'data', name), 'utf8')
-}
-
-test('TopdeckFetcher: parseHtml extracts stats from DOM when available', () => {
+test('TopdeckFetcher: parseHtml extracts info from fixture', () => {
   const html = readFixture('topdeck.html')
-  const handle = '@k0shiii'
-  const url = `https://topdeck.gg/profile/${handle}`
+  const url = 'https://topdeck.gg/profile/@k0shiii'
   const fetcher = new TopdeckFetcher()
 
-  const result = fetcher.parseHtml(html, url, handle)
+  const result = fetcher.parseHtml(html, url, '@k0shiii')
 
-  assert.ok(result, 'Should return a result object')
-  assert.equal(result.source, 'Topdeck')
-  assert.equal(result.url, url)
-  assert.equal(result.name, 'Björn Kimminich')
-  assert.equal(result.pronouns, 'He/Him', 'Should extract pronouns from badge')
-  assert.equal(result.twitter, 'bkimminich', 'Should extract Twitter handle')
-  assert.equal(result.youtube, '@BjörnKimminich', 'Should extract YouTube handle')
+  assert.strictEqual(result.source, 'Topdeck')
+  assert.strictEqual(result.name, 'Björn Kimminich')
+  assert.strictEqual(result.photo, 'https://imagedelivery.net/kN_u_RUfFF6xsGMKYWhO1g/2a7b8d12-5924-4a58-5f9c-c0bf55766800/square')
+  assert.strictEqual(result.twitter, 'bkimminich')
+  assert.strictEqual(result.youtube, '@BjörnKimminich')
+  assert.match(result.tournaments, /^\d+$/)
+  assert.match(result.record, /^\d+-\d+-\d+$/)
 })
 
-test('TopdeckFetcher: fetchStats updates playerInfo with data from stats JSON', async () => {
-  const statsJson = readFixture('topdeck.json')
-  const internalId = 'm4VSTJShiXR1PCSCWaM9TBY0rcg1'
+test('TopdeckFetcher: parseHtml handles missing stats and different DOM shapes', () => {
   const fetcher = new TopdeckFetcher()
-  const playerInfo = { source: 'Topdeck' }
+  const html = `
+    <html>
+      <body>
+        <h1>Simple Name</h1>
+        <div class="stats-container">
+          <div class="stat">
+            <div class="label">Win Rate</div>
+            <div class="value">55%</div>
+          </div>
+        </div>
+      </body>
+    </html>
+  `
+  const result = fetcher.parseHtml(html, 'url', 'handle')
+  assert.strictEqual(result.name, 'Simple Name')
+  assert.strictEqual(result['win rate'], '55%')
+})
 
-  mock.method(httpClient, 'request', async (url) => {
-    if (url.endsWith(`/profile/${internalId}/stats`)) {
-      return { data: statsJson }
-    }
-    throw new Error(`Unexpected URL: ${url}`)
+test('TopdeckFetcher: fetchById and fetchStats integration', async (t) => {
+  const fetcher = new TopdeckFetcher()
+
+  await t.test('successful fetch with stats', async () => {
+    const mockRequest = t.mock.method(httpClient, 'request')
+    mockRequest.mock.mockImplementation(async (url) => {
+      if (url.includes('/stats')) {
+        return { data: { yearlyStats: { 2024: { overall: { totalTournaments: 5, wins: 3, losses: 1, draws: 1 } } } }, status: 200 }
+      }
+      return { data: '<html><h2>Test User</h2>const playerId = "abc123";</html>', status: 200 }
+    })
+
+    const result = await fetcher.fetchById('testuser')
+    assert.strictEqual(result.name, '@testuser')
+    assert.strictEqual(result.record, '3-1-1')
+    assert.strictEqual(result['win rate'], '60.00%')
+    mockRequest.mock.restore()
   })
 
-  await fetcher.fetchStats(internalId, playerInfo)
+  await t.test('fetch error handling', async () => {
+    const mockRequest = t.mock.method(httpClient, 'request', () => { throw new Error('Boom') })
+    await withMutedConsole(async () => {
+      const result = await fetcher.fetchById('testuser')
+      assert.strictEqual(result, null)
+    })
+    mockRequest.mock.restore()
+  })
 
-  assert.match(playerInfo.tournaments, /^\d+$/)
-  assert.match(playerInfo.record, /^\d+-\d+-\d+$/)
-  assert.match(playerInfo['win rate'], /^\d+(\.\d+)?%$/)
+  await t.test('stats fetch error handling', async () => {
+    const mockRequest = t.mock.method(httpClient, 'request')
+    mockRequest.mock.mockImplementation(async (url) => {
+      if (url.includes('/stats')) throw new Error('Stats Error')
+      return { data: '<html>const playerId = "abc123";</html>', status: 200 }
+    })
+
+    await withMutedConsole(async () => {
+      const result = await fetcher.fetchById('testuser')
+      assert.ok(result)
+      assert.ok(!result.record)
+    })
+    mockRequest.mock.restore()
+  })
 })

package/test/unityLeague.test.js

@@ -1,30 +1,71 @@
 const test = require('node:test')
 const assert = require('node:assert/strict')
-const fs = require('node:fs')
-const path = require('node:path')
-
 const UnityLeagueFetcher = require('../src/fetchers/unityLeague')
+const httpClient = require('../src/utils/httpClient')
+const { readFixture, withMutedConsole } = require('./helpers')
 
-function readFixture (name) {
-  return fs.readFileSync(path.join(__dirname, 'data', name), 'utf8')
-}
-
-test('UnityLeagueFetcher: parseHtml extracts profile, photo, ranks and stats', () => {
+test('UnityLeagueFetcher: parseHtml extracts info from fixture', () => {
   const html = readFixture('unityLeague.html')
-  const url = 'https://unityleague.gg/player/16215/'
+  const url = 'https://unityleague.gg/player/koshiii/'
   const fetcher = new UnityLeagueFetcher()
 
   const result = fetcher.parseHtml(html, url)
 
-  assert.ok(result, 'Should return a result object')
-  assert.equal(result.source, 'Unity League')
-  assert.equal(result.url, url)
-  assert.equal(result.name, 'Björn Kimminich')
-  assert.equal(result.photo, 'https://unityleague.gg/media/player_profile/1000023225.jpg')
-  assert.equal(result.country, 'de')
-  assert.match(result['rank germany'], /^\d+$/)
-  assert.match(result['rank europe'], /^\d+$/)
-  assert.match(result['rank points'], /^\d+$/)
+  assert.strictEqual(result.source, 'Unity League')
+  assert.strictEqual(result.name, 'Björn Kimminich')
+  assert.strictEqual(result.photo, 'https://unityleague.gg/media/player_profile/1000023225.jpg')
+  assert.strictEqual(result.country, 'de')
+  assert.ok(result.bio.includes('Smugly held back'))
   assert.match(result.record, /^\d+-\d+-\d+$/)
   assert.match(result['win rate'], /^\d+(\.\d+)?%$/)
 })
+
+test('UnityLeagueFetcher: parseHtml handles edge cases in DOM', () => {
+  const fetcher = new UnityLeagueFetcher()
+
+  const cases = [
+    {
+      label: 'non-profile image',
+      html: '<html><body><div class="card-body"><img class="img-fluid" src="/other.jpg"></div></body></html>',
+      check: (res) => assert.strictEqual(res.photo, null)
+    },
+    {
+      label: 'country from dd list',
+      html: '<html><body><dt class="small text-muted">Country:</dt><dd><i class="fi fi-us"></i> United States</dd></body></html>',
+      check: (res) => assert.strictEqual(res.country, 'us')
+    },
+    {
+      label: 'no account header',
+      html: '<html><body></body></html>',
+      check: (res) => assert.strictEqual(res.name, '')
+    }
+  ]
+
+  for (const { html, check } of cases) {
+    const res = fetcher.parseHtml(html, 'url')
+    check(res)
+  }
+})
+
+test('UnityLeagueFetcher: fetchById handles success and error scenarios', async (t) => {
+  const fetcher = new UnityLeagueFetcher()
+
+  await t.test('successful fetch', async () => {
+    const mockRequest = t.mock.method(httpClient, 'request', async () => ({
+      data: '<html><h1 class="d-inline">Fetched User</h1></html>',
+      status: 200
+    }))
+    const result = await fetcher.fetchById('koshiii')
+    assert.strictEqual(result.name, 'Fetched User')
+    mockRequest.mock.restore()
+  })
+
+  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('koshiii')
+      assert.strictEqual(result, null)
+    })
+    mockRequest.mock.restore()
+  })
+})