github.com/Equinix-Metal/virtlet@v1.5.2-0.20210807010419-342346535dc5/pkg/version/version_test.go (about)

     1  package version
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/Equinix-Metal/virtlet/tests/gm"
     7  )
     8  
     9  func withNodeName(name string, v Info) Info {
    10  	v.NodeName = name
    11  	return v
    12  }
    13  
    14  var (
    15  	sampleVersionInfo = Info{
    16  		Major:        "1",
    17  		Minor:        "0",
    18  		GitVersion:   "v1.0.0-6+318faff6ad0609-dirty",
    19  		GitCommit:    "318faff6ad060954387c1ff594bcbb4bb128577a",
    20  		GitTreeState: "dirty",
    21  		BuildDate:    "2018-04-16T21:02:05Z",
    22  		GoVersion:    "go1.8.3",
    23  		Compiler:     "gc",
    24  		Platform:     "darwin/amd64",
    25  		ImageTag:     "ivan4th_version",
    26  	}
    27  	linuxVersionInfo = Info{
    28  		NodeName:     "kube-node-1",
    29  		Major:        "1",
    30  		Minor:        "0",
    31  		GitVersion:   "v1.0.0-6+318faff6ad0609",
    32  		GitCommit:    "318faff6ad060954387c1ff594bcbb4bb128577a",
    33  		GitTreeState: "clean",
    34  		BuildDate:    "2018-04-16T21:02:05Z",
    35  		GoVersion:    "go1.8.3",
    36  		Compiler:     "gc",
    37  		Platform:     "linux/amd64",
    38  	}
    39  	sampleClusterVersionInfo = ClusterVersionInfo{
    40  		ClientVersion: sampleVersionInfo,
    41  		NodeVersions: []Info{
    42  			withNodeName("kube-node-1", linuxVersionInfo),
    43  			withNodeName("kube-node-2", linuxVersionInfo),
    44  		},
    45  	}
    46  	emptyClusterVersionInfo = ClusterVersionInfo{
    47  		ClientVersion: sampleVersionInfo,
    48  	}
    49  )
    50  
    51  func TestVersion(t *testing.T) {
    52  	for _, tc := range []struct {
    53  		format string
    54  		error  bool
    55  		wrap   func([]byte) gm.Verifier
    56  	}{
    57  		{
    58  			format: "text",
    59  			error:  false,
    60  		},
    61  		{
    62  			format: "short",
    63  			error:  false,
    64  		},
    65  		{
    66  			format: "json",
    67  			error:  false,
    68  			wrap:   func(bs []byte) gm.Verifier { return gm.NewJSONVerifier(bs) },
    69  		},
    70  		{
    71  			format: "yaml",
    72  			error:  false,
    73  			wrap:   func(bs []byte) gm.Verifier { return gm.NewYamlVerifier(bs) },
    74  		},
    75  		{
    76  			format: "foobar",
    77  			error:  true,
    78  		},
    79  	} {
    80  		t.Run(tc.format, func(t *testing.T) {
    81  			out, err := sampleVersionInfo.ToBytes(tc.format)
    82  			switch {
    83  			case err != nil && tc.error:
    84  				// ok
    85  			case err != nil:
    86  				t.Errorf("ToBytes(): unexpected error: %v", err)
    87  			case tc.wrap != nil:
    88  				gm.Verify(t, tc.wrap(out))
    89  			default:
    90  				gm.Verify(t, out)
    91  			}
    92  		})
    93  	}
    94  }
    95  
    96  func TestClusterVersion(t *testing.T) {
    97  	for _, tc := range []struct {
    98  		format string
    99  		error  bool
   100  		wrap   func([]byte) gm.Verifier
   101  	}{
   102  		{
   103  			format: "text",
   104  			error:  false,
   105  		},
   106  		{
   107  			format: "short",
   108  			error:  false,
   109  		},
   110  		{
   111  			format: "json",
   112  			error:  false,
   113  			wrap:   func(bs []byte) gm.Verifier { return gm.NewJSONVerifier(bs) },
   114  		},
   115  		{
   116  			format: "yaml",
   117  			error:  false,
   118  			wrap:   func(bs []byte) gm.Verifier { return gm.NewYamlVerifier(bs) },
   119  		},
   120  		{
   121  			format: "foobar",
   122  			error:  true,
   123  		},
   124  	} {
   125  		for _, sub := range []struct {
   126  			suffix string
   127  			v      ClusterVersionInfo
   128  		}{{"", sampleClusterVersionInfo}, {"/empty", emptyClusterVersionInfo}} {
   129  			t.Run(tc.format+sub.suffix, func(t *testing.T) {
   130  				out, err := sub.v.ToBytes(tc.format)
   131  				switch {
   132  				case err != nil && tc.error:
   133  					// ok
   134  				case err != nil:
   135  					t.Errorf("ToBytes(): unexpected error: %v", err)
   136  				case tc.wrap != nil:
   137  					gm.Verify(t, tc.wrap(out))
   138  				default:
   139  					gm.Verify(t, out)
   140  				}
   141  			})
   142  		}
   143  	}
   144  }
   145  
   146  func TestNodeConsistency(t *testing.T) {
   147  	if !emptyClusterVersionInfo.AreNodesConsistent() {
   148  		t.Errorf("unexpected node inconsistency in %#v (no nodes)", emptyClusterVersionInfo)
   149  	}
   150  	if !sampleClusterVersionInfo.AreNodesConsistent() {
   151  		t.Errorf("unexpected node inconsistency in %#v", sampleClusterVersionInfo)
   152  	}
   153  	v := ClusterVersionInfo{
   154  		ClientVersion: sampleVersionInfo,
   155  		NodeVersions: []Info{
   156  			withNodeName("kube-node-1", linuxVersionInfo),
   157  			withNodeName("kube-node-2", linuxVersionInfo),
   158  		},
   159  	}
   160  	v.NodeVersions[1].BuildDate = "2018-04-17T07:16:01Z"
   161  	if v.AreNodesConsistent() {
   162  		t.Errorf("nodes aren't expected to be consistent in %#v", v)
   163  	}
   164  }