forked from rook/rook
Eng Zer Jun
77bff6a07c
From the Go specification [1]: "1. For a nil slice, the number of iterations is 0." "3. If the map is nil, the number of iterations is 0." `len` returns 0 if the slice or map is nil [2]. Therefore, checking `len(v) > 0` before a loop is unnecessary. [1]: https://go.dev/ref/spec#For_range [2]: https://pkg.go.dev/builtin#len Signed-off-by: Eng Zer Jun <engzerjun@gmail.com>
107 lines
3.9 KiB
Go
107 lines
3.9 KiB
Go
/*
|
|
Copyright 2018 The Rook Authors. All rights reserved.
|
|
|
|
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 test provides common resources useful for testing many Ceph daemons. This includes
|
|
// functions for testing that resources match what is expected.
|
|
package test
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/coreos/pkg/capnslog"
|
|
optest "github.com/rook/rook/pkg/operator/test"
|
|
"github.com/stretchr/testify/assert"
|
|
"k8s.io/api/core/v1"
|
|
)
|
|
|
|
// ContainerTestDefinition defines which k8s container values to test and what those values should
|
|
// be. Any definition item may be nil, and a nil value will prevent the item from being tested in
|
|
// the container test.
|
|
type ContainerTestDefinition struct {
|
|
// Image is the name of the container image
|
|
Image *string
|
|
// Command is the container command
|
|
Command []string
|
|
// Args is a list of expected arguments in the same format as the expected arguments from
|
|
// the ArgumentsMatchExpected() function.
|
|
Args [][]string
|
|
// InOrderArgs is a map of argument position (int) to the argument itself (string). If the
|
|
// "third" arg must be exactly the third argument this should be: InOrderArgs[2]="third"
|
|
InOrderArgs map[int]string
|
|
// VolumeMountNames is a list of volume mount names which must be mounted in the container
|
|
VolumeMountNames []string
|
|
// EnvCount is the number of 'Env' variables the container should define
|
|
EnvCount *int
|
|
// Ports is a list of ports the container must define. This list is in order, and each port's
|
|
// 'ContainerPort' and 'Protocol' are tested for equality.
|
|
// Note: port's in general aren't order-dependent, but there is not yet a method to test for
|
|
// the existence of a port in a list of ports without caring about order.
|
|
Ports []v1.ContainerPort
|
|
// IsPrivileged tests if the container is privileged (true) or unprivileged (false)
|
|
IsPrivileged *bool
|
|
}
|
|
|
|
// TestContainer tests that a container matches the container test definition. Moniker is a name
|
|
// given to the container for identifying it in tests. Cont is the container to be tested.
|
|
// Logger is the logger to output logs to.
|
|
func (d *ContainerTestDefinition) TestContainer(
|
|
t *testing.T,
|
|
moniker string,
|
|
cont *v1.Container,
|
|
logger *capnslog.PackageLogger,
|
|
) {
|
|
if d.Image != nil {
|
|
assert.Equal(t, *d.Image, cont.Image)
|
|
}
|
|
logCommandWithArgs(moniker, cont.Command, cont.Args, logger)
|
|
if d.Command != nil {
|
|
assert.Equal(t, len(d.Command), len(cont.Command))
|
|
assert.Equal(t, strings.Join(d.Command, " "), strings.Join(cont.Command, " "))
|
|
}
|
|
if d.Args != nil {
|
|
assert.Nil(t, optest.ArgumentsMatchExpected(cont.Args, d.Args))
|
|
}
|
|
|
|
for argNum, arg := range d.InOrderArgs {
|
|
assert.Equal(t, cont.Args[argNum], arg)
|
|
}
|
|
|
|
assert.Equal(t, len(d.VolumeMountNames), len(cont.VolumeMounts))
|
|
for _, n := range d.VolumeMountNames {
|
|
assert.Nil(t, optest.VolumeMountExists(n, cont.VolumeMounts))
|
|
}
|
|
|
|
if d.EnvCount != nil {
|
|
assert.Equal(t, *d.EnvCount, len(cont.Env))
|
|
}
|
|
|
|
assert.Equal(t, len(d.Ports), len(cont.Ports))
|
|
for i, p := range d.Ports {
|
|
assert.Equal(t, p.ContainerPort, cont.Ports[i].ContainerPort)
|
|
assert.Equal(t, p.Protocol, cont.Ports[i].Protocol)
|
|
}
|
|
|
|
if d.IsPrivileged != nil {
|
|
assert.Equal(t, *d.IsPrivileged, *cont.SecurityContext.Privileged)
|
|
}
|
|
}
|
|
|
|
// logCommandWithArgs writes a command and its arguments to the logger with a moniker to identify it
|
|
func logCommandWithArgs(moniker string, command, args []string, logger *capnslog.PackageLogger) {
|
|
logger.Infof("%s command : %s %s", moniker, strings.Join(command, " "), strings.Join(args, " "))
|
|
}
|