Remove silly build token in version and add goreleaser config

* 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

.gitignore

@@ -1,5 +1,6 @@
 *~*
 bin
+dist
 *.db
 *.pem
 

.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

.goreleaser.yml

@@ -0,0 +1,31 @@
+builds:
+  - binary: eris
+    flags: -tags "static_build"
+    ldflags: -w -X mail.Version={{.Version}} -X main.Commit={{.Commit}}
+    env:
+      - CGO_ENABLED=0
+    goos:
+      - darwin
+      - freebsd
+      - linux
+      - windows
+    goarch:
+      - i386
+      - amd64
+      - arm
+      - amd64
+    goarm:
+      - 6
+      - 7
+sign:
+  artifacts: checksum
+archive:
+  wrap_in_directory: true
+  format_overrides:
+    - goos: windows
+      format: zip
+  files:
+    - "*.pem"
+    - "*.yml"
+    - "LICENSE"
+    - "README.md"

Dockerfile

@@ -2,7 +2,6 @@
 FROM golang:alpine AS build
 
 ARG TAG
-ARG BUILD
 
 ENV APP eris
 ENV REPO prologic/$APP
@@ -12,7 +11,7 @@ RUN apk add --update git make build-base && \
 
 WORKDIR /go/src/github.com/$REPO
 COPY . /go/src/github.com/$REPO
-RUN make TAG=$TAG BUILD=$BUILD build
+RUN make TAG=$TAG build
 
 # Runtime
 FROM alpine

Makefile

@@ -6,7 +6,6 @@ APP=eris
 PACKAGE=irc
 REPO?=prologic/$(APP)
 TAG?=latest
-BUILD?=dev
 
 all: dev
 
@@ -17,13 +16,13 @@ deps:
 	@go get ./...
 
 build: clean deps
-	@echo " -> Building $(TAG)$(BUILD)"
+	@echo " -> Building $(REPO) v$(TAG)-@$(COMMIT)"
 	@go build -tags "netgo static_build" -installsuffix netgo \
-		-ldflags "-w -X github.com/$(REPO)/${PACKAGE}.GitCommit=$(COMMIT) -X github.com/$(REPO)/${PACKAGE}.Build=$(BUILD)" .
+		-ldflags "-w -X github.com/$(REPO)/${PACKAGE}.GitCommit=$(COMMIT)
 	@echo "Built $$(./$(APP) -v)"
 
 image:
-	@docker build --build-arg TAG=$(TAG) --build-arg BUILD=$(BUILD) -t $(REPO):$(TAG) .
+	@docker build --build-arg TAG=$(TAG) -t $(REPO):$(TAG) .
 	@echo "Image created: $(REPO):$(TAG)"
 
 test:

README.md

