istio.io/istio@v0.0.0-20240520182934-d79c90f27776/pilot/pkg/model/destination_rule_test.go (about)

     1  // Copyright Istio Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package model
    16  
    17  import (
    18  	"testing"
    19  
    20  	"k8s.io/apimachinery/pkg/types"
    21  
    22  	"istio.io/istio/pkg/test/util/assert"
    23  )
    24  
    25  func TestConsolidatedDestRuleEquals(t *testing.T) {
    26  	testcases := []struct {
    27  		name     string
    28  		l        *ConsolidatedDestRule
    29  		r        *ConsolidatedDestRule
    30  		expected bool
    31  	}{
    32  		{
    33  			name:     "two nil",
    34  			expected: true,
    35  		},
    36  		{
    37  			name: "l is nil",
    38  			l:    nil,
    39  			r: &ConsolidatedDestRule{
    40  				from: []types.NamespacedName{
    41  					{
    42  						Namespace: "default",
    43  						Name:      "dr1",
    44  					},
    45  				},
    46  			},
    47  			expected: false,
    48  		},
    49  		{
    50  			name: "r is nil",
    51  			l: &ConsolidatedDestRule{
    52  				from: []types.NamespacedName{
    53  					{
    54  						Namespace: "default",
    55  						Name:      "dr1",
    56  					},
    57  				},
    58  			},
    59  			r:        nil,
    60  			expected: false,
    61  		},
    62  		{
    63  			name: "from length not equal",
    64  			l: &ConsolidatedDestRule{
    65  				from: []types.NamespacedName{
    66  					{
    67  						Namespace: "default",
    68  						Name:      "dr1",
    69  					},
    70  				},
    71  			},
    72  			r: &ConsolidatedDestRule{
    73  				from: []types.NamespacedName{
    74  					{
    75  						Namespace: "default",
    76  						Name:      "dr1",
    77  					},
    78  					{
    79  						Namespace: "default",
    80  						Name:      "dr2",
    81  					},
    82  				},
    83  			},
    84  			expected: false,
    85  		},
    86  		{
    87  			name: "from length equals but element is different",
    88  			l: &ConsolidatedDestRule{
    89  				from: []types.NamespacedName{
    90  					{
    91  						Namespace: "default",
    92  						Name:      "dr1",
    93  					},
    94  					{
    95  						Namespace: "default",
    96  						Name:      "dr2",
    97  					},
    98  				},
    99  			},
   100  			r: &ConsolidatedDestRule{
   101  				from: []types.NamespacedName{
   102  					{
   103  						Namespace: "default",
   104  						Name:      "dr1",
   105  					},
   106  					{
   107  						Namespace: "default",
   108  						Name:      "dr3",
   109  					},
   110  				},
   111  			},
   112  			expected: false,
   113  		},
   114  		{
   115  			name: "all from elements equal",
   116  			l: &ConsolidatedDestRule{
   117  				from: []types.NamespacedName{
   118  					{
   119  						Namespace: "default",
   120  						Name:      "dr1",
   121  					},
   122  					{
   123  						Namespace: "default",
   124  						Name:      "dr2",
   125  					},
   126  				},
   127  			},
   128  			r: &ConsolidatedDestRule{
   129  				from: []types.NamespacedName{
   130  					{
   131  						Namespace: "default",
   132  						Name:      "dr1",
   133  					},
   134  					{
   135  						Namespace: "default",
   136  						Name:      "dr2",
   137  					},
   138  				},
   139  			},
   140  			expected: true,
   141  		},
   142  	}
   143  
   144  	for _, tc := range testcases {
   145  		t.Run(tc.name, func(t *testing.T) {
   146  			assert.Equal(t, tc.l.Equals(tc.r), tc.expected)
   147  		})
   148  	}
   149  }