segnapunti/tests/unit/server-utils.test.js

import { describe, it, expect, vi, afterEach } from 'vitest'
import * as os from 'os'

vi.mock('os', async (importOriginal) => {
    return {
        ...await importOriginal(),
        networkInterfaces: vi.fn(() => ({}))
    }
})

import { getNetworkIPs, printServerInfo } from '../../src/server-utils.js'

describe('Server Utils', () => {

    afterEach(() => {
        vi.restoreAllMocks()
    })

    // =============================================
    // getNetworkIPs
    // =============================================
    describe('getNetworkIPs', () => {
        it('dovrebbe restituire indirizzi IPv4 non-loopback', () => {
            os.networkInterfaces.mockReturnValue({
                eth0: [
                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
                ]
            })
            expect(getNetworkIPs()).toEqual(['192.168.1.100'])
        })

        it('dovrebbe escludere indirizzi loopback (internal)', () => {
            os.networkInterfaces.mockReturnValue({
                lo: [
                    { family: 'IPv4', internal: true, address: '127.0.0.1' }
                ],
                eth0: [
                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
                ]
            })
            const ips = getNetworkIPs()
            expect(ips).not.toContain('127.0.0.1')
            expect(ips).toContain('192.168.1.100')
        })

        it('dovrebbe escludere indirizzi IPv6', () => {
            os.networkInterfaces.mockReturnValue({
                eth0: [
                    { family: 'IPv6', internal: false, address: 'fe80::1' },
                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
                ]
            })
            const ips = getNetworkIPs()
            expect(ips).toEqual(['192.168.1.100'])
        })

        it('dovrebbe escludere bridge Docker 172.17.x.x', () => {
            os.networkInterfaces.mockReturnValue({
                docker0: [
                    { family: 'IPv4', internal: false, address: '172.17.0.1' }
                ],
                eth0: [
                    { family: 'IPv4', internal: false, address: '10.0.0.5' }
                ]
            })
            const ips = getNetworkIPs()
            expect(ips).not.toContain('172.17.0.1')
            expect(ips).toContain('10.0.0.5')
        })

        it('dovrebbe escludere bridge Docker 172.18.x.x', () => {
            os.networkInterfaces.mockReturnValue({
                br0: [
                    { family: 'IPv4', internal: false, address: '172.18.0.1' }
                ]
            })
            expect(getNetworkIPs()).toEqual([])
        })

        it('dovrebbe restituire array vuoto se nessuna interfaccia disponibile', () => {
            os.networkInterfaces.mockReturnValue({})
            expect(getNetworkIPs()).toEqual([])
        })

        it('dovrebbe restituire più indirizzi da interfacce diverse', () => {
            os.networkInterfaces.mockReturnValue({
                eth0: [
                    { family: 'IPv4', internal: false, address: '192.168.1.100' }
                ],
                wlan0: [
                    { family: 'IPv4', internal: false, address: '192.168.1.101' }
                ]
            })
            const ips = getNetworkIPs()
            expect(ips).toHaveLength(2)
            expect(ips).toContain('192.168.1.100')
            expect(ips).toContain('192.168.1.101')
        })
    })

    // =============================================
    // printServerInfo
    // =============================================
    describe('printServerInfo', () => {
        it('dovrebbe stampare le porte corrette (default)', () => {
            os.networkInterfaces.mockReturnValue({})
            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
            printServerInfo()
            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
            expect(allLogs).toContain('5173')
            expect(allLogs).toContain('3001')
            consoleSpy.mockRestore()
        })

        it('dovrebbe stampare le porte personalizzate', () => {
            os.networkInterfaces.mockReturnValue({})
            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
            printServerInfo(3000, 4000)
            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
            expect(allLogs).toContain('3000')
            expect(allLogs).toContain('4000')
            consoleSpy.mockRestore()
        })

        it('dovrebbe mostrare gli URL remoti se ci sono IP di rete', () => {
            os.networkInterfaces.mockReturnValue({
                eth0: [
                    { family: 'IPv4', internal: false, address: '192.168.1.50' }
                ]
            })
            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
            printServerInfo(3000, 3001)
            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
            expect(allLogs).toContain('192.168.1.50')
            expect(allLogs).toContain('remoti')
            consoleSpy.mockRestore()
        })

        it('non dovrebbe mostrare sezione remoti se nessun IP di rete', () => {
            os.networkInterfaces.mockReturnValue({})
            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
            printServerInfo(3000, 3001)
            const allLogs = consoleSpy.mock.calls.map(c => c[0]).join('\n')
            expect(allLogs).not.toContain('remoti')
            consoleSpy.mockRestore()
        })
    })
})