diff --git a/infrastructure/repository/contest_test.go b/infrastructure/repository/contest_test.go
index f87b9a50..dee9edcc 100644
--- a/infrastructure/repository/contest_test.go
+++ b/infrastructure/repository/contest_test.go
@@ -3,424 +3,355 @@ package repository
 import (
 	"context"
 	"testing"
-	"time"
 
 	"github.com/gofrs/uuid"
+	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/assert"
 	"github.com/traPtitech/traPortfolio/domain"
-	"github.com/traPtitech/traPortfolio/infrastructure/external/mock_external_e2e"
+	"github.com/traPtitech/traPortfolio/infrastructure/external"
+	"github.com/traPtitech/traPortfolio/infrastructure/external/mock_external"
 
-	urepository "github.com/traPtitech/traPortfolio/usecases/repository"
-	"github.com/traPtitech/traPortfolio/util/mockdata"
+	"github.com/traPtitech/traPortfolio/usecases/repository"
 	"github.com/traPtitech/traPortfolio/util/random"
 )
 
-func TestContestRepository_GetContests(t *testing.T) {
+func Test_GetContests(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
-	contests, err := repo.GetContests(context.Background())
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
+
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
+	assert.NoError(t, err)
+	contest2, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
 
-	expected := []*domain.Contest{&contest1.Contest, &contest2.Contest}
+	t.Run("get all contests", func(t *testing.T) {
+		gotContests, err := repo.GetContests(context.Background())
+		assert.NoError(t, err)
 
-	assert.ElementsMatch(t, expected, contests)
+		expectedContests := []*domain.Contest{&contest1.Contest, &contest2.Contest}
+		assert.ElementsMatch(t, expectedContests, gotContests)
+	})
 }
 
-func TestContestRepository_GetContest(t *testing.T) {
+func Test_GetContest(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
 
-	gotContest1, err := repo.GetContest(context.Background(), contest1.ID)
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	assert.Equal(t, contest1, gotContest1)
-
-	gotContest2, err := repo.GetContest(context.Background(), contest2.ID)
+	contest2, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	assert.Equal(t, contest2, gotContest2)
+
+	t.Run("get contest1", func(t *testing.T) {
+		gotContest, err := repo.GetContest(context.Background(), contest1.ID)
+		assert.NoError(t, err)
+		assert.Equal(t, contest1, gotContest)
+	})
+
+	t.Run("get contest2", func(t *testing.T) {
+		gotContest, err := repo.GetContest(context.Background(), contest2.ID)
+		assert.NoError(t, err)
+		assert.Equal(t, contest2, gotContest)
+	})
 }
 
-func TestContestRepository_UpdateContest(t *testing.T) {
+func Test_CreateContest(t *testing.T) {}
+
+func Test_UpdateContest(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-	tests := []struct {
-		name string
-		ctx  context.Context
-		args *urepository.UpdateContestArgs
-	}{
-		{
-			name: "all fields",
-			ctx:  context.Background(),
-			args: random.UpdateContestArgs(),
-		},
-		{
-			name: "partial fields",
-			ctx:  context.Background(),
-			args: random.UpdateContestArgs(),
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			contest1 := mustMakeContest(t, repo, nil)
-			contest2 := mustMakeContest(t, repo, nil)
-
-			args := tt.args
-			contest1.Name = args.Name.ValueOr(contest1.Name)
-			contest1.Description = args.Description.ValueOr(contest1.Description)
-			contest1.Link = args.Link.ValueOr(contest1.Link)
-			contest1.TimeStart = args.Since.ValueOr(contest1.TimeStart)
-			contest1.TimeEnd = args.Until.ValueOr(contest1.TimeEnd)
-
-			err := repo.UpdateContest(context.Background(), contest1.ID, args)
-			assert.NoError(t, err)
-
-			gotContest1, err := repo.GetContest(context.Background(), contest1.ID)
-			assert.NoError(t, err)
-			gotContest2, err := repo.GetContest(context.Background(), contest2.ID)
-			assert.NoError(t, err)
-
-			expected := []*domain.ContestDetail{contest1, contest2}
-			gots := []*domain.ContestDetail{gotContest1, gotContest2}
-
-			for i := range expected {
-				assert.True(t, expected[i].TimeStart.Equal(gots[i].TimeStart))
-				assert.True(t, expected[i].TimeEnd.Equal(gots[i].TimeEnd))
-				expected[i].TimeStart = time.Time{}
-				expected[i].TimeEnd = time.Time{}
-				gots[i].TimeStart = time.Time{}
-				gots[i].TimeEnd = time.Time{}
-				assert.Equal(t, expected[i], gots[i])
-			}
-		})
-	}
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
+
+	contest, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
+	assert.NoError(t, err)
+
+	t.Run("update all fields", func(t *testing.T) {
+		args := random.UpdateContestArgs()
+		err := repo.UpdateContest(context.Background(), contest.ID, args)
+		assert.NoError(t, err)
+
+		gotContest, err := repo.GetContest(context.Background(), contest.ID)
+		assert.NoError(t, err)
+
+		contest.Name = args.Name.ValueOr(contest.Name)
+		contest.Description = args.Description.ValueOr(contest.Description)
+		contest.Link = args.Link.ValueOr(contest.Link)
+		contest.TimeStart = args.Since.ValueOr(contest.TimeStart)
+		contest.TimeEnd = args.Until.ValueOr(contest.TimeEnd)
+		assert.Equal(t, contest, gotContest)
+	})
+
+	t.Run("update no fields", func(t *testing.T) {
+		args := &repository.UpdateContestArgs{}
+		err := repo.UpdateContest(context.Background(), contest.ID, args)
+		assert.NoError(t, err)
+
+		gotContest, err := repo.GetContest(context.Background(), contest.ID)
+		assert.NoError(t, err)
+
+		assert.Equal(t, contest, gotContest)
+	})
 }
 
-func TestContestRepository_DeleteContest(t *testing.T) {
+func Test_DeleteContest(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
 
-	gotContest1, err := repo.GetContest(context.Background(), contest1.ID)
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	assert.Equal(t, contest1, gotContest1)
-
-	gotContest2, err := repo.GetContest(context.Background(), contest2.ID)
+	contest2, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	assert.Equal(t, contest2, gotContest2)
 
-	err = repo.DeleteContest(context.Background(), contest1.ID)
-	assert.NoError(t, err)
+	t.Run("delete contest1", func(t *testing.T) {
+		gotContest1, err := repo.GetContest(context.Background(), contest1.ID)
+		assert.NoError(t, err)
+		assert.Equal(t, contest1, gotContest1)
 
-	deletedContest1, err := repo.GetContest(context.Background(), contest1.ID)
-	assert.Nil(t, deletedContest1)
-	assert.Equal(t, err, urepository.ErrNotFound)
+		err = repo.DeleteContest(context.Background(), contest1.ID)
+		assert.NoError(t, err)
 
-	gotContest2, err = repo.GetContest(context.Background(), contest2.ID)
-	assert.NoError(t, err)
-	assert.Equal(t, contest2, gotContest2)
+		deletedContest1, err := repo.GetContest(context.Background(), contest1.ID)
+		assert.Nil(t, deletedContest1)
+		assert.Equal(t, err, repository.ErrNotFound)
+	})
+
+	t.Run("delete of contest1 doesn't affect contest2", func(t *testing.T) {
+		gotContest2, err := repo.GetContest(context.Background(), contest2.ID)
+		assert.NoError(t, err)
+		assert.Equal(t, contest2, gotContest2)
+	})
 }
 
-func TestContestRepository_GetContestTeams(t *testing.T) {
+func Test_GetContestTeams(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
-	team1 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	team2 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
 
-	expected1 := []*domain.ContestTeam{&team1.ContestTeam, &team2.ContestTeam}
-	gotTeams1, err := repo.GetContestTeams(context.Background(), contest1.ID)
+	// contest1 has two teams (team1, team2)
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected1, gotTeams1)
-
-	expected2 := []*domain.ContestTeam{}
-	gotTeams2, err := repo.GetContestTeams(context.Background(), contest2.ID)
+	team1, err := repo.CreateContestTeam(context.Background(), contest1.ID, random.CreateContestTeamArgs())
+	assert.NoError(t, err)
+	team2, err := repo.CreateContestTeam(context.Background(), contest1.ID, random.CreateContestTeamArgs())
+	assert.NoError(t, err)
+	// contest2 has no teams
+	contest2, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected2, gotTeams2)
+
+	t.Run("get teams of contest1 (two teams belongs)", func(t *testing.T) {
+		expectedTeams := []*domain.ContestTeam{&team1.ContestTeam, &team2.ContestTeam}
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotTeams, err := repo.GetContestTeams(context.Background(), contest1.ID)
+		assert.NoError(t, err)
+		assert.ElementsMatch(t, expectedTeams, gotTeams)
+	})
+
+	t.Run("get teams of contest2 (no teams belongs)", func(t *testing.T) {
+		expectedTeams := []*domain.ContestTeam{}
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotTeams, err := repo.GetContestTeams(context.Background(), contest2.ID)
+		assert.NoError(t, err)
+		assert.ElementsMatch(t, expectedTeams, gotTeams)
+	})
 }
 
-func TestContestRepository_GetContestTeam(t *testing.T) {
+func Test_GetContestTeam(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
-	team1 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	team2 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
 
-	gotTeams1, err := repo.GetContestTeam(context.Background(), contest1.ID, team1.ID)
+	// contest1 has a team (team1)
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
+	assert.NoError(t, err)
+	team1, err := repo.CreateContestTeam(context.Background(), contest1.ID, random.CreateContestTeamArgs())
 	assert.NoError(t, err)
-	assert.Equal(t, team1, gotTeams1)
+	// contest2 has no teams
+	contest2, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
+	assert.NoError(t, err)
+
+	t.Run("get team1 (belongs to contest1)", func(t *testing.T) {
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotTeam1, err := repo.GetContestTeam(context.Background(), contest1.ID, team1.ID)
+		assert.NoError(t, err)
+		assert.Equal(t, team1, gotTeam1)
+	})
 
-	gotTeams2, err := repo.GetContestTeam(context.Background(), contest2.ID, team2.ID)
-	assert.Error(t, err)
-	assert.Nil(t, gotTeams2)
+	t.Run("cannot get team1 (doesn't belong to contest2)", func(t *testing.T) {
+		_, err := repo.GetContestTeam(context.Background(), contest2.ID, team1.ID)
+		assert.Error(t, err)
+		assert.Equal(t, err, repository.ErrNotFound)
+	})
 }
 
-// func TestCreateContestTeam(t *testing.T) {
-// }
+func Test_CreateContestTeam(t *testing.T) {}
 
-func TestContestRepository_UpdateContestTeam(t *testing.T) {
+func Test_UpdateContestTeam(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-
-	tests := []struct {
-		name string
-		ctx  context.Context
-		args *urepository.UpdateContestTeamArgs
-	}{
-		{
-			name: "all fields",
-			ctx:  context.Background(),
-			args: random.UpdateContestTeamArgs(),
-		},
-		{
-			name: "partial fields",
-			ctx:  context.Background(),
-			args: random.OptUpdateContestTeamArgs(),
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			contest := mustMakeContest(t, repo, nil)
-			team := mustMakeContestTeam(t, repo, contest.ID, &urepository.CreateContestTeamArgs{
-				Name:        random.AlphaNumeric(),
-				Result:      random.Optional(random.AlphaNumeric()),
-				Link:        random.Optional(random.RandURLString()),
-				Description: random.AlphaNumeric(),
-			})
-
-			args := tt.args
-			team.Name = args.Name.ValueOr(team.Name)
-			team.Result = args.Result.ValueOr(team.Result)
-			team.Link = args.Link.ValueOr(team.Link)
-			team.Description = args.Description.ValueOr(team.Description)
-
-			err := repo.UpdateContestTeam(tt.ctx, team.ID, args)
-			assert.NoError(t, err)
-
-			got, err := repo.GetContestTeam(tt.ctx, contest.ID, team.ID)
-			assert.NoError(t, err)
-			assert.Equal(t, team, got)
-		})
-	}
-}
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
 
-func TestContestRepository_DeleteContestTeam(t *testing.T) {
-	t.Parallel()
+	contest, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
+	assert.NoError(t, err)
+	team, err := repo.CreateContestTeam(context.Background(), contest.ID, random.CreateContestTeamArgs())
+	assert.NoError(t, err)
 
-	db := SetupTestGormDB(t)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
-	team1 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
+	t.Run("update all fields", func(t *testing.T) {
+		args := random.UpdateContestTeamArgs()
+		err := repo.UpdateContestTeam(context.Background(), team.ID, args)
+		assert.NoError(t, err)
+
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotTeam, err := repo.GetContestTeam(context.Background(), contest.ID, team.ID)
+		assert.NoError(t, err)
+
+		team.Name = args.Name.ValueOr(team.Name)
+		team.Result = args.Result.ValueOr(team.Result)
+		team.Link = args.Link.ValueOr(team.Link)
+		team.Description = args.Description.ValueOr(team.Description)
+		assert.Equal(t, team, gotTeam)
 	})
-	team2 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
+
+	t.Run("update no fields", func(t *testing.T) {
+		args := &repository.UpdateContestTeamArgs{}
+		err := repo.UpdateContestTeam(context.Background(), team.ID, args)
+		assert.NoError(t, err)
+
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotTeam, err := repo.GetContestTeam(context.Background(), contest.ID, team.ID)
+		assert.NoError(t, err)
+
+		assert.Equal(t, team, gotTeam)
 	})
+}
 
-	expected1 := []*domain.ContestTeam{&team1.ContestTeam, &team2.ContestTeam}
-	gotTeams1, err := repo.GetContestTeams(context.Background(), contest1.ID)
-	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected1, gotTeams1)
+func Test_DeleteContestTeam(t *testing.T) {
+	t.Parallel()
 
-	expected2 := []*domain.ContestTeam{}
-	gotTeams2, err := repo.GetContestTeams(context.Background(), contest2.ID)
-	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected2, gotTeams2)
+	db := SetupTestGormDB(t)
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
 
-	err = repo.DeleteContestTeam(context.Background(), contest1.ID, team1.ID)
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	expected3 := []*domain.ContestTeam{&team2.ContestTeam}
-	gotTeams3, err := repo.GetContestTeams(context.Background(), contest1.ID)
+	team1, err := repo.CreateContestTeam(context.Background(), contest1.ID, random.CreateContestTeamArgs())
 	assert.NoError(t, err)
-	assert.Equal(t, expected3, gotTeams3)
-
-	err = repo.DeleteContestTeam(context.Background(), contest1.ID, team2.ID)
+	team2, err := repo.CreateContestTeam(context.Background(), contest1.ID, random.CreateContestTeamArgs())
 	assert.NoError(t, err)
-	expected4 := []*domain.ContestTeam{}
-	gotTeams4, err := repo.GetContestTeams(context.Background(), contest1.ID)
+	contest2, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	assert.Equal(t, expected4, gotTeams4)
+
+	t.Run("delete team1 (belongs to contest1)", func(t *testing.T) {
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotTeam1, err := repo.GetContestTeam(context.Background(), contest1.ID, team1.ID)
+		assert.NoError(t, err)
+		assert.Equal(t, team1, gotTeam1)
+
+		err = repo.DeleteContestTeam(context.Background(), contest1.ID, team1.ID)
+		assert.NoError(t, err)
+
+		deletedTeam1, err := repo.GetContestTeam(context.Background(), contest1.ID, team1.ID)
+		assert.Nil(t, deletedTeam1)
+		assert.Equal(t, err, repository.ErrNotFound)
+	})
+
+	t.Run("delete of team1 doesn't affect team2", func(t *testing.T) {
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotTeam2, err := repo.GetContestTeam(context.Background(), contest1.ID, team2.ID)
+		assert.NoError(t, err)
+		assert.Equal(t, team2, gotTeam2)
+	})
+
+	t.Run("cannot delete team1 (doesn't belong to contest2)", func(t *testing.T) {
+		err := repo.DeleteContestTeam(context.Background(), contest2.ID, team1.ID)
+		assert.Error(t, err)
+		assert.Equal(t, err, repository.ErrNotFound)
+	})
 }
 
-func TestContestRepository_GetContestTeamMembers(t *testing.T) {
+func Test_GetContestTeamMembers(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	err := mockdata.InsertSampleDataToDB(db)
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
+	traqAPI := mock_external.NewMockTraQAPI(gomock.NewController(t))
+	userRepo := NewUserRepository(db, portalAPI, traqAPI)
+
+	// contest1 has a team (team1)
+	// team1 has two members (user1, user2)
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
-	team1 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	team2 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	team3 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	user1 := mockdata.MockUsers[1]
-	user2 := mockdata.MockUsers[2]
-	portalUser1 := mockdata.MockPortalUsers[1]
-	portalUser2 := mockdata.MockPortalUsers[2]
-
-	mustExistContestTeamMembers(t, repo, team1.ID, []uuid.UUID{user1.ID, user2.ID})
-	mustExistContestTeamMembers(t, repo, team2.ID, []uuid.UUID{user2.ID})
-
-	expected1 := []*domain.User{
-		domain.NewUser(user1.ID, user1.Name, portalUser1.RealName, user1.Check),
-		domain.NewUser(user2.ID, user2.Name, portalUser2.RealName, user2.Check),
-	}
-	users1, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team1.ID)
+	team1, err := repo.CreateContestTeam(context.Background(), contest1.ID, random.CreateContestTeamArgs())
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected1, users1)
-
-	expected2 := []*domain.User{
-		domain.NewUser(user2.ID, user2.Name, portalUser2.RealName, user2.Check),
-	}
-	users2, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team2.ID)
+	createUserArgs1 := random.CreateUserArgs()
+	portalAPI.EXPECT().GetUserByTraqID(createUserArgs1.Name).Return(&external.PortalUserResponse{}, nil)
+	user1, err := userRepo.CreateUser(context.Background(), createUserArgs1)
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected2, users2)
-
-	expected3 := []*domain.User{}
-	users3, err := repo.GetContestTeamMembers(context.Background(), contest2.ID, team3.ID)
+	createUserArgs2 := random.CreateUserArgs()
+	portalAPI.EXPECT().GetUserByTraqID(createUserArgs2.Name).Return(&external.PortalUserResponse{}, nil)
+	user2, err := userRepo.CreateUser(context.Background(), createUserArgs2)
+	assert.NoError(t, err)
+	memberIDs := []uuid.UUID{user1.ID, user2.ID}
+	err = repo.EditContestTeamMembers(context.Background(), team1.ID, memberIDs)
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected3, users3)
-}
 
