displayconfig_validate_test.go

Documentation: edge-infra.dev/pkg/sds/display/k8s/apis/v2

     1  package v2
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  
     8  	v1 "edge-infra.dev/pkg/sds/display/k8s/apis/v1"
     9  )
    10  
    11  func TestValidateDisplayPorts(t *testing.T) {
    12  	tcs := []struct {
    13  		displayConfig *DisplayConfig
    14  		valid         bool
    15  	}{
    16  		// test case 1: no displays configured
    17  		{
    18  			displayConfig: &DisplayConfig{Displays: Displays{}},
    19  			valid:         true,
    20  		},
    21  		// test case 2: single display port configured
    22  		{
    23  			displayConfig: &DisplayConfig{Displays: Displays{
    24  				{DisplayPort: NewDisplayPort("card0", "DP1")},
    25  			}},
    26  			valid: true,
    27  		},
    28  		// test case 3: multiple display ports configured
    29  		{
    30  			displayConfig: &DisplayConfig{Displays: Displays{
    31  				{DisplayPort: NewDisplayPort("card0", "DP1")},
    32  				{DisplayPort: NewDisplayPort("card1", "DP2")},
    33  			}},
    34  			valid: true,
    35  		},
    36  		// test case 4: identical displays ports configured
    37  		{
    38  			displayConfig: &DisplayConfig{Displays: Displays{
    39  				{DisplayPort: NewDisplayPort("card0", "DP1")},
    40  				{DisplayPort: NewDisplayPort("card0", "DP1")},
    41  			}},
    42  			valid: false,
    43  		},
    44  	}
    45  	for idx, tc := range tcs {
    46  		err := tc.displayConfig.Validate()
    47  		if tc.valid {
    48  			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
    49  			continue
    50  		}
    51  		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
    52  	}
    53  }
    54  
    55  func TestValidateNonSettableFields(t *testing.T) {
    56  	mpid := MPID("1234")
    57  	tcs := []struct {
    58  		displayConfig *DisplayConfig
    59  		valid         bool
    60  	}{
    61  		// test case 1: MPID is set in display config spec
    62  		{
    63  			displayConfig: &DisplayConfig{Displays: Displays{
    64  				{MPID: nil, SupportedResolutions: []Resolution{}},
    65  			}},
    66  			valid: false,
    67  		},
    68  		// test case 2: supported resolutions is set in display config spec
    69  		{
    70  			displayConfig: &DisplayConfig{Displays: Displays{
    71  				{MPID: &mpid, SupportedResolutions: nil},
    72  			}},
    73  			valid: false,
    74  		},
    75  		// test case 3: MPID / supported resolutions are not set in display spec
    76  		{
    77  			displayConfig: &DisplayConfig{Displays: Displays{
    78  				{MPID: nil, SupportedResolutions: nil},
    79  			}},
    80  			valid: true,
    81  		},
    82  	}
    83  	for idx, tc := range tcs {
    84  		err := tc.displayConfig.Validate()
    85  		if tc.valid {
    86  			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
    87  			continue
    88  		}
    89  		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
    90  	}
    91  }
    92  
    93  func TestValidateV1(t *testing.T) {
    94  	tcs := []struct {
    95  		displayConfig *DisplayConfig
    96  		valid         bool
    97  	}{
    98  		// test case 1: v1 display configuration is not configured
    99  		{
   100  			displayConfig: &DisplayConfig{V1: nil},
   101  			valid:         true,
   102  		},
   103  		// test case 2: v2 displays and v1 display configuration configured
   104  		{
   105  			displayConfig: &DisplayConfig{Displays: Displays{
   106  				{Primary: &primary, DisplayPort: NewDisplayPort("card0", "DP1")},
   107  			},
   108  				V1: &v1.DisplayConfig{}},
   109  			valid: false,
   110  		},
   111  		// test case 3: v2 layouts and v1 display configuration configured
   112  		{
   113  			displayConfig: &DisplayConfig{
   114  				Layout: Layout{NewDisplayPort("card0", "DP1")},
   115  				V1:     &v1.DisplayConfig{},
   116  			},
   117  			valid: false,
   118  		},
   119  		// test case 4: v2 DPMS and v1 display configuration configured
   120  		{
   121  			displayConfig: &DisplayConfig{
   122  				DPMS: &DPMS{
   123  					StandbyTime: &thirtySeconds,
   124  					SuspendTime: &sixtySeconds,
   125  					OffTime:     &ninetySeconds,
   126  				},
   127  				V1: &v1.DisplayConfig{}},
   128  			valid: false,
   129  		},
   130  		// test case 5: v1 display configuration configured
   131  		{
   132  			displayConfig: &DisplayConfig{
   133  				V1: &v1.DisplayConfig{},
   134  			},
   135  			valid: true,
   136  		},
   137  	}
   138  	for idx, tc := range tcs {
   139  		err := tc.displayConfig.Validate()
   140  		if tc.valid {
   141  			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
   142  			continue
   143  		}
   144  		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
   145  	}
   146  }
   147  
   148  func TestValidatePrimary(t *testing.T) {
   149  	tcs := []struct {
   150  		displayConfig *DisplayConfig
   151  		valid         bool
   152  	}{
   153  		// test case 1: no primary dislay configured
   154  		{
   155  			displayConfig: &DisplayConfig{
   156  				Displays: Displays{
   157  					{DisplayPort: NewDisplayPort("card0", "DP1")},
   158  					{DisplayPort: NewDisplayPort("card1", "DP2")},
   159  				},
   160  			},
   161  			valid: true,
   162  		},
   163  		// test case 2: single primary display configured
   164  		{
   165  			displayConfig: &DisplayConfig{
   166  				Displays: Displays{
   167  					{Primary: &primary, DisplayPort: NewDisplayPort("card0", "DP1")},
   168  				},
   169  			},
   170  			valid: true,
   171  		},
   172  		// test case 3: multiple primary displays configured
   173  		{
   174  			displayConfig: &DisplayConfig{Displays: Displays{
   175  				{Primary: &primary, DisplayPort: NewDisplayPort("card0", "DP1")},
   176  				{Primary: &primary, DisplayPort: NewDisplayPort("card1", "DP2")},
   177  			}},
   178  			valid: false,
   179  		},
   180  	}
   181  	for idx, tc := range tcs {
   182  		err := tc.displayConfig.Validate()
   183  		if tc.valid {
   184  			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
   185  			continue
   186  		}
   187  		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
   188  	}
   189  }
   190  
   191  func TestValidateDMPS(t *testing.T) {
   192  	tcs := []struct {
   193  		displayConfig *DisplayConfig
   194  		valid         bool
   195  	}{
   196  		// test case 1: DPMS is not configured
   197  		{
   198  			displayConfig: &DisplayConfig{DPMS: nil},
   199  			valid:         true,
   200  		},
   201  		// test case 2: standby time greater than suspendTime
   202  		{
   203  			displayConfig: &DisplayConfig{DPMS: &DPMS{
   204  				StandbyTime: &sixtySeconds,
   205  				SuspendTime: &thirtySeconds,
   206  			}},
   207  			valid: false,
   208  		},
   209  		// test case 3: suspendTime greater than offTime
   210  		{
   211  			displayConfig: &DisplayConfig{DPMS: &DPMS{
   212  				SuspendTime: &sixtySeconds,
   213  				OffTime:     &thirtySeconds,
   214  			}},
   215  			valid: false,
   216  		},
   217  		// test case 4: valid DPMS configuration
   218  		{
   219  			displayConfig: &DisplayConfig{DPMS: &DPMS{
   220  				StandbyTime: &thirtySeconds,
   221  				SuspendTime: &sixtySeconds,
   222  				OffTime:     &ninetySeconds,
   223  			}},
   224  			valid: true,
   225  		},
   226  	}
   227  	for idx, tc := range tcs {
   228  		err := tc.displayConfig.Validate()
   229  		if tc.valid {
   230  			assert.NoError(t, err, "test case %d failed: display config should be valid", idx+1)
   231  			continue
   232  		}
   233  		assert.Error(t, err, "test case %d failed: display config should be invalid", idx+1)
   234  	}
   235  }
   236
View as plain text