irc-client/client_test.go

package ircclient

import (
	"encoding/json"
	"fmt"
	"net"
	"reflect"
	"strconv"
	"strings"
	"syscall"
	"testing"
)

func TestMarshal(t *testing.T) {
	var config IRCConfig = IRCConfig{
		Port:         6667,
		Hostname:     "irc.red.green.com",
		UseTLS:       false,
		Nick:         "test",
		Username:     "testuser",
		Realname:     "Marshal Test",
		Password:     "12345",
		AutoJoin:     []string{"#test", "#chat"},
		RejoinDelay:  2000,
		Version:      "Test v3.14",
		Debug_Output: true,
	}
	var buffer []byte
	var err error
	buffer, err = json.Marshal(&config)
	if err != nil {
		t.Error("json.Marshal:", err)
	}

	var verify IRCConfig
	err = json.Unmarshal(buffer, &verify)
	if err != nil {
		t.Error("json.Unmarshal:", err)
	}

	var fields []reflect.StructField = reflect.VisibleFields(reflect.TypeOf(config))
	var config_value reflect.Value = reflect.ValueOf(config)
	var verify_value reflect.Value = reflect.ValueOf(verify)

	for _, field := range fields {
		var name string = field.Name
		var isType reflect.Kind = verify_value.FieldByName(name).Kind()

		// t.Logf("%s is %s\n", name, isType)

		if isType == reflect.String {
			var got, expect string

			got = verify_value.FieldByName(name).String()
			expect = config_value.FieldByName(name).String()

			if got != expect {
				t.Errorf("For %s Got %s, Expected %s", name, got, expect)
			}
		}

		if isType == reflect.Bool {
			var got, expect bool

			got = verify_value.FieldByName(name).Bool()
			expect = config_value.FieldByName(name).Bool()

			if got != expect {
				t.Errorf("For %s Got %t, Expected %t", name, got, expect)
			}
		}

		if isType == reflect.Int {
			var got, expect int64

			got = verify_value.FieldByName(name).Int()
			expect = config_value.FieldByName(name).Int()

			if got != expect {
				t.Errorf("For %s Got %d, Expected %d", name, got, expect)
			}
		}

	}

	for x, got := range verify.AutoJoin {
		if got != config.AutoJoin[x] {
			t.Errorf("For AutoJoin %d Got %s, Expected %s", x, got, config.AutoJoin[x])
		}
	}
}

