Fixed writeloop goroutine leadk

* Added TestChannel_PRIVMSG test

* Refactored integration testing framework for better timtouts and added TestChannel_InviteOnly test

* Try to fix TestChannel_PRIVMSG test

* Fuck it

* Added TestChannel_NoExternal test

* Added TestChannel_BadChannelKey and TestChannel_GoodChannelKey tests

* Bah humbut

* Update vendored 3rd-party deps

* Removed use of deadlock sync package

* Fix all tests :D yay

* Added some topic tests

* Add TestSASL

.drone.yml

@@ -6,9 +6,15 @@ pipeline:
   build:
     image: golang
     commands:
-      - go get -d
+      - go get -d ./...
       - go build .
 
+  test:
+    image: golang
+    commands:
+      - go get -d ./...
+      - go test ./...
+
   docker:
     image: plugins/docker
     repo: r.mills.io/prologic/eris

.gitmodules

@@ -43,9 +43,15 @@
 [submodule "vendor/github.com/prometheus/procfs"]
 	path = vendor/github.com/prometheus/procfs
 	url = https://github.com/prometheus/procfs
-[submodule "vendor/github.com/sasha-s/go-deadlock"]
-	path = vendor/github.com/sasha-s/go-deadlock
-	url = https://github.com/sasha-s/go-deadlock
-[submodule "vendor/github.com/petermattis/goid"]
-	path = vendor/github.com/petermattis/goid
-	url = https://github.com/petermattis/goid
+[submodule "vendor/github.com/thoj/go-ircevent"]
+	path = vendor/github.com/thoj/go-ircevent
+	url = https://github.com/thoj/go-ircevent
+[submodule "vendor/github.com/stretchr/testify"]
+	path = vendor/github.com/stretchr/testify
+	url = https://github.com/stretchr/testify
+[submodule "vendor/github.com/renstrom/shortuuid"]
+	path = vendor/github.com/renstrom/shortuuid
+	url = https://github.com/renstrom/shortuuid
+[submodule "vendor/github.com/satori/go.uuid"]
+	path = vendor/github.com/satori/go.uuid
+	url = https://github.com/satori/go.uuid

CONTRIBUTING.md

@@ -46,4 +46,4 @@ $ git push -u origin my-feature
 
 When describing your bug report; please be concise and as detailed as you can
 so we can easily work out what the problem is. It's also very helpful if you
-are able to provide a test case that repeatedly demonstrates the bug at hand:
+are able to provide a test case that repeatedly demonstrates the bug at hand.

README.md

@@ -35,9 +35,9 @@ Discussion at:
 * /server irc.mills.io +6697 (*use TLS/SSL*)
 * /join #lobby
 
-Or (*not recommended*)P
+Or (**not recommended**):
 
-* /server irc.mills.io (*default port 6667, non-TLS)
+* /server irc.mills.io (*default port 6667, non-TLS*)
 * /join #lobby
 
 ## Features
@@ -54,6 +54,7 @@ Or (*not recommended*)P
 * Simple IRC operator privileges (*overrides most things*)
 * Secure connection tracking (+z) and SecureOnly user mode (+Z)
 * Secure channels (+Z)
+* Three layers of channel privacy, Public, Private (+p) and Secret (s)
 
 ## Quick Start
 