@@ -1,4 +1,4 @@
-# eris - IRC Server / Daemon written in Go
+:set spell eris - IRC Server / Daemon written in Go
 
 [![Build Status](https://travis-ci.org/prologic/eris.svg)](https://travis-ci.org/prologic/eris)
 [![Go Report Card](https://goreportcard.com/badge/github.com/prologic/eris)](https://goreportcard.com/report/github.com/prologic/eris)
@@ -25,7 +25,7 @@ The connotation here is that IRC (*Internet Relay Chat*) is a place of chaos,
 strife and discord. IRC is a place where you argue and get into arguments for
 the sake of argument.
 
-So `eris` is an IRC daemon written from scratch in Go to factiliate discord
+So `eris` is an IRC daemon written from scratch in Go to facilitate discord
 and have arguments for the sake of argument!
 
 Pull requests and issues are welcome.

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()
@@ -209,6 +218,7 @@ func (client *Client) Register() {
 		return
 	}
 	client.registered = true
+	client.flags[HostMask] = true
 	client.Touch()
 }
 

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/modes.go

@@ -58,11 +58,12 @@ const (
 	Registered UserMode = 'r' // not a real user mode (flag)
 	SecureConn UserMode = 'z'
 	SecureOnly UserMode = 'Z'
+	HostMask   UserMode = 'x'
 )
 
 var (
 	SupportedUserModes = UserModes{
-		Invisible, Operator,
+		Invisible, Operator, HostMask,
 	}
 	DefaultChannelModes = ChannelModes{
 		NoOutside, OpOnlyTopic,
@@ -116,7 +117,7 @@ func (m *ModeCommand) HandleServer(s *Server) {
 
 	for _, change := range m.changes {
 		switch change.mode {
-		case Invisible, WallOps, SecureOnly:
+		case Invisible, HostMask, WallOps, SecureOnly:
 			switch change.op {
 			case Add:
 				if target.flags[change.mode] {

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/reply.go

@@ -266,7 +266,7 @@ func (target *Client) RplWhois(client *Client) {
 func (target *Client) RplWhoisUser(client *Client) {
 	var clientHost Name
 
-	if target.flags[Operator] {
+	if target.flags[Operator] || !client.flags[HostMask] {
 		clientHost = client.hostname
 	} else {
 		clientHost = client.hostmask
@@ -342,7 +342,7 @@ func (target *Client) RplChannelModeIs(channel *Channel) {
 func (target *Client) RplWhoReply(channel *Channel, client *Client) {
 	var clientHost Name
 
-	if target.flags[Operator] {
+	if target.flags[Operator] || !client.flags[HostMask] {
 		clientHost = client.hostname
 	} else {
 		clientHost = client.hostmask

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

@@ -80,7 +80,7 @@ func NewServer(config *Config) *Server {
 
 	log.Debugf("accounts: %v", config.Accounts())
 
-	// TODO: Make this configurabel?
+	// TODO: Make this configureable?
 	server.ids["global"] = NewIdentity(config.Server.Name, "global")
 
 	if config.Server.Password != "" {
@@ -136,7 +136,7 @@ func NewServer(config *Config) *Server {
 		},
 	)
 
-	// server clients gauge (by secure/insecire)
+	// server clients gauge (by secure/insecure)
 	server.metrics.NewGaugeVec(
 		"server", "clients",
 		"Number of registered clients connected (by secure/insecure)",
@@ -202,6 +202,10 @@ func (server *Server) Shutdown() {
 	server.Global("shutting down...")
 }
 
+func (server *Server) Stop() {
+	server.done <- true
+}
+
 func (server *Server) Run() {
 	for {
 		select {
@@ -212,7 +216,7 @@ func (server *Server) Run() {
 			// Give at least 1s for clients to see the shutdown
 			go func() {
 				time.Sleep(1 * time.Second)
-				server.done <- true
+				server.Stop()
 			}()
 
 		case conn := <-server.newConns:

irc/types.go

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

irc/version.go

@@ -5,20 +5,17 @@ import (
 )
 
 var (
-	//PackageName package name
+	// Package package name
 	Package = "eris"
 
 	// Version release version
-	Version = "1.6.3"
+	Version = "1.6.4"
 
-	// Build will be overwritten automatically by the build system
-	Build = "dev"
-
-	// GitCommit will be overwritten automatically by the build system
-	GitCommit = "HEAD"
+	// Commit will be overwritten automatically by the build system
+	Commit = "HEAD"
 )
 
 // FullVersion display the full version and build
 func FullVersion() string {
-	return fmt.Sprintf("%s-%s-%s@%s", Package, Version, Build, GitCommit)
+	return fmt.Sprintf("%s-%s@%s", Package, Version, Commit)
 }

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,575 @@
+package main
+
+import (
+	"crypto/sha256"
+	"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_WithHostMask(t *testing.T) {
+	assert := assert.New(t)
+
+	client1 := newClient(false)
+	client2 := newClient(false)
+
+	expected := fmt.Sprintf("%x", sha256.Sum256([]byte("localhost")))
+	actual := make(chan string)
+
+	client1.AddCallback("001", func(e *irc.Event) {
+		client1.Mode(client1.GetNick(), "+x")
+	})
+
+	client2.AddCallback("001", func(e *irc.Event) {
+		client2.Whois(client1.GetNick())
+	})
+
+	client2.AddCallback("401", func(e *irc.Event) {
+		client2.Whois(client1.GetNick())
+	})
+
+	client2.AddCallback("311", func(e *irc.Event) {
+		actual <- e.Arguments[3]
+	})
+
+	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 TestUser_WithoutHostMask(t *testing.T) {
+	assert := assert.New(t)
+
+	client1 := newClient(false)
+	client2 := newClient(false)
+
+	expected := "localhost"
+	actual := make(chan string)
+
+	client1.AddCallback("001", func(e *irc.Event) {
+		client1.Mode(client1.GetNick(), "-x")
+	})
+
+	client2.AddCallback("001", func(e *irc.Event) {
+		client2.Whois(client1.GetNick())
+	})
+
+	client2.AddCallback("401", func(e *irc.Event) {
+		client2.Whois(client1.GetNick())
+	})
+
+	client2.AddCallback("311", func(e *irc.Event) {
+		actual <- e.Arguments[3]
+	})
+
+	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 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")
+	}
+}