func TestParse(t *testing.T) {
	var Msg IRCMsg
	var Expect map[string]IRCMsg = map[string]IRCMsg{
		"PING :78629A0F5F3F164F": IRCMsg{
			Cmd: "PING", Msg: "78629A0F5F3F164F", MsgParts: []string{"PING"}},
		":irc.red-green.com 001 test :Welcome to the RedGreen IRC Network": IRCMsg{
			From: "irc.red-green.com", Cmd: "001", To: "test",
			Msg:      "Welcome to the RedGreen IRC Network",
			MsgParts: []string{":irc.red-green.com", "001", "test"}},
		":irc.red-green.com 375 test :- irc.red-green.com Message of the Day -": IRCMsg{
			From: "irc.red-green.com", Cmd: "375", To: "test",
			Msg:      "- irc.red-green.com Message of the Day -",
			MsgParts: []string{":irc.red-green.com", "375", "test"}},
		":irc.red-green.com 433 :Nick already in use": IRCMsg{
			From: "irc.red-green.com", Cmd: "433",
			Msg:      "Nick already in use",
			MsgParts: []string{":irc.red-green.com", "433"}},
		":[email protected] NOTICE test :Password accepted - you are now recognized.": IRCMsg{
			From: "NickServ", Cmd: "NOTICE", To: "test",
			Msg: "Password accepted - you are now recognized.",
			MsgParts: []string{":[email protected]",
				"NOTICE", "test"}},
		":irc.red-green.com 005 meow-bot HCN INVEX KICKLEN=307 KNOCK MAP MAXCHANNELS=10 MAXLIST=b:60,e:60,I:60 MAXNICKLEN=30 MINNICKLEN=0 MODES=12 NAMESX NETWORK=RedGreen :are supported by this server": IRCMsg{
			From: "irc.red-green.com", Cmd: "005", To: "meow-bot",
			Msg: "are supported by this server",
			MsgParts: []string{":irc.red-green.com", "005", "meow-bot", "HCN", "INVEX",
				"KICKLEN=307", "KNOCK", "MAP", "MAXCHANNELS=10", "MAXLIST=b:60,e:60,I:60",
				"MAXNICKLEN=30", "MINNICKLEN=0", "MODES=12", "NAMESX", "NETWORK=RedGreen"}},
		":irc.red-green.com 353 meow-bot = #backstage :meow-bot performer5 performer4 performer3 performer1 performer2 Stage_Manager Apollo ~bugz": IRCMsg{
			From: "irc.red-green.com", Cmd: "353", To: "meow-bot",
			Msg:      "meow-bot performer5 performer4 performer3 performer1 performer2 Stage_Manager Apollo ~bugz",
			MsgParts: []string{":irc.red-green.com", "353", "meow-bot", "=", "#backstage"}},
	}

	for line, msgout := range Expect {
		Msg = IRCParse(line)
		var fields []string = []string{"To", "From", "Cmd", "Msg"}
		msg_value := reflect.ValueOf(Msg)
		msgout_value := reflect.ValueOf(msgout)

		for _, field := range fields {
			var got string
			var expect string
			got = msg_value.FieldByName(field).String()
			expect = msgout_value.FieldByName(field).String()
			if got != expect {
				t.Errorf("%s %s: got %s, expected %s", line, field, got, expect)
			}
		}

		/*
			if Msg.To != msgout.To {
				t.Errorf("%s To: got %s, expected %s", line, Msg.To, msgout.To)
			}
			if Msg.From != msgout.From {
				t.Errorf("%s From: got %s, expected %s", line, Msg.From, msgout.From)
			}
			if Msg.Cmd != msgout.Cmd {
				t.Errorf("%s Cmd: got %s, expected %s", line, Msg.Cmd, msgout.Cmd)
			}
			if Msg.Msg != msgout.Msg {
				t.Errorf("%s Msg: got %s, expected %s", line, Msg.Msg, msgout.Msg)
			}
		*/
		if len(Msg.MsgParts) != len(msgout.MsgParts) {
			t.Errorf("%s MsgParts got len %d, expected len %d", line, len(Msg.MsgParts), len(msgout.MsgParts))
			// Length didn't match, don't need to compare each part.
		} else {
			// Length matches, compare each part
			for idx := range Msg.MsgParts {
				if Msg.MsgParts[idx] != msgout.MsgParts[idx] {
					t.Errorf("%s MsgParts[%d] %s, expected %s", line, idx, Msg.MsgParts[idx], msgout.MsgParts[idx])
				}
			}
		}
	}
}

