mirror of
https://github.com/google/alertmanager-irc-relay.git
synced 2024-11-16 16:19:21 +01:00
592 lines
14 KiB
Go
592 lines
14 KiB
Go
// Copyright 2018 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
irc "github.com/fluffle/goirc/client"
|
|
)
|
|
|
|
func makeTestIRCConfig(IRCPort int) *Config {
|
|
return &Config{
|
|
IRCNick: "foo",
|
|
IRCNickPass: "",
|
|
IRCHost: "127.0.0.1",
|
|
IRCPort: IRCPort,
|
|
IRCUseSSL: false,
|
|
IRCChannels: []IRCChannel{
|
|
IRCChannel{Name: "#foo"},
|
|
},
|
|
UsePrivmsg: false,
|
|
}
|
|
}
|
|
|
|
func makeTestNotifier(t *testing.T, config *Config) (*IRCNotifier, chan AlertMsg, context.Context, context.CancelFunc, *sync.WaitGroup) {
|
|
fakeDelayerMaker := &FakeDelayerMaker{}
|
|
alertMsgs := make(chan AlertMsg)
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
stopWg := sync.WaitGroup{}
|
|
stopWg.Add(1)
|
|
notifier, err := NewIRCNotifier(config, alertMsgs, fakeDelayerMaker)
|
|
if err != nil {
|
|
t.Fatal(fmt.Sprintf("Could not create IRC notifier: %s", err))
|
|
}
|
|
notifier.Client.Config().Flood = true
|
|
|
|
return notifier, alertMsgs, ctx, cancel, &stopWg
|
|
}
|
|
|
|
func TestServerPassword(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
config.IRCHostPass = "hostsecret"
|
|
notifier, _, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
joinHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return nil
|
|
}
|
|
server.SetHandler("JOIN", joinHandler)
|
|
|
|
testStep.Add(1)
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"PASS hostsecret",
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Did not send IRC server password")
|
|
}
|
|
}
|
|
|
|
func TestSendAlertOnPreJoinedChannel(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
notifier, alertMsgs, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
testChannel := "#foo"
|
|
testMessage := "test message"
|
|
|
|
// Send the alert after configured channels have joined, to ensure we
|
|
// check for no re-join attempt.
|
|
joinedHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
if line.Args[0] == testChannel {
|
|
testStep.Done()
|
|
}
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinedHandler)
|
|
|
|
testStep.Add(1)
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
testStep.Wait()
|
|
|
|
server.SetHandler("JOIN", hJOIN)
|
|
|
|
noticeHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return nil
|
|
}
|
|
server.SetHandler("NOTICE", noticeHandler)
|
|
|
|
testStep.Add(1)
|
|
alertMsgs <- AlertMsg{Channel: testChannel, Alert: testMessage}
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
"NOTICE #foo :test message",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Alert not sent correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestUsePrivmsgToSendAlertOnPreJoinedChannel(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
config.UsePrivmsg = true
|
|
notifier, alertMsgs, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
testChannel := "#foo"
|
|
testMessage := "test message"
|
|
|
|
// Send the alert after configured channels have joined, to ensure we
|
|
// check for no re-join attempt.
|
|
joinedHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
if line.Args[0] == testChannel {
|
|
testStep.Done()
|
|
}
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinedHandler)
|
|
|
|
testStep.Add(1)
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
testStep.Wait()
|
|
|
|
server.SetHandler("JOIN", hJOIN)
|
|
|
|
privmsgHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return nil
|
|
}
|
|
server.SetHandler("PRIVMSG", privmsgHandler)
|
|
|
|
testStep.Add(1)
|
|
alertMsgs <- AlertMsg{Channel: testChannel, Alert: testMessage}
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
"PRIVMSG #foo :test message",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Alert not sent correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestSendAlertAndJoinChannel(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
notifier, alertMsgs, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
testChannel := "#foobar"
|
|
testMessage := "test message"
|
|
|
|
// Send the alert after configured channels have joined, to ensure log
|
|
// ordering.
|
|
joinHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinHandler)
|
|
|
|
testStep.Add(1)
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
testStep.Wait()
|
|
|
|
server.SetHandler("JOIN", hJOIN)
|
|
|
|
noticeHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return nil
|
|
}
|
|
server.SetHandler("NOTICE", noticeHandler)
|
|
|
|
testStep.Add(1)
|
|
alertMsgs <- AlertMsg{Channel: testChannel, Alert: testMessage}
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
// #foobar joined before sending message
|
|
"JOIN #foobar",
|
|
"NOTICE #foobar :test message",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Alert not sent correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestSendAlertDisconnected(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
notifier, alertMsgs, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
|
|
var testStep, holdUserStep sync.WaitGroup
|
|
|
|
testChannel := "#foo"
|
|
disconnectedTestMessage := "disconnected test message"
|
|
connectedTestMessage := "connected test message"
|
|
|
|
// First send an alert while the session is not established.
|
|
testStep.Add(1)
|
|
holdUserStep.Add(1)
|
|
holdUser := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
log.Printf("=Server= Wait before completing session")
|
|
testStep.Wait()
|
|
log.Printf("=Server= Completing session")
|
|
holdUserStep.Done()
|
|
return hUSER(conn, line)
|
|
}
|
|
server.SetHandler("USER", holdUser)
|
|
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
// Alert channels is not consumed while disconnected
|
|
select {
|
|
case alertMsgs <- AlertMsg{Channel: testChannel, Alert: disconnectedTestMessage}:
|
|
t.Error("Alert consumed while disconnected")
|
|
default:
|
|
}
|
|
|
|
testStep.Done()
|
|
holdUserStep.Wait()
|
|
|
|
// Make sure session is established by checking that pre-joined
|
|
// channel is there.
|
|
testStep.Add(1)
|
|
joinHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinHandler)
|
|
|
|
testStep.Wait()
|
|
|
|
// Now send and wait until a notice has been received.
|
|
testStep.Add(1)
|
|
noticeHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return nil
|
|
}
|
|
server.SetHandler("NOTICE", noticeHandler)
|
|
|
|
alertMsgs <- AlertMsg{Channel: testChannel, Alert: connectedTestMessage}
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
// Only message sent while being connected is received.
|
|
"NOTICE #foo :connected test message",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Alert not sent correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestReconnect(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
notifier, _, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
joinHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinHandler)
|
|
|
|
testStep.Add(1)
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
// Wait until the pre-joined channel is seen.
|
|
testStep.Wait()
|
|
|
|
// Simulate disconnection.
|
|
testStep.Add(1)
|
|
server.Client.Close()
|
|
|
|
// Wait again until the pre-joined channel is seen.
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
// Commands from first connection
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
// Commands from reconnection
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Reconnection did not happen correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestConnectErrorRetry(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
// Attempt SSL handshake. The server does not support it, resulting in
|
|
// a connection error.
|
|
config.IRCUseSSL = true
|
|
notifier, _, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
// Pilot reconnect attempts via backoff delay to prevent race
|
|
// conditions in the test while we change the components behavior on
|
|
// the fly.
|
|
delayer := notifier.BackoffCounter.(*FakeDelayer)
|
|
delayer.DelayOnChan = true
|
|
|
|
var testStep, joinStep sync.WaitGroup
|
|
|
|
testStep.Add(1)
|
|
earlyHandler := func() {
|
|
testStep.Done()
|
|
}
|
|
|
|
server.SetCloseEarly(earlyHandler)
|
|
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
delayer.StopDelay <- true
|
|
|
|
testStep.Wait()
|
|
|
|
// We have caused a connection failure, now check for a reconnection
|
|
notifier.Client.Config().SSL = false
|
|
joinStep.Add(1)
|
|
joinHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
joinStep.Done()
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinHandler)
|
|
server.SetCloseEarly(nil)
|
|
|
|
delayer.StopDelay <- true
|
|
|
|
joinStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"JOIN #foo",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Reconnection did not happen correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestIdentify(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
config.IRCNickPass = "nickpassword"
|
|
notifier, _, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
notifier.NickservDelayWait = 0 * time.Second
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
// Wait until the pre-joined channel is seen (joining happens
|
|
// after identification).
|
|
joinHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinHandler)
|
|
|
|
testStep.Add(1)
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"PRIVMSG NickServ :IDENTIFY nickpassword",
|
|
"JOIN #foo",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Identification did not happen correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestGhostAndIdentify(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
config.IRCNickPass = "nickpassword"
|
|
notifier, _, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
notifier.NickservDelayWait = 0 * time.Second
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
// Trigger 433 for first nick when we see the USER command
|
|
userHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
var err error
|
|
if line.Args[0] == "foo" {
|
|
_, err = conn.WriteString(":example.com 433 * foo :nick in use\n")
|
|
}
|
|
return err
|
|
}
|
|
server.SetHandler("USER", userHandler)
|
|
|
|
// Trigger 001 when we see NICK foo^
|
|
nickHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
var err error
|
|
if line.Args[0] == "foo^" {
|
|
_, err = conn.WriteString(":example.com 001 foo^ :Welcome\n")
|
|
}
|
|
return err
|
|
}
|
|
server.SetHandler("NICK", nickHandler)
|
|
|
|
// Wait until the pre-joined channel is seen (joining happens
|
|
// after identification).
|
|
joinHandler := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
testStep.Done()
|
|
return hJOIN(conn, line)
|
|
}
|
|
server.SetHandler("JOIN", joinHandler)
|
|
|
|
testStep.Add(1)
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"NICK foo^",
|
|
"PRIVMSG NickServ :GHOST foo nickpassword",
|
|
"NICK foo",
|
|
"PRIVMSG NickServ :IDENTIFY nickpassword",
|
|
"JOIN #foo",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Ghosting did not happen correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|
|
|
|
func TestStopRunningWhenHalfConnected(t *testing.T) {
|
|
server, port := makeTestServer(t)
|
|
config := makeTestIRCConfig(port)
|
|
notifier, _, ctx, cancel, stopWg := makeTestNotifier(t, config)
|
|
|
|
var testStep sync.WaitGroup
|
|
|
|
// Send a StopRunning request while the client is connected but the
|
|
// session is not up
|
|
testStep.Add(1)
|
|
holdUser := func(conn *bufio.ReadWriter, line *irc.Line) error {
|
|
log.Printf("=Server= NOT completing session")
|
|
testStep.Done()
|
|
return nil
|
|
}
|
|
server.SetHandler("USER", holdUser)
|
|
|
|
go notifier.Run(ctx, stopWg)
|
|
|
|
testStep.Wait()
|
|
|
|
cancel()
|
|
stopWg.Wait()
|
|
|
|
// Client has left, cleanup the server side before stopping
|
|
server.Client.Close()
|
|
|
|
server.Stop()
|
|
|
|
expectedCommands := []string{
|
|
"NICK foo",
|
|
"USER foo 12 * :",
|
|
"QUIT :see ya",
|
|
}
|
|
|
|
if !reflect.DeepEqual(expectedCommands, server.Log) {
|
|
t.Error("Alert not sent correctly. Received commands:\n", strings.Join(server.Log, "\n"))
|
|
}
|
|
}
|