-// func TestContestRepository_AddContestTeamMembers(t *testing.T) {
-// }
+	t.Run("get team1 members", func(t *testing.T) {
+		expectedMembers := []*domain.User{&user1.User, &user2.User}
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		gotMembers, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team1.ID)
+		assert.NoError(t, err)
+		assert.ElementsMatch(t, expectedMembers, gotMembers)
+	})
+}
 
-func TestContestRepository_EditContestTeamMembers(t *testing.T) {
+func Test_EditContestTeamMembers(t *testing.T) {
 	t.Parallel()
 
 	db := SetupTestGormDB(t)
-	err := mockdata.InsertSampleDataToDB(db)
+	portalAPI := mock_external.NewMockPortalAPI(gomock.NewController(t))
+	repo := NewContestRepository(db, portalAPI)
+	traqAPI := mock_external.NewMockTraQAPI(gomock.NewController(t))
+	userRepo := NewUserRepository(db, portalAPI, traqAPI)
+
+	// contest1 has a team (team1)
+	// team1 has a member (user1)
+	contest1, err := repo.CreateContest(context.Background(), random.CreateContestArgs())
 	assert.NoError(t, err)
-	repo := NewContestRepository(db, mock_external_e2e.NewMockPortalAPI())
-
-	contest1 := mustMakeContest(t, repo, nil)
-	contest2 := mustMakeContest(t, repo, nil)
-	team1 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	team2 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	team3 := mustMakeContestTeam(t, repo, contest1.ID, &urepository.CreateContestTeamArgs{
-		Name:        random.AlphaNumeric(),
-		Result:      random.Optional(random.AlphaNumeric()),
-		Link:        random.Optional(random.RandURLString()),
-		Description: random.AlphaNumeric(),
-	})
-	user1 := mockdata.MockUsers[1]
-	user2 := mockdata.MockUsers[2]
-	portalUser1 := mockdata.MockPortalUsers[1]
-	portalUser2 := mockdata.MockPortalUsers[2]
-
-	mustExistContestTeamMembers(t, repo, team1.ID, []uuid.UUID{user1.ID, user2.ID})
-	mustExistContestTeamMembers(t, repo, team2.ID, []uuid.UUID{user2.ID})
-
-	expected1 := []*domain.User{
-		domain.NewUser(user1.ID, user1.Name, portalUser1.RealName, user1.Check),
-		domain.NewUser(user2.ID, user2.Name, portalUser2.RealName, user2.Check),
-	}
-	users1, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team1.ID)
+	team1, err := repo.CreateContestTeam(context.Background(), contest1.ID, random.CreateContestTeamArgs())
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected1, users1)
-
-	expected2 := []*domain.User{
-		domain.NewUser(user2.ID, user2.Name, portalUser2.RealName, user2.Check),
-	}
-	users2, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team2.ID)
+	createUserArgs1 := random.CreateUserArgs()
+	portalAPI.EXPECT().GetUserByTraqID(createUserArgs1.Name).Return(&external.PortalUserResponse{}, nil)
+	user1, err := userRepo.CreateUser(context.Background(), createUserArgs1)
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected2, users2)
-
-	expected3 := []*domain.User{}
-	users3, err := repo.GetContestTeamMembers(context.Background(), contest2.ID, team3.ID)
+	memberIDs := []uuid.UUID{user1.ID}
+	err = repo.EditContestTeamMembers(context.Background(), team1.ID, memberIDs)
 	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected3, users3)
 
