config_test.go

Documentation: edge-infra.dev/pkg/sds/display/k8s/controllers/xserver/config

     1  package config
     2  
     3  import (
     4  	"strconv"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	corev1 "k8s.io/api/core/v1"
     9  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    10  	"k8s.io/utils/ptr"
    11  
    12  	"edge-infra.dev/pkg/sds/display/constants"
    13  )
    14  
    15  var (
    16  	hostname = "test"
    17  
    18  	xorgConf        = "Section \"Screen\""
    19  	updatedXorgConf = "Section \"Monitor\""
    20  
    21  	openboxConf        = "<openbox_config></openbox_config>"
    22  	updatedOpenboxConf = "<openbox_config><theme></theme></openbox_config>"
    23  
    24  	enabled  = true
    25  	disabled = false
    26  )
    27  
    28  func TestDeepCopy(t *testing.T) {
    29  	src := &Config{
    30  		Hostname:          hostname,
    31  		xorgConf:          &updatedXorgConf,
    32  		openboxConf:       &updatedOpenboxConf,
    33  		cursorEnabled:     &enabled,
    34  		displayctlEnabled: &disabled,
    35  	}
    36  
    37  	dst := src.DeepCopy()
    38  
    39  	// check pointers are for new addresses
    40  	assert.NotSame(t, src, dst)
    41  	assert.NotSame(t, src.xorgConf, dst.xorgConf)
    42  	assert.NotSame(t, src.openboxConf, dst.openboxConf)
    43  	assert.NotSame(t, src.cursorEnabled, dst.cursorEnabled)
    44  	assert.NotSame(t, src.displayctlEnabled, dst.displayctlEnabled)
    45  
    46  	// check values were copied
    47  	assert.Equal(t, src.Hostname, dst.Hostname)
    48  	assert.Equal(t, src.xorgConf, dst.xorgConf)
    49  	assert.Equal(t, src.openboxConf, dst.openboxConf)
    50  	assert.Equal(t, src.cursorEnabled, dst.cursorEnabled)
    51  	assert.Equal(t, src.displayctlEnabled, dst.displayctlEnabled)
    52  }
    53  
    54  func TestDeepCopyInto(t *testing.T) {
    55  	src := &Config{
    56  		Hostname:      hostname,
    57  		xorgConf:      &updatedXorgConf,
    58  		cursorEnabled: &enabled,
    59  	}
    60  
    61  	dst := &Config{
    62  		Hostname:          "old",
    63  		xorgConf:          ptr.To("old"),
    64  		cursorEnabled:     ptr.To(false),
    65  		displayctlEnabled: ptr.To(false),
    66  	}
    67  
    68  	src.DeepCopyInto(dst)
    69  
    70  	// check pointers are for new addresses
    71  	assert.NotSame(t, src, dst)
    72  	assert.NotSame(t, src.xorgConf, dst.xorgConf)
    73  	assert.NotSame(t, src.cursorEnabled, dst.cursorEnabled)
    74  
    75  	// check nil pointers are the same
    76  	assert.Same(t, src.openboxConf, dst.openboxConf)
    77  	assert.Same(t, src.displayctlEnabled, dst.displayctlEnabled)
    78  
    79  	// check values were copied
    80  	assert.Equal(t, src.Hostname, dst.Hostname)
    81  	assert.Equal(t, src.xorgConf, dst.xorgConf)
    82  	assert.Equal(t, src.cursorEnabled, dst.cursorEnabled)
    83  }
    84  
    85  func TestEqual(t *testing.T) {
    86  	assert.True(t, Equal(
    87  		nil,
    88  		nil,
    89  	))
    90  	assert.True(t, Equal(
    91  		&Config{},
    92  		&Config{},
    93  	))
    94  	assert.True(t, Equal(
    95  		&Config{xorgConf: &xorgConf, openboxConf: &openboxConf, cursorEnabled: &enabled, displayctlEnabled: &disabled},
    96  		&Config{xorgConf: &xorgConf, openboxConf: &openboxConf, cursorEnabled: &enabled, displayctlEnabled: &disabled},
    97  	))
    98  
    99  	assert.False(t, Equal(
   100  		nil,
   101  		&Config{},
   102  	))
   103  	assert.False(t, Equal(
   104  		&Config{xorgConf: &xorgConf},
   105  		nil,
   106  	))
   107  	assert.False(t, Equal(
   108  		&Config{xorgConf: &xorgConf},
   109  		&Config{xorgConf: &updatedXorgConf},
   110  	))
   111  	assert.False(t, Equal(
   112  		&Config{xorgConf: &xorgConf, openboxConf: &openboxConf, cursorEnabled: &enabled, displayctlEnabled: &disabled},
   113  		&Config{xorgConf: &xorgConf, openboxConf: &updatedOpenboxConf, cursorEnabled: &enabled, displayctlEnabled: &disabled},
   114  	))
   115  	assert.False(t, Equal(
   116  		&Config{xorgConf: &xorgConf, openboxConf: &openboxConf, cursorEnabled: &enabled, displayctlEnabled: &disabled},
   117  		&Config{xorgConf: &xorgConf, openboxConf: &openboxConf, cursorEnabled: &disabled, displayctlEnabled: &disabled},
   118  	))
   119  	assert.False(t, Equal(
   120  		&Config{xorgConf: &xorgConf, openboxConf: &openboxConf, cursorEnabled: &enabled, displayctlEnabled: &enabled},
   121  		&Config{xorgConf: &xorgConf, openboxConf: &openboxConf, cursorEnabled: &disabled, displayctlEnabled: &disabled},
   122  	))
   123  }
   124  
   125  func TestXorgConf(t *testing.T) {
   126  	// xorg config should be empty by default
   127  	config := &Config{}
   128  	assert.Equal(t, "", config.XorgConf())
   129  
   130  	// xorg config should return value when set
   131  	config.SetXorgConf(xorgConf)
   132  	assert.Equal(t, xorgConf, config.XorgConf())
   133  }
   134  
   135  func TestOpenboxConf(t *testing.T) {
   136  	// openbox config should be empty by default
   137  	config := &Config{}
   138  	assert.Equal(t, "", config.OpenboxConf())
   139  
   140  	// openbox config should return value when set
   141  	config.SetOpenboxConf(openboxConf)
   142  	assert.Equal(t, openboxConf, config.OpenboxConf())
   143  }
   144  
   145  func TestCursor(t *testing.T) {
   146  	// cursor should be disabled by default
   147  	config := &Config{}
   148  	assert.False(t, config.CursorEnabled())
   149  
   150  	// cursor should be disabled if set in config
   151  	config.SetCursorEnabled(false)
   152  	assert.False(t, config.CursorEnabled())
   153  
   154  	// cursor should be enabled if set in config
   155  	config.SetCursorEnabled(true)
   156  	assert.True(t, config.CursorEnabled())
   157  }
   158  
   159  func TestDisplayctlEnabled(t *testing.T) {
   160  	// dispalyctl should be enabled by default
   161  	config := &Config{}
   162  	assert.True(t, config.DisplayctlEnabled())
   163  
   164  	// displayctl should be disabled if Xorg config is provided
   165  	// but displayctl enabled is not specified
   166  	config.SetXorgConf(xorgConf)
   167  	assert.False(t, config.DisplayctlEnabled())
   168  
   169  	// displayctl should be enabled if Xorg config is provided
   170  	// and displayctl is enabled
   171  	config.SetDisplayctlEnabled(true)
   172  	assert.True(t, config.DisplayctlEnabled())
   173  }
   174  
   175  func TestToConfigMap(t *testing.T) {
   176  	config := &Config{
   177  		Hostname: hostname,
   178  	}
   179  
   180  	// empty config
   181  	assert.Equal(
   182  		t,
   183  		&corev1.ConfigMap{
   184  			ObjectMeta: metav1.ObjectMeta{
   185  				Namespace: constants.Namespace,
   186  				Name:      "xserver-config-test",
   187  			},
   188  			Data: map[string]string{},
   189  		},
   190  		config.ToConfigMap(),
   191  	)
   192  
   193  	// only Xorg config configured
   194  	config.SetXorgConf(xorgConf)
   195  	assert.Equal(
   196  		t,
   197  		&corev1.ConfigMap{
   198  			ObjectMeta: metav1.ObjectMeta{
   199  				Namespace: constants.Namespace,
   200  				Name:      "xserver-config-test",
   201  			},
   202  			Data: map[string]string{
   203  				xorgConfKey: xorgConf,
   204  			},
   205  		},
   206  		config.ToConfigMap(),
   207  	)
   208  
   209  	// all fields configured
   210  	config.SetOpenboxConf(openboxConf)
   211  	config.SetCursorEnabled(true)
   212  	config.SetDisplayctlEnabled(true)
   213  	assert.Equal(
   214  		t,
   215  		&corev1.ConfigMap{
   216  			ObjectMeta: metav1.ObjectMeta{
   217  				Namespace: constants.Namespace,
   218  				Name:      "xserver-config-test",
   219  			},
   220  			Data: map[string]string{
   221  				xorgConfKey:          xorgConf,
   222  				openboxConfKey:       openboxConf,
   223  				cursorEnabledKey:     strconv.FormatBool(enabled),
   224  				displayctlEnabledKey: strconv.FormatBool(enabled),
   225  			},
   226  		},
   227  		config.ToConfigMap(),
   228  	)
   229  }
   230  
   231  func TestFromConfigMap(t *testing.T) {
   232  	// nil ConfigMap returns error
   233  	config, err := FromConfigMap(nil)
   234  	assert.Nil(t, config)
   235  	assert.ErrorIs(t, err, errXServerConfigMapCannotBeNil)
   236  
   237  	// invalid name returns error
   238  	configMap := &corev1.ConfigMap{
   239  		ObjectMeta: metav1.ObjectMeta{
   240  			Namespace: constants.Namespace,
   241  			Name:      "xserver-config", // expects xserver-config-HOSTNAME
   242  		},
   243  		Data: map[string]string{},
   244  	}
   245  	config, err = FromConfigMap(configMap)
   246  	assert.Nil(t, config)
   247  	assert.ErrorContains(t, err, errXServerConfigMapNameHasFromFormat.Error())
   248  
   249  	// valid name returns config as expected
   250  	configMap.ObjectMeta.Name = ConfigMapNameFromHostname(hostname)
   251  	config, err = FromConfigMap(configMap)
   252  	assert.NoError(t, err)
   253  	assert.Equal(t,
   254  		&Config{
   255  			Hostname: hostname,
   256  		},
   257  		config,
   258  	)
   259  
   260  	// update config fields
   261  	configMap.Data[xorgConfKey] = xorgConf
   262  	configMap.Data[openboxConfKey] = openboxConf
   263  	configMap.Data[cursorEnabledKey] = strconv.FormatBool(disabled)
   264  	configMap.Data[displayctlEnabledKey] = strconv.FormatBool(enabled)
   265  	config, err = FromConfigMap(configMap)
   266  	assert.NoError(t, err)
   267  	assert.Equal(t,
   268  		&Config{
   269  			Hostname:          hostname,
   270  			xorgConf:          &xorgConf,
   271  			openboxConf:       &openboxConf,
   272  			cursorEnabled:     &disabled,
   273  			displayctlEnabled: &enabled,
   274  		},
   275  		config,
   276  	)
   277  
   278  	// invalid cursor enabled value returns error
   279  	configMap.Data[cursorEnabledKey] = "enabled" // expects true/false
   280  	config, err = FromConfigMap(configMap)
   281  	assert.Nil(t, config)
   282  	assert.ErrorContains(t, err, cursorEnabledKey)
   283  	assert.ErrorContains(t, err, errFlagShouldBeTrueFalse.Error())
   284  
   285  	// invalid displayctl enabled value returns error
   286  	configMap.Data[cursorEnabledKey] = strconv.FormatBool(enabled)
   287  	configMap.Data[displayctlEnabledKey] = "enabled" // expects true/false
   288  	config, err = FromConfigMap(configMap)
   289  	assert.Nil(t, config)
   290  	assert.ErrorContains(t, err, displayctlEnabledKey)
   291  	assert.ErrorContains(t, err, errFlagShouldBeTrueFalse.Error())
   292  }
   293
View as plain text