KtIrc/src/test/kotlin/com/dmdirc/ktirc/IrcClientTest.kt

package com.dmdirc.ktirc

import com.dmdirc.ktirc.events.IrcEvent
import com.dmdirc.ktirc.events.ServerWelcome
import com.dmdirc.ktirc.io.CaseMapping
import com.dmdirc.ktirc.io.LineBufferedSocket
import com.dmdirc.ktirc.model.*
import com.nhaarman.mockitokotlin2.*
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows

internal class IrcClientImplTest {

    companion object {
        private const val HOST = "thegibson.com"
        private const val PORT = 12345
        private const val NICK = "AcidBurn"
        private const val REAL_NAME = "Kate Libby"
        private const val USER_NAME = "acidb"
        private const val PASSWORD = "HackThePlanet"
    }

    private val readLineChannel = Channel<ByteArray>(10)

    private val mockSocket = mock<LineBufferedSocket> {
        on { readLines(any()) } doReturn readLineChannel
    }

    private val mockSocketFactory = mock<(String, Int, Boolean) -> LineBufferedSocket> {
        on { invoke(eq(HOST), eq(PORT), any()) } doReturn mockSocket
    }

    private val mockEventHandler = mock<(IrcEvent) -> Unit>()

    @BeforeEach
    fun setUp() {
        IrcMessage.currentTimeProvider = { TestConstants.time }
    }

    @Test
    fun `IrcClientImpl uses socket factory to create a new socket on connect`() {
        runBlocking {
            val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
            client.socketFactory = mockSocketFactory
            readLineChannel.close()

            client.connect()

            verify(mockSocketFactory).invoke(HOST, PORT, false)
        }
    }

    @Test
    fun `IrcClientImpl uses socket factory to create a new tls on connect`() {
        runBlocking {
            val client = IrcClientImpl(Server(HOST, PORT, true), Profile(NICK, REAL_NAME, USER_NAME))
            client.socketFactory = mockSocketFactory
            readLineChannel.close()

            client.connect()

            verify(mockSocketFactory).invoke(HOST, PORT, true)
        }
    }

    @Test
    fun `IrcClientImpl throws if socket already exists`() {
        runBlocking {
            val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
            client.socketFactory = mockSocketFactory
            readLineChannel.close()

            client.connect()

            assertThrows<IllegalStateException> {
                runBlocking {
                    client.connect()
                }
            }
        }
    }

    @Test
    fun `IrcClientImpl sends basic connection strings`() {
        runBlocking {
            val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
            client.socketFactory = mockSocketFactory
            readLineChannel.close()

            client.connect()

            with(inOrder(mockSocket).verify(mockSocket)) {
                sendLine("CAP LS 302")
                sendLine("NICK :$NICK")
                sendLine("USER $USER_NAME localhost $HOST :$REAL_NAME")
            }
        }
    }

    @Test
    fun `IrcClientImpl sends password first, when present`() {
        runBlocking {
            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
            client.socketFactory = mockSocketFactory
            readLineChannel.close()

            client.connect()

            with(inOrder(mockSocket).verify(mockSocket)) {
                sendLine("CAP LS 302")
                sendLine("PASS :$PASSWORD")
                sendLine("NICK :$NICK")
            }
        }
    }

    @Test
    fun `IrcClientImpl sends events to provided event handler`() {
        runBlocking {
            val client = IrcClientImpl(Server(HOST, PORT, password = PASSWORD), Profile(NICK, REAL_NAME, USER_NAME))
            client.socketFactory = mockSocketFactory
            client.onEvent(mockEventHandler)

            launch {
                readLineChannel.send(":the.gibson 001 acidBurn :Welcome to the IRC!".toByteArray())
                readLineChannel.close()
            }

            client.connect()

            verify(mockEventHandler).invoke(isA<ServerWelcome>())
        }
    }

    @Test
    fun `IrcClient gets case mapping from server features`() {
        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
        client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.RfcStrict
        assertEquals(CaseMapping.RfcStrict, client.caseMapping)
    }

    @Test
    fun `IrcClient indicates if user is local user or not`() {
        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
        client.serverState.localNickname = "[acidBurn]"

        assertTrue(client.isLocalUser(User("{acidBurn}", "libby", "root.localhost")))
        assertFalse(client.isLocalUser(User("acid-Burn", "libby", "root.localhost")))
    }

    @Test
    fun `IrcClient uses current case mapping to check local user`() {
        val client = IrcClientImpl(Server(HOST, PORT), Profile(NICK, REAL_NAME, USER_NAME))
        client.serverState.localNickname = "[acidBurn]"
        client.serverState.features[ServerFeature.ServerCaseMapping] = CaseMapping.Ascii
        assertFalse(client.isLocalUser(User("{acidBurn}", "libby", "root.localhost")))
    }

}