-	expected4 := []*domain.User{
-		domain.NewUser(user2.ID, user2.Name, portalUser2.RealName, user2.Check),
-	}
-	err = repo.EditContestTeamMembers(context.Background(), team1.ID, []uuid.UUID{user2.ID})
-	assert.NoError(t, err)
-	users4, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team1.ID)
-	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected4, users4)
+	t.Run("edit team1 members", func(t *testing.T) {
+		portalAPI.EXPECT().GetUsers().Return([]*external.PortalUserResponse{}, nil)
+		err := repo.EditContestTeamMembers(context.Background(), team1.ID, []uuid.UUID{})
+		assert.NoError(t, err)
 
-	expected5 := []*domain.User{}
-	err = repo.EditContestTeamMembers(context.Background(), team1.ID, []uuid.UUID{})
-	assert.NoError(t, err)
-	users5, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team1.ID)
-	assert.NoError(t, err)
-	assert.ElementsMatch(t, expected5, users5)
+		expectedMembers := []*domain.User{}
+		gotMembers, err := repo.GetContestTeamMembers(context.Background(), contest1.ID, team1.ID)
+		assert.NoError(t, err)
+		assert.ElementsMatch(t, expectedMembers, gotMembers)
+	})
 }
diff --git a/util/random/repository.go b/util/random/repository.go
index bbe4e121..d7398915 100644
--- a/util/random/repository.go
+++ b/util/random/repository.go
@@ -2,12 +2,24 @@ package random
 
 import (
 	"math/rand/v2"
+	"time"
 
 	"github.com/traPtitech/traPortfolio/domain"
 	"github.com/traPtitech/traPortfolio/usecases/repository"
 	"github.com/traPtitech/traPortfolio/util/optional"
 )
 
