playground/backend/internal/components/cache_component_test.go

// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package components

import (
	"context"
	"os"
	"reflect"
	"testing"
	"time"

	pb "beam.apache.org/playground/backend/internal/api/v1"
	"beam.apache.org/playground/backend/internal/cache"
	"beam.apache.org/playground/backend/internal/cache/local"
	"beam.apache.org/playground/backend/internal/constants"
	db "beam.apache.org/playground/backend/internal/db/datastore"
	"beam.apache.org/playground/backend/internal/db/entity"
	"beam.apache.org/playground/backend/internal/tests/test_cleaner"
	"beam.apache.org/playground/backend/internal/utils"
)

var datastoreDb *db.EmulatedDatastore
var ctx context.Context
var cacheComponent *CacheComponent
var cacheService cache.Cache
var defaultCacheRequestTimeout = 10 * time.Second

func TestMain(m *testing.M) {
	setup()
	code := m.Run()
	teardown()
	os.Exit(code)
}

func setup() {
	ctx = context.Background()
	ctx = context.WithValue(ctx, constants.DatastoreNamespaceKey, "components")
	cacheService = local.New(ctx)
	var err error
	datastoreDb, err = db.NewEmulated(ctx)
	if err != nil {
		panic(err)
	}
	cacheComponent = NewService(cacheService, datastoreDb)
}

func teardown() {
	clientCloseErr := datastoreDb.Close()
	if clientCloseErr != nil {
		panic(clientCloseErr)
	}
}

func TestCacheComponent_GetSdkCatalogFromCacheOrDatastore(t *testing.T) {
	sdks := getSDKs()
	tests := []struct {
		name    string
		prepare func()
		wantErr bool
	}{
		{
			name: "Getting sdk catalog from cache in the usual case",
			prepare: func() {
				_ = cacheService.SetSdkCatalog(ctx, sdks)
			},
			wantErr: false,
		},
		{
			name: "Getting sdk catalog from datastore in the usual case",
			prepare: func() {
				_ = datastoreDb.PutSDKs(ctx, sdks)
			},
			wantErr: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.prepare()
			result, err := cacheComponent.GetSdkCatalogFromCacheOrDatastore(ctx, defaultCacheRequestTimeout)
			if (err != nil) != tt.wantErr {
				t.Error("GetSdkCatalogFromCacheOrDatastore() unexpected error")
				return
			}
			if !reflect.DeepEqual(sdks, result) {
				t.Error("GetSdkCatalogFromCacheOrDatastore() unexpected result")
			}
		})
	}
}

func TestCacheComponent_GetCatalogFromCacheOrDatastore(t *testing.T) {
	catalog := getCatalog()
	tests := []struct {
		name      string
		storeType string
		prepare   func()
		wantErr   bool
		clean     func()
	}{
		{
			name:      "Getting catalog from cache in the usual case",
			storeType: "CACHE",
			prepare: func() {
				_ = cacheService.SetCatalog(ctx, catalog)
			},
			wantErr: false,
			clean: func() {
				_ = cacheService.SetCatalog(ctx, nil)
			},
		},
		{
			name:      "Getting catalog from datastore in the usual case",
			storeType: "DB",
			prepare: func() {
				_ = cacheService.SetSdkCatalog(ctx, getSDKs())
				exampleId := utils.GetIDWithDelimiter(pb.Sdk_SDK_JAVA.String(), "MOCK_EXAMPLE")
				saveExample("MOCK_EXAMPLE", pb.Sdk_SDK_JAVA.String())
				saveSnippet(exampleId, pb.Sdk_SDK_JAVA.String())
				savePCObjs(exampleId)
			},
			wantErr: false,
			clean: func() {
				exampleId := utils.GetIDWithDelimiter(pb.Sdk_SDK_JAVA.String(), "MOCK_EXAMPLE")
				test_cleaner.CleanPCObjs(ctx, t, exampleId)
				test_cleaner.CleanFiles(ctx, t, exampleId, 1)
				test_cleaner.CleanSnippet(ctx, t, exampleId)
				test_cleaner.CleanExample(ctx, t, exampleId)
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.prepare()
			result, err := cacheComponent.GetCatalogFromCacheOrDatastore(ctx, defaultCacheRequestTimeout)
			if (err != nil) != tt.wantErr {
				t.Error("GetCatalogFromCacheOrDatastore() unexpected error")
				return
			}
			switch tt.storeType {
			case "CACHE":
				if !reflect.DeepEqual(result, catalog) {
					t.Error("GetCatalogFromCacheOrDatastore() unexpected result")
				}
				tt.clean()
			case "DB":
				if result[0].GetSdk() != pb.Sdk_SDK_JAVA {
					t.Error("GetCatalogFromCacheOrDatastore() unexpected result: wrong sdk")
				}
				actualCatName := result[0].GetCategories()[0].GetCategoryName()
				actualPCObj := result[0].GetCategories()[0].GetPrecompiledObjects()[0]
				if actualCatName != "MOCK_CATEGORY" {
					t.Error("GetCatalogFromCacheOrDatastore() unexpected result: wrong category")
				}
				if actualPCObj.DefaultExample != false ||
					actualPCObj.Multifile != false ||
					actualPCObj.Name != "MOCK_EXAMPLE" ||
					actualPCObj.Type.String() != "PRECOMPILED_OBJECT_TYPE_EXAMPLE" ||
					actualPCObj.CloudPath != "SDK_JAVA_MOCK_EXAMPLE" ||
					actualPCObj.PipelineOptions != "MOCK_OPTIONS" ||
					actualPCObj.Description != "MOCK_DESCR" ||
					actualPCObj.Link != "MOCK_PATH" ||
					actualPCObj.ContextLine != 32 ||
					actualPCObj.Complexity != pb.Complexity_COMPLEXITY_MEDIUM {
					t.Error("GetCatalogFromCacheOrDatastore() unexpected result: wrong precompiled obj")
				}
				tt.clean()
			}
		})
	}
}

