Skip to content

Commit

Permalink
test: supplementary unit tests for karpor server (#583)
Browse files Browse the repository at this point in the history
## What type of PR is this?

/kind test

## What this PR does / why we need it:

supplementary unit tests for karpor server

## Which issue(s) this PR fixes:

Fixes #496
  • Loading branch information
cheny-alf authored Aug 21, 2024
1 parent 66ab414 commit 56d95e6
Show file tree
Hide file tree
Showing 14 changed files with 1,122 additions and 1 deletion.
5 changes: 5 additions & 0 deletions pkg/core/entity/resource_group_rule_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -57,3 +57,8 @@ func TestResourceGroupRule_Validate(t *testing.T) {
})
}
}

func TestUUID(t *testing.T) {
uuid := UUID()
require.NotEmpty(t, uuid)
}
74 changes: 74 additions & 0 deletions pkg/core/manager/cluster/manager_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,7 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
"k8s.io/client-go/dynamic"
k8syaml "sigs.k8s.io/yaml"
)

// TestGetCluster tests the GetCluster method of the ClusterManager for various
Expand Down Expand Up @@ -817,3 +818,76 @@ func (m *mockNamespaceableResource) Delete(
}
return errors.NewNotFound(clusterv1beta1.Resource("cluster"), name)
}

func TestClusterManager_GetNamespace(t *testing.T) {
manager := NewClusterManager()
mockey.Mock((*dynamic.DynamicClient).Resource).Return(&mockNamespaceableResource{}).Build()
defer mockey.UnPatchAll()

testCases := []struct {
name string
namespace string
descending bool
expectError bool
expectResult *unstructured.Unstructured
}{
{
name: "Success - GetNamespace",
namespace: "existing-cluster",
expectError: false,
expectResult: newMockCluster("existing-cluster"),
},
}

for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
summary, err := manager.GetNamespace(context.TODO(), &multicluster.MultiClusterClient{
DynamicClient: &dynamic.DynamicClient{},
}, tc.namespace)

if tc.expectError {
require.Error(t, err)
} else {
require.NoError(t, err)
require.Equal(t, tc.expectResult, summary)
}
})
}
}

func TestClusterManager_GetNamespaceYAML(t *testing.T) {
manager := NewClusterManager()
mockey.Mock((*dynamic.DynamicClient).Resource).Return(&mockNamespaceableResource{}).Build()
defer mockey.UnPatchAll()

expectResult, _ := k8syaml.Marshal(newMockCluster("existing-cluster"))
testCases := []struct {
name string
namespace string
descending bool
expectError bool
expectResult []byte
}{
{
name: "Success - GetNamespaceYAML",
namespace: "existing-cluster",
expectError: false,
expectResult: expectResult,
},
}

for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
summary, err := manager.GetNamespaceYAML(context.TODO(), &multicluster.MultiClusterClient{
DynamicClient: &dynamic.DynamicClient{},
}, tc.namespace)

if tc.expectError {
require.Error(t, err)
} else {
require.NoError(t, err)
require.Equal(t, tc.expectResult, summary)
}
})
}
}
294 changes: 294 additions & 0 deletions pkg/core/manager/insight/events_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,294 @@
// Copyright The Karpor Authors.
//
// Licensed 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 insight

import (
"context"
"testing"

"github.com/KusionStack/karpor/pkg/core/entity"
"github.com/bytedance/mockey"
"github.com/stretchr/testify/require"
genericapiserver "k8s.io/apiserver/pkg/server"
"k8s.io/client-go/dynamic"
)

func TestInsightManager_GetResourceEvents(t *testing.T) {
// Initialize InsightManager
manager, err := NewInsightManager(&mockSearchStorage{}, &mockResourceStorage{}, &mockResourceGroupRuleStorage{}, &genericapiserver.CompletedConfig{})
require.NoError(t, err, "Unexpected error initializing InsightManager")

// Set up mocks for dynamic client
mockey.Mock((*dynamic.DynamicClient).Resource).Return(&mockEventResource{}).Build()
defer mockey.UnPatchAll()

// Test cases
testCases := []struct {
name string
resourceGroup *entity.ResourceGroup
expectedLength int
expectError bool
}{
{
name: "Success - GetResourceEvents",
resourceGroup: &entity.ResourceGroup{
Name: "default-name",
APIVersion: "v1",
Kind: "Pod",
},
expectedLength: 1,
expectError: false,
},
{
name: "Failed - GetResourceEvents",
resourceGroup: &entity.ResourceGroup{
Name: "default-test",
APIVersion: "v1",
Kind: "Pod",
},
expectedLength: 0,
expectError: false,
},
}

// Execute test cases
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Call GetResourceGroupSummary method
events, err := manager.GetResourceEvents(context.Background(), mockMultiClusterClient(), tc.resourceGroup)

// Check error expectation
if tc.expectError {
require.Error(t, err, "Expected an error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
} else {
require.NoError(t, err, "Did not expect error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
}
})
}
}