@@ -135,15 +136,19 @@ You may want to customize the configuration however and create your own image ba
 $ docker stack deploy -c docker-compose.yml eris
 ```
 
-Which assumes a `ircd.yml` coniguration fiel int he current directory which Docker will use to distribute as the configuration. The `docker-compose.yml` (*Docker Stackfile*) is available at the root of this repository.
+Which assumes a `ircd.yml` coniguration file in the current directory which Docker will use to distribute as the configuration. The `docker-compose.yml` (*Docker Stackfile*) is available at the root of this repository.
 
-## Related Proejcts
+## Related Projects
 
 There are a number of supported accompanying services that are being developed alongside Eris:
 
 * [Soter](https://github.com/prologic/soter) -- An IRC Bot that persists channel modes and topics.
 * [Cadmus](https://github.com/prologic/cadmus) -- An IRC Bot that logs channels and provides an interface for viewing and searching logs
 
+## Recommended Mobile clients
+
+* [Palaver (iOS)](https://palaverapp.com/) -- SASL, TLS, Server Password, Push Notifications, IRCv3 (*Also supports custom image upload service(s) for better privacy of shared photos/images over IRC*)
+
 ## License
 
 eris is licensed under the MIT License.

irc/channel.go

@@ -374,7 +374,7 @@ func (channel *Channel) applyMode(client *Client, change *ChannelModeChange) boo
 		return channel.applyModeMask(client, change.mode, change.op,
 			NewName(change.arg))
 
-	case InviteOnly, Moderated, NoOutside, OpOnlyTopic, Private, SecureChan:
+	case InviteOnly, Moderated, NoOutside, OpOnlyTopic, Private, Secret, SecureChan:
 		return channel.applyModeFlag(client, change.mode, change.op)
 
 	case Key:

irc/client.go

@@ -72,8 +72,17 @@ func NewClient(server *Server, conn net.Conn) *Client {
 //
 
 func (client *Client) writeloop() {
-	for reply := range client.replies {
-		client.socket.Write(reply)
+	for {
+		select {
+		case reply, ok := <-client.replies:
+			if !ok || reply == "" || client.socket == nil {
+				return
+			}
+			client.socket.Write(reply)
+		}
+		if client.replies == nil {
+			break
+		}
 	}
 }
 
@@ -119,13 +128,6 @@ func (client *Client) readloop() {
 }
 
 func (client *Client) processCommand(cmd Command) {
-	client.server.metrics.Counter("client", "commands").Inc()
-
-	defer func(t time.Time) {
-		v := client.server.metrics.SummaryVec("client", "command_duration_seconds")
-		v.WithLabelValues(cmd.Code().String()).Observe(time.Now().Sub(t).Seconds())
-	}(time.Now())
-
 	cmd.SetClient(client)
 
 	if !client.registered {
@@ -144,6 +146,13 @@ func (client *Client) processCommand(cmd Command) {
 		return
 	}
 
+	client.server.metrics.Counter("client", "commands").Inc()
+
+	defer func(t time.Time) {
+		v := client.server.metrics.SummaryVec("client", "command_duration_seconds")
+		v.WithLabelValues(cmd.Code().String()).Observe(time.Now().Sub(t).Seconds())
+	}(time.Now())
+
 	switch srvCmd.(type) {
 	case *PingCommand, *PongCommand:
 		client.Touch()
@@ -222,6 +231,12 @@ func (client *Client) destroy() {
 
 	// clean up server
 
+	if _, ok := client.socket.conn.(*tls.Conn); ok {
+		client.server.metrics.GaugeVec("server", "clients").WithLabelValues("secure").Dec()
+	} else {
+		client.server.metrics.GaugeVec("server", "clients").WithLabelValues("insecure").Dec()
+	}
+
 	client.server.connections.Dec()
 	client.server.clients.Remove(client)
 
@@ -235,6 +250,7 @@ func (client *Client) destroy() {
 	}
 
 	close(client.replies)
+	client.replies = nil
 
 	client.socket.Close()
 
@@ -351,7 +367,9 @@ func (client *Client) ChangeNickname(nickname Name) {
 }
 
 func (client *Client) Reply(reply string) {
-	client.replies <- reply
+	if client.replies != nil {
+		client.replies <- reply
+	}
 }
 
 func (client *Client) Quit(message Text) {

irc/client_lookup_set.go

@@ -4,9 +4,7 @@ import (
 	"errors"
 	"regexp"
 	"strings"
-	//"sync"
-
-	sync "github.com/sasha-s/go-deadlock"
+	"sync"
 
 	"github.com/DanielOaks/girc-go/ircmatch"
 )

irc/config.go

@@ -4,9 +4,7 @@ import (
 	"errors"
 	"io/ioutil"
 	"log"
-	//"sync"
-
-	sync "github.com/sasha-s/go-deadlock"
+	"sync"
 
 	"github.com/imdario/mergo"
 	"gopkg.in/yaml.v2"

irc/metrics.go

@@ -20,6 +20,7 @@ var DefObjectives = map[float64]float64{
 type Metrics struct {
 	namespace string
 	metrics   map[string]prometheus.Metric
+	gaugevecs map[string]*prometheus.GaugeVec
 	sumvecs   map[string]*prometheus.SummaryVec
 }
 
@@ -27,6 +28,7 @@ func NewMetrics(namespace string) *Metrics {
 	return &Metrics{
 		namespace: namespace,
 		metrics:   make(map[string]prometheus.Metric),
+		gaugevecs: make(map[string]*prometheus.GaugeVec),
 		sumvecs:   make(map[string]*prometheus.SummaryVec),
 	}
 }
@@ -101,6 +103,24 @@ func (m *Metrics) NewGaugeFunc(subsystem, name, help string, f func() float64) p
 	return guage
 }
 
+func (m *Metrics) NewGaugeVec(subsystem, name, help string, labels []string) *prometheus.GaugeVec {
+	gauagevec := prometheus.NewGaugeVec(
+		prometheus.GaugeOpts{
+			Namespace: m.namespace,
+			Subsystem: subsystem,
+			Name:      name,
+			Help:      help,
+		},
+		labels,
+	)
+
+	key := fmt.Sprintf("%s_%s", subsystem, name)
+	m.gaugevecs[key] = gauagevec
+	prometheus.MustRegister(gauagevec)
+
+	return gauagevec
+}
+
 func (m *Metrics) NewSummary(subsystem, name, help string) prometheus.Summary {
 	summary := prometheus.NewSummary(
 		prometheus.SummaryOpts{
@@ -148,6 +168,11 @@ func (m *Metrics) Gauge(subsystem, name string) prometheus.Gauge {
 	return m.metrics[key].(prometheus.Gauge)
 }
 
+func (m *Metrics) GaugeVec(subsystem, name string) *prometheus.GaugeVec {
+	key := fmt.Sprintf("%s_%s", subsystem, name)
+	return m.gaugevecs[key]
+}
+
 func (m *Metrics) Summary(subsystem, name string) prometheus.Summary {
 	key := fmt.Sprintf("%s_%s", subsystem, name)
 	return m.metrics[key].(prometheus.Summary)

irc/modes.go

@@ -70,7 +70,6 @@ var (
 )
 
 const (
-	Anonymous       ChannelMode = 'a' // flag
 	BanMask         ChannelMode = 'b' // arg
 	ChannelCreator  ChannelMode = 'O' // flag
 	ChannelOperator ChannelMode = 'o' // arg
@@ -82,8 +81,6 @@ const (
 	NoOutside       ChannelMode = 'n' // flag
 	OpOnlyTopic     ChannelMode = 't' // flag
 	Private         ChannelMode = 'p' // flag
-	Quiet           ChannelMode = 'q' // flag
-	ReOp            ChannelMode = 'r' // flag
 	Secret          ChannelMode = 's' // flag, deprecated
 	UserLimit       ChannelMode = 'l' // flag arg
 	Voice           ChannelMode = 'v' // arg
@@ -93,7 +90,7 @@ const (
 var (
 	SupportedChannelModes = ChannelModes{
 		BanMask, ExceptMask, InviteMask, InviteOnly, Key, NoOutside,
-		OpOnlyTopic, Private, UserLimit, SecureChan,
+		OpOnlyTopic, Private, UserLimit, Secret, SecureChan,
 	}
 )
 

irc/password.go

@@ -4,9 +4,8 @@ import (
 	"encoding/base64"
 	"fmt"
 	"golang.org/x/crypto/bcrypt"
-	//"sync"
+	"sync"
 
-	sync "github.com/sasha-s/go-deadlock"
 	log "github.com/sirupsen/logrus"
 )
 

irc/privacy.go

@@ -0,0 +1,22 @@
+package irc
+
+func CanSeeChannel(client *Client, channel *Channel) bool {
+	isPrivate := channel.flags.Has(Private)
+	isSecret := channel.flags.Has(Secret)
+
+	isMember := channel.members.Has(client)
+	isOperator := client.flags[Operator]
+	isRegistered := client.flags[Registered]
+	isSecure := client.flags[SecureConn]
+
+	if !(isSecret || isPrivate) {
+		return true
+	}
+	if isSecret && (isMember || isOperator) {
+		return true
+	}
+	if isPrivate && (isMember || isOperator || (isRegistered && isSecure)) {
+		return true
+	}
+	return false
+}

irc/reply.go

@@ -260,7 +260,7 @@ func (target *Client) RplWhois(client *Client) {
 	}
 	target.RplWhoisServer(client)
 	target.RplWhoisLoggedIn(client)
-	target.RplEndOfWhois()
+	target.RplEndOfWhois(client)
 }
 
 func (target *Client) RplWhoisUser(client *Client) {
@@ -324,9 +324,12 @@ func (target *Client) RplWhoisServer(client *Client) {
 	)
 }
 
-func (target *Client) RplEndOfWhois() {
-	target.NumericReply(RPL_ENDOFWHOIS,
-		":End of WHOIS list")
+func (target *Client) RplEndOfWhois(client *Client) {
+	target.NumericReply(
+		RPL_ENDOFWHOIS,
+		"%s :End of WHOIS list",
+		client.Nick(),
+	)
 }
 
 func (target *Client) RplChannelModeIs(channel *Channel) {
@@ -486,8 +489,13 @@ func (target *Client) RplMOTDEnd() {
 }
 
 func (target *Client) RplList(channel *Channel) {
-	target.NumericReply(RPL_LIST,
-		"%s %d :%s", channel, channel.members.Count(), channel.topic)
+	target.NumericReply(
+		RPL_LIST,
+		"%s %d :%s",
+		channel,
+		channel.members.Count(),
+		channel.topic,
+	)
 }
 
 func (target *Client) RplListEnd(server *Server) {
@@ -501,8 +509,12 @@ func (target *Client) RplNamReply(channel *Channel) {
 }
 
 func (target *Client) RplWhoisChannels(client *Client) {
-	target.MultilineReply(client.WhoisChannelsNames(), RPL_WHOISCHANNELS,
-		"%s :%s", client.Nick())
+	target.MultilineReply(
+		client.WhoisChannelsNames(target),
+		RPL_WHOISCHANNELS,
+		"%s :%s",
+		client.Nick(),
+	)
 }
 
 func (target *Client) RplVersion() {

irc/sasl.go

@@ -2,9 +2,7 @@ package irc
 
 import (
 	"bytes"
-	//"sync"
-
-	sync "github.com/sasha-s/go-deadlock"
+	"sync"
 )
 
 type SaslState struct {

irc/server.go

@@ -44,13 +44,16 @@ type Server struct {
 	accounts    PasswordStore
 	password    []byte
 	signals     chan os.Signal
+	done        chan bool
 	whoWas      *WhoWasList
 	ids         map[string]*Identity
 }
 
 var (
-	SERVER_SIGNALS = []os.Signal{syscall.SIGINT, syscall.SIGHUP,
-		syscall.SIGTERM, syscall.SIGQUIT}
+	SERVER_SIGNALS = []os.Signal{
+		syscall.SIGINT, syscall.SIGHUP,
+		syscall.SIGTERM, syscall.SIGQUIT,
+	}
 )
 
 func NewServer(config *Config) *Server {
@@ -70,6 +73,7 @@ func NewServer(config *Config) *Server {
 		operators:   config.Operators(),
 		accounts:    NewMemoryPasswordStore(config.Accounts(), PasswordStoreOpts{}),
 		signals:     make(chan os.Signal, len(SERVER_SIGNALS)),
+		done:        make(chan bool),
 		whoWas:      NewWhoWasList(100),
 		ids:         make(map[string]*Identity),
 	}
@@ -123,15 +127,22 @@ func NewServer(config *Config) *Server {
 		},
 	)
 
-	// server clients gauge
+	// server registered (clients) gauge
 	server.metrics.NewGaugeFunc(
-		"server", "clients",
+		"server", "registered",
 		"Number of registered clients connected",
 		func() float64 {
 			return float64(server.clients.Count())
 		},
 	)
 
+	// server clients gauge (by secure/insecire)
+	server.metrics.NewGaugeVec(
+		"server", "clients",
+		"Number of registered clients connected (by secure/insecure)",
+		[]string{"secure"},
+	)
+
 	// server channels gauge
 	server.metrics.NewGaugeFunc(
 		"server", "channels",
@@ -191,13 +202,22 @@ func (server *Server) Shutdown() {
 	server.Global("shutting down...")
 }
 
+func (server *Server) Stop() {
+	server.done <- true
+}
+
 func (server *Server) Run() {
-	done := false
-	for !done {
+	for {
 		select {
+		case <-server.done:
+			return
 		case <-server.signals:
 			server.Shutdown()
-			done = true
+			// Give at least 1s for clients to see the shutdown
+			go func() {
+				time.Sleep(1 * time.Second)
+				server.Stop()
+			}()
 
 		case conn := <-server.newConns:
 			go NewClient(server, conn)
@@ -217,6 +237,12 @@ func (s *Server) acceptor(listener net.Listener) {
 		}
 		log.Debugf("%s accept: %s", s, conn.RemoteAddr())
 
+		if _, ok := conn.(*tls.Conn); ok {
+			s.metrics.GaugeVec("server", "clients").WithLabelValues("secure").Inc()
+		} else {
+			s.metrics.GaugeVec("server", "clients").WithLabelValues("insecure").Inc()
+		}
+
 		s.connections.Inc()
 		s.newConns <- conn
 	}
@@ -603,10 +629,14 @@ func (msg *PrivMsgCommand) HandleServer(server *Server) {
 	}
 }
 
-func (client *Client) WhoisChannelsNames() []string {
+func (client *Client) WhoisChannelsNames(target *Client) []string {
 	chstrs := make([]string, client.channels.Count())
 	index := 0
 	client.channels.Range(func(channel *Channel) bool {
+		if !CanSeeChannel(target, channel) {
+			return true
+		}
+
 		switch {
 		case channel.members.Get(client).Has(ChannelOperator):
 			chstrs[index] = "@" + channel.name.String()
@@ -813,7 +843,7 @@ func (msg *ListCommand) HandleServer(server *Server) {
 
 	if len(msg.channels) == 0 {
 		server.channels.Range(func(name Name, channel *Channel) bool {
-			if !client.flags[Operator] && channel.flags.Has(Private) {
+			if !CanSeeChannel(client, channel) {
 				return true
 			}
 			client.RplList(channel)
@@ -822,7 +852,7 @@ func (msg *ListCommand) HandleServer(server *Server) {
 	} else {
 		for _, chname := range msg.channels {
 			channel := server.channels.Get(chname)
-			if channel == nil || (!client.flags[Operator] && channel.flags.Has(Private)) {
+			if channel == nil || !CanSeeChannel(client, channel) {
 				client.ErrNoSuchChannel(chname)
 				continue
 			}

irc/types.go

@@ -3,9 +3,7 @@ package irc
 import (
 	"fmt"
 	"strings"
-	//"sync"
-
-	sync "github.com/sasha-s/go-deadlock"
+	"sync"
 )
 
 //

irc/version.go

@@ -9,7 +9,7 @@ var (
 	Package = "eris"
 
 	// Version release version
-	Version = "1.6.2"
+	Version = "1.6.4"
 
 	// Build will be overwritten automatically by the build system
 	Build = "dev"

irc/whowas.go

@@ -1,9 +1,7 @@
 package irc
 
 import (
-	//"sync"
-
-	sync "github.com/sasha-s/go-deadlock"
+	"sync"
 )
 
 type WhoWasList struct {

main_test.go

@@ -0,0 +1,498 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+
+	"github.com/renstrom/shortuuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/thoj/go-ircevent"
+
+	eris "github.com/prologic/eris/irc"
+)
+
+const (
+	TIMEOUT = 3 * time.Second
+)
+
+var (
+	server *eris.Server
+
+	debug = flag.Bool("d", false, "enable debug logging")
+)
+
+func setupServer() *eris.Server {
+	config := &eris.Config{}
+
+	config.Network.Name = "Test"
+	config.Server.Name = "test"
+	config.Server.Description = "Test"
+	config.Server.Listen = []string{":6667"}
+
+	// SASL
+	config.Account = map[string]*eris.PassConfig{
+		"admin": &eris.PassConfig{"JDJhJDA0JGtUU1JVc1JOUy9DbEh1WEdvYVlMdGVnclp6YnA3NDBOZGY1WUZhdTZtRzVmb1VKdXQ5ckZD"},
+	}
+
+	server := eris.NewServer(config)
+
+	go server.Run()
+
+	return server
+}
+
+func randomValidName() string {
+	var name eris.Name
+	for {
+		name = eris.NewName(shortuuid.New())
+		if name.IsNickname() {
+			break
+		}
+	}
+	return name.String()
+}
+
+func newClient(start bool) *irc.Connection {
+	name := randomValidName()
+	client := irc.IRC(name, name)
+	client.RealName = fmt.Sprintf("Test Client: %s", name)
+
+	err := client.Connect("localhost:6667")
+	if err != nil {
+		log.Fatalf("error setting up test client: %s", err)
+	}
+
+	if start {
+		go client.Loop()
+	}
+
+	return client
+}
+
+func TestMain(m *testing.M) {
+	flag.Parse()
+
+	if *debug {
+		log.SetLevel(log.DebugLevel)
+	} else {
+		log.SetLevel(log.WarnLevel)
+	}
+
+	server = setupServer()
+
+	result := m.Run()
+
+	server.Stop()
+
+	os.Exit(result)
+}
+
+func TestConnection(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client := newClient(false)
+
+	client.AddCallback("001", func(e *irc.Event) {
+		actual <- true
+	})
+
+	defer client.Quit()
+	go client.Loop()
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestSASL(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client := newClient(false)
+	client.SASLLogin = "admin"
+	client.SASLPassword = "admin"
+
+	client.AddCallback("001", func(e *irc.Event) {
+		actual <- true
+	})
+
+	defer client.Quit()
+	go client.Loop()
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestRplWelcome(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := "Welcome to the .* Internet Relay Network .*!.*@.*"
+	actual := make(chan string)
+
+	client := newClient(false)
+
+	client.AddCallback("001", func(e *irc.Event) {
+		actual <- e.Message()
+	})
+
+	defer client.Quit()
+	go client.Loop()
+
+	select {
+	case res := <-actual:
+		assert.Regexp(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestUser_JOIN(t *testing.T) {
+	assert := assert.New(t)
+
+	client := newClient(false)
+
+	expected := []string{client.GetNick(), "=", "#join", fmt.Sprintf("@%s", client.GetNick())}
+	actual := make(chan string)
+
+	client.AddCallback("353", func(e *irc.Event) {
+		for i := range e.Arguments {
+			actual <- e.Arguments[i]
+		}
+	})
+
+	defer client.Quit()
+	go client.Loop()
+
+	client.Join("#join")
+	client.SendRaw("NAMES #join")
+
+	for i := range expected {
+		select {
+		case res := <-actual:
+			assert.Equal(expected[i], res)
+		case <-time.After(TIMEOUT):
+			assert.Fail("timeout")
+		}
+	}
+}
+
+func TestChannel_InviteOnly(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client1 := newClient(false)
+	client2 := newClient(false)
+
+	client1.AddCallback("324", func(e *irc.Event) {
+		if strings.Contains(e.Arguments[2], "i") {
+			client2.Join("#inviteonly")
+		} else {
+			client1.Mode("#inviteonly")
+		}
+	})
+
+	client2.AddCallback("473", func(e *irc.Event) {
+		actual <- true
+	})
+	client2.AddCallback("JOIN", func(e *irc.Event) {
+		actual <- false
+	})
+
+	defer client1.Quit()
+	defer client2.Quit()
+	go client1.Loop()
+	go client2.Loop()
+
+	client1.Join("#inviteonly")
+	client1.Mode("#inviteonly", "+i")
+	client1.Mode("#inviteonly")
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestUser_PRIVMSG(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := "Hello World!"
+	actual := make(chan string)
+
+	client1 := newClient(false)
+	client2 := newClient(false)
+
+	client1.AddCallback("001", func(e *irc.Event) {
+		client1.Privmsg(client2.GetNick(), expected)
+
+	})
+	client1.AddCallback("PRIVMSG", func(e *irc.Event) {
+		actual <- e.Message()
+	})
+
+	client2.AddCallback("001", func(e *irc.Event) {
+		client2.Privmsg(client1.GetNick(), expected)
+	})
+	client2.AddCallback("PRIVMSG", func(e *irc.Event) {
+		actual <- e.Message()
+	})
+
+	defer client1.Quit()
+	defer client2.Quit()
+	go client1.Loop()
+	go client2.Loop()
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestChannel_PRIVMSG(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := "Hello World!"
+	actual := make(chan string)
+
+	client1 := newClient(false)
+	client2 := newClient(false)
+
+	client1.AddCallback("JOIN", func(e *irc.Event) {
+		client1.Privmsg(e.Arguments[0], expected)
+	})
+	client2.AddCallback("JOIN", func(e *irc.Event) {
+		client2.Privmsg(e.Arguments[0], expected)
+	})
+
+	client1.AddCallback("PRIVMSG", func(e *irc.Event) {
+		actual <- e.Message()
+	})
+	client2.AddCallback("PRIVMSG", func(e *irc.Event) {
+		actual <- e.Message()
+	})
+
+	defer client1.Quit()
+	defer client2.Quit()
+	go client1.Loop()
+	go client2.Loop()
+
+	client1.Join("#channelprivmsg")
+	client2.Join("#channelprivmsg")
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestChannel_NoExternal(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client1 := newClient(true)
+	client2 := newClient(true)
+
+	client1.AddCallback("JOIN", func(e *irc.Event) {
+		channel := e.Arguments[0]
+		if channel == "#noexternal" {
+			if e.Nick == client1.GetNick() {
+				client2.Privmsg("#noexternal", "FooBar!")
+			} else {
+				assert.Fail(fmt.Sprintf("unexpected user %s joined %s", e.Nick, channel))
+			}
+		} else {
+			assert.Fail(fmt.Sprintf("unexpected channel %s", channel))
+		}
+	})
+
+	client2.AddCallback("PRIVMSG", func(e *irc.Event) {
+		if e.Arguments[0] == "#noexternal" {
+			actual <- false
+		}
+	})
+	client2.AddCallback("404", func(e *irc.Event) {
+		actual <- true
+	})
+
+	defer client1.Quit()
+	defer client2.Quit()
+	go client1.Loop()
+	go client2.Loop()
+
+	client1.Join("#noexternal")
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestChannel_SetTopic_InvalidChannel(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client1 := newClient(false)
+
+	client1.AddCallback("403", func(e *irc.Event) {
+		actual <- true
+	})
+
+	defer client1.Quit()
+	go client1.Loop()
+
+	client1.SendRaw("TOPIC #invalidchannel :FooBar")
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestChannel_SetTopic_NotOnChannel(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client1 := newClient(false)
+	client2 := newClient(false)
+
+	client1.AddCallback("442", func(e *irc.Event) {
+		actual <- true
+	})
+	client2.AddCallback("JOIN", func(e *irc.Event) {
+		client1.SendRaw("TOPIC #notonchannel :FooBar")
+	})
+
+	defer client1.Quit()
+	go client1.Loop()
+
+	client2.Join("#notonchannel")
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestChannel_BadChannelKey(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client1 := newClient(false)
+	client2 := newClient(false)
+
+	client1.AddCallback("324", func(e *irc.Event) {
+		if strings.Contains(e.Arguments[2], "k") {
+			client2.Join(e.Arguments[1])
+		} else {
+			client1.Mode("#badchannelkey")
+		}
+	})
+
+	client2.AddCallback("JOIN", func(e *irc.Event) {
+		if e.Nick == client2.GetNick() && e.Arguments[0] == "#badchannelkey" {
+			actual <- false
+		}
+	})
+	client2.AddCallback("475", func(e *irc.Event) {
+		actual <- true
+	})
+
+	defer client1.Quit()
+	defer client2.Quit()
+	go client1.Loop()
+	go client2.Loop()
+
+	client1.Join("#badchannelkey")
+	client1.Mode("#badchannelkey", "+k", "opensesame")
+	client1.Mode("#badchannelkey")
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}
+
+func TestChannel_GoodChannelKey(t *testing.T) {
+	assert := assert.New(t)
+
+	expected := true
+	actual := make(chan bool)
+
+	client1 := newClient(true)
+	client2 := newClient(true)
+
+	client1.AddCallback("324", func(e *irc.Event) {
+		if strings.Contains(e.Arguments[2], "k") {
+			client2.SendRawf("JOIN %s :opensesame", e.Arguments[1])
+		} else {
+			client1.Mode("#goodchannelkey")
+		}
+	})
+
+	client2.AddCallback("JOIN", func(e *irc.Event) {
+		if e.Nick == client2.GetNick() && e.Arguments[0] == "#goodchannelkey" {
+			actual <- true
+		}
+	})
+	client2.AddCallback("475", func(e *irc.Event) {
+		actual <- false
+	})
+
+	defer client1.Quit()
+	defer client2.Quit()
+	go client1.Loop()
+	go client2.Loop()
+
+	client1.Join("#goodchannelkey")
+	client1.Mode("#goodchannelkey", "+k", "opensesame")
+	client1.Mode("#goodchannelkey")
+
+	select {
+	case res := <-actual:
+		assert.Equal(expected, res)
+	case <-time.After(TIMEOUT):
+		assert.Fail("timeout")
+	}
+}