mirror of
https://github.com/ChronosX88/go-gun.git
synced 2024-11-23 19:02:18 +00:00
144 lines
3.8 KiB
Go
144 lines
3.8 KiB
Go
package tests
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/cretz/esgopeta/gun"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type testContext struct {
|
|
context.Context
|
|
*testing.T
|
|
Require *require.Assertions
|
|
GunJSPort int
|
|
}
|
|
|
|
const defaultTestTimeout = 1 * time.Minute
|
|
|
|
func newContext(t *testing.T) (*testContext, context.CancelFunc) {
|
|
return withTestContext(context.Background(), t)
|
|
}
|
|
|
|
func newContextWithGunJServer(t *testing.T) (*testContext, context.CancelFunc) {
|
|
ctx, cancelFn := newContext(t)
|
|
serverCancelFn := ctx.startGunJSServer()
|
|
return ctx, func() {
|
|
serverCancelFn()
|
|
cancelFn()
|
|
}
|
|
}
|
|
|
|
const defaultGunJSPort = 8080
|
|
const defaultRemoteGunServerURL = "https://gunjs.herokuapp.com/gun"
|
|
|
|
func withTestContext(ctx context.Context, t *testing.T) (*testContext, context.CancelFunc) {
|
|
ctx, cancelFn := context.WithTimeout(ctx, defaultTestTimeout)
|
|
return &testContext{
|
|
Context: ctx,
|
|
T: t,
|
|
Require: require.New(t),
|
|
GunJSPort: defaultGunJSPort,
|
|
}, cancelFn
|
|
}
|
|
|
|
func (t *testContext) debugf(format string, args ...interface{}) {
|
|
if testing.Verbose() {
|
|
log.Printf(format, args...)
|
|
}
|
|
}
|
|
|
|
func (t *testContext) runJS(script string) []byte {
|
|
cmd := exec.CommandContext(t, "node")
|
|
_, currFile, _, _ := runtime.Caller(0)
|
|
cmd.Dir = filepath.Dir(currFile)
|
|
cmd.Stdin = bytes.NewReader([]byte(script))
|
|
out, err := cmd.CombinedOutput()
|
|
out = removeGunJSWelcome(out)
|
|
t.Require.NoErrorf(err, "JS failure, output:\n%v", string(out))
|
|
return out
|
|
}
|
|
|
|
func (t *testContext) runJSWithGun(script string) []byte {
|
|
return t.runJSWithGunURL("http://127.0.0.1:"+strconv.Itoa(t.GunJSPort)+"/gun", script)
|
|
}
|
|
|
|
func (t *testContext) runJSWithGunURL(url string, script string) []byte {
|
|
return t.runJS(`
|
|
var Gun = require('gun')
|
|
const gun = Gun({
|
|
peers: ['` + url + `'],
|
|
radisk: false
|
|
})
|
|
` + script)
|
|
}
|
|
|
|
func (t *testContext) startJS(script string) (*bytes.Buffer, *exec.Cmd, context.CancelFunc) {
|
|
cmdCtx, cancelFn := context.WithCancel(t)
|
|
cmd := exec.CommandContext(cmdCtx, "node")
|
|
_, currFile, _, _ := runtime.Caller(0)
|
|
cmd.Dir = filepath.Dir(currFile)
|
|
cmd.Stdin = bytes.NewReader([]byte(script))
|
|
var buf bytes.Buffer
|
|
cmd.Stdout, cmd.Stderr = &buf, &buf
|
|
t.Require.NoError(cmd.Start())
|
|
return &buf, cmd, cancelFn
|
|
}
|
|
|
|
func (t *testContext) startGunJSServer() context.CancelFunc {
|
|
// If we're logging, use a proxy
|
|
port := t.GunJSPort
|
|
if testing.Verbose() {
|
|
t.startGunWebSocketProxyLogger(port, "ws://127.0.0.1:"+strconv.Itoa(port+1)+"/gun")
|
|
port++
|
|
}
|
|
// Remove entire data folder first just in case
|
|
t.Require.NoError(os.RemoveAll("radata-server"))
|
|
_, cmd, cancelFn := t.startJS(`
|
|
var Gun = require('gun')
|
|
const server = require('http').createServer().listen(` + strconv.Itoa(port) + `)
|
|
const gun = Gun({web: server, file: 'radata-server'})
|
|
`)
|
|
return func() {
|
|
cancelFn()
|
|
cmd.Wait()
|
|
// Remove the data folder at the end
|
|
os.RemoveAll("radata-server")
|
|
}
|
|
}
|
|
|
|
func (t *testContext) prepareRemoteGunServer(origURL string) (newURL string) {
|
|
// If we're verbose, use proxy, otherwise just use orig
|
|
if !testing.Verbose() {
|
|
return origURL
|
|
}
|
|
origURL = strings.Replace(origURL, "http://", "ws://", 1)
|
|
origURL = strings.Replace(origURL, "https://", "wss://", 1)
|
|
t.startGunWebSocketProxyLogger(t.GunJSPort, origURL)
|
|
return "http://127.0.0.1:" + strconv.Itoa(t.GunJSPort) + "/gun"
|
|
}
|
|
|
|
func (t *testContext) newGunConnectedToGunJS() *gun.Gun {
|
|
return t.newGunConnectedToGunServer("http://127.0.0.1:" + strconv.Itoa(t.GunJSPort) + "/gun")
|
|
}
|
|
|
|
func (t *testContext) newGunConnectedToGunServer(url string) *gun.Gun {
|
|
config := gun.Config{
|
|
PeerURLs: []string{url},
|
|
PeerErrorHandler: func(errPeer *gun.ErrPeer) { t.debugf("Got peer error: %v", errPeer) },
|
|
}
|
|
g, err := gun.New(t, config)
|
|
t.Require.NoError(err)
|
|
return g
|
|
}
|