mirrors/kube-arangodb
1
0
Fork 0
mirror of https://github.com/arangodb/kube-arangodb.git synced 2024-12-14 11:57:37 +00:00
Code Activity

Added unit tests for pv_creator.go

Browse source
This commit is contained in:
Ewout Prangsma 2018-06-08 08:10:05 +02:00
parent d12ad72fdb
commit 6e9cb0f3e3
No known key found for this signature in database
GPG key ID: 4DBAD380D93D0698
4 changed files with 341 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Makefile
View file

@ -235,6 +235,7 @@ run-unit-tests: $(GOBUILDDIR) $(SOURCES)
$(REPOPATH)/pkg/apis/storage/v1alpha \
$(REPOPATH)/pkg/deployment/reconcile \
$(REPOPATH)/pkg/deployment/resources \
$(REPOPATH)/pkg/storage \
$(REPOPATH)/pkg/util/k8sutil \
$(REPOPATH)/pkg/util/k8sutil/test \
$(REPOPATH)/pkg/util/probe \

36
pkg/storage/provisioner/mocks/mocks.go Normal file
View file

@ -0,0 +1,36 @@
//
// DISCLAIMER
//
// Copyright 2018 ArangoDB GmbH, Cologne, Germany
//
// 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.
//
// Copyright holder is ArangoDB GmbH, Cologne, Germany
//
// Author Ewout Prangsma
//
package mocks
import (
"github.com/stretchr/testify/mock"
)
type MockGetter interface {
AsMock() *mock.Mock
}
// AsMock performs a typeconversion to *Mock.
func AsMock(obj interface{}) *mock.Mock {
return obj.(MockGetter).AsMock()
}

95
pkg/storage/provisioner/mocks/provisioner.go Normal file
View file

@ -0,0 +1,95 @@
//
// DISCLAIMER
//
// Copyright 2018 ArangoDB GmbH, Cologne, Germany
//
// 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.
//
// Copyright holder is ArangoDB GmbH, Cologne, Germany
//
// Author Ewout Prangsma
//
package mocks
import (
"context"
"fmt"
"github.com/stretchr/testify/mock"
"github.com/arangodb/kube-arangodb/pkg/storage/provisioner"
)
type Provisioner interface {
provisioner.API
MockGetter
}
type provisionerMock struct {
mock.Mock
nodeName string
available, capacity int64
localPaths map[string]struct{}
}
// NewProvisioner returns a new mocked provisioner
func NewProvisioner(nodeName string, available, capacity int64) Provisioner {
return &provisionerMock{
nodeName: nodeName,
available: available,
capacity: capacity,
localPaths: make(map[string]struct{}),
}
}
func (m *provisionerMock) AsMock() *mock.Mock {
return &m.Mock
}
// GetNodeInfo fetches information from the current node.
func (m *provisionerMock) GetNodeInfo(ctx context.Context) (provisioner.NodeInfo, error) {
return provisioner.NodeInfo{
NodeName: m.nodeName,
}, nil
}
// GetInfo fetches information from the filesystem containing
// the given local path on the current node.
func (m *provisionerMock) GetInfo(ctx context.Context, localPath string) (provisioner.Info, error) {
return provisioner.Info{
NodeInfo: provisioner.NodeInfo{
NodeName: m.nodeName,
},
Available: m.available,
Capacity: m.capacity,
}, nil
}
// Prepare a volume at the given local path
func (m *provisionerMock) Prepare(ctx context.Context, localPath string) error {
if _, found := m.localPaths[localPath]; found {
return fmt.Errorf("Path already exists: %s", localPath)
}
m.localPaths[localPath] = struct{}{}
return nil
}
// Remove a volume with the given local path
func (m *provisionerMock) Remove(ctx context.Context, localPath string) error {
if _, found := m.localPaths[localPath]; !found {
return fmt.Errorf("Path not found: %s", localPath)
}
delete(m.localPaths, localPath)
return nil
}

209
pkg/storage/pv_creator_test.go Normal file
View file