+// CreateContestArgs
+func CreateContestArgs() *repository.CreateContestArgs {
+	return &repository.CreateContestArgs{
+		Name:        AlphaNumeric(),
+		Description: AlphaNumeric(),
+		Link:        Optional(RandURLString()),
+		Since:       time.Now(),
+		Until:       Optional(time.Now().Add(time.Hour)),
+	}
+}
+
 // UpdateContestArgs 全てのフィールドがvalidなUpdateContestArgsを生成します
 func UpdateContestArgs() *repository.UpdateContestArgs {
 	a := repository.UpdateContestArgs{
@@ -20,16 +32,14 @@ func UpdateContestArgs() *repository.UpdateContestArgs {
 	return &a
 }
 
-// OptUpdateContestArgs validかどうかも含めてランダムなUpdateContestArgsを生成します
-func OptUpdateContestArgs() *repository.UpdateContestArgs {
-	a := repository.UpdateContestArgs{
-		Name:        Optional(AlphaNumeric()),
-		Description: Optional(AlphaNumeric()),
+// CreateContestTeamArgs
+func CreateContestTeamArgs() *repository.CreateContestTeamArgs {
+	return &repository.CreateContestTeamArgs{
+		Name:        AlphaNumeric(),
+		Result:      Optional(AlphaNumeric()),
 		Link:        Optional(RandURLString()),
-		Since:       Optional(Time()),
-		Until:       Optional(Time()),
+		Description: AlphaNumeric(),
 	}
-	return &a
 }
 
 // UpdateContestTeamArgs 全てのフィールドがvalidなUpdateContestTeamArgsを生成します
@@ -82,6 +92,15 @@ func OptUpdateProjectArgs() *repository.UpdateProjectArgs {
 	return &a
 }
 
+// CreateUserArgs
+func CreateUserArgs() *repository.CreateUserArgs {
+	return &repository.CreateUserArgs{
+		Description: AlphaNumeric(),
+		Check:       Bool(),
+		Name:        AlphaNumeric(),
+	}
+}
+
 // UpdateUserArgs 全てのフィールドがvalidなUpdateUserArgsを生成します
 func UpdateUserArgs() *repository.UpdateUserArgs {
 	a := repository.UpdateUserArgs{