func TestCacheComponent_GetDefaultPrecompiledObjectFromCacheOrDatastore(t *testing.T) {
	pcObj := getPCObj()
	tests := []struct {
		name    string
		prepare func()
		wantErr bool
	}{
		{
			name: "Getting default precompiled object from cache in the usual case",
			prepare: func() {
				_ = cacheService.SetDefaultPrecompiledObject(ctx, pb.Sdk_SDK_JAVA, pcObj)
			},
			wantErr: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.prepare()
			result, err := cacheComponent.GetDefaultPrecompiledObjectFromCacheOrDatastore(ctx, pb.Sdk_SDK_JAVA, defaultCacheRequestTimeout)
			if (err != nil) != tt.wantErr {
				t.Error("GetDefaultPrecompiledObjectFromCacheOrDatastore() unexpected error")
				return
			}
			if !reflect.DeepEqual(pcObj, result) {
				t.Error("GetDefaultPrecompiledObjectFromCacheOrDatastore() unexpected result")
			}
		})
	}
}

func getSDKs() []*entity.SDKEntity {
	var sdkEntities []*entity.SDKEntity
	for _, sdk := range pb.Sdk_name {
		if sdk == pb.Sdk_SDK_UNSPECIFIED.String() {
			continue
		}
		sdkEntities = append(sdkEntities, &entity.SDKEntity{
			Name:           sdk,
			DefaultExample: "MOCK_DEFAULT_EXAMPLE",
		})
	}
	return sdkEntities
}

func getPCObj() *pb.PrecompiledObject {
	return &pb.PrecompiledObject{
		CloudPath:       "MOCK_PATH",
		Name:            "MOCK_NAME",
		Description:     "MOCK_DESCR",
		Type:            1,
		PipelineOptions: "MOCK_OPTIONS",
		Link:            "MOCK_LINK",
		Multifile:       false,
		ContextLine:     32,
		DefaultExample:  true,
	}
}

func getCatalog() []*pb.Categories {
	return []*pb.Categories{
		{
			Sdk: pb.Sdk_SDK_JAVA,
			Categories: []*pb.Categories_Category{
				{
					CategoryName: "TestCategory", PrecompiledObjects: []*pb.PrecompiledObject{
						{
							CloudPath:   "SDK_JAVA/TestCategory/TestName.java",
							Name:        "TestName",
							Description: "TestDescription",
							Type:        pb.PrecompiledObjectType_PRECOMPILED_OBJECT_TYPE_EXAMPLE,
						},
					},
				},
				{
					CategoryName: "AnotherTestCategory", PrecompiledObjects: []*pb.PrecompiledObject{
						{
							CloudPath:   "SDK_JAVA/AnotherTestCategory/TestName.java",
							Name:        "TestName",
							Description: "TestDescription",
							Type:        pb.PrecompiledObjectType_PRECOMPILED_OBJECT_TYPE_EXAMPLE,
						},
					},
				},
			},
		},
		{
			Sdk: pb.Sdk_SDK_PYTHON,
			Categories: []*pb.Categories_Category{
				{
					CategoryName: "TestCategory", PrecompiledObjects: []*pb.PrecompiledObject{
						{
							CloudPath:   "SDK_PYTHON/TestCategory/TestName.java",
							Name:        "TestName",
							Description: "TestDescription",
							Type:        pb.PrecompiledObjectType_PRECOMPILED_OBJECT_TYPE_EXAMPLE,
						},
					},
				},
			},
		},
	}
}

func saveExample(name, sdk string) {
	_, _ = datastoreDb.Client.Put(ctx, utils.GetExampleKey(ctx, sdk, name), &entity.ExampleEntity{
		Name:        name,
		Sdk:         utils.GetSdkKey(ctx, sdk),
		Descr:       "MOCK_DESCR",
		Cats:        []string{"MOCK_CATEGORY"},
		Path:        "MOCK_PATH",
		UrlVCS:      "MOCK_URL_VCS",
		UrlNotebook: "MOCK_URL_NOTEBOOK",
		Type:        pb.PrecompiledObjectType_PRECOMPILED_OBJECT_TYPE_EXAMPLE.String(),
		Origin:      constants.ExampleOrigin,
		SchVer:      utils.GetSchemaVerKey(ctx, "MOCK_VERSION"),
	})
}

func saveSnippet(snipId, sdk string) {
	_ = datastoreDb.PutSnippet(ctx, snipId, &entity.Snippet{
		IDMeta: &entity.IDMeta{
			Salt:     "MOCK_SALT",
			IdLength: 11,
		},
		Snippet: &entity.SnippetEntity{
			Sdk:           utils.GetSdkKey(ctx, sdk),
			PipeOpts:      "MOCK_OPTIONS",
			Origin:        constants.ExampleOrigin,
			NumberOfFiles: 1,
			Complexity:    pb.Complexity_COMPLEXITY_MEDIUM.String(),
		},
		Files: []*entity.FileEntity{{
			Name:     "MOCK_NAME",
			Content:  "MOCK_CONTENT",
			CntxLine: 32,
			IsMain:   true,
		}},
	})
}

func savePCObjs(exampleId string) {
	pcTypes := []string{constants.PCOutputType, constants.PCLogType, constants.PCGraphType}
	for _, pcType := range pcTypes {
		_, _ = datastoreDb.Client.Put(
			ctx,
			utils.GetPCObjectKey(ctx, exampleId, pcType),
			&entity.PrecompiledObjectEntity{Content: "MOCK_CONTENT_" + pcType})
	}
}