package database import ( "context" "fmt" "reflect" "testing" "git.dragse.it/anthrove/otter-space-sdk/internal/postgres" "git.dragse.it/anthrove/otter-space-sdk/pkg/models" "git.dragse.it/anthrove/otter-space-sdk/test" "gorm.io/gorm" ) func TestNewPostgresqlConnection(t *testing.T) { // Test tests := []struct { name string want OtterSpace }{ { name: "Test 1: Create new postgresql connection", want: nil, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if tt.want != NewPostgresqlConnection() { } else { t.Errorf("NewPostgresqlConnection() = %s", tt.want) } }) } } func Test_postgresqlConnection_Connect(t *testing.T) { // Setup trow away container ctx := context.Background() container, _, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Tests dbConfig, err := test.DatabaseModesFromConnectionString(ctx, container) if err != nil { t.Fatalf("Could not parse database config: %v", err) } // Test type args struct { in0 context.Context config models.DatabaseConfig } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Connect to postgresql connection", args: args{ in0: ctx, config: *dbConfig, }, wantErr: false, }, { name: "Test 1: Empty connection config", args: args{ in0: ctx, config: models.DatabaseConfig{}, }, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{} if err := p.Connect(tt.args.in0, tt.args.config); (err != nil) != tt.wantErr { t.Errorf("Connect() error = %v, wantErr %v", err, tt.wantErr) } }) } } func Test_postgresqlConnection_CreateUserWithRelationToSource(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validSourceID1 := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1")) source := &models.Source{ BaseModel: models.BaseModel[models.AnthroveSourceID]{ID: validSourceID1}, DisplayName: "e621", Domain: "e621.net", Icon: "icon.e621.net", } err = postgres.CreateSource(ctx, gormDB, source) if err != nil { t.Fatal(err) } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID sourceID models.AnthroveSourceID accountId string accountUsername string } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Valid anthroveUserID, sourceID, accountId, accountUsername", args: args{ ctx: ctx, anthroveUserID: validUserID, sourceID: source.ID, accountId: "e1", accountUsername: "marius", }, wantErr: false, }, { name: "Test 2: Invalid anthroveUserID, valid sourceID, accountId, accountUsername", args: args{ ctx: ctx, anthroveUserID: "2", sourceID: source.ID, accountId: "e1", accountUsername: "marius", }, wantErr: true, }, { name: "Test 3: Empty anthroveUserID", args: args{ ctx: ctx, anthroveUserID: "", sourceID: source.ID, accountId: "e1", accountUsername: "marius", }, wantErr: true, }, { name: "Test 4: invalid sourceID", args: args{ ctx: ctx, anthroveUserID: validUserID, sourceID: "fa.net", accountId: "e1", accountUsername: "marius", }, wantErr: true, }, { name: "Test 5: no accountId", args: args{ ctx: ctx, anthroveUserID: validUserID, sourceID: source.ID, accountId: "", accountUsername: "marius", }, wantErr: true, }, { name: "Test 6: no accountUsername", args: args{ ctx: ctx, anthroveUserID: validUserID, sourceID: source.ID, accountId: "aa", accountUsername: "", }, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } if err := p.CreateUserWithRelationToSource(tt.args.ctx, tt.args.anthroveUserID, tt.args.sourceID, tt.args.accountId, tt.args.accountUsername); (err != nil) != tt.wantErr { t.Errorf("CreateUserWithRelationToSource() error = %v, wantErr %v", err, tt.wantErr) } }) } } func Test_postgresqlConnection_CreateSource(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validSource := &models.Source{ DisplayName: "e621", Domain: "e621.net", Icon: "icon.e621.net", } invalidSource := &models.Source{ Domain: "", } // Test type args struct { ctx context.Context anthroveSource *models.Source } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Valid anthroveSource", args: args{ ctx: ctx, anthroveSource: validSource, }, wantErr: false, }, { name: "Test 2: inValid anthroveSource", args: args{ ctx: ctx, anthroveSource: invalidSource, }, wantErr: true, }, { name: "Test 3: unique anthroveSource", args: args{ ctx: ctx, anthroveSource: validSource, }, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } if err := p.CreateSource(tt.args.ctx, tt.args.anthroveSource); (err != nil) != tt.wantErr { t.Errorf("CreateSource() error = %v, wantErr %v", err, tt.wantErr) } }) } } func Test_postgresqlConnection_CreatePost(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Tests validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) validPost := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } invalidPost := &models.Post{ Rating: "error", } // Test type args struct { ctx context.Context anthrovePost *models.Post } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Valid AnthrovePostID and Rating", args: args{ ctx: context.Background(), anthrovePost: validPost, }, wantErr: false, }, { name: "Test 2: Invalid Rating", args: args{ ctx: context.Background(), anthrovePost: invalidPost, }, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } if err := p.CreatePost(tt.args.ctx, tt.args.anthrovePost); (err != nil) != tt.wantErr { t.Errorf("CreatePost() error = %v, wantErr %v", err, tt.wantErr) } }) } } func Test_postgresqlConnection_CreateTagAndReferenceToPost(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) post := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } err = postgres.CreatePost(ctx, gormDB, post) if err != nil { t.Fatal(err) } tag := &models.Tag{ Name: "JayTheFerret", Type: "artist", } // Test type args struct { ctx context.Context anthrovePostID models.AnthrovePostID anthroveTag *models.Tag } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Valid PostID and Tag", args: args{ ctx: ctx, anthrovePostID: post.ID, anthroveTag: tag, }, wantErr: false, }, { name: "Test 2: Valid PostID and no Tag", args: args{ ctx: ctx, anthrovePostID: post.ID, anthroveTag: nil, }, wantErr: true, }, { name: "Test 3: Invalid PostID and valid Tag", args: args{ ctx: ctx, anthrovePostID: "123456", anthroveTag: tag, }, wantErr: true, }, { name: "Test 4: No PostID and valid Tag", args: args{ ctx: ctx, anthrovePostID: "", anthroveTag: tag, }, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } if err := p.CreateTagAndReferenceToPost(tt.args.ctx, tt.args.anthrovePostID, tt.args.anthroveTag); (err != nil) != tt.wantErr { t.Errorf("CreateTagAndReferenceToPost() error = %v, wantErr %v", err, tt.wantErr) } }) } } func Test_postgresqlConnection_CreateReferenceBetweenPostAndSource(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) validSourceID1 := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1")) post := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } source := &models.Source{ BaseModel: models.BaseModel[models.AnthroveSourceID]{ID: validSourceID1}, DisplayName: "e621", Domain: "e621.net", Icon: "icon.e621.net", } err = postgres.CreatePost(ctx, gormDB, post) if err != nil { t.Fatal(err) } err = postgres.CreateSource(ctx, gormDB, source) if err != nil { t.Fatal(err) } // Test type args struct { ctx context.Context anthrovePostID models.AnthrovePostID sourceDomain models.AnthroveSourceDomain postURl models.AnthrovePostURL } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Valid AnthrovePostID and anthroveSourceDomain", args: args{ ctx: ctx, anthrovePostID: post.ID, sourceDomain: "e621.net", postURl: "http://e621.net/post/eeasd", }, wantErr: false, }, { name: "Test 2: Invalid AnthrovePostID and Valid anthroveSourceDomain", args: args{ ctx: ctx, anthrovePostID: "123456", sourceDomain: "e621.net", postURl: "", }, wantErr: true, }, { name: "Test 3: Invalid anthroveSourceDomain and Valid AnthrovePostID", args: args{ ctx: ctx, anthrovePostID: "1234", sourceDomain: "fa.banana", postURl: "", }, wantErr: true, }, { name: "Test 4: Invalid anthroveSourceDomain and Invalid AnthrovePostID", args: args{ ctx: ctx, anthrovePostID: "696969", postURl: "", }, wantErr: true, }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } if err := p.CreateReferenceBetweenPostAndSource(tt.args.ctx, tt.args.anthrovePostID, tt.args.sourceDomain, tt.args.postURl); (err != nil) != tt.wantErr { t.Errorf("CreateReferenceBetweenPostAndSource() error = %v, wantErr %v", err, tt.wantErr) } }) } } func Test_postgresqlConnection_CreateReferenceBetweenUserAndPost(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) err = postgres.CreateUser(ctx, gormDB, validUserID) if err != nil { t.Fatal(err) } post := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } err = postgres.CreatePost(ctx, gormDB, post) if err != nil { t.Fatal(err) } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID anthrovePostID models.AnthrovePostID } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Valid AnthroveUserID and AnthrovePostID", args: args{ ctx: ctx, anthroveUserID: validUserID, anthrovePostID: post.ID, }, wantErr: false, }, { name: "Test 2: Valid AnthroveUserID and invalid AnthrovePostID", args: args{ ctx: ctx, anthroveUserID: validUserID, anthrovePostID: "123456", }, wantErr: true, }, { name: "Test 3: Valid AnthrovePostID and invalid AnthroveUserID", args: args{ ctx: ctx, anthroveUserID: "123", anthrovePostID: "1234", }, wantErr: true, }, { name: "Test 4: Invalid AnthrovePostID and invalid AnthroveUserID", args: args{ ctx: ctx, anthroveUserID: "123", anthrovePostID: "123456", }, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } if err := p.CreateReferenceBetweenUserAndPost(tt.args.ctx, tt.args.anthroveUserID, tt.args.anthrovePostID); (err != nil) != tt.wantErr { t.Errorf("CreateReferenceBetweenUserAndPost() error = %v, wantErr %v", err, tt.wantErr) } }) } } func Test_postgresqlConnection_CheckReferenceBetweenUserAndPost(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) err = postgres.CreateUser(ctx, gormDB, validUserID) if err != nil { t.Fatal(err) } post := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } err = postgres.CreatePost(ctx, gormDB, post) if err != nil { t.Fatal(err) } err = postgres.CreateReferenceBetweenUserAndPost(ctx, gormDB, validUserID, post.ID) if err != nil { t.Fatal(err) } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID anthrovePostID models.AnthrovePostID } tests := []struct { name string args args want bool wantErr bool }{ { name: "Test 1: Valid AnthroveUserID and AnthrovePostID", args: args{ ctx: ctx, anthroveUserID: validUserID, anthrovePostID: post.ID, }, want: true, wantErr: false, }, { name: "Test 2: Valid AnthroveUserID and invalid AnthrovePostID", args: args{ ctx: ctx, anthroveUserID: validUserID, anthrovePostID: "qadw", }, want: false, wantErr: true, }, { name: "Test 3: Valid AnthrovePostID and invalid AnthroveUserID", args: args{ ctx: ctx, anthroveUserID: "123", anthrovePostID: post.ID, }, want: false, wantErr: true, }, { name: "Test 4: Invalid AnthrovePostID and invalid AnthroveUserID", args: args{ ctx: ctx, anthroveUserID: "123", anthrovePostID: "123456", }, want: false, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.CheckReferenceBetweenUserAndPost(tt.args.ctx, tt.args.anthroveUserID, tt.args.anthrovePostID) if (err != nil) != tt.wantErr { t.Errorf("CheckReferenceBetweenUserAndPost() error = %v, wantErr %v", err, tt.wantErr) return } if got != tt.want { t.Errorf("CheckReferenceBetweenUserAndPost() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetPostByAnthroveID(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Tests validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) post := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } err = postgres.CreatePost(ctx, gormDB, post) if err != nil { t.Fatal("Could not create post", err) } // Test type args struct { ctx context.Context anthrovePost models.AnthrovePostID } tests := []struct { name string args args want *models.Post wantErr bool }{ { name: "Test 1: Valid anthrovePostID", args: args{ ctx: ctx, anthrovePost: post.ID, }, want: post, wantErr: false, }, { name: "Test 2: No anthrovePostID", args: args{ ctx: ctx, anthrovePost: "nil", }, want: nil, wantErr: true, }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetPostByAnthroveID(tt.args.ctx, tt.args.anthrovePost) if (err != nil) != tt.wantErr { t.Errorf("GetPostByAnthroveID() error = %v, wantErr %v", err, tt.wantErr) return } if !checkPost(got, tt.want) { t.Errorf("GetPostByAnthroveID() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetPostByURL(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Tests validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) post := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } err = postgres.CreatePost(ctx, gormDB, post) if err != nil { t.Fatal("Could not create post", err) } source := models.Source{ BaseModel: models.BaseModel[models.AnthroveSourceID]{ ID: models.AnthroveSourceID(fmt.Sprintf("%025s", "1")), }, DisplayName: "e621", Domain: "e621.net", Icon: "https://e621.net/icon.ico", } err = postgres.CreateSource(ctx, gormDB, &source) if err != nil { t.Fatal("Could not create source", err) } err = postgres.CreateReferenceBetweenPostAndSource(ctx, gormDB, post.ID, models.AnthroveSourceDomain(source.Domain), "https://e62asdwad.com/asdas") if err != nil { t.Fatal("Could not create source reference", err) } // Test type args struct { ctx context.Context sourceUrl string } tests := []struct { name string args args want *models.Post wantErr bool }{ { name: "Test 1: Valid sourceUrl", args: args{ ctx: ctx, sourceUrl: "https://e62asdwad.com/asdas", }, want: post, wantErr: false, }, { name: "Test 2: Invalid sourceUrl", args: args{ ctx: ctx, sourceUrl: "1234", }, want: nil, wantErr: true, }, { name: "Test 3: No sourceUrl", args: args{ ctx: ctx, sourceUrl: "", }, want: nil, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetPostByURL(tt.args.ctx, tt.args.sourceUrl) if (err != nil) != tt.wantErr { t.Errorf("GetPostByURL() error = %v, wantErr %v", err, tt.wantErr) return } if !checkPost(got, tt.want) { t.Errorf("GetPostByURL() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetPostBySourceID(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Tests validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) validSourceID1 := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1")) post := &models.Post{ BaseModel: models.BaseModel[models.AnthrovePostID]{ ID: validPostID1, }, Rating: "safe", } source := models.Source{ BaseModel: models.BaseModel[models.AnthroveSourceID]{ ID: validSourceID1, }, DisplayName: "e621", Domain: "e621.net", Icon: "https://e621.net/icon.ico", } err = postgres.CreatePost(ctx, gormDB, post) if err != nil { t.Fatal("Could not create post", err) } err = postgres.CreateSource(ctx, gormDB, &source) if err != nil { t.Fatal("Could not create source", err) } err = postgres.CreateReferenceBetweenPostAndSource(ctx, gormDB, post.ID, models.AnthroveSourceDomain(source.Domain), "https://easd15aed.de/asd") if err != nil { t.Fatal("Could not create source reference", err) } // Test type args struct { ctx context.Context sourceID models.AnthroveSourceID } tests := []struct { name string args args want *models.Post wantErr bool }{ { name: "Test 1: Valid sourceID", args: args{ ctx: ctx, sourceID: source.ID, }, want: post, wantErr: false, }, { name: "Test 2: Invalid sourceID", args: args{ ctx: ctx, sourceID: "1234", }, want: nil, wantErr: true, }, { name: "Test 3: No sourceID", args: args{ ctx: ctx, sourceID: "", }, want: nil, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetPostBySourceID(tt.args.ctx, tt.args.sourceID) if (err != nil) != tt.wantErr { t.Errorf("GetPostBySourceID() error = %v, wantErr %v", err, tt.wantErr) return } if !checkPost(got, tt.want) { t.Errorf("GetPostBySourceID() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetUserFavoritesCount(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) validPostID2 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post2")) validPostID3 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post3")) validPostID4 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post4")) validPostID5 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post5")) validPostID6 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post6")) expectedResultPosts := []models.Post{ { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID1}, Rating: "safe", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID2}, Rating: "safe", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID3}, Rating: "explicit", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID4}, Rating: "explicit", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID5}, Rating: "questionable", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID6}, Rating: "safe", }, } err = postgres.CreateUser(ctx, gormDB, validAnthroveUserID) if err != nil { t.Fatal(err) } for _, post := range expectedResultPosts { err = postgres.CreatePost(ctx, gormDB, &post) if err != nil { t.Fatal(err) } err = postgres.CreateReferenceBetweenUserAndPost(ctx, gormDB, validAnthroveUserID, post.ID) if err != nil { t.Fatal(err) } } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID } tests := []struct { name string args args want int64 wantErr bool }{ { name: "Test 1: Valid anthroveUserID and 6 favorite posts", args: args{ ctx: ctx, anthroveUserID: validAnthroveUserID, }, want: 6, wantErr: false, }, { name: "Test 2: Invalid anthroveUserID and 6 favorite posts", args: args{ ctx: ctx, anthroveUserID: "2", }, want: 0, wantErr: true, }, { name: "Test 3: no anthroveUserID and 6 favorite posts", args: args{ ctx: ctx, anthroveUserID: "", }, want: 0, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetUserFavoritesCount(tt.args.ctx, tt.args.anthroveUserID) if (err != nil) != tt.wantErr { t.Errorf("GetUserFavoritesCount() error = %v, wantErr %v", err, tt.wantErr) return } if got != tt.want { t.Errorf("GetUserFavoritesCount() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetUserSourceLinks(t *testing.T) { // Setup trow away containert ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validSourceID1 := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1")) validSourceID2 := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source2")) eSource := &models.Source{ BaseModel: models.BaseModel[models.AnthroveSourceID]{ID: validSourceID1}, DisplayName: "e621", Domain: "e621.net", } err = postgres.CreateSource(ctx, gormDB, eSource) if err != nil { t.Fatal(err) } faSource := &models.Source{ BaseModel: models.BaseModel[models.AnthroveSourceID]{ID: validSourceID2}, DisplayName: "fa", Domain: "fa.net", } err = postgres.CreateSource(ctx, gormDB, faSource) if err != nil { t.Fatal(err) } expectedResult := make(map[string]models.UserSource) expectedResult["e621"] = models.UserSource{ UserID: "e1", AccountUsername: "e621-user", Source: models.Source{ DisplayName: eSource.DisplayName, Domain: eSource.Domain, }, } expectedResult["fa"] = models.UserSource{ UserID: "fa1", AccountUsername: "fa-user", Source: models.Source{ DisplayName: faSource.DisplayName, Domain: faSource.Domain, }, } err = postgres.CreateUserWithRelationToSource(ctx, gormDB, validAnthroveUserID, eSource.ID, expectedResult["e621"].UserID, expectedResult["e621"].AccountUsername) if err != nil { t.Fatal(err) } err = postgres.CreateUserWithRelationToSource(ctx, gormDB, validAnthroveUserID, faSource.ID, expectedResult["fa"].UserID, expectedResult["fa"].AccountUsername) if err != nil { t.Fatal(err) } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID } tests := []struct { name string args args want map[string]models.UserSource wantErr bool }{ { name: "Test 1: Get Data", args: args{ ctx: ctx, anthroveUserID: validAnthroveUserID, }, want: expectedResult, wantErr: false, }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetUserSourceLinks(tt.args.ctx, tt.args.anthroveUserID) if (err != nil) != tt.wantErr { t.Errorf("GetUserSourceLinks() error = %v, wantErr %v", err, tt.wantErr) return } if !reflect.DeepEqual(got, tt.want) { t.Errorf("GetUserSourceLinks() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetUserSourceBySourceID(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) invalidUserID := models.AnthroveUserID("XXX") validSourceID := models.AnthroveSourceID(fmt.Sprintf("%025s", "Source1")) expectedResult := make(map[string]models.UserSource) source := &models.Source{ BaseModel: models.BaseModel[models.AnthroveSourceID]{ ID: validSourceID, }, DisplayName: "e621", Domain: "e621.net", } expectedResult["e621"] = models.UserSource{ UserID: "e1", AccountUsername: "euser", Source: models.Source{ DisplayName: source.DisplayName, Domain: source.Domain, Icon: source.Icon, }, } err = postgres.CreateSource(ctx, gormDB, source) if err != nil { t.Fatal(err) } err = postgres.CreateUserWithRelationToSource(ctx, gormDB, validUserID, validSourceID, expectedResult["e621"].UserID, expectedResult["e621"].AccountUsername) if err != nil { t.Fatal(err) } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID sourceID models.AnthroveSourceID } tests := []struct { name string args args want map[string]models.UserSource wantErr bool }{ { name: "Test 1: Valid AnthroveUserID and sourceID", args: args{ ctx: ctx, anthroveUserID: validUserID, sourceID: source.ID, }, want: expectedResult, wantErr: false, }, { name: "Test 2: Invalid AnthroveUserID and valid sourceID", args: args{ ctx: ctx, anthroveUserID: invalidUserID, sourceID: source.ID, }, want: nil, wantErr: true, }, { name: "Test 3: Valid AnthroveUserID and invalid sourceID", args: args{ ctx: ctx, anthroveUserID: validUserID, sourceID: "fa", }, want: nil, wantErr: true, }, { name: "Test 4: No AnthroveUserID and Valid sourceID", args: args{ ctx: ctx, anthroveUserID: "", sourceID: source.ID, }, want: nil, wantErr: true, }, { name: "Test 5: Valid AnthroveUserID and No SourceDisplayName", args: args{ ctx: ctx, anthroveUserID: "1", sourceID: "", }, want: nil, wantErr: true, }, { name: "Test 6: No AnthroveUserID and No SourceDisplayName", args: args{ ctx: ctx, anthroveUserID: "", sourceID: "", }, want: nil, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetUserSourceBySourceID(tt.args.ctx, tt.args.anthroveUserID, tt.args.sourceID) if (err != nil) != tt.wantErr { t.Errorf("GetUserSourceBySourceID() error = %v, wantErr %v", err, tt.wantErr) return } if !reflect.DeepEqual(got, tt.want) { t.Errorf("GetUserSourceBySourceID() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetAllAnthroveUserIDs(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validUserID01 := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validUserID02 := models.AnthroveUserID(fmt.Sprintf("%025s", "User2")) validUserID03 := models.AnthroveUserID(fmt.Sprintf("%025s", "User3")) users := []models.AnthroveUserID{validUserID01, validUserID02, validUserID03} for _, user := range users { err = postgres.CreateUser(ctx, gormDB, user) if err != nil { t.Fatal(err) } } // Test type args struct { ctx context.Context } tests := []struct { name string args args want []models.AnthroveUserID wantErr bool }{ { name: "Test 1: Get Data", args: args{ ctx: ctx, }, want: users, wantErr: false, }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetAllAnthroveUserIDs(tt.args.ctx) if (err != nil) != tt.wantErr { t.Errorf("GetAllAnthroveUserIDs() error = %v, wantErr %v", err, tt.wantErr) return } if !reflect.DeepEqual(got, tt.want) { t.Errorf("GetAllAnthroveUserIDs() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetUserFavoriteWithPagination(t *testing.T) { // Setup trow away containert ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) validPostID2 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post2")) validPostID3 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post3")) validPostID4 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post4")) validPostID5 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post5")) validPostID6 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post6")) expectedResultPosts := []models.Post{ { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID1}, Rating: "safe", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID2}, Rating: "safe", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID3}, Rating: "explicit", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID4}, Rating: "explicit", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID5}, Rating: "questionable", }, { BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID6}, Rating: "safe", }, } expectedResult := &models.FavoriteList{ Posts: expectedResultPosts, } expectedResult2 := &models.FavoriteList{ Posts: expectedResultPosts[2:], } expectedResult3 := &models.FavoriteList{ Posts: expectedResultPosts[:3], } err = postgres.CreateUser(ctx, gormDB, validAnthroveUserID) if err != nil { t.Fatal(err) } for _, expectedResultPost := range expectedResultPosts { err = postgres.CreatePost(ctx, gormDB, &expectedResultPost) if err != nil { t.Fatal(err) } err = postgres.CreateReferenceBetweenUserAndPost(ctx, gormDB, validAnthroveUserID, expectedResultPost.ID) if err != nil { t.Fatal(err) } } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID skip int limit int } tests := []struct { name string args args want *models.FavoriteList wantErr bool }{ { name: "Test 1: Valid AnthroveUserID", args: args{ ctx: ctx, anthroveUserID: validAnthroveUserID, skip: 0, limit: 2000, }, want: expectedResult, wantErr: false, }, { name: "Test 2: Skip first two", args: args{ ctx: ctx, anthroveUserID: validAnthroveUserID, skip: 2, limit: 2000, }, want: expectedResult2, wantErr: false, }, { name: "Test 3: Limit of 3", args: args{ ctx: ctx, anthroveUserID: validAnthroveUserID, skip: 0, limit: 3, }, want: expectedResult3, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetUserFavoriteWithPagination(tt.args.ctx, tt.args.anthroveUserID, tt.args.skip, tt.args.limit) if (err != nil) != tt.wantErr { t.Errorf("GetUserFavoriteWithPagination() error = %v, wantErr %v", err, tt.wantErr) return } if !reflect.DeepEqual(got, tt.want) { t.Errorf("GetUserFavoriteWithPagination() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetUserTagWitRelationToFavedPosts(t *testing.T) { // Setup trow away containert ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test validAnthroveUserID := models.AnthroveUserID(fmt.Sprintf("%025s", "User1")) validPostID1 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post1")) validPostID2 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post2")) validPostID3 := models.AnthrovePostID(fmt.Sprintf("%025s", "Post3")) err = postgres.CreateUser(ctx, gormDB, validAnthroveUserID) if err != nil { t.Fatal(err) } posts := []models.Post{ {BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID1}, Rating: "safe"}, {BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID2}, Rating: "safe"}, {BaseModel: models.BaseModel[models.AnthrovePostID]{ID: validPostID3}, Rating: "explicit"}, } for _, post := range posts { err = postgres.CreatePost(ctx, gormDB, &post) if err != nil { t.Fatal(err) } err = postgres.CreateReferenceBetweenUserAndPost(ctx, gormDB, validAnthroveUserID, models.AnthrovePostID(post.ID)) if err != nil { t.Fatal(err) } } tags := []models.Tag{ {Name: "JayTheFerret", Type: "artist"}, {Name: "Ferret", Type: "species"}, {Name: "Jay", Type: "character"}, } for i, tag := range tags { err = postgres.CreateTagAndReferenceToPost(ctx, gormDB, posts[i].ID, &tag) if err != nil { t.Fatal(err) } } expectedResult := []models.TagsWithFrequency{ { Frequency: 1, Tags: models.Tag{ Name: tags[0].Name, Type: tags[0].Type, }, }, { Frequency: 1, Tags: models.Tag{ Name: tags[2].Name, Type: tags[2].Type, }, }, { Frequency: 1, Tags: models.Tag{ Name: tags[1].Name, Type: tags[1].Type, }, }, } // Test type args struct { ctx context.Context anthroveUserID models.AnthroveUserID } tests := []struct { name string args args want []models.TagsWithFrequency wantErr bool }{ { name: "Test 1: Get Data", args: args{ ctx: ctx, anthroveUserID: validAnthroveUserID, }, want: expectedResult, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetUserTagWitRelationToFavedPosts(tt.args.ctx, tt.args.anthroveUserID) if (err != nil) != tt.wantErr { t.Errorf("GetUserTagWitRelationToFavedPosts() error = %v, wantErr %v", err, tt.wantErr) return } if !reflect.DeepEqual(got, tt.want) { t.Errorf("GetUserTagWitRelationToFavedPosts() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetAllTags(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test tags := []models.Tag{ { Name: "JayTheFerret", Type: "artist", }, { Name: "anthro", Type: "general", }, { Name: "soxx", Type: "character", }, } for _, tag := range tags { err = postgres.CreateTag(ctx, gormDB, &tag) if err != nil { t.Fatal(err) } } // Test type args struct { ctx context.Context } tests := []struct { name string args args want []models.Tag wantErr bool }{ { name: "Test 1: Get Tags", args: args{ ctx: ctx, }, want: tags, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetAllTags(tt.args.ctx) if (err != nil) != tt.wantErr { t.Errorf("GetAllTags() error = %v, wantErr %v", err, tt.wantErr) return } if !reflect.DeepEqual(got, tt.want) { t.Errorf("GetAllTags() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetAllSources(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test sources := []models.Source{ { DisplayName: "e621", Domain: "e621.net", Icon: "icon.e621.net", }, { DisplayName: "furaffinity", Domain: "furaffinity.net", Icon: "icon.furaffinity.net", }, { DisplayName: "fenpaws", Domain: "fenpa.ws", Icon: "icon.fenpa.ws", }, } for _, source := range sources { err = postgres.CreateSource(ctx, gormDB, &source) if err != nil { t.Fatal(err) } } // Test type args struct { ctx context.Context } tests := []struct { name string args args want []models.Source wantErr bool }{ { name: "Test 1: Get all entries", args: args{ ctx: ctx, }, want: sources, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetAllSources(tt.args.ctx) if (err != nil) != tt.wantErr { t.Errorf("GetAllSources() error = %v, wantErr %v", err, tt.wantErr) return } if !checkSources(got, tt.want) { t.Errorf("GetAllSources() got = %v, want %v", got, tt.want) } }) } } func Test_postgresqlConnection_GetSourceByDomain(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test source := &models.Source{ DisplayName: "e621", Domain: "e621.net", Icon: "icon.e621.net", } err = postgres.CreateSource(ctx, gormDB, source) if err != nil { t.Fatal(err) } // Test type args struct { ctx context.Context sourceDomain models.AnthroveSourceDomain } tests := []struct { name string args args want *models.Source wantErr bool }{ { name: "Test 1: Valid URL", args: args{ ctx: ctx, sourceDomain: "e621.net", }, want: source, wantErr: false, }, { name: "Test 2: Invalid URL", args: args{ ctx: ctx, sourceDomain: "eeeee.net", }, want: nil, wantErr: true, }, { name: "Test 2: No URL", args: args{ ctx: ctx, sourceDomain: "", }, want: nil, wantErr: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } got, err := p.GetSourceByDomain(tt.args.ctx, tt.args.sourceDomain) if (err != nil) != tt.wantErr { t.Errorf("GetSourceByDomain() error = %v, wantErr %v", err, tt.wantErr) return } if !checkSource(got, tt.want) { t.Errorf("GetSourceByDomain() got = %v, want %v", got, tt.want) } }) } } func checkSource(got *models.Source, want *models.Source) bool { if want == nil && got == nil { return true } if got.Domain != want.Domain { return false } return true } func checkPost(got *models.Post, want *models.Post) bool { if got == nil && want == nil { return true } else if got == nil || want == nil { return false } if got.ID != want.ID { return false } if got.Rating != want.Rating { return false } return true } func checkSources(got []models.Source, want []models.Source) bool { for i, source := range want { if source.DisplayName != got[i].DisplayName { return false } if source.Domain != got[i].Domain { return false } if source.Icon != got[i].Icon { return false } } return true } func Test_postgresqlConnection_migrateDatabase(t *testing.T) { // Setup trow away container ctx := context.Background() container, gormDB, err := test.StartPostgresContainer(ctx) if err != nil { t.Fatalf("Could not start PostgreSQL container: %v", err) } defer container.Terminate(ctx) // Setup Test // Test type args struct { dbPool *gorm.DB } tests := []struct { name string args args wantErr bool }{ { name: "Test 1: Migrate Databases", args: args{dbPool: gormDB}, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &postgresqlConnection{ db: gormDB, debug: true, } if err := p.migrateDatabase(tt.args.dbPool); (err != nil) != tt.wantErr { t.Errorf("migrateDatabase() error = %v, wantErr %v", err, tt.wantErr) } }) } }