github.com/kaisenlinux/docker@v0.0.0-20230510090727-ea55db55fac7/swarmkit/api/equality/equality_test.go (about)

     1  package equality
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/docker/swarmkit/api"
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func TestTasksEqualStable(t *testing.T) {
    12  	const taskCount = 5
    13  	var tasks [taskCount]*api.Task
    14  
    15  	for i := 0; i < taskCount; i++ {
    16  		tasks[i] = &api.Task{
    17  			ID:   "task-id",
    18  			Meta: api.Meta{Version: api.Version{Index: 6}},
    19  			Spec: api.TaskSpec{
    20  				Runtime: &api.TaskSpec_Container{
    21  					Container: &api.ContainerSpec{
    22  						Image: "redis:3.0.7",
    23  					},
    24  				},
    25  			},
    26  			ServiceID:    "service-id",
    27  			Slot:         3,
    28  			NodeID:       "node-id",
    29  			Status:       api.TaskStatus{State: api.TaskStateAssigned},
    30  			DesiredState: api.TaskStateReady,
    31  		}
    32  	}
    33  
    34  	tasks[1].Status.State = api.TaskStateFailed
    35  	tasks[2].Meta.Version.Index = 7
    36  	tasks[3].DesiredState = api.TaskStateRunning
    37  	tasks[4].Spec.Runtime = &api.TaskSpec_Container{
    38  		Container: &api.ContainerSpec{
    39  			Image: "redis:3.2.1",
    40  		},
    41  	}
    42  
    43  	var tests = []struct {
    44  		task        *api.Task
    45  		expected    bool
    46  		failureText string
    47  	}{
    48  		{tasks[1], true, "Tasks with different Status should be equal"},
    49  		{tasks[2], true, "Tasks with different Meta should be equal"},
    50  		{tasks[3], false, "Tasks with different DesiredState are not equal"},
    51  		{tasks[4], false, "Tasks with different Spec are not equal"},
    52  	}
    53  	for _, test := range tests {
    54  		assert.Equal(t, TasksEqualStable(tasks[0], test.task), test.expected, test.failureText)
    55  	}
    56  }
    57  
    58  func TestRootCAEqualStable(t *testing.T) {
    59  	root1 := api.RootCA{
    60  		CACert:     []byte("1"),
    61  		CAKey:      []byte("2"),
    62  		CACertHash: "hash",
    63  	}
    64  	root2 := root1
    65  	root2.JoinTokens = api.JoinTokens{
    66  		Worker:  "worker",
    67  		Manager: "manager",
    68  	}
    69  	root3 := root1
    70  	root3.RootRotation = &api.RootRotation{
    71  		CACert:            []byte("3"),
    72  		CAKey:             []byte("4"),
    73  		CrossSignedCACert: []byte("5"),
    74  	}
    75  
    76  	for _, v := range []struct{ a, b *api.RootCA }{
    77  		{a: nil, b: nil},
    78  		{a: &root1, b: &root1},
    79  		{a: &root1, b: &root2},
    80  		{a: &root3, b: &root3},
    81  	} {
    82  		require.True(t, RootCAEqualStable(v.a, v.b), "should be equal:\n%v\n%v\n", v.a, v.b)
    83  	}
    84  
    85  	root1Permutations := []api.RootCA{root1, root1, root1}
    86  	root3Permutations := []api.RootCA{root3, root3, root3}
    87  	for _, r := range root3Permutations {
    88  		copy := *r.RootRotation
    89  		root3.RootRotation = &copy
    90  	}
    91  	root1Permutations[0].CACert = []byte("nope")
    92  	root1Permutations[1].CAKey = []byte("nope")
    93  	root1Permutations[2].CACertHash = "nope"
    94  	root3Permutations[0].RootRotation.CACert = []byte("nope")
    95  	root3Permutations[1].RootRotation.CAKey = []byte("nope")
    96  	root3Permutations[2].RootRotation.CrossSignedCACert = []byte("nope")
    97  
    98  	for _, v := range []struct{ a, b *api.RootCA }{
    99  		{a: &root1, b: &root3},
   100  		{a: &root1, b: &root1Permutations[0]},
   101  		{a: &root1, b: &root1Permutations[1]},
   102  		{a: &root1, b: &root1Permutations[2]},
   103  		{a: &root3, b: &root3Permutations[0]},
   104  		{a: &root3, b: &root3Permutations[1]},
   105  		{a: &root3, b: &root3Permutations[2]},
   106  	} {
   107  		require.False(t, RootCAEqualStable(v.a, v.b), "should not be equal:\n%v\n%v\n", v.a, v.b)
   108  	}
   109  }
   110  
   111  func TestExternalCAsEqualStable(t *testing.T) {
   112  	externals := []*api.ExternalCA{
   113  		{URL: "1"},
   114  		{
   115  			URL:    "1",
   116  			CACert: []byte("cacert"),
   117  		},
   118  		{
   119  			URL:      "1",
   120  			CACert:   []byte("cacert"),
   121  			Protocol: 1,
   122  		},
   123  		{
   124  			URL:    "1",
   125  			CACert: []byte("cacert"),
   126  			Options: map[string]string{
   127  				"hello": "there",
   128  			},
   129  		},
   130  		{
   131  			URL:    "1",
   132  			CACert: []byte("cacert"),
   133  			Options: map[string]string{
   134  				"hello": "world",
   135  			},
   136  		},
   137  	}
   138  	// equal
   139  	for _, v := range []struct{ a, b []*api.ExternalCA }{
   140  		{a: nil, b: []*api.ExternalCA{}},
   141  		{a: externals, b: externals},
   142  		{a: externals[0:1], b: externals[0:1]},
   143  	} {
   144  		require.True(t, ExternalCAsEqualStable(v.a, v.b), "should be equal:\n%v\n%v\n", v.a, v.b)
   145  	}
   146  	// not equal
   147  	for _, v := range []struct{ a, b []*api.ExternalCA }{
   148  		{a: nil, b: externals},
   149  		{a: externals[2:3], b: externals[3:4]},
   150  		{a: externals[2:3], b: externals[4:5]},
   151  		{a: externals[3:4], b: externals[4:5]},
   152  	} {
   153  		require.False(t, ExternalCAsEqualStable(v.a, v.b), "should not be equal:\n%v\n%v\n", v.a, v.b)
   154  	}
   155  }