go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/chirp/pkg/model/main_test.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package model

import (
	"context"
	"fmt"
	"log"
	"math/rand"
	"os"
	"testing"
	"time"

	"go.charczuk.com/sdk/apputil"
	"go.charczuk.com/sdk/assert"
	"go.charczuk.com/sdk/db"
	"go.charczuk.com/sdk/logutil"
	"go.charczuk.com/sdk/testutil"
	"go.charczuk.com/sdk/util"
	"go.charczuk.com/sdk/uuid"
)

func TestMain(m *testing.M) {
	var logger *log.Logger
	if os.Getenv("TEST_DEBUG") != "" {
		logger = logutil.New()
	} else {
		logger = logutil.Discard()
	}
	testutil.New(m,
		testutil.OptWithDefaultDB(
			db.OptLog(logger),
		),
		testutil.OptBefore(
			func(ctx context.Context) error {
				return Migrations().Apply(ctx, testutil.DefaultDB())
			},
		),
	).Run()
}

type testData struct {
	users       []*apputil.User
	userFollows map[uuid.UUID][]uuid.UUID
	userChirps  [][]uuid.UUID
}

func seedTestData(t *testing.T, mgr *Manager) testData {
	users := []*apputil.User{
		createTestUser(t, mgr, 0),
		createTestUser(t, mgr, 1),
		createTestUser(t, mgr, 2),
		createTestUser(t, mgr, 3),
		createTestUser(t, mgr, 4),
		createTestUser(t, mgr, 5),
		createTestUser(t, mgr, 6),
	}

	userFollows := map[uuid.UUID][]uuid.UUID{
		users[0].ID: {
			users[1].ID,
			users[2].ID,
			users[3].ID,
			users[4].ID,
		},
		users[1].ID: {
			users[0].ID,
			users[2].ID,
		},
		users[2].ID: {
			users[0].ID,
			users[1].ID,
			users[3].ID,
		},
		users[5].ID: {
			users[6].ID,
		},
		users[6].ID: {
			users[5].ID,
		},
	}

	for userID, follows := range userFollows {
		for _, followID := range follows {
			followUser(t, mgr, userID, followID)
		}
	}

	var userChirps [][]uuid.UUID
	for index, u := range users {
		userChirps = append(userChirps, createTestChirps(t, mgr, u.Username(), u.ID, time.Duration(index)*time.Minute))
	}

	quoteChirp(t, mgr, users[0].Username(), users[0].ID, pickRandom(userChirps[1]))
	quoteChirp(t, mgr, users[0].Username(), users[0].ID, pickRandom(userChirps[2]))
	rechirp(t, mgr, users[0].ID, pickRandom(userChirps[4]))

	return testData{
		users,
		userFollows,
		userChirps,
	}
}

func pickRandom[T any](values []T) T {
	index := rand.Intn(len(values) - 1)
	return values[index]
}

func createTestUser(t *testing.T, mgr *Manager, index int) *apputil.User {
	u := apputil.NewTestUser()
	u.Email = fmt.Sprintf("user-%d@example.com", index)
	assert.ItsNil(t, mgr.Invoke(context.Background()).Create(&u))

	ui := UserInfo{
		UserID:    u.ID,
		IsPrivate: false,
		IsAdmin:   false,
	}
	err := mgr.Invoke(context.Background()).Create(&ui)
	assert.ItsNil(t, err)
	return &u
}

func followUser(t *testing.T, mgr *Manager, userID, followingID uuid.UUID) {
	err := mgr.Invoke(context.Background()).Create(Graph{
		UserID:       userID,
		TimestampUTC: time.Now().UTC(),
		TargetID:     followingID,
		Type:         EdgeTypeFollow,
	})
	assert.ItsNil(t, err)
}

func blockUser(t *testing.T, mgr *Manager, userID, followingID uuid.UUID) {
	err := mgr.Invoke(context.Background()).Create(Graph{
		UserID:       userID,
		TimestampUTC: time.Now().UTC(),
		TargetID:     followingID,
		Type:         EdgeTypeBlock,
	})
	assert.ItsNil(t, err)
}

func muteUser(t *testing.T, mgr *Manager, userID, followingID uuid.UUID) {
	err := mgr.Invoke(context.Background()).Create(Graph{
		UserID:       userID,
		TimestampUTC: time.Now().UTC(),
		TargetID:     followingID,
		Type:         EdgeTypeBlock,
	})
	assert.ItsNil(t, err)
}

func createTestChirps(t *testing.T, mgr *Manager, userName string, userID uuid.UUID, timeOffset time.Duration) (ids []uuid.UUID) {
	for x := 0; x < 32; x++ {
		c := &Chirp{
			UserID:       userID,
			CreatedUTC:   time.Now().Add(-((time.Duration(x) * time.Minute) + timeOffset)),
			PublishedUTC: util.Ref(time.Now().Add(-((time.Duration(x) * time.Minute) + timeOffset))),
			Text:         fmt.Sprintf("%v-chirp-%d", userName, x),
		}
		err := mgr.CreateChirp(context.Background(), c)
		assert.ItsNil(t, err)
		err = mgr.PublishChirp(context.Background(), c)
		assert.ItsNil(t, err)
		ids = append(ids, c.ID)
	}
	return
}

func quoteChirp(t *testing.T, mgr *Manager, userName string, userID, chirpID uuid.UUID) (id uuid.UUID) {
	var err error
	c := &Chirp{
		UserID:       userID,
		CreatedUTC:   time.Now().Add(-time.Duration(5) * time.Minute),
		PublishedUTC: util.Ref(time.Now().Add(-time.Duration(5) * time.Minute)),
		Text:         fmt.Sprintf("%v-quote-chirp-%v", userName, chirpID),
		QuotedID:     &chirpID,
	}
	err = mgr.CreateChirp(context.Background(), c)
	assert.ItsNil(t, err)
	err = mgr.PublishChirp(context.Background(), c)
	assert.ItsNil(t, err)
	return
}

func rechirp(t *testing.T, mgr *Manager, userID, chirpID uuid.UUID) (id uuid.UUID) {
	var err error
	c := &Chirp{
		UserID:       userID,
		CreatedUTC:   time.Now().Add(-time.Duration(5) * time.Minute),
		PublishedUTC: util.Ref(time.Now().Add(-time.Duration(5) * time.Minute)),
		QuotedID:     &chirpID,
	}
	err = mgr.CreateChirp(context.Background(), c)
	assert.ItsNil(t, err)
	err = mgr.PublishChirp(context.Background(), c)
	assert.ItsNil(t, err)
	return
}

func replyTo(t *testing.T, mgr *Manager, userID, chirpID uuid.UUID) (id uuid.UUID) {
	var err error
	c := &Chirp{
		UserID:       userID,
		CreatedUTC:   time.Now().Add(-time.Duration(5) * time.Minute),
		PublishedUTC: util.Ref(time.Now().Add(-time.Duration(5) * time.Minute)),
		ReplyID:      &chirpID,
	}
	err = mgr.CreateChirp(context.Background(), c)
	assert.ItsNil(t, err)
	err = mgr.PublishChirp(context.Background(), c)
	assert.ItsNil(t, err)
	return
}