port_group_test.go

/**
 * Copyright (c) 2020 Red Hat Inc.
 *
 * 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 assertd 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 goovn

import (
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"reflect"
	"sort"
	"testing"
)

const (
	PG_TEST_PG1         = "TestPortGroup1"
	PG_TEST_PG2         = "TestPortGroup2"
	PG_TEST_LS1         = "TestLogicalSwitch"
	PG_TEST_LSP1        = "TestLogicalSwitchPort1"
	PG_TEST_LSP2        = "TestLogicalSwitchPort2"
	PG_TEST_LSP3        = "TestLogicalSwitchPort3"
	PG_TEST_LSP4        = "TestLogicalSwitchPort4"
	PG_TEST_KEY_1       = "mac_addr"
	PG_TEST_ID_1        = "00:01:02:03:04:05"
	PG_TEST_KEY_2       = "ip_addr"
	PG_TEST_ID_2        = "169.254.1.1"
	PG_TEST_KEY_3       = "foo1"
	PG_TEST_ID_3        = "bar1"
)

type pgConfig struct {
	pgName      string
	ports       []string
	externalIds map[string]string
}

type pgTest struct {
name        string
testFunc    func(group string, ports []string, external_ids map[string]string) (*OvnCommand, error)
startConfig pgConfig
testConfig  pgConfig
}

func lspNameToUUID(lspName string, c Client) (string, error) {
	lsp1, err := c.LSPGet(lspName)
	if err == nil {
		return lsp1.UUID, nil
	} else {
		return "", ErrorNotFound
	}
}

func compareExternalIds(want map[string]string, got map[interface{}]interface{}) bool {
	if len(want) != len(got) {
		return false
	}
	for key, w := range want {
		if w != got[key] {
			return false
		}
	}
	return true
}

func TestPortGroupAPI(t *testing.T) {
	ovndbapi := getOVNClient(DBNB)
	assert := assert.New(t)
	var cmd *OvnCommand
	var err error

	// create Switch with four ports
	createSwitch := func(t *testing.T) {
		t.Helper()
		var cmds []*OvnCommand
		// Create Switch
		cmd, err := ovndbapi.LSAdd(PG_TEST_LS1)
		assert.Nil(err)
		cmds = append(cmds, cmd)
		// Add ports
		cmd, err = ovndbapi.LSPAdd(PG_TEST_LS1, PG_TEST_LSP1)
		assert.Nil(err)
		cmds = append(cmds, cmd)
		cmd, err = ovndbapi.LSPAdd(PG_TEST_LS1, PG_TEST_LSP2)
		assert.Nil(err)
		cmds = append(cmds, cmd)
		cmd, err = ovndbapi.LSPAdd(PG_TEST_LS1, PG_TEST_LSP3)
		assert.Nil(err)
		cmds = append(cmds, cmd)
		cmd, err = ovndbapi.LSPAdd(PG_TEST_LS1, PG_TEST_LSP4)
		assert.Nil(err)
		cmds = append(cmds, cmd)

		err = ovndbapi.Execute(cmds...)
		assert.Nil(err)
	}

	// Delete Switch
	deleteSwitch := func(t *testing.T) {
		t.Helper()

		cmd, err = ovndbapi.LSDel(PG_TEST_LS1)
		assert.Nil(err)

		err = ovndbapi.Execute(cmd)
		assert.Nil(err)
	}

	// Create a switch w/four ports to be used for logical port tests
	createSwitch(t)

	// LSP commands require that ports be described by a UUID, so get the UUIDs
	lsp1UUID, err := lspNameToUUID(PG_TEST_LSP1, ovndbapi)
	assert.Nil(err)
	lsp2UUID, err := lspNameToUUID(PG_TEST_LSP2, ovndbapi)
	assert.Nil(err)
	lsp3UUID, err := lspNameToUUID(PG_TEST_LSP3, ovndbapi)
	assert.Nil(err)
	lsp4UUID, err := lspNameToUUID(PG_TEST_LSP4, ovndbapi)
	assert.Nil(err)

	portGroupAddTests := []pgTest {
		{
			name: "add an empty port group",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName:"",
				ports: nil,
				externalIds: nil,
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: nil,
				externalIds: nil,
			},
		},
		{
			name: "add a port group with two ports",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName:"",
				ports:nil,
				externalIds:nil,
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: []string{lsp1UUID, lsp2UUID},
				externalIds: nil,
			},
		},
		{
			name: "add a port group with four ports",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName:"",
				ports:nil,
				externalIds:nil,
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: []string{lsp1UUID, lsp2UUID, lsp3UUID, lsp4UUID},
				externalIds: nil,
			},
		},
		{
			name: "add two port groups with the same ports",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: []string{lsp1UUID, lsp2UUID},
				externalIds: nil,
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG2,
				ports: []string{lsp1UUID, lsp2UUID},
				externalIds: nil,
			},
		},
		{
			name: "add a port group with external ids",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName:"",
				ports:nil,
				externalIds:nil,
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: nil,
				externalIds: map[string]string{PG_TEST_KEY_1: PG_TEST_ID_1, PG_TEST_KEY_2: PG_TEST_ID_2},
			},
		},
		{
			name: "add a port group with ports and external ids",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName:"",
				ports:nil,
				externalIds:nil,
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: []string{lsp1UUID, lsp2UUID},
				externalIds: map[string]string{PG_TEST_KEY_1: PG_TEST_ID_1, PG_TEST_KEY_2: PG_TEST_ID_2},
			},
		},
		{
			name: "add a port group with empty name",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName:"",
				ports:nil,
				externalIds:nil,
			},
			testConfig: pgConfig{
				pgName: "",
				ports:nil,
				externalIds:nil,
			},
		},
		{
			name: "add a port group when another exists",
			testFunc: ovndbapi.PortGroupAdd,
			startConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: []string{lsp1UUID, lsp2UUID},
				externalIds: map[string]string{PG_TEST_KEY_1: PG_TEST_ID_1, PG_TEST_KEY_2: PG_TEST_ID_2},
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG2,
				ports: []string{lsp3UUID, lsp4UUID},
				externalIds: map[string]string{PG_TEST_KEY_1: PG_TEST_ID_1, PG_TEST_KEY_2: PG_TEST_ID_2},
			},
		},
		{
			name: "set ports and external ids on existing empty port group",
			testFunc: ovndbapi.PortGroupUpdate,
			startConfig: pgConfig{
				pgName:PG_TEST_PG1,
				ports:nil,
				externalIds:nil,
			},
			testConfig: pgConfig{
				pgName: PG_TEST_PG1,
				ports: []string{lsp1UUID, lsp2UUID},
				externalIds: map[string]string{PG_TEST_KEY_1: PG_TEST_ID_1, PG_TEST_KEY_2: PG_TEST_ID_2},
			},
		},
		{
			name: "set ports and external ids on existing port group with exiting config",
			testFunc: ovndbapi.PortGroupUpdate,
			startConfig: pgConfig{
				pgName:PG_TEST_PG1,
				ports: []string{lsp1UUID, lsp2UUID},
				externalIds: map[string]string{PG_TEST_KEY_1: PG_TEST_ID_1},
			},
			testConfig: pgConfig{
				pgName:PG_TEST_PG1,
				ports: []string{lsp3UUID, lsp4UUID},
				externalIds: map[string]string{PG_TEST_KEY_2: PG_TEST_ID_2, PG_TEST_KEY_3: PG_TEST_ID_3},
			},
		},
	}

	for _, tc := range portGroupAddTests {
		t.Run(tc.name, func(t *testing.T) {
			if tc.startConfig.pgName != "" {
				// Add start config
				cmd, err = ovndbapi.PortGroupAdd(tc.startConfig.pgName, tc.startConfig.ports, tc.startConfig.externalIds)
				assert.Nil(err)
				err = ovndbapi.Execute(cmd)
				assert.Nil(err)
			}

			// Add or Set the port group
			cmd, err = tc.testFunc(tc.testConfig.pgName, tc.testConfig.ports, tc.testConfig.externalIds)
			assert.Nil(err)
			err = ovndbapi.Execute(cmd)
			assert.Nil(err)

			// Validate port group
			pg, err := ovndbapi.PortGroupGet(tc.testConfig.pgName)
			assert.Nil(err)
			assert.NotNil(pg)
			assert.Equal(pg.Name, tc.testConfig.pgName)
			if tc.testConfig.ports != nil {
				sort.Strings(tc.testConfig.ports)
				sort.Strings(pg.Ports)
				assert.True(reflect.DeepEqual(tc.testConfig.ports, pg.Ports))
			}
			if tc.testConfig.externalIds != nil {
				assert.True(compareExternalIds(tc.testConfig.externalIds, pg.ExternalID))
			}

			// Delete the port group
			cmd, err = ovndbapi.PortGroupDel(tc.testConfig.pgName)
			assert.Nil(err)
			err = ovndbapi.Execute(cmd)
			assert.Nil(err)

			// Confirm that it's deleted
			_, err = ovndbapi.PortGroupGet(tc.testConfig.pgName)
			assert.NotNil(err)

			if (tc.startConfig.pgName != "") &&  (tc.startConfig.pgName != tc.testConfig.pgName) {
				// Delete the start config port group.
				cmd, err = ovndbapi.PortGroupDel(tc.startConfig.pgName)
				assert.Nil(err)
				err = ovndbapi.Execute(cmd)
				assert.Nil(err)
			}
		})
	}

	// The following are negative/boundary cases that are not as easy to generalize

	t.Run("add duplicate port group", func(t *testing.T) {
		// Add first port group
		cmd, err = ovndbapi.PortGroupAdd(PG_TEST_PG1, []string{lsp1UUID, lsp2UUID}, nil)
		assert.Nil(err)
		err = ovndbapi.Execute(cmd)
		assert.Nil(err)

		cmd, err = ovndbapi.PortGroupAdd(PG_TEST_PG1, []string{lsp1UUID, lsp2UUID}, nil)
		assert.NotNil(err)

		// Delete the first port group
		cmd, err = ovndbapi.PortGroupDel(PG_TEST_PG1)
		assert.Nil(err)
		err = ovndbapi.Execute(cmd)
		assert.Nil(err)
	})

	t.Run("add port group with non-existent ports", func(t *testing.T) {
		badUUID, err := uuid.NewRandom()
		assert.Nil(err)
		ports := []string{lsp1UUID, badUUID.String()}

		// Add the port group
		cmd, err = ovndbapi.PortGroupAdd(PG_TEST_PG1, ports, nil)
		assert.Nil(err)
		err = ovndbapi.Execute(cmd)
		assert.Nil(err)
		// The way this currently works, ovsdb doesn't care whether the ports exist,
		// and will add the port group regardless. Should it?

		// Validate port group
		pg, err := ovndbapi.PortGroupGet(PG_TEST_PG1)
		assert.Nil(err)
		assert.NotNil(pg)
		assert.Equal(pg.Name, PG_TEST_PG1)
		sort.Strings(ports)
		sort.Strings(pg.Ports)
		// Don't expect the badUUID to be in the list
		assert.False(reflect.DeepEqual(ports, pg.Ports))

		// Delete the port group
		cmd, err = ovndbapi.PortGroupDel(PG_TEST_PG1)
		assert.Nil(err)
		err = ovndbapi.Execute(cmd)
		assert.Nil(err)
	})

	t.Run("set port group that doesn't exist", func(t *testing.T) {
		cmd, err = ovndbapi.PortGroupUpdate(PG_TEST_PG1, []string{lsp1UUID, lsp2UUID}, nil)
		assert.NotNil(err)
	})

	deleteSwitch(t)
}