func TestInsightManager_GetNamespaceGVKEvents(t *testing.T) {
// Initialize InsightManager
manager, err := NewInsightManager(&mockSearchStorage{}, &mockResourceStorage{}, &mockResourceGroupRuleStorage{}, &genericapiserver.CompletedConfig{})
require.NoError(t, err, "Unexpected error initializing InsightManager")

// Set up mocks for dynamic client
mockey.Mock((*dynamic.DynamicClient).Resource).Return(&mockEventResource{}).Build()
defer mockey.UnPatchAll()

// Test cases
testCases := []struct {
name string
resourceGroup *entity.ResourceGroup
expectedLength int
expectError bool
}{
{
name: "Success - GetNamespaceGVKEvents",
resourceGroup: &entity.ResourceGroup{
APIVersion: "v1",
Kind: "Pod",
},
expectedLength: 1,
expectError: false,
},
{
name: "Failed - GetNamespaceGVKEvents",
resourceGroup: &entity.ResourceGroup{
APIVersion: "v2",
Kind: "Pod",
},
expectedLength: 0,
expectError: false,
},
}

// Execute test cases
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Call GetResourceGroupSummary method
events, err := manager.GetNamespaceGVKEvents(context.Background(), mockMultiClusterClient(), tc.resourceGroup)

// Check error expectation
if tc.expectError {
require.Error(t, err, "Expected an error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
} else {
require.NoError(t, err, "Did not expect error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
}
})
}
}

func TestInsightManager_GetNamespaceEvents(t *testing.T) {
// Initialize InsightManager
manager, err := NewInsightManager(&mockSearchStorage{}, &mockResourceStorage{}, &mockResourceGroupRuleStorage{}, &genericapiserver.CompletedConfig{})
require.NoError(t, err, "Unexpected error initializing InsightManager")

// Set up mocks for dynamic client
mockey.Mock((*dynamic.DynamicClient).Resource).Return(&mockEventResource{}).Build()
defer mockey.UnPatchAll()

// Test cases
testCases := []struct {
name string
resourceGroup *entity.ResourceGroup
expectedLength int
expectError bool
}{
{
name: "Success - GetNamespaceEvents",
resourceGroup: &entity.ResourceGroup{
APIVersion: "v1",
Kind: "Pod",
Namespace: "default",
},
expectedLength: 1,
expectError: false,
},
{
name: "Failed - GetNamespaceEvents",
resourceGroup: &entity.ResourceGroup{
APIVersion: "v2",
Kind: "Pod",
Namespace: "non-default",
},
expectedLength: 0,
expectError: false,
},
}

// Execute test cases
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Call GetResourceGroupSummary method
events, err := manager.GetNamespaceEvents(context.Background(), mockMultiClusterClient(), tc.resourceGroup)

// Check error expectation
if tc.expectError {
require.Error(t, err, "Expected an error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
} else {
require.NoError(t, err, "Did not expect error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
}
})
}
}

func TestInsightManager_GetGVKEvents(t *testing.T) {
// Initialize InsightManager
manager, err := NewInsightManager(&mockSearchStorage{}, &mockResourceStorage{}, &mockResourceGroupRuleStorage{}, &genericapiserver.CompletedConfig{})
require.NoError(t, err, "Unexpected error initializing InsightManager")

// Set up mocks for dynamic client
mockey.Mock((*dynamic.DynamicClient).Resource).Return(&mockEventResource{}).Build()
defer mockey.UnPatchAll()

// Test cases
testCases := []struct {
name string
resourceGroup *entity.ResourceGroup
expectedLength int
expectError bool
}{
{
name: "Success - GetGVKEvents",
resourceGroup: &entity.ResourceGroup{
APIVersion: "v1",
Kind: "Pod",
Namespace: "default",
},
expectedLength: 1,
expectError: false,
},
{
name: "Failed - GetGVKEvents",
resourceGroup: &entity.ResourceGroup{
APIVersion: "v2",
Kind: "Pod",
Namespace: "non-default",
},
expectedLength: 0,
expectError: false,
},
}

// Execute test cases
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Call GetResourceGroupSummary method
events, err := manager.GetGVKEvents(context.Background(), mockMultiClusterClient(), tc.resourceGroup)

// Check error expectation
if tc.expectError {
require.Error(t, err, "Expected an error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
} else {
require.NoError(t, err, "Did not expect error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
}
})
}
}

func TestInsightManager_GetClusterEvents(t *testing.T) {
// Initialize InsightManager
manager, err := NewInsightManager(&mockSearchStorage{}, &mockResourceStorage{}, &mockResourceGroupRuleStorage{}, &genericapiserver.CompletedConfig{})
require.NoError(t, err, "Unexpected error initializing InsightManager")

// Set up mocks for dynamic client
mockey.Mock((*dynamic.DynamicClient).Resource).Return(&mockEventResource{}).Build()
defer mockey.UnPatchAll()

// Test cases
testCases := []struct {
name string
resourceGroup *entity.ResourceGroup
expectedLength int
expectError bool
}{
{
name: "Success - GetGVKEvents",
resourceGroup: &entity.ResourceGroup{
APIVersion: "v1",
Kind: "Pod",
Namespace: "default",
},
expectedLength: 1,
expectError: false,
},
}

// Execute test cases
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
// Call GetResourceGroupSummary method
events, err := manager.GetClusterEvents(context.Background(), mockMultiClusterClient(), tc.resourceGroup)

// Check error expectation
if tc.expectError {
require.Error(t, err, "Expected an error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
} else {
require.NoError(t, err, "Did not expect error")
require.Len(t, events, tc.expectedLength, "Expected nil result on error")
}
})
}
}
Loading

0 comments on commit 56d95e6

Please sign in to comment.