bbj2/server/cmd/api/api_test.go

package api

import (
	"log"
	"net/http"
	"os"
	"reflect"
	"strings"
	"testing"
	"time"

	"git.tilde.town/tildetown/bbj2/server/cmd/config"
	"git.tilde.town/tildetown/bbj2/server/cmd/db"
)

func createTestState() (opts *config.Options, err error) {
	var dbFile *os.File
	if dbFile, err = os.CreateTemp("", "bbj2-test"); err != nil {
		return
	}

	opts = &config.Options{
		Logger: log.New(os.Stdout, "bbj2 test", log.Lshortfile),
		Config: config.Config{
			Admins:       []string{"jillValentine", "rebeccaChambers"},
			Port:         666,
			Host:         "hell.cool",
			InstanceName: "cool test zone",
			AllowAnon:    true,
			DBPath:       dbFile.Name(),
		},
	}

	return
}

func TestUserRegister(t *testing.T) {
	opts, err := createTestState()
	if err != nil {
		t.Fatalf("failed to create test state: %s", err.Error())
		return
	}

	ts := []struct {
		name    string
		req     func() *http.Request
		setup   func(*config.Options) error
		assert  func(*config.Options, *testing.T) error
		wantErr *HTTPError
	}{
		{
			name: "user already exists",
			setup: func(opts *config.Options) error {
				return db.CreateUser(opts.DB, db.User{
					Username: "albertwesker",
					Hash:     "1234abc",
					Created:  time.Now(),
				})
			},
			assert: func(opts *config.Options, t *testing.T) error {
				var count int
				var err error
				if err = opts.DB.QueryRow("SELECT count(*) FROM users").Scan(&count); err != nil {
					return err
				}

				if count != 1 {
					t.Errorf("expected 1 user, got %d", count)
				}

				return nil
			},
			wantErr: &HTTPError{Code: 403, Msg: "user already exists"},
		},
		{
			name: "bad method",
			req: func() *http.Request {
				r, _ := http.NewRequest("GET", "", strings.NewReader(""))
				return r
			},
			wantErr: &HTTPError{
				Msg:  "bad method",
				Code: 400,
			},
		},
		// TODO
	}

	for _, tt := range ts {
		t.Run(tt.name, func(t *testing.T) {
			var req *http.Request
			if tt.req == nil {
				req, _ = http.NewRequest("POST", "", strings.NewReader(`{"user_name":"albertwesker","auth_hash":"1234abc"}`))
			} else {
				req = tt.req()
			}
			teardown, err := db.Setup(opts)
			if err != nil {
				t.Fatalf("could not initialize DB: %s", err.Error())
				return
			}
			defer teardown()

			err = db.EnsureSchema(*opts)
			if err != nil {
				t.Fatalf("could not initialize DB: %s", err.Error())
				return
			}

			if tt.setup != nil {
				err = tt.setup(opts)
				if err != nil {
					t.Fatalf("setup failed: %s", err.Error())
					return
				}
			}

			api := &API{Opts: *opts}
			ctx := &ReqCtx{Req: req}
			_, err = api.UserRegister(ctx)
			if tt.wantErr != nil && err != nil {
				if !reflect.DeepEqual(tt.wantErr, err) {
					t.Errorf("got unwanted error: %s", err.Error())
				}
				return
			}

			if tt.assert != nil {
				err = tt.assert(opts, t)
				if err != nil {
					t.Fatal(err.Error())
					return
				}
			}

			if tt.wantErr != nil && err == nil {
				t.Errorf("expected error")
				return
			}

		})
	}
}

func TestInstanceInfo(t *testing.T) {
	opts, err := createTestState()
	if err != nil {
		t.Fatalf("failed to create test state: %s", err.Error())
		return
	}

	ts := []struct {
		name     string
		req      func() *http.Request
		wantData instanceInfo
		wantErr  *HTTPError
	}{
		{
			name: "basic",
			wantData: instanceInfo{
				InstanceName: "cool test zone",
				AllowAnon:    true,
				Admins:       []string{"jillValentine", "rebeccaChambers"},
			},
		},
		{
			name: "bad method",
			req: func() *http.Request {
				r, _ := http.NewRequest("POST", "", strings.NewReader(""))
				return r
			},
			wantErr: &HTTPError{
				Msg:  "bad method",
				Code: 400,
			},
		},
	}
	for _, tt := range ts {
		t.Run(tt.name, func(t *testing.T) {
			var req *http.Request
			if tt.req == nil {
				req, _ = http.NewRequest("GET", "", strings.NewReader(""))
			} else {
				req = tt.req()
			}
			api := &API{Opts: *opts}
			ctx := &ReqCtx{Req: req}
			resp, err := api.InstanceInfo(ctx)
			if tt.wantErr != nil && err != nil {
				if !reflect.DeepEqual(tt.wantErr, err) {
					t.Errorf("got unwanted error: %s", err.Error())
				}
				return
			}

			if tt.wantErr != nil && err == nil {
				t.Errorf("expected error")
				return
			}

			ii, ok := resp.Data.(instanceInfo)
			if !ok {
				t.Errorf("could not cast data in %s", tt.name)
			}

			if !reflect.DeepEqual(ii, tt.wantData) {
				t.Errorf("did not get expected data in %s", tt.name)
			}
		})
	}
}