network_stats_test.go

Documentation: k8s.io/kubernetes/pkg/kubelet/winstats

     1  //go:build windows
     2  // +build windows
     3  
     4  /*
     5  Copyright 2023 The Kubernetes Authors.
     6  
     7  Licensed under the Apache License, Version 2.0 (the "License");
     8  you may not use this file except in compliance with the License.
     9  You may obtain a copy of the License at
    10  
    11      http://www.apache.org/licenses/LICENSE-2.0
    12  
    13  Unless required by applicable law or agreed to in writing, software
    14  distributed under the License is distributed on an "AS IS" BASIS,
    15  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    16  See the License for the specific language governing permissions and
    17  limitations under the License.
    18  */
    19  
    20  package winstats
    21  
    22  import (
    23  	"errors"
    24  	"testing"
    25  
    26  	cadvisorapi "github.com/google/cadvisor/info/v1"
    27  	"github.com/stretchr/testify/assert"
    28  )
    29  
    30  const fakeAdapterName = "fake-adapter"
    31  
    32  type fakePerfCounterImpl struct {
    33  	// Returned name.
    34  	name string
    35  	// Returned value.
    36  	value uint64
    37  	// If the perfCounter should raise an error.
    38  	raiseError bool
    39  }
    40  
    41  func (p *fakePerfCounterImpl) getData() (uint64, error) {
    42  	if p.raiseError {
    43  		return 0, errors.New("Expected getData error.")
    44  	}
    45  	return p.value, nil
    46  }
    47  
    48  func (p *fakePerfCounterImpl) getDataList() (map[string]uint64, error) {
    49  	if p.raiseError {
    50  		return nil, errors.New("Expected getDataList error.")
    51  	}
    52  
    53  	data := make(map[string]uint64)
    54  	data[p.name] = p.value
    55  	return data, nil
    56  }
    57  
    58  func newFakedNetworkCounters(raiseError bool) *networkCounter {
    59  	counters := make([]*fakePerfCounterImpl, 8)
    60  	for i := 0; i < 8; i++ {
    61  		counters[i] = &fakePerfCounterImpl{
    62  			name:       fakeAdapterName,
    63  			value:      1,
    64  			raiseError: raiseError,
    65  		}
    66  	}
    67  	return &networkCounter{
    68  		packetsReceivedPerSecondCounter: counters[0],
    69  		packetsSentPerSecondCounter:     counters[1],
    70  		bytesReceivedPerSecondCounter:   counters[2],
    71  		bytesSentPerSecondCounter:       counters[3],
    72  		packetsReceivedDiscardedCounter: counters[4],
    73  		packetsReceivedErrorsCounter:    counters[5],
    74  		packetsOutboundDiscardedCounter: counters[6],
    75  		packetsOutboundErrorsCounter:    counters[7],
    76  		adapterStats:                    map[string]cadvisorapi.InterfaceStats{},
    77  	}
    78  }
    79  
    80  func TestNewNetworkCounters(t *testing.T) {
    81  	_, err := newNetworkCounters()
    82  	assert.NoError(t, err)
    83  }
    84  
    85  func TestNetworkGetData(t *testing.T) {
    86  	netCounter := newFakedNetworkCounters(false)
    87  
    88  	// Add a net adapter that no longer exists in the adapterStats cache. It will
    89  	// have to be cleaned up after processing the data.
    90  	netCounter.adapterStats["other-fake-adapter"] = cadvisorapi.InterfaceStats{}
    91  
    92  	data, err := netCounter.getData()
    93  	assert.NoError(t, err)
    94  
    95  	// Make sure that we only have data from a single net adapter.
    96  	expectedStats := cadvisorapi.InterfaceStats{
    97  		Name:      fakeAdapterName,
    98  		RxPackets: 1,
    99  		TxPackets: 1,
   100  		RxBytes:   1,
   101  		TxBytes:   1,
   102  		RxDropped: 1,
   103  		RxErrors:  1,
   104  		TxDropped: 1,
   105  		TxErrors:  1,
   106  	}
   107  	assert.Equal(t, []cadvisorapi.InterfaceStats{expectedStats}, data)
   108  
   109  	// The returned data is cumulative, so the resulting values should be double on a second call.
   110  	data, err = netCounter.getData()
   111  	assert.NoError(t, err)
   112  	expectedStats = cadvisorapi.InterfaceStats{
   113  		Name:      fakeAdapterName,
   114  		RxPackets: 2,
   115  		TxPackets: 2,
   116  		RxBytes:   2,
   117  		TxBytes:   2,
   118  		RxDropped: 1,
   119  		RxErrors:  1,
   120  		TxDropped: 1,
   121  		TxErrors:  1,
   122  	}
   123  	assert.Equal(t, []cadvisorapi.InterfaceStats{expectedStats}, data)
   124  }
   125  
   126  func TestNetworkGetDataFailures(t *testing.T) {
   127  	netCounter := newFakedNetworkCounters(true)
   128  
   129  	_, err := netCounter.getData()
   130  	expectedMsg := "Expected getDataList error."
   131  	if err == nil || err.Error() != expectedMsg {
   132  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   133  	}
   134  
   135  	_, err = netCounter.getData()
   136  	netCounter.packetsReceivedPerSecondCounter.(*fakePerfCounterImpl).raiseError = false
   137  	if err == nil || err.Error() != expectedMsg {
   138  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   139  	}
   140  
   141  	_, err = netCounter.getData()
   142  	netCounter.packetsSentPerSecondCounter.(*fakePerfCounterImpl).raiseError = false
   143  	if err == nil || err.Error() != expectedMsg {
   144  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   145  	}
   146  
   147  	_, err = netCounter.getData()
   148  	netCounter.bytesReceivedPerSecondCounter.(*fakePerfCounterImpl).raiseError = false
   149  	if err == nil || err.Error() != expectedMsg {
   150  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   151  	}
   152  
   153  	_, err = netCounter.getData()
   154  	netCounter.bytesSentPerSecondCounter.(*fakePerfCounterImpl).raiseError = false
   155  	if err == nil || err.Error() != expectedMsg {
   156  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   157  	}
   158  
   159  	_, err = netCounter.getData()
   160  	netCounter.packetsReceivedDiscardedCounter.(*fakePerfCounterImpl).raiseError = false
   161  	if err == nil || err.Error() != expectedMsg {
   162  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   163  	}
   164  
   165  	_, err = netCounter.getData()
   166  	netCounter.packetsReceivedErrorsCounter.(*fakePerfCounterImpl).raiseError = false
   167  	if err == nil || err.Error() != expectedMsg {
   168  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   169  	}
   170  
   171  	_, err = netCounter.getData()
   172  	netCounter.packetsOutboundDiscardedCounter.(*fakePerfCounterImpl).raiseError = false
   173  	if err == nil || err.Error() != expectedMsg {
   174  		t.Fatalf("expected error message `%s` but got `%v`", expectedMsg, err)
   175  	}
   176  }
   177
View as plain text