prologic-saltyim/client_e2e_test.go

package saltyim_test

import (
	"bytes"
	"context"
	"fmt"
	"net/http"
	"os"
	"testing"
	"time"

	"github.com/avast/retry-go"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"golang.org/x/sync/errgroup"

	"go.mills.io/saltyim"
	"go.mills.io/saltyim/internal"
)

var (
	serverBind          = ":443"
	serverBaseURL       = "https://salty.home.arpa"
	serverPrimaryDomain = "home.arpa"

	tlsKey = "./certs/home.arpa/key.pem"
	tlsCrt = "./certs/home.arpa/cert.pem"

	userFoo   = "foo@home.arpa"
	userAlice = "alice@home.arpa"
	userBob   = "bob@home.arpa"
)

func TestMain(m *testing.M) {
	if !internal.FileExists(tlsKey) || !internal.FileExists(tlsCrt) {
		fmt.Printf("error: certs not found, please run: make certs\n")
		os.Exit(1)
	}

	data, err := os.MkdirTemp("", "data*")
	if err != nil {
		fmt.Printf("error creating data dir: %s\n", err)
		os.Exit(1)
	}
	defer os.RemoveAll(data)

	svr, err := internal.NewServer(serverBind,
		// Debug mode
		internal.WithDebug(true),

		// TLS options
		internal.WithTLS(true),
		internal.WithTLSKey(tlsKey),
		internal.WithTLSCert(tlsCrt),

		// Basic options
		internal.WithData(data),
		internal.WithStore("memory://"),
		internal.WithBaseURL(serverBaseURL),
		internal.WithPrimaryDomain(serverPrimaryDomain),

		// Operator
		internal.WithAdminUser("admin@localhost"),
		internal.WithSupportEmail("support@localhost"),
	)
	if err != nil {
		fmt.Printf("error creating server: %s\n", err)
		os.Exit(1)
	}

	stop := make(chan struct{})

	wg, ctx := errgroup.WithContext(context.Background())

	wg.Go(func() error {
		return svr.Run(ctx)
	})

	wg.Go(func() error {
		<-stop
		ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
		defer cancel()

		return svr.Shutdown(ctx)
	})

	if err := retry.Do(func() error {
		_, err := http.Get(serverBaseURL + "/api/v1/ping")
		return err
	},
		retry.LastErrorOnly(true),
		retry.OnRetry(func(n uint, err error) {
			fmt.Printf("waiting for server to be ready (try #%d): %s", n, err)
		}),
	); err != nil {
		fmt.Printf("error waiting for server: %s\n", err)
		os.Exit(1)
	}

	i := m.Run()

	close(stop)

	go func() {
		<-time.After(3 * time.Second)
		fmt.Println("KILLING IT ALL!! Service failed to shutdown on time!!")
		os.Exit(0)
	}()

	err = wg.Wait()
	fmt.Println(err)

	os.Exit(i)
}

func TestClient(t *testing.T) {
	assert := assert.New(t)
	require := require.New(t)

	t.Run("Register", func(t *testing.T) {
		cli := internal.NewTestUser(userFoo, serverBaseURL, t)
		err := cli.Register(serverBaseURL)
		require.NoError(err)
	})

	alice := internal.NewTestUser(userAlice, serverBaseURL, t)
	require.NoError(alice.Register(serverBaseURL))

	bob := internal.NewTestUser(userBob, serverBaseURL, t)
	require.NoError(bob.Register(serverBaseURL))

	t.Run("SendRead", func(t *testing.T) {
		message := "Hello Bob"
		require.NoError(alice.Send(bob.Me().String(), message))

		msg, err := bob.Read()
		require.NoError(err)
		assert.Equal(msg.Key.ID(), alice.Key().ID())

		assertMessage(t, msg.Text, alice.Me().String(), message)
	})

	t.Run("SendReadFollow", func(t *testing.T) {
		var received []saltyim.Message

		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
		defer cancel()

		wg, ctx := errgroup.WithContext(ctx)

		wg.Go(func() error {
			ch := bob.Subscribe(ctx)
			select {
			case <-ctx.Done():
				break
			case msg := <-ch:
				received = append(received, msg)
			}
			return nil
		})

		messages := []string{"Hello Bob!", "How are you doing?", "Goodbye bob!"}
		wg.Go(func() error {
			// Give time for the subscriber to actually subscribe 😅
			time.Sleep(time.Second * 1)
			for _, message := range messages {
				require.NoError(alice.Send(bob.Me().String(), message))
			}
			return nil
		})

		wg.Wait()

		t.Logf("received: #%v", received)
		for i, msg := range received {
			assert.Equal(msg.Key.ID(), alice.Key().ID())
			assertMessage(t, msg.Text, alice.Me().String(), messages[i])
		}
	})

	t.Run("Blobs", func(t *testing.T) {
		t.Run("Write", func(t *testing.T) {
			buf := bytes.NewBufferString("Hello World!")
			err := alice.Blobs().Write(buf, saltyim.WithKey("hello"))
			require.NoError(err)
		})

		t.Run("ReadWrite", func(t *testing.T) {
			buf := bytes.NewBufferString("Hello World!")
			err := alice.Blobs().Write(buf, saltyim.WithKey("hello"))
			require.NoError(err)

			data, err := alice.Blobs().Read("hello")
			require.NoError(err)
			assert.EqualValues("Hello World!", data)

		})
	})
}