porter/internal/repository/gorm/project_test.go

package gorm_test

import (
	"testing"

	"github.com/go-test/deep"
	"github.com/porter-dev/porter/internal/models"

	"gorm.io/gorm"
	orm "gorm.io/gorm"
)

func TestCreateProject(t *testing.T) {
	tester := &tester{
		dbFileName: "./porter_create_proj.db",
	}

	setupTestEnv(tester, t)
	defer cleanup(tester, t)

	proj := &models.Project{
		Name: "project-test",
	}

	proj, err := tester.repo.Project.CreateProject(proj)

	if err != nil {
		t.Fatalf("%v\n", err)
	}

	proj, err = tester.repo.Project.ReadProject(proj.Model.ID)

	if err != nil {
		t.Fatalf("%v\n", err)
	}

	// make sure id is 1 and name is "project-test"
	if proj.Model.ID != 1 {
		t.Errorf("incorrect project ID: expected %d, got %d\n", 1, proj.Model.ID)
	}

	if proj.Name != "project-test" {
		t.Errorf("incorrect project name: expected %s, got %s\n", "project-test", proj.Name)
	}
}

func TestCreateProjectRole(t *testing.T) {
	tester := &tester{
		dbFileName: "./porter_create_proj_role.db",
	}

	setupTestEnv(tester, t)
	initProject(tester, t)
	defer cleanup(tester, t)

	role := &models.Role{
		Kind:      models.RoleAdmin,
		UserID:    0,
		ProjectID: tester.initProjects[0].Model.ID,
	}

	role, err := tester.repo.Project.CreateProjectRole(tester.initProjects[0], role)

	if err != nil {
		t.Fatalf("%v\n", err)
	}

	proj, err := tester.repo.Project.ReadProject(tester.initProjects[0].Model.ID)

	if err != nil {
		t.Fatalf("%v\n", err)
	}

	// make sure IDs are correct
	if proj.Model.ID != 1 {
		t.Errorf("incorrect project ID: expected %d, got %d\n", 1, proj.Model.ID)
	}

	if len(proj.Roles) != 1 {
		t.Fatalf("project roles incorrect length: expected %d, got %d\n", 1, len(proj.Roles))
	}

	if proj.Roles[0].Model.ID != 1 {
		t.Fatalf("incorrect role ID: expected %d, got %d\n", 1, proj.Roles[0].Model.ID)
	}

	// make sure data is correct
	expProj := &models.Project{
		Name: "project-test",
		Roles: []models.Role{
			models.Role{
				Kind:      models.RoleAdmin,
				UserID:    0,
				ProjectID: 1,
			},
		},
	}

	copyProj := proj

	// reset fields for reflect.DeepEqual
	copyProj.Model = orm.Model{}
	copyProj.Roles[0].Model = orm.Model{}

	if diff := deep.Equal(copyProj, expProj); diff != nil {
		t.Errorf("incorrect project")
		t.Error(diff)
	}
}

func TestListProjectsByUserID(t *testing.T) {
	tester := &tester{
		dbFileName: "./list_projects_user_id.db",
	}

	setupTestEnv(tester, t)
	initUser(tester, t)
	// create two projects, same name
	initProject(tester, t)
	initProjectRole(tester, t)
	initProject(tester, t)

	role := &models.Role{
		Kind:   models.RoleAdmin,
		UserID: 1,
	}

	role, err := tester.repo.Project.CreateProjectRole(tester.initProjects[1], role)

	if err != nil {
		t.Fatalf("%v\n", err)
	}

	defer cleanup(tester, t)

	projects, err := tester.repo.Project.ListProjectsByUserID(tester.initUsers[0].Model.ID)

	if err != nil {
		t.Fatalf("%v\n", err)
	}

	if len(projects) != 2 {
		t.Fatalf("projects length was not 2\n")
	}

	for i, project := range projects {
		// make sure data is correct
		expProj := &models.Project{
			Name: "project-test",
			Roles: []models.Role{
				models.Role{
					Kind:      models.RoleAdmin,
					UserID:    tester.initUsers[0].Model.ID,
					ProjectID: uint(i + 1),
				},
			},
		}

		copyProj := project

		// reset fields for reflect.DeepEqual
		copyProj.Model = orm.Model{}
		copyProj.Roles[0].Model = orm.Model{}

		if diff := deep.Equal(copyProj, expProj); diff != nil {
			t.Errorf("incorrect project")
			t.Error(diff)
		}
	}

}

func TestDeleteProject(t *testing.T) {
	tester := &tester{
		dbFileName: "./porter_create_proj_role.db",
	}

	setupTestEnv(tester, t)
	initProject(tester, t)
	defer cleanup(tester, t)

	proj, err := tester.repo.Project.DeleteProject(tester.initProjects[0])

	if err != nil {
		t.Fatalf("%v\n", err)
	}

	// attempt to read the project and ensure that the error is gorm.ErrRecordNotFound
	_, err = tester.repo.Project.ReadProject(proj.Model.ID)

	if err != gorm.ErrRecordNotFound {
		t.Fatalf("read should have returned record not found: returned %v\n", err)
	}
}