func TestConnect(t *testing.T) {
	var config IRCConfig = IRCConfig{Nick: "test",
		Username:       "test",
		Realname:       "testing",
		Password:       "12345",
		ServerPassword: "allow"}
	var listen net.Listener
	var address string

	listen, address = setupSocket()
	var parts []string = strings.Split(address, ":")

	config.Hostname = parts[0]
	config.Port, _ = strconv.Atoi(parts[1])
	var irc IRCClient = IRCClient{IRCConfig: config}
	go ircServer(listen, t, &irc)
	var FromIRC chan IRCMsg = make(chan IRCMsg)

	irc.ReadChannel = FromIRC

	irc.Connect()
	defer irc.Close()

	var Msg IRCMsg
	var motd, identify, support bool
	var isupport map[string]string = map[string]string{
		"AWAYLEN": "307", "BOT": "B", "CASEMAPPING": "ascii",
		"CHANLIMIT": "#:10", "CHANMODES": "beI,kLf,lH,psmntirzMQNRTOVKDdGPZSCc",
		"CHANNELLEN": "32", "CHANTYPES": "#", "CLIENTTAGDENY": "*,-draft/typing,-typing",
		"DEAF": "d", "ELIST": "MNUCT", "EXCEPTS": "", "EXTBAN": "~,GptmTSOcarnqjf",
		"HCN": "", "INVEX": "", "KICKLEN": "307", "KNOCK": "", "MAP": "", "MAXCHANNELS": "10",
		"MAXLIST": "b:60,e:60,I:60", "MAXNICKLEN": "30", "MINNICKLEN": "0", "MODES": "12",
		"NAMESX": "", "NETWORK": "RedGreen", "NICKLEN": "30", "PREFIX": "(qaohv)~&@%+",
		"QUITLEN": "307", "SAFELIST": "", "SILENCE": "15", "STATUSMSG": "~&@%+",
		"TARGMAX":  "DCCALLOW:,ISON:,JOIN:,KICK:4,KILL:,LIST:,NAMES:1,NOTICE:1,PART:,PRIVMSG:4,SAJOIN:,SAPART:,TAGMSG:1,USERHOST:,USERIP:,WATCH:,WHOIS:1,WHOWAS:1",
		"TOPICLEN": "360", "UHNAMES": "", "USERIP": "", "WALLCHOPS": "", "WATCH": "128",
		"WATCHOPTS": "A", "WHOX": "",
	}

	for Msg = range FromIRC {
		if Msg.Cmd == "EndMOTD" {
			t.Log("Got EndMOTD")
			motd = true

			support = true
			// Verify we parsed 005 ISupport:
			for key, value := range isupport {
				var got string
				var has bool
				got, has = irc.ISupport[key]
				if !has {
					t.Errorf("Missing ISUPPORT[%s] expected (%s)", key, value)
					support = false
				} else {
					if got != value {
						t.Errorf("ISUPPORT[%s] got %s, expected %s", key, got, value)
						support = false
					}
				}
			}

		}

		if Msg.Cmd == "Identified" {
			t.Log("Identified")
			identify = true
		}
	}

	if !motd {
		t.Error("Missing EndMOTD")
	}
	if !identify {
		t.Error("Missing Identified")
	}
	if !support {
		t.Error("Missing ISupport")
	}
	if irc.MyNick != config.Nick {
		t.Errorf("Got %s, Expected %s", irc.MyNick, config.Nick)
	}

}

func TestConnectNickInUse(t *testing.T) {
	var config IRCConfig = IRCConfig{Nick: "bad",
		Username:    "test",
		Realname:    "testing",
		Flood_Num:   1,
		Flood_Delay: 20,
	}
	var listen net.Listener
	var address string

	listen, address = setupSocket()
	var parts []string = strings.Split(address, ":")

	config.Hostname = parts[0]
	config.Port, _ = strconv.Atoi(parts[1])
	var irc IRCClient = IRCClient{IRCConfig: config}
	go ircServer(listen, t, &irc)
	var FromIRC chan IRCMsg = make(chan IRCMsg)
	irc.ReadChannel = FromIRC

	irc.Connect()
	defer irc.Close()

	var Msg IRCMsg
	var motd, identify bool
	var missing int

	for Msg = range FromIRC {
		if Msg.Cmd == "EndMOTD" {
			t.Log("Got EndMOTD")
			motd = true
			irc.WriteTo("missing", "PRIVMSG missing :Missing user")
			irc.WriteTo("missing", "PRIVMSG missing :Missing user")
			irc.WriteTo("missing", "PRIVMSG missing :Missing user")
			irc.WriteTo("#missing", "PRIVMSG #missing :Missing channel")
		}
		if Msg.Cmd == "Identified" {
			t.Log("Identified")
			identify = true
		}
		if Msg.Cmd == "404" || Msg.Cmd == "401" {
			missing++
		}
	}

	if !motd {
		t.Error("Missing EndMOTD")
	}
	if identify {
		t.Error("Should not have been Identified")
	}
	if missing < 2 {
		t.Errorf("Missing should have been 2, was %d", missing)
	}
	if irc.MyNick == config.Nick {
		t.Errorf("Nick should be different: Got %s, Didn't Expect %s", irc.MyNick, config.Nick)
	}
}
func TestConnectTLS(t *testing.T) {
	var config IRCConfig = IRCConfig{Nick: "test",
		Username:       "test",
		Realname:       "testing",
		Password:       "12345",
		UseTLS:         true,
		UseSASL:        true,
		Insecure:       true,
		ServerPassword: "allow"}
	var listen net.Listener
	var address string

	listen, address = setupTLSSocket()
	var parts []string = strings.Split(address, ":")

	config.Hostname = parts[0]
	config.Port, _ = strconv.Atoi(parts[1])
	var irc IRCClient = IRCClient{IRCConfig: config}
	go ircServer(listen, t, &irc)
	var FromIRC chan IRCMsg = make(chan IRCMsg)
	irc.ReadChannel = FromIRC

	irc.Connect()
	defer irc.Close()

	var Msg IRCMsg
	var motd, identify bool
	for Msg = range FromIRC {
		if Msg.Cmd == "EndMOTD" {
			t.Log("Got EndMOTD")
			motd = true
		}
		if Msg.Cmd == "Identified" {
			t.Log("Identified")
			identify = true
		}
	}

	if !motd {
		t.Error("Missing EndMOTD")
	}
	if !identify {
		t.Error("Missing Identified")
	}

	if irc.MyNick != config.Nick {
		t.Errorf("Got %s, Expected %s", irc.MyNick, config.Nick)
	}

}

