constellation/cli/internal/state/state_test.go

/*
Copyright (c) Edgeless Systems GmbH

SPDX-License-Identifier: AGPL-3.0-only
*/

package state

import (
	"testing"

	"github.com/edgelesssys/constellation/v2/internal/constants"
	"github.com/edgelesssys/constellation/v2/internal/file"
	"github.com/siderolabs/talos/pkg/machinery/config/encoder"
	"github.com/spf13/afero"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gopkg.in/yaml.v3"
)

func defaultState() *State {
	return &State{
		Version: "v1",
		Infrastructure: Infrastructure{
			UID:             "123",
			ClusterEndpoint: "test-cluster-endpoint",
			InitSecret:      []byte{0x41},
			APIServerCertSANs: []string{
				"api-server-cert-san-test",
				"api-server-cert-san-test-2",
			},
			IPCidrNode: "test-cidr-node",
			Azure: &Azure{
				ResourceGroup:            "test-rg",
				SubscriptionID:           "test-sub",
				NetworkSecurityGroupName: "test-nsg",
				LoadBalancerName:         "test-lb",
				UserAssignedIdentity:     "test-uami",
				AttestationURL:           "test-maaUrl",
			},
			GCP: &GCP{
				ProjectID: "test-project",
				IPCidrPod: "test-cidr-pod",
			},
		},
		ClusterValues: ClusterValues{
			ClusterID:       "test-cluster-id",
			OwnerID:         "test-owner-id",
			MeasurementSalt: []byte{0x41},
		},
	}
}

func TestWriteToFile(t *testing.T) {
	testCases := map[string]struct {
		state   *State
		fh      file.Handler
		wantErr bool
	}{
		"success": {
			state: defaultState(),
			fh:    file.NewHandler(afero.NewMemMapFs()),
		},
		"overwrite": {
			state: defaultState(),
			fh: func() file.Handler {
				fs := file.NewHandler(afero.NewMemMapFs())
				require.NoError(t, fs.Write(constants.StateFilename, []byte{0x41}))
				return fs
			}(),
		},
		"empty state": {
			state: &State{},
			fh:    file.NewHandler(afero.NewMemMapFs()),
		},
		"rofs": {
			state:   defaultState(),
			fh:      file.NewHandler(afero.NewReadOnlyFs(afero.NewMemMapFs())),
			wantErr: true,
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			assert := assert.New(t)
			require := require.New(t)

			err := tc.state.WriteToFile(tc.fh, constants.StateFilename)

			if tc.wantErr {
				assert.Error(err)
			} else {
				assert.NoError(err)
				assert.YAMLEq(mustMarshalYaml(require, tc.state), mustReadFromFile(require, tc.fh))
			}
		})
	}
}

func TestReadFromFile(t *testing.T) {
	testCases := map[string]struct {
		fs        file.Handler
		wantState *State
		wantErr   bool
	}{
		"success": {
			fs: func() file.Handler {
				fh := file.NewHandler(afero.NewMemMapFs())
				require.NoError(t, fh.WriteYAML(constants.StateFilename, defaultState()))
				return fh
			}(),
			wantState: defaultState(),
		},
		"no state file present": {
			fs:      file.NewHandler(afero.NewMemMapFs()),
			wantErr: true,
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			assert := assert.New(t)
			require := require.New(t)

			state, err := ReadFromFile(tc.fs, constants.StateFilename)

			if tc.wantErr {
				assert.Error(err)
			} else {
				assert.NoError(err)
				assert.YAMLEq(mustMarshalYaml(require, tc.wantState), mustMarshalYaml(require, state))
			}
		})
	}
}

func mustMarshalYaml(require *require.Assertions, v any) string {
	b, err := encoder.NewEncoder(v).Encode()
	require.NoError(err)
	return string(b)
}

func mustReadFromFile(require *require.Assertions, fh file.Handler) string {
	b, err := fh.Read(constants.StateFilename)
	require.NoError(err)
	return string(b)
}

