108 lines
3.1 KiB
Go
108 lines
3.1 KiB
Go
package goricochet
|
|
|
|
import "testing"
|
|
import "time"
|
|
import "log"
|
|
|
|
type TestService struct {
|
|
StandardRicochetService
|
|
ReceivedMessage bool
|
|
KnownContact bool // Mocking contact request
|
|
}
|
|
|
|
func (ts *TestService) OnAuthenticationResult(oc *OpenConnection, channelID int32, result bool, isKnownContact bool) {
|
|
ts.StandardRicochetService.OnAuthenticationResult(oc, channelID, result, isKnownContact)
|
|
if !isKnownContact {
|
|
log.Printf("Sending Contact Request")
|
|
oc.SendContactRequest(3, "test", "test")
|
|
}
|
|
}
|
|
|
|
func (ts *TestService) OnContactRequest(oc *OpenConnection, channelID int32, nick string, message string) {
|
|
ts.StandardRicochetService.OnContactRequest(oc, channelID, nick, message)
|
|
oc.AckContactRequestOnResponse(channelID, "Pending")
|
|
oc.AckContactRequest(channelID, "Accepted")
|
|
ts.KnownContact = true
|
|
oc.CloseChannel(channelID)
|
|
}
|
|
|
|
func (ts *TestService) OnOpenChannelRequestSuccess(oc *OpenConnection, channelID int32) {
|
|
ts.StandardRicochetService.OnOpenChannelRequestSuccess(oc, channelID)
|
|
oc.SendMessage(channelID, "TEST MESSAGE")
|
|
}
|
|
|
|
func (ts *TestService) OnContactRequestAck(oc *OpenConnection, channelID int32, status string) {
|
|
ts.StandardRicochetService.OnContactRequestAck(oc, channelID, status)
|
|
if status == "Accepted" {
|
|
log.Printf("Got accepted contact request")
|
|
ts.KnownContact = true
|
|
oc.OpenChatChannel(5)
|
|
} else if status == "Pending" {
|
|
log.Printf("Got pending contact request")
|
|
}
|
|
}
|
|
|
|
func (ts *TestService) OnChatMessage(oc *OpenConnection, channelID int32, messageID int32, message string) {
|
|
ts.StandardRicochetService.OnChatMessage(oc, channelID, messageID, message)
|
|
if message == "TEST MESSAGE" {
|
|
ts.ReceivedMessage = true
|
|
}
|
|
}
|
|
|
|
func (ts *TestService) IsKnownContact(hostname string) bool {
|
|
return ts.KnownContact
|
|
}
|
|
|
|
func TestServer(t *testing.T) {
|
|
ricochetService := new(TestService)
|
|
err := ricochetService.Init("./private_key")
|
|
|
|
if err != nil {
|
|
t.Errorf("Could not initate ricochet service: %v", err)
|
|
}
|
|
|
|
go ricochetService.Listen(ricochetService, 9878)
|
|
|
|
time.Sleep(time.Second * 2)
|
|
|
|
ricochetService2 := new(TestService)
|
|
err = ricochetService2.Init("./private_key")
|
|
|
|
if err != nil {
|
|
t.Errorf("Could not initate ricochet service: %v", err)
|
|
}
|
|
|
|
go ricochetService2.Listen(ricochetService2, 9879)
|
|
err = ricochetService2.Connect("127.0.0.1:9878|kwke2hntvyfqm7dr")
|
|
if err != nil {
|
|
t.Errorf("Could not connect to ricochet service: %v", err)
|
|
}
|
|
|
|
time.Sleep(time.Second * 5) // Wait a bit longer
|
|
if !ricochetService.ReceivedMessage {
|
|
t.Errorf("Test server did not receive message")
|
|
}
|
|
|
|
}
|
|
|
|
func TestServerInvalidKey(t *testing.T) {
|
|
ricochetService := new(TestService)
|
|
err := ricochetService.Init("./private_key.does.not.exist")
|
|
|
|
if err == nil {
|
|
t.Errorf("Should not have initate ricochet service, private key should not exist")
|
|
}
|
|
}
|
|
|
|
func TestServerCouldNotConnect(t *testing.T) {
|
|
ricochetService := new(TestService)
|
|
err := ricochetService.Init("./private_key")
|
|
if err != nil {
|
|
t.Errorf("Could not initate ricochet service: %v", err)
|
|
}
|
|
err = ricochetService.Connect("127.0.0.1:65535|kwke2hntvyfqm7dr")
|
|
if err == nil {
|
|
t.Errorf("Should not have been been able to connect to 127.0.0.1:65535|kwke2hntvyfqm7dr")
|
|
}
|
|
}
|