func TestConnectAutojoin(t *testing.T) {
	var config IRCConfig = IRCConfig{Nick: "test",
		Username:    "test",
		Realname:    "testing",
		Password:    "12345",
		UseTLS:      true,
		UseSASL:     true,
		Insecure:    true,
		AutoJoin:    []string{"#chat", "#test"},
		Flood_Num:   2,
		Flood_Delay: 10,
		Version:     "Test",
	}
	var listen net.Listener
	var address string

	listen, address = setupTLSSocket()
	var parts []string = strings.Split(address, ":")

	config.Hostname = parts[0]
	config.Port, _ = strconv.Atoi(parts[1])
	var irc IRCClient = IRCClient{IRCConfig: config}
	go ircServer(listen, t, &irc)
	var FromIRC chan IRCMsg = make(chan IRCMsg)
	irc.ReadChannel = FromIRC

	irc.Connect()
	defer irc.Close()

	var Msg IRCMsg
	var motd, identify bool
	var joins int
	var expect string
	var ctcpExpect []string = []string{"VERSION",
		"TIME",
		"PING 12345",
	}
	var noticeExpect []string = []string{"Testing",
		fmt.Sprintf("VERSION %s red-green.com/irc-client", config.Version),
		"TIME ",
		"PING 12345",
	}

	for Msg = range FromIRC {
		/*
			if (Msg.Cmd == "ACTION") || (Msg.Cmd == "NOTICE") {
				t.Log(Msg)
			}
		*/
		if Msg.Cmd == "EndMOTD" {
			t.Log("Got EndMOTD")
			motd = true
		}
		if Msg.Cmd == "Identified" {
			t.Log("Identified")
			identify = true
		}
		if Msg.Cmd == "JOIN" {
			joins++
			if joins == 2 {
				// messages set to echo are returned to us
				irc.WriteTo("echo", "PRIVMSG echo :\x01VERSION\x01")
				irc.WriteTo("echo", "PRIVMSG echo :\x01TIME\x01")
				irc.WriteTo("echo", "PRIVMSG echo :\x01PING 12345\x01")
				irc.Action("echo", "dances.")
				irc.Notice("echo", "Testing")
				irc.Msg("#test", "Message 1")
				irc.Msg("#test", "Message 2")
				irc.PriorityWrite("PRIVMSG #test :Message")
			}
		}
		if Msg.Cmd == "CTCP" {
			expect = ctcpExpect[0]
			ctcpExpect = ctcpExpect[1:]
			if Msg.Msg != expect {
				t.Errorf("CTCP Got %s, Expected %s", Msg.Msg, expect)
			}
		}
		if Msg.Cmd == "NOTICE" {
			expect = noticeExpect[0]
			if expect != "Testing" {
				expect = "\x01" + expect
			}
			noticeExpect = noticeExpect[1:]
			if !strings.HasPrefix(Msg.Msg, expect) {
				t.Errorf("NOTICE Got [%s], Expected [%s]", Msg.Msg, expect)
			}
		}
		if Msg.Cmd == "ACTION" {
			expect = "dances."
			if Msg.Msg != expect {
				t.Errorf("ACTION Got %s, Expected %s", Msg.Msg, expect)
			}
		}
	}

	if joins != 2 {
		t.Errorf("Expected to autojoin 2 channels, got %d", joins)
	}
	if !motd {
		t.Error("Missing EndMOTD")
	}
	if !identify {
		t.Error("Missing Identified")
	}
	if len(noticeExpect) != 0 {
		t.Errorf("Expected more NOTICEs (%d)", len(noticeExpect))
	}
	if len(ctcpExpect) != 0 {
		t.Errorf("Expected more CTCPs (%d)", len(ctcpExpect))
	}

	if irc.MyNick != config.Nick {
		t.Errorf("Got %s, Expected %s", irc.MyNick, config.Nick)
	}

}

