github.com/Cloud-Foundations/Dominator@v0.3.4/lib/mdb/compare_test.go (about)

     1  package mdb
     2  
     3  import (
     4  	"reflect"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/Cloud-Foundations/Dominator/lib/tags"
     9  )
    10  
    11  var (
    12  	stringType = reflect.TypeOf([]string{})
    13  )
    14  
    15  func makeNonzeroMachine(t *testing.T, zeroIndex int) Machine {
    16  	var machine Machine
    17  	machineValue := reflect.ValueOf(&machine).Elem()
    18  	machineType := reflect.TypeOf(machine)
    19  	for index := 0; index < machineValue.NumField(); index++ {
    20  		if index == zeroIndex {
    21  			continue
    22  		}
    23  		fieldValue := machineValue.Field(index)
    24  		fieldKind := fieldValue.Kind()
    25  		fieldName := machineType.Field(index).Name
    26  		switch fieldKind {
    27  		case reflect.Bool:
    28  			fieldValue.SetBool(true)
    29  		case reflect.String:
    30  			fieldValue.SetString(fieldName)
    31  		case reflect.Ptr:
    32  			fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
    33  		case reflect.Map:
    34  			mapValue := reflect.MakeMap(fieldValue.Type())
    35  			fieldValue.Set(mapValue)
    36  			mapValue.SetMapIndex(reflect.ValueOf("key"),
    37  				reflect.ValueOf("value"))
    38  		case reflect.Slice:
    39  			sliceValue := reflect.MakeSlice(stringType, 2, 2)
    40  			fieldValue.Set(sliceValue)
    41  			sliceValue.Index(0).SetString(fieldName)
    42  			sliceValue.Index(1).SetString(strings.ToLower(fieldName))
    43  		default:
    44  			t.Fatalf("Unsupported field type: %s", fieldKind)
    45  		}
    46  	}
    47  	return machine
    48  }
    49  
    50  func TestCompare(t *testing.T) {
    51  	left := makeNonzeroMachine(t, -1)
    52  	right := Machine{Hostname: left.Hostname}
    53  	if got := left.Compare(right); got != false {
    54  		t.Errorf("Compare(%v, %v) = %v", left, right, got)
    55  	}
    56  	right = makeNonzeroMachine(t, -1)
    57  	if got := left.Compare(right); got != true {
    58  		t.Errorf("Compare(%v, %v) = %v", left, right, got)
    59  	}
    60  	right.Tags["key"] = "value"
    61  	if got := left.Compare(right); got != true {
    62  		t.Errorf("Compare(%v, %v) = %v", left, right, got)
    63  	}
    64  	right.Tags["key"] = "another value"
    65  	if got := left.Compare(right); got != false {
    66  		t.Errorf("Compare(%v, %v) = %v", left, right, got)
    67  	}
    68  }
    69  
    70  func TestCompareAwsMetadata(t *testing.T) {
    71  	var tests = []struct {
    72  		left, right *AwsMetadata
    73  		want        bool
    74  	}{
    75  		{ // No tags, same metadata.
    76  			&AwsMetadata{"aId-0", "aName-0", "i-0", "r-0", nil},
    77  			&AwsMetadata{"aId-0", "aName-0", "i-0", "r-0", nil}, true},
    78  		{ // No tags, different instance.
    79  			&AwsMetadata{"aId-0", "aName-0", "i-0", "r-0", nil},
    80  			&AwsMetadata{"aId-0", "aName-0", "i-1", "r-0", nil}, false},
    81  		{ // No tags, different AccountId.
    82  			&AwsMetadata{"aId-0", "aName-0", "i-0", "r-0", nil},
    83  			&AwsMetadata{"aId-1", "aName-0", "i-0", "r-0", nil}, false},
    84  		{ // No tags, different AccountName.
    85  			&AwsMetadata{"aId-0", "aName-0", "i-0", "r-0", nil},
    86  			&AwsMetadata{"aId-0", "aName-1", "i-0", "r-0", nil}, false},
    87  		{ // No tags, different Region.
    88  			&AwsMetadata{"aId-0", "aName-0", "i-0", "r-0", nil},
    89  			&AwsMetadata{"aId-0", "aName-0", "i-0", "r-1", nil}, false},
    90  		{ // One tag, the same.
    91  			&AwsMetadata{"aId-0", "aName-0", "i-2", "r-0",
    92  				tags.Tags{"k0": "v0"}},
    93  			&AwsMetadata{"aId-0", "aName-0", "i-2", "r-0",
    94  				tags.Tags{"k0": "v0"}},
    95  			true,
    96  		},
    97  		{ // One tag, different.
    98  			&AwsMetadata{"aId-0", "aName-0", "i-3", "r-0",
    99  				tags.Tags{"k0": "v0"}},
   100  			&AwsMetadata{"aId-0", "aName-0", "i-3", "r-0",
   101  				tags.Tags{"k0": "v1"}},
   102  			false,
   103  		},
   104  		{ // Two tags, the same.
   105  			&AwsMetadata{"aId-0", "aName-0", "i-4", "r-0",
   106  				tags.Tags{"k0": "v0", "k1": "v1"}},
   107  			&AwsMetadata{"aId-0", "aName-0", "i-4", "r-0",
   108  				tags.Tags{"k0": "v0", "k1": "v1"}},
   109  			true,
   110  		},
   111  		{ // Two tags added in a different order, the same
   112  			&AwsMetadata{"aId-0", "aName-0", "i-5", "r-0",
   113  				tags.Tags{"k0": "v0", "k1": "v1"}},
   114  			&AwsMetadata{"aId-0", "aName-0", "i-5", "r-0",
   115  				tags.Tags{"k1": "v1", "k0": "v0"}},
   116  			true,
   117  		},
   118  		{ // Two tags, values swapped.
   119  			&AwsMetadata{"aId-0", "aName-0", "i-6", "r-0",
   120  				tags.Tags{"k0": "v0", "k1": "v1"}},
   121  			&AwsMetadata{"aId-0", "aName-0", "i-6", "r-0",
   122  				tags.Tags{"k0": "v1", "k1": "v0"}},
   123  			false,
   124  		},
   125  	}
   126  	for _, test := range tests {
   127  		if got := compareAwsMetadata(test.left, test.right); got != test.want {
   128  			t.Errorf("Less(%q, %q) = %v", test.left, test.right, got)
   129  		}
   130  	}
   131  }
   132  
   133  func TestCompareEachField(t *testing.T) {
   134  	left := makeNonzeroMachine(t, -1)
   135  	for index := 0; index < reflect.TypeOf(left).NumField(); index++ {
   136  		right := makeNonzeroMachine(t, index)
   137  		if got := left.Compare(right); got != false {
   138  			t.Errorf("Compare(%v, %v) = %v", left, right, got)
   139  		}
   140  	}
   141  }