github.com/netdata/go.d.plugin@v0.58.1/modules/vsphere/discover/discover_test.go (about)

     1  // SPDX-License-Identifier: GPL-3.0-or-later
     2  
     3  package discover
     4  
     5  import (
     6  	"crypto/tls"
     7  	"net/url"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/netdata/go.d.plugin/modules/vsphere/client"
    12  	rs "github.com/netdata/go.d.plugin/modules/vsphere/resources"
    13  	"github.com/netdata/go.d.plugin/pkg/tlscfg"
    14  
    15  	"github.com/stretchr/testify/assert"
    16  	"github.com/stretchr/testify/require"
    17  	"github.com/vmware/govmomi/simulator"
    18  )
    19  
    20  func TestDiscoverer_Discover(t *testing.T) {
    21  	d, _, teardown := prepareDiscovererSim(t)
    22  	defer teardown()
    23  
    24  	res, err := d.Discover()
    25  
    26  	require.NoError(t, err)
    27  	assert.True(t, len(res.DataCenters) > 0)
    28  	assert.True(t, len(res.Folders) > 0)
    29  	assert.True(t, len(res.Clusters) > 0)
    30  	assert.True(t, len(res.Hosts) > 0)
    31  	assert.True(t, len(res.VMs) > 0)
    32  	assert.True(t, isHierarchySet(res))
    33  	assert.True(t, isMetricListsCollected(res))
    34  }
    35  
    36  func TestDiscoverer_discover(t *testing.T) {
    37  	d, model, teardown := prepareDiscovererSim(t)
    38  	defer teardown()
    39  
    40  	raw, err := d.discover()
    41  
    42  	require.NoError(t, err)
    43  	count := model.Count()
    44  	assert.Lenf(t, raw.dcs, count.Datacenter, "datacenters")
    45  	assert.Lenf(t, raw.folders, count.Folder-1, "folders") // minus root folder
    46  	dummyClusters := model.Host * count.Datacenter
    47  	assert.Lenf(t, raw.clusters, count.Cluster+dummyClusters, "clusters")
    48  	assert.Lenf(t, raw.hosts, count.Host, "hosts")
    49  	assert.Lenf(t, raw.vms, count.Machine, "hosts")
    50  }
    51  
    52  func TestDiscoverer_build(t *testing.T) {
    53  	d, _, teardown := prepareDiscovererSim(t)
    54  	defer teardown()
    55  
    56  	raw, err := d.discover()
    57  	require.NoError(t, err)
    58  
    59  	res := d.build(raw)
    60  
    61  	assert.Lenf(t, res.DataCenters, len(raw.dcs), "datacenters")
    62  	assert.Lenf(t, res.Folders, len(raw.folders), "folders")
    63  	assert.Lenf(t, res.Clusters, len(raw.clusters), "clusters")
    64  	assert.Lenf(t, res.Hosts, len(raw.hosts), "hosts")
    65  	assert.Lenf(t, res.VMs, len(raw.vms), "hosts")
    66  }
    67  
    68  func TestDiscoverer_setHierarchy(t *testing.T) {
    69  	d, _, teardown := prepareDiscovererSim(t)
    70  	defer teardown()
    71  
    72  	raw, err := d.discover()
    73  	require.NoError(t, err)
    74  	res := d.build(raw)
    75  
    76  	err = d.setHierarchy(res)
    77  
    78  	require.NoError(t, err)
    79  	assert.True(t, isHierarchySet(res))
    80  }
    81  
    82  func TestDiscoverer_removeUnmatched(t *testing.T) {
    83  	d, _, teardown := prepareDiscovererSim(t)
    84  	defer teardown()
    85  
    86  	d.HostMatcher = falseHostMatcher{}
    87  	d.VMMatcher = falseVMMatcher{}
    88  	raw, err := d.discover()
    89  	require.NoError(t, err)
    90  	res := d.build(raw)
    91  
    92  	numVMs, numHosts := len(res.VMs), len(res.Hosts)
    93  	assert.Equal(t, numVMs+numHosts, d.removeUnmatched(res))
    94  	assert.Lenf(t, res.Hosts, 0, "hosts")
    95  	assert.Lenf(t, res.VMs, 0, "vms")
    96  }
    97  
    98  func TestDiscoverer_collectMetricLists(t *testing.T) {
    99  	d, _, teardown := prepareDiscovererSim(t)
   100  	defer teardown()
   101  
   102  	raw, err := d.discover()
   103  	require.NoError(t, err)
   104  
   105  	res := d.build(raw)
   106  	err = d.collectMetricLists(res)
   107  
   108  	require.NoError(t, err)
   109  	assert.True(t, isMetricListsCollected(res))
   110  }
   111  
   112  func prepareDiscovererSim(t *testing.T) (d *Discoverer, model *simulator.Model, teardown func()) {
   113  	model, srv := createSim(t)
   114  	teardown = func() { model.Remove(); srv.Close() }
   115  	c := newClient(t, srv.URL)
   116  
   117  	return New(c), model, teardown
   118  }
   119  
   120  func newClient(t *testing.T, vCenterURL *url.URL) *client.Client {
   121  	c, err := client.New(client.Config{
   122  		URL:       vCenterURL.String(),
   123  		User:      "admin",
   124  		Password:  "password",
   125  		Timeout:   time.Second * 3,
   126  		TLSConfig: tlscfg.TLSConfig{InsecureSkipVerify: true},
   127  	})
   128  	require.NoError(t, err)
   129  	return c
   130  }
   131  
   132  func createSim(t *testing.T) (*simulator.Model, *simulator.Server) {
   133  	model := simulator.VPX()
   134  	err := model.Create()
   135  	require.NoError(t, err)
   136  	model.Service.TLS = new(tls.Config)
   137  	return model, model.Service.NewServer()
   138  }
   139  
   140  func isHierarchySet(res *rs.Resources) bool {
   141  	for _, c := range res.Clusters {
   142  		if !c.Hier.IsSet() {
   143  			return false
   144  		}
   145  	}
   146  	for _, h := range res.Hosts {
   147  		if !h.Hier.IsSet() {
   148  			return false
   149  		}
   150  	}
   151  	for _, v := range res.VMs {
   152  		if !v.Hier.IsSet() {
   153  			return false
   154  		}
   155  	}
   156  	return true
   157  }
   158  
   159  func isMetricListsCollected(res *rs.Resources) bool {
   160  	for _, h := range res.Hosts {
   161  		if h.MetricList == nil {
   162  			return false
   163  		}
   164  	}
   165  	for _, v := range res.VMs {
   166  		if v.MetricList == nil {
   167  			return false
   168  		}
   169  	}
   170  	return true
   171  }
   172  
   173  type falseHostMatcher struct{}
   174  
   175  func (falseHostMatcher) Match(*rs.Host) bool { return false }
   176  
   177  type falseVMMatcher struct{}
   178  
   179  func (falseVMMatcher) Match(*rs.VM) bool { return false }