func TestConnectKick(t *testing.T) {
	var config IRCConfig = IRCConfig{Nick: "test",
		Username:    "test",
		Realname:    "testing",
		Password:    "12345",
		UseTLS:      true,
		UseSASL:     true,
		Insecure:    true,
		AutoJoin:    []string{"#chat", "#test", "#kick"},
		RejoinDelay: 1,
		Flood_Num:   2,
		Flood_Delay: 10,
	}
	var listen net.Listener
	var address string

	listen, address = setupTLSSocket()
	var parts []string = strings.Split(address, ":")

	config.Hostname = parts[0]
	config.Port, _ = strconv.Atoi(parts[1])

	// Save and Restore abortAfter
	var abortPrev = abortAfter
	defer func() { abortAfter = abortPrev }()
	abortAfter = 500
	var irc IRCClient = IRCClient{IRCConfig: config}
	go ircServer(listen, t, &irc)

	var FromIRC chan IRCMsg = make(chan IRCMsg)
	irc.ReadChannel = FromIRC

	irc.Connect()
	defer irc.Close()

	var Msg IRCMsg
	var motd, identify bool
	var joins int

	for Msg = range FromIRC {
		if Msg.Cmd == "EndMOTD" {
			t.Log("Got EndMOTD")
			motd = true
		}
		if Msg.Cmd == "Identified" {
			t.Log("Identified")
			identify = true
		}
		if Msg.Cmd == "JOIN" {
			joins++
			if joins == 4 {
				irc.PriorityWrite("NICK something")
			}
		}
	}

	// 3 channels joined, 1 kick, +1 join=4.
	if joins != 4 {
		t.Errorf("Expected to join 4 times, got %d", joins)
	}
	if !motd {
		t.Error("Missing EndMOTD")
	}
	if !identify {
		t.Error("Missing Identified")
	}
	if irc.MyNick != "something" {
		t.Errorf("Expected nick to be something, not %s", irc.MyNick)
	}
}

func TestConnectSignal(t *testing.T) {
	var exit bool

	var onexit func() = func() { exit = true }

	var config IRCConfig = IRCConfig{Nick: "test",
		Username:    "test",
		Realname:    "testing",
		Password:    "12345",
		UseTLS:      true,
		UseSASL:     true,
		Insecure:    true,
		AutoJoin:    []string{"#chat"},
		Flood_Num:   2,
		Flood_Delay: 10,
	}
	var irc IRCClient = IRCClient{IRCConfig: config,
		OnExit: onexit,
	}

	var listen net.Listener
	var address string

	listen, address = setupTLSSocket()
	var parts []string = strings.Split(address, ":")

	irc.Hostname = parts[0]
	irc.Port, _ = strconv.Atoi(parts[1])
	go ircServer(listen, t, &irc)
	var FromIRC chan IRCMsg = make(chan IRCMsg)
	irc.ReadChannel = FromIRC

	irc.Connect()
	// defer config.Close()

	var Msg IRCMsg
	var motd, identify bool

	for Msg = range FromIRC {
		if Msg.Cmd == "EndMOTD" {
			t.Log("Got EndMOTD")
			motd = true
			// config.PriorityWrite("NICK something")
		}
		if Msg.Cmd == "Identified" {
			t.Log("Identified")
			identify = true
		}
		if Msg.Cmd == "JOIN" {
			// Ok, we've joined.  Test the signal
			e := syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
			t.Log("Kill:", e)
		}
	}

	if !motd {
		t.Error("Missing EndMOTD")
	}
	if !identify {
		t.Error("Missing Identified")
	}

	irc.Close()

	if !exit {
		t.Error("AtExit wasn't called.")
	}
}

func TestMatch(t *testing.T) {
	var testdata map[string]string = map[string]string{"TEST": "test",
		"TEst": "teST", "[bugz]": "{BUGZ}"}

	for nick1, nick2 := range testdata {
		if !Match(nick1, nick2) {
			t.Errorf("Match %s [%s] != %s [%s] Failed match!", nick1, NameLower(nick1), nick2, NameLower(nick2))
		}
	}
}