Skip to content

Commit a15c255

Browse files
shazowshazow
committed
tests: Add chat.TestIgnore again
1 parent f2e1827 commit a15c255

File tree

1 file changed

+88
-106
lines changed

1 file changed

+88
-106
lines changed

‎chat/room_test.go‎

Lines changed: 88 additions & 106 deletions
Original file line numberDiff line numberDiff line change
@@ -34,112 +34,6 @@ func TestRoomServe(t *testing.T) {
3434
}
3535
}
3636

37-
/*
38-
func TestIgnore(t *testing.T) {
39-
var buffer []byte
40-
41-
ch := NewRoom()
42-
go ch.Serve()
43-
defer ch.Close()
44-
45-
// Create 3 users, join the room and clear their screen buffers
46-
users := make([]ScreenedUser, 3)
47-
for i := 0; i < 3; i++ {
48-
screen := &MockScreen{}
49-
user := message.NewScreen(fmt.Sprintf("user%d", i), screen)
50-
users[i] = ScreenedUser{
51-
user: user,
52-
screen: screen,
53-
}
54-
55-
_, err := ch.Join(user)
56-
if err != nil {
57-
t.Fatal(err)
58-
}
59-
}
60-
61-
for _, u := range users {
62-
for i := 0; i < 3; i++ {
63-
u.user.HandleMsg(u.user.ConsumeOne())
64-
u.screen.Read(&buffer)
65-
}
66-
}
67-
68-
// Use some handy variable names for distinguish between roles
69-
ignorer := users[0]
70-
ignored := users[1]
71-
other := users[2]
72-
73-
// test ignoring unexisting user
74-
if err := sendCommand("/ignore test", ignorer, ch, &buffer); err != nil {
75-
t.Fatal(err)
76-
}
77-
expectOutput(t, buffer, "-> Err: user not found: test"+message.Newline)
78-
79-
// test ignoring existing user
80-
if err := sendCommand("/ignore "+ignored.user.Name(), ignorer, ch, &buffer); err != nil {
81-
t.Fatal(err)
82-
}
83-
expectOutput(t, buffer, "-> Ignoring: "+ignored.user.Name()+message.Newline)
84-
85-
// ignoring the same user twice returns an error message and doesn't add the user twice
86-
if err := sendCommand("/ignore "+ignored.user.Name(), ignorer, ch, &buffer); err != nil {
87-
t.Fatal(err)
88-
}
89-
expectOutput(t, buffer, "-> Err: user already ignored: user1"+message.Newline)
90-
if ignoredList := ignorer.user.Ignored.ListPrefix(""); len(ignoredList) != 1 {
91-
t.Fatalf("should have %d ignored users, has %d", 1, len(ignoredList))
92-
}
93-
94-
// when a message is sent from the ignored user, it is delivered to non-ignoring users
95-
ch.Send(message.NewPublicMsg("hello", ignored.user))
96-
other.user.HandleMsg(other.user.ConsumeOne())
97-
other.screen.Read(&buffer)
98-
expectOutput(t, buffer, ignored.user.Name()+": hello"+message.Newline)
99-
100-
// ensure ignorer doesn't have received any message
101-
if ignorer.user.HasMessages() {
102-
t.Fatal("should not have messages")
103-
}
104-
105-
// `/ignore` returns a list of ignored users
106-
if err := sendCommand("/ignore", ignorer, ch, &buffer); err != nil {
107-
t.Fatal(err)
108-
}
109-
expectOutput(t, buffer, "-> 1 ignored: "+ignored.user.Name()+message.Newline)
110-
111-
// `/unignore [USER]` removes the user from ignored ones
112-
if err := sendCommand("/unignore "+ignored.user.Name(), users[0], ch, &buffer); err != nil {
113-
t.Fatal(err)
114-
}
115-
expectOutput(t, buffer, "-> No longer ignoring: user1"+message.Newline)
116-
117-
if err := sendCommand("/ignore", users[0], ch, &buffer); err != nil {
118-
t.Fatal(err)
119-
}
120-
expectOutput(t, buffer, "-> 0 users ignored."+message.Newline)
121-
122-
if ignoredList := ignorer.user.Ignored.ListPrefix(""); len(ignoredList) != 0 {
123-
t.Fatalf("should have %d ignored users, has %d", 0, len(ignoredList))
124-
}
125-
126-
// after unignoring a user, its messages can be received again
127-
ch.Send(message.NewPublicMsg("hello again!", ignored.user))
128-
129-
// give some time for the channel to get the message
130-
time.Sleep(100)
131-
132-
// ensure ignorer has received the message
133-
if !ignorer.user.HasMessages() {
134-
// FIXME: This is flaky :/
135-
t.Fatal("should have messages")
136-
}
137-
ignorer.user.HandleMsg(ignorer.user.ConsumeOne())
138-
ignorer.screen.Read(&buffer)
139-
expectOutput(t, buffer, ignored.user.Name()+": hello again!"+message.Newline)
140-
}
141-
*/
142-
14337
func expectOutput(t *testing.T, buffer []byte, expected string) {
14438
bytes := []byte(expected)
14539
if !reflect.DeepEqual(buffer, bytes) {
@@ -185,6 +79,94 @@ func TestRoomJoin(t *testing.T) {
18579
}
18680
}
18781

82+
func TestIgnore(t *testing.T) {
83+
ch := NewRoom()
84+
go ch.Serve()
85+
defer ch.Close()
86+
87+
addUser := func(name string) (message.Author, <-chan []byte) {
88+
s := &ChannelWriter{
89+
Chan: make(chan []byte, 3),
90+
}
91+
u := message.PipedScreen(name, s)
92+
u.SetConfig(message.UserConfig{
93+
Quiet: true,
94+
})
95+
ch.Join(u)
96+
return u, s.Chan
97+
}
98+
99+
u_foo, m_foo := addUser("foo")
100+
u_bar, m_bar := addUser("bar")
101+
u_quux, m_quux := addUser("quux")
102+
103+
var expected, actual []byte
104+
105+
// foo ignores bar, quux hears both
106+
ch.Send(message.ParseInput("/ignore bar", u_foo))
107+
expected = []byte("-> Ignoring: bar" + message.Newline)
108+
actual = <-m_foo
109+
if !reflect.DeepEqual(actual, expected) {
110+
t.Errorf("Got: %q; Expected: %q", actual, expected)
111+
}
112+
113+
// bar and quux sends a message, quux hears bar, foo only hears quux
114+
ch.Send(message.ParseInput("i am bar", u_bar))
115+
ch.Send(message.ParseInput("i am quux", u_quux))
116+
117+
expected = []byte("bar: i am bar" + message.Newline)
118+
actual = <-m_quux
119+
if !reflect.DeepEqual(actual, expected) {
120+
t.Errorf("Got: %q; Expected: %q", actual, expected)
121+
}
122+
123+
expected = []byte("quux: i am quux" + message.Newline)
124+
actual = <-m_bar
125+
if !reflect.DeepEqual(actual, expected) {
126+
t.Errorf("Got: %q; Expected: %q", actual, expected)
127+
}
128+
actual = <-m_foo
129+
if !reflect.DeepEqual(actual, expected) {
130+
t.Errorf("Got: %q; Expected: %q", actual, expected)
131+
}
132+
133+
// foo sends a message, both quux and bar hear it
134+
ch.Send(message.ParseInput("i am foo", u_foo))
135+
expected = []byte("foo: i am foo" + message.Newline)
136+
137+
actual = <-m_quux
138+
if !reflect.DeepEqual(actual, expected) {
139+
t.Errorf("Got: %q; Expected: %q", actual, expected)
140+
}
141+
actual = <-m_bar
142+
if !reflect.DeepEqual(actual, expected) {
143+
t.Errorf("Got: %q; Expected: %q", actual, expected)
144+
}
145+
146+
// Confirm foo's message queue is still empty
147+
select {
148+
case actual = <-m_foo:
149+
t.Errorf("foo's message queue is not empty: %q", actual)
150+
default:
151+
// Pass.
152+
}
153+
154+
// Unignore and listen to bar again.
155+
ch.Send(message.ParseInput("/unignore bar", u_foo))
156+
expected = []byte("-> No longer ignoring: bar" + message.Newline)
157+
actual = <-m_foo
158+
if !reflect.DeepEqual(actual, expected) {
159+
t.Errorf("Got: %q; Expected: %q", actual, expected)
160+
}
161+
162+
ch.Send(message.ParseInput("i am bar again", u_bar))
163+
expected = []byte("bar: i am bar again" + message.Newline)
164+
actual = <-m_foo
165+
if !reflect.DeepEqual(actual, expected) {
166+
t.Errorf("Got: %q; Expected: %q", actual, expected)
167+
}
168+
}
169+
188170
func TestRoomDoesntBroadcastAnnounceMessagesWhenQuiet(t *testing.T) {
189171
msgs := make(chan message.Message)
190172
u := message.HandledScreen("foo", func(m message.Message) error {

0 commit comments

Comments
 (0)