func TestMerge(t *testing.T) {
	testCases := map[string]struct {
		state    *State
		other    *State
		expected *State
		wantErr  bool
	}{
		"success": {
			state: &State{
				Infrastructure: Infrastructure{
					ClusterEndpoint: "test-cluster-endpoint",
					UID:             "123",
				},
			},
			other: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
			expected: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					ClusterEndpoint: "test-cluster-endpoint",
					UID:             "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
		},
		"empty state": {
			state: &State{},
			other: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
			expected: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
		},
		"empty other": {
			state: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
			other: &State{},
			expected: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
		},
		"empty state and other": {
			state:    &State{},
			other:    &State{},
			expected: &State{},
		},
		"identical": {
			state: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
			other: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
			expected: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
		},
		"nested pointer": {
			state: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "123",
					Azure: &Azure{
						AttestationURL: "test-maaUrl",
					},
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
			other: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
					Azure: &Azure{
						AttestationURL: "test-maaUrl-2",
					},
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
			expected: &State{
				Version: "v1",
				Infrastructure: Infrastructure{
					UID: "456",
					Azure: &Azure{
						AttestationURL: "test-maaUrl-2",
					},
				},
				ClusterValues: ClusterValues{
					ClusterID: "test-cluster-id",
				},
			},
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			assert := assert.New(t)

			_, err := tc.state.Merge(tc.other)

			if tc.wantErr {
				assert.Error(err)
			} else {
				assert.NoError(err)
				assert.Equal(tc.expected, tc.state)
			}
		})
	}
}

func TestMarshalHexBytes(t *testing.T) {
	testCases := map[string]struct {
		in       HexBytes
		expected string
		wantErr  bool
	}{
		"success": {
			in:       []byte{0xab, 0xcd, 0xef},
			expected: "abcdef\n",
		},
		"empty": {
			in:       []byte{},
			expected: "\"\"\n",
		},
		"nil": {
			in:       nil,
			expected: "\"\"\n",
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			assert := assert.New(t)

			actual, err := yaml.Marshal(tc.in)

			if tc.wantErr {
				assert.Error(err)
			} else {
				assert.NoError(err)
				assert.Equal(tc.expected, string(actual))
			}
		})
	}
}

func TestUnmarshalHexBytes(t *testing.T) {
	testCases := map[string]struct {
		in       string
		expected HexBytes
		wantErr  bool
	}{
		"success": {
			in:       "abcdef",
			expected: []byte{0xab, 0xcd, 0xef},
		},
		"empty": {
			in:       "",
			expected: nil,
		},
		"byte slice compat": {
			in:       "[0xab, 0xcd, 0xef]",
			expected: []byte{0xab, 0xcd, 0xef},
		},
		"byte slice compat 2": {
			in:       "[00, 12, 34]",
			expected: []byte{0x00, 0x0c, 0x22},
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			assert := assert.New(t)

			var actual HexBytes
			err := yaml.Unmarshal([]byte(tc.in), &actual)

			if tc.wantErr {
				assert.Error(err)
			} else {
				assert.NoError(err)
				assert.Equal(tc.expected, actual)
			}
		})
	}
}

func TestMarshalUnmarshalHexBytes(t *testing.T) {
	in := HexBytes{0xab, 0xcd, 0xef}
	expected := "abcdef\n"

	actual, err := yaml.Marshal(in)
	require.NoError(t, err)
	assert.Equal(t, expected, string(actual))

	var actual2 HexBytes
	err = yaml.Unmarshal(actual, &actual2)
	require.NoError(t, err)
	assert.Equal(t, in, actual2)
}

func TestCreateOrRead(t *testing.T) {
	testCases := map[string]struct {
		fs        file.Handler
		wantState *State
		wantErr   bool
	}{
		"file exists": {
			fs: func() file.Handler {
				fh := file.NewHandler(afero.NewMemMapFs())
				require.NoError(t, fh.WriteYAML(constants.StateFilename, defaultState()))
				return fh
			}(),
			wantState: defaultState(),
		},
		"file does not exist": {
			fs:        file.NewHandler(afero.NewMemMapFs()),
			wantState: New(),
		},
		"unable to write file": {
			fs:      file.NewHandler(afero.NewReadOnlyFs(afero.NewMemMapFs())),
			wantErr: true,
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			assert := assert.New(t)

			require := require.New(t)
			state, err := CreateOrRead(tc.fs, constants.StateFilename)

			if tc.wantErr {
				assert.Error(err)
				return
			}
			assert.NoError(err)
			assert.YAMLEq(mustMarshalYaml(require, tc.wantState), mustMarshalYaml(require, state))
			assert.YAMLEq(mustMarshalYaml(require, tc.wantState), mustReadFromFile(require, tc.fs))
		})
	}
}