@ -0,0 +1,209 @@
//
// DISCLAIMER
//
// Copyright 2018 ArangoDB GmbH, Cologne, Germany
//
// 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.
//
// Copyright holder is ArangoDB GmbH, Cologne, Germany
//
// Author Ewout Prangsma
//
package storage
import (
"context"
"testing"
"github.com/stretchr/testify/assert"
"k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"github.com/arangodb/kube-arangodb/pkg/storage/provisioner"
"github.com/arangodb/kube-arangodb/pkg/storage/provisioner/mocks"
)
// TestCreateValidEndpointList tests createValidEndpointList.
func TestCreateValidEndpointList(t *testing.T) {
tests := []struct {
Input *v1.EndpointsList
Expected []string
}{
{
Input: &v1.EndpointsList{},
Expected: []string{},
},
{
Input: &v1.EndpointsList{
Items: []v1.Endpoints{
v1.Endpoints{
Subsets: []v1.EndpointSubset{
v1.EndpointSubset{
Addresses: []v1.EndpointAddress{
v1.EndpointAddress{
IP: "1.2.3.4",
},
},
},
v1.EndpointSubset{
Addresses: []v1.EndpointAddress{
v1.EndpointAddress{
IP: "5.6.7.8",
},
v1.EndpointAddress{
IP: "9.10.11.12",
},
},
},
},
},
},
},
Expected: []string{
"1.2.3.4:8929",
"5.6.7.8:8929",
"9.10.11.12:8929",
},
},
}
for _, test := range tests {
output := createValidEndpointList(test.Input)
assert.Equal(t, test.Expected, output)
}
}
// TestCreateNodeAffinity tests createNodeAffinity.
func TestCreateNodeAffinity(t *testing.T) {
tests := map[string]string{
"foo": "{\"requiredDuringSchedulingIgnoredDuringExecution\":{\"nodeSelectorTerms\":[{\"matchExpressions\":[{\"key\":\"kubernetes.io/hostname\",\"operator\":\"In\",\"values\":[\"foo\"]}]}]}}",
"bar": "{\"requiredDuringSchedulingIgnoredDuringExecution\":{\"nodeSelectorTerms\":[{\"matchExpressions\":[{\"key\":\"kubernetes.io/hostname\",\"operator\":\"In\",\"values\":[\"bar\"]}]}]}}",
}
for input, expected := range tests {
output, err := createNodeAffinity(input)
assert.NoError(t, err)
assert.Equal(t, expected, output, "Input: '%s'", input)
}
}
// TestCreateNodeClientMap tests createNodeClientMap.
func TestCreateNodeClientMap(t *testing.T) {
GB := int64(1024 * 1024 * 1024)
foo := mocks.NewProvisioner("foo", 100*GB, 100*GB)
bar := mocks.NewProvisioner("bar", 100*GB, 100*GB)
tests := []struct {
Input []provisioner.API
Expected map[string]provisioner.API
}{
{
Input: nil,
Expected: map[string]provisioner.API{},
},
{
Input: []provisioner.API{foo, bar},
Expected: map[string]provisioner.API{
"bar": bar,
"foo": foo,
},
},
}
ctx := context.Background()
for _, test := range tests {
output := createNodeClientMap(ctx, test.Input)
assert.Equal(t, test.Expected, output)
}
}
// TestGetDeploymentInfo tests getDeploymentInfo.
func TestGetDeploymentInfo(t *testing.T) {
tests := []struct {
Input v1.PersistentVolumeClaim
ExpectedDeploymentName string
ExpectedRole string
ExpectedEnforceAntiAffinity bool
}{
{
Input: v1.PersistentVolumeClaim{},
ExpectedDeploymentName: "",
ExpectedRole: "",
ExpectedEnforceAntiAffinity: false,
},
{
Input: v1.PersistentVolumeClaim{
ObjectMeta: metav1.ObjectMeta{
Annotations: map[string]string{
"database.arangodb.com/enforce-anti-affinity": "true",
},
Labels: map[string]string{
"arango_deployment": "foo",
"role": "r1",
},
},
},
ExpectedDeploymentName: "foo",
ExpectedRole: "r1",
ExpectedEnforceAntiAffinity: true,
},
{
Input: v1.PersistentVolumeClaim{
ObjectMeta: metav1.ObjectMeta{
Annotations: map[string]string{
"database.arangodb.com/enforce-anti-affinity": "false",
},
Labels: map[string]string{
"arango_deployment": "foo",
"role": "r1",
},
},
},
ExpectedDeploymentName: "foo",
ExpectedRole: "r1",
ExpectedEnforceAntiAffinity: false,
},
{
Input: v1.PersistentVolumeClaim{
ObjectMeta: metav1.ObjectMeta{
Annotations: map[string]string{
"database.arangodb.com/enforce-anti-affinity": "wrong",
},
Labels: map[string]string{
"arango_deployment": "bar",
"role": "r77",
},
},
},
ExpectedDeploymentName: "bar",
ExpectedRole: "r77",
ExpectedEnforceAntiAffinity: false,
},
}
for _, test := range tests {
deploymentName, role, enforceAntiAffinity := getDeploymentInfo(test.Input)
assert.Equal(t, test.ExpectedDeploymentName, deploymentName)
assert.Equal(t, test.ExpectedRole, role)
assert.Equal(t, test.ExpectedEnforceAntiAffinity, enforceAntiAffinity)
}
}
// TestShortHash tests shortHash.
func TestShortHash(t *testing.T) {
tests := map[string]string{
"foo": "0beec7",
"": "da39a3",
"something very very very very very looooooooooooooooooooooooooooooooong": "68ff76",
}
for input, expected := range tests {
output := shortHash(input)
assert.Equal(t, expected, output, "Input: '%s'", input)
}
}