mirror of
https://github.com/kubeshark/kubeshark.git
synced 2026-05-07 09:47:19 +00:00
0eb7883a47
* Rename `mizu` to `kubeshark` * Rename `up9inc` to `kubeshark` * Change the logo, title, motto and the main color * Replace the favicon * Update the docs link * Change the copyright text in C files * Remove a comment * Rewrite the `README.md` and update the logo and screenshots used in it * Add a `TODO` * Fix the grammar * Fix the bottom text in the filtering guide * Change the Docker Hub username of cross-compilation intermediate images * Add an install script * Fix `docker/login-action` in the CI * Delete `build-custom-branch.yml` GitHub workflow * Update `README.md` * Remove `install.sh` * Change the motto back to "Traffic viewer for Kubernetes"
638 lines
17 KiB
Go
638 lines
17 KiB
Go
package acceptanceTests
|
|
|
|
import (
|
|
"archive/zip"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os/exec"
|
|
"path"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestTap(t *testing.T) {
|
|
basicTapTest(t, false)
|
|
}
|
|
|
|
func basicTapTest(t *testing.T, shouldCheckSrcAndDest bool, extraArgs ...string) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
tests := []int{50}
|
|
|
|
for _, entriesCount := range tests {
|
|
t.Run(fmt.Sprintf("%d", entriesCount), func(t *testing.T) {
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
|
|
tapCmdArgs = append(tapCmdArgs, extraArgs...)
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
proxyUrl := GetProxyUrl(DefaultNamespaceName, DefaultServiceName)
|
|
for i := 0; i < entriesCount; i++ {
|
|
if _, requestErr := ExecuteHttpGetRequest(fmt.Sprintf("%v/get", proxyUrl)); requestErr != nil {
|
|
t.Errorf("failed to send proxy request, err: %v", requestErr)
|
|
return
|
|
}
|
|
}
|
|
|
|
expectedPods := []PodDescriptor{
|
|
{Name: "httpbin", Namespace: "kubeshark-tests"},
|
|
{Name: "httpbin2", Namespace: "kubeshark-tests"},
|
|
}
|
|
|
|
var expectedPodsStr string
|
|
for i := 0; i < len(expectedPods); i++ {
|
|
expectedPodsStr += fmt.Sprintf("Name:%vNamespace:%v", expectedPods[i].Name, expectedPods[i].Namespace)
|
|
}
|
|
|
|
RunCypressTests(t, fmt.Sprintf("npx cypress run --spec \"cypress/e2e/tests/UiTest.js\" --env entriesCount=%d,arrayDict=%v,shouldCheckSrcAndDest=%v",
|
|
entriesCount, expectedPodsStr, shouldCheckSrcAndDest))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTapGuiPort(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
tests := []uint16{8898}
|
|
|
|
for _, guiPort := range tests {
|
|
t.Run(fmt.Sprintf("%d", guiPort), func(t *testing.T) {
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
|
|
tapCmdArgs = append(tapCmdArgs, "-p", fmt.Sprintf("%d", guiPort))
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(guiPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
proxyUrl := GetProxyUrl(DefaultNamespaceName, DefaultServiceName)
|
|
for i := 0; i < DefaultEntriesCount; i++ {
|
|
if _, requestErr := ExecuteHttpGetRequest(fmt.Sprintf("%v/get", proxyUrl)); requestErr != nil {
|
|
t.Errorf("failed to send proxy request, err: %v", requestErr)
|
|
return
|
|
}
|
|
}
|
|
|
|
RunCypressTests(t, fmt.Sprintf("npx cypress run --spec \"cypress/e2e/tests/GuiPort.js\" --env name=%v,namespace=%v,port=%d",
|
|
"httpbin", "kubeshark-tests", guiPort))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTapAllNamespaces(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
expectedPods := []PodDescriptor{
|
|
{Name: "httpbin", Namespace: "kubeshark-tests"},
|
|
{Name: "httpbin2", Namespace: "kubeshark-tests"},
|
|
{Name: "httpbin", Namespace: "kubeshark-tests2"},
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
tapCmdArgs = append(tapCmdArgs, "-A")
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
RunCypressTests(t, fmt.Sprintf("npx cypress run --spec \"cypress/e2e/tests/MultipleNamespaces.js\" --env name1=%v,name2=%v,name3=%v,namespace1=%v,namespace2=%v,namespace3=%v",
|
|
expectedPods[0].Name, expectedPods[1].Name, expectedPods[2].Name, expectedPods[0].Namespace, expectedPods[1].Namespace, expectedPods[2].Namespace))
|
|
}
|
|
|
|
func TestTapMultipleNamespaces(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
expectedPods := []PodDescriptor{
|
|
{Name: "httpbin", Namespace: "kubeshark-tests"},
|
|
{Name: "httpbin2", Namespace: "kubeshark-tests"},
|
|
{Name: "httpbin", Namespace: "kubeshark-tests2"},
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
var namespacesCmd []string
|
|
for _, expectedPod := range expectedPods {
|
|
namespacesCmd = append(namespacesCmd, "-n", expectedPod.Namespace)
|
|
}
|
|
tapCmdArgs = append(tapCmdArgs, namespacesCmd...)
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
RunCypressTests(t, fmt.Sprintf("npx cypress run --spec \"cypress/e2e/tests/MultipleNamespaces.js\" --env name1=%v,name2=%v,name3=%v,namespace1=%v,namespace2=%v,namespace3=%v",
|
|
expectedPods[0].Name, expectedPods[1].Name, expectedPods[2].Name, expectedPods[0].Namespace, expectedPods[1].Namespace, expectedPods[2].Namespace))
|
|
}
|
|
|
|
func TestTapRegex(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
regexPodName := "httpbin2"
|
|
expectedPods := []PodDescriptor{
|
|
{Name: regexPodName, Namespace: "kubeshark-tests"},
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgsWithRegex(regexPodName)
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
RunCypressTests(t, fmt.Sprintf("npx cypress run --spec \"cypress/e2e/tests/Regex.js\" --env name=%v,namespace=%v",
|
|
expectedPods[0].Name, expectedPods[0].Namespace))
|
|
}
|
|
|
|
func TestTapDryRun(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
|
|
tapCmdArgs = append(tapCmdArgs, "--dry-run")
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
resultChannel := make(chan string, 1)
|
|
|
|
go func() {
|
|
if err := tapCmd.Wait(); err != nil {
|
|
resultChannel <- "fail"
|
|
return
|
|
}
|
|
resultChannel <- "success"
|
|
}()
|
|
|
|
go func() {
|
|
time.Sleep(ShortRetriesCount * time.Second)
|
|
resultChannel <- "fail"
|
|
}()
|
|
|
|
testResult := <-resultChannel
|
|
if testResult != "success" {
|
|
t.Errorf("unexpected result - dry run cmd not done")
|
|
}
|
|
}
|
|
|
|
func TestTapRedact(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
tapCmdArgs = append(tapCmdArgs, "--redact", "--set", "tap.redact-patterns.request-headers=User-Header", "--set", "tap.redact-patterns.request-body=User")
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
proxyUrl := GetProxyUrl(DefaultNamespaceName, DefaultServiceName)
|
|
requestHeaders := map[string]string{"User-Header": "Kubeshark"}
|
|
requestBody := map[string]string{"User": "Kubeshark"}
|
|
for i := 0; i < DefaultEntriesCount; i++ {
|
|
if _, requestErr := ExecuteHttpPostRequestWithHeaders(fmt.Sprintf("%v/post", proxyUrl), requestHeaders, requestBody); requestErr != nil {
|
|
t.Errorf("failed to send proxy request, err: %v", requestErr)
|
|
return
|
|
}
|
|
}
|
|
|
|
RunCypressTests(t, "npx cypress run --spec \"cypress/e2e/tests/Redact.js\"")
|
|
}
|
|
|
|
func TestTapNoRedact(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
proxyUrl := GetProxyUrl(DefaultNamespaceName, DefaultServiceName)
|
|
requestHeaders := map[string]string{"User-Header": "Kubeshark"}
|
|
requestBody := map[string]string{"User": "Kubeshark"}
|
|
for i := 0; i < DefaultEntriesCount; i++ {
|
|
if _, requestErr := ExecuteHttpPostRequestWithHeaders(fmt.Sprintf("%v/post", proxyUrl), requestHeaders, requestBody); requestErr != nil {
|
|
t.Errorf("failed to send proxy request, err: %v", requestErr)
|
|
return
|
|
}
|
|
}
|
|
|
|
RunCypressTests(t, "npx cypress run --spec \"cypress/e2e/tests/NoRedact.js\"")
|
|
}
|
|
|
|
func TestTapIgnoredUserAgents(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
|
|
ignoredUserAgentValue := "ignore"
|
|
tapCmdArgs = append(tapCmdArgs, "--set", fmt.Sprintf("tap.ignored-user-agents=%v", ignoredUserAgentValue))
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
t.Cleanup(func() {
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Logf("failed to cleanup tap command, err: %v", err)
|
|
}
|
|
})
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
proxyUrl := GetProxyUrl(DefaultNamespaceName, DefaultServiceName)
|
|
|
|
ignoredUserAgentCustomHeader := "Ignored-User-Agent"
|
|
headers := map[string]string{"User-Agent": ignoredUserAgentValue, ignoredUserAgentCustomHeader: ""}
|
|
for i := 0; i < DefaultEntriesCount; i++ {
|
|
if _, requestErr := ExecuteHttpGetRequestWithHeaders(fmt.Sprintf("%v/get", proxyUrl), headers); requestErr != nil {
|
|
t.Errorf("failed to send proxy request, err: %v", requestErr)
|
|
return
|
|
}
|
|
}
|
|
|
|
for i := 0; i < DefaultEntriesCount; i++ {
|
|
if _, requestErr := ExecuteHttpGetRequest(fmt.Sprintf("%v/get", proxyUrl)); requestErr != nil {
|
|
t.Errorf("failed to send proxy request, err: %v", requestErr)
|
|
return
|
|
}
|
|
}
|
|
|
|
RunCypressTests(t, "npx cypress run --spec \"cypress/e2e/tests/IgnoredUserAgents.js\"")
|
|
}
|
|
|
|
func TestTapDumpLogs(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("ignored acceptance test")
|
|
}
|
|
|
|
cliPath, cliPathErr := GetCliPath()
|
|
if cliPathErr != nil {
|
|
t.Errorf("failed to get cli path, err: %v", cliPathErr)
|
|
return
|
|
}
|
|
|
|
tapCmdArgs := GetDefaultTapCommandArgs()
|
|
|
|
tapNamespace := GetDefaultTapNamespace()
|
|
tapCmdArgs = append(tapCmdArgs, tapNamespace...)
|
|
|
|
tapCmdArgs = append(tapCmdArgs, "--set", "dump-logs=true")
|
|
|
|
tapCmd := exec.Command(cliPath, tapCmdArgs...)
|
|
t.Logf("running command: %v", tapCmd.String())
|
|
|
|
if err := tapCmd.Start(); err != nil {
|
|
t.Errorf("failed to start tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
apiServerUrl := GetApiServerUrl(DefaultApiServerPort)
|
|
|
|
if err := WaitTapPodsReady(apiServerUrl); err != nil {
|
|
t.Errorf("failed to start tap pods on time, err: %v", err)
|
|
return
|
|
}
|
|
|
|
if err := CleanupCommand(tapCmd); err != nil {
|
|
t.Errorf("failed to cleanup tap command, err: %v", err)
|
|
return
|
|
}
|
|
|
|
kubesharkFolderPath, kubesharkPathErr := GetKubesharkFolderPath()
|
|
if kubesharkPathErr != nil {
|
|
t.Errorf("failed to get kubeshark folder path, err: %v", kubesharkPathErr)
|
|
return
|
|
}
|
|
|
|
files, readErr := ioutil.ReadDir(kubesharkFolderPath)
|
|
if readErr != nil {
|
|
t.Errorf("failed to read kubeshark folder files, err: %v", readErr)
|
|
return
|
|
}
|
|
|
|
var dumpLogsPath string
|
|
for _, file := range files {
|
|
fileName := file.Name()
|
|
if strings.Contains(fileName, "kubeshark_logs") {
|
|
dumpLogsPath = path.Join(kubesharkFolderPath, fileName)
|
|
break
|
|
}
|
|
}
|
|
|
|
if dumpLogsPath == "" {
|
|
t.Errorf("dump logs file not found")
|
|
return
|
|
}
|
|
|
|
zipReader, zipError := zip.OpenReader(dumpLogsPath)
|
|
if zipError != nil {
|
|
t.Errorf("failed to get zip reader, err: %v", zipError)
|
|
return
|
|
}
|
|
|
|
t.Cleanup(func() {
|
|
if err := zipReader.Close(); err != nil {
|
|
t.Logf("failed to close zip reader, err: %v", err)
|
|
}
|
|
})
|
|
|
|
var logsFileNames []string
|
|
for _, file := range zipReader.File {
|
|
logsFileNames = append(logsFileNames, file.Name)
|
|
}
|
|
|
|
if !Contains(logsFileNames, "kubeshark.kubeshark-api-server.kubeshark-api-server.log") {
|
|
t.Errorf("api server logs not found")
|
|
return
|
|
}
|
|
|
|
if !Contains(logsFileNames, "kubeshark.kubeshark-api-server.basenine.log") {
|
|
t.Errorf("basenine logs not found")
|
|
return
|
|
}
|
|
|
|
if !Contains(logsFileNames, "kubeshark_cli.log") {
|
|
t.Errorf("cli logs not found")
|
|
return
|
|
}
|
|
|
|
if !Contains(logsFileNames, "kubeshark_events.log") {
|
|
t.Errorf("events logs not found")
|
|
return
|
|
}
|
|
|
|
if !ContainsPartOfValue(logsFileNames, "kubeshark.kubeshark-tapper-daemon-set") {
|
|
t.Errorf("tapper logs not found")
|
|
return
|
|
}
|
|
}
|
|
|
|
func TestIpResolving(t *testing.T) {
|
|
namespace := AllNamespaces
|
|
|
|
t.Log("add permissions for ip-resolution for current user")
|
|
if err := ApplyKubeFilesForTest(
|
|
t,
|
|
"minikube",
|
|
namespace,
|
|
"../cli/cmd/permissionFiles/permissions-all-namespaces-ip-resolution-optional.yaml",
|
|
); err != nil {
|
|
t.Errorf("failed to create k8s permissions, %v", err)
|
|
return
|
|
}
|
|
|
|
basicTapTest(t, true)
|
|
}
|
|
|
|
func TestRestrictedMode(t *testing.T) {
|
|
namespace := "kubeshark-tests"
|
|
|
|
t.Log("creating permissions for restricted user")
|
|
if err := ApplyKubeFilesForTest(
|
|
t,
|
|
"minikube",
|
|
namespace,
|
|
"../cli/cmd/permissionFiles/permissions-ns-tap.yaml",
|
|
); err != nil {
|
|
t.Errorf("failed to create k8s permissions, %v", err)
|
|
return
|
|
}
|
|
|
|
t.Log("switching k8s context to user")
|
|
if err := SwitchKubeContextForTest(t, "user-with-restricted-access"); err != nil {
|
|
t.Errorf("failed to switch k8s context, %v", err)
|
|
return
|
|
}
|
|
|
|
extraArgs := []string{"--set", fmt.Sprintf("kubeshark-resources-namespace=%s", namespace)}
|
|
t.Run("basic tap", func(testingT *testing.T) { basicTapTest(testingT, false, extraArgs...) })
|
|
}
|