github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/common/configtx/compare_test.go (about)

     1  /*
     2  Copyright hechain. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package configtx
     8  
     9  import (
    10  	"testing"
    11  
    12  	cb "github.com/hyperledger/fabric-protos-go/common"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestCompareConfigValue(t *testing.T) {
    17  	// Normal equality
    18  	require.True(t, comparable{
    19  		ConfigValue: &cb.ConfigValue{
    20  			Version:   0,
    21  			ModPolicy: "foo",
    22  			Value:     []byte("bar"),
    23  		},
    24  	}.equals(comparable{
    25  		ConfigValue: &cb.ConfigValue{
    26  			Version:   0,
    27  			ModPolicy: "foo",
    28  			Value:     []byte("bar"),
    29  		},
    30  	}), "Should have found identical config values to be identical")
    31  
    32  	// Different Mod Policy
    33  	require.False(t, comparable{
    34  		ConfigValue: &cb.ConfigValue{
    35  			Version:   0,
    36  			ModPolicy: "foo",
    37  			Value:     []byte("bar"),
    38  		},
    39  	}.equals(comparable{
    40  		ConfigValue: &cb.ConfigValue{
    41  			Version:   0,
    42  			ModPolicy: "bar",
    43  			Value:     []byte("bar"),
    44  		},
    45  	}), "Should have detected different mod policy")
    46  
    47  	// Different Value
    48  	require.False(t, comparable{
    49  		ConfigValue: &cb.ConfigValue{
    50  			Version:   0,
    51  			ModPolicy: "foo",
    52  			Value:     []byte("bar"),
    53  		},
    54  	}.equals(comparable{
    55  		ConfigValue: &cb.ConfigValue{
    56  			Version:   0,
    57  			ModPolicy: "foo",
    58  			Value:     []byte("foo"),
    59  		},
    60  	}), "Should have detected different value")
    61  
    62  	// Different Version
    63  	require.False(t, comparable{
    64  		ConfigValue: &cb.ConfigValue{
    65  			Version:   0,
    66  			ModPolicy: "foo",
    67  			Value:     []byte("bar"),
    68  		},
    69  	}.equals(comparable{
    70  		ConfigValue: &cb.ConfigValue{
    71  			Version:   1,
    72  			ModPolicy: "foo",
    73  			Value:     []byte("bar"),
    74  		},
    75  	}), "Should have detected different version")
    76  
    77  	// One nil value
    78  	require.False(t, comparable{
    79  		ConfigValue: &cb.ConfigValue{
    80  			Version:   0,
    81  			ModPolicy: "foo",
    82  			Value:     []byte("bar"),
    83  		},
    84  	}.equals(comparable{}), "Should have detected nil other value")
    85  }
    86  
    87  func TestCompareConfigPolicy(t *testing.T) {
    88  	// Normal equality
    89  	require.True(t, comparable{
    90  		ConfigPolicy: &cb.ConfigPolicy{
    91  			Version:   0,
    92  			ModPolicy: "foo",
    93  			Policy: &cb.Policy{
    94  				Type:  1,
    95  				Value: []byte("foo"),
    96  			},
    97  		},
    98  	}.equals(comparable{
    99  		ConfigPolicy: &cb.ConfigPolicy{
   100  			Version:   0,
   101  			ModPolicy: "foo",
   102  			Policy: &cb.Policy{
   103  				Type:  1,
   104  				Value: []byte("foo"),
   105  			},
   106  		},
   107  	}), "Should have found identical config policies to be identical")
   108  
   109  	// Different mod policy
   110  	require.False(t, comparable{
   111  		ConfigPolicy: &cb.ConfigPolicy{
   112  			Version:   0,
   113  			ModPolicy: "foo",
   114  			Policy: &cb.Policy{
   115  				Type:  1,
   116  				Value: []byte("foo"),
   117  			},
   118  		},
   119  	}.equals(comparable{
   120  		ConfigPolicy: &cb.ConfigPolicy{
   121  			Version:   0,
   122  			ModPolicy: "bar",
   123  			Policy: &cb.Policy{
   124  				Type:  1,
   125  				Value: []byte("foo"),
   126  			},
   127  		},
   128  	}), "Should have detected different mod policy")
   129  
   130  	// Different version
   131  	require.False(t, comparable{
   132  		ConfigPolicy: &cb.ConfigPolicy{
   133  			Version:   0,
   134  			ModPolicy: "foo",
   135  			Policy: &cb.Policy{
   136  				Type:  1,
   137  				Value: []byte("foo"),
   138  			},
   139  		},
   140  	}.equals(comparable{
   141  		ConfigPolicy: &cb.ConfigPolicy{
   142  			Version:   1,
   143  			ModPolicy: "foo",
   144  			Policy: &cb.Policy{
   145  				Type:  1,
   146  				Value: []byte("foo"),
   147  			},
   148  		},
   149  	}), "Should have detected different version")
   150  
   151  	// Different policy type
   152  	require.False(t, comparable{
   153  		ConfigPolicy: &cb.ConfigPolicy{
   154  			Version:   0,
   155  			ModPolicy: "foo",
   156  			Policy: &cb.Policy{
   157  				Type:  1,
   158  				Value: []byte("foo"),
   159  			},
   160  		},
   161  	}.equals(comparable{
   162  		ConfigPolicy: &cb.ConfigPolicy{
   163  			Version:   0,
   164  			ModPolicy: "foo",
   165  			Policy: &cb.Policy{
   166  				Type:  2,
   167  				Value: []byte("foo"),
   168  			},
   169  		},
   170  	}), "Should have detected different policy type")
   171  
   172  	// Different policy value
   173  	require.False(t, comparable{
   174  		ConfigPolicy: &cb.ConfigPolicy{
   175  			Version:   0,
   176  			ModPolicy: "foo",
   177  			Policy: &cb.Policy{
   178  				Type:  1,
   179  				Value: []byte("foo"),
   180  			},
   181  		},
   182  	}.equals(comparable{
   183  		ConfigPolicy: &cb.ConfigPolicy{
   184  			Version:   0,
   185  			ModPolicy: "foo",
   186  			Policy: &cb.Policy{
   187  				Type:  1,
   188  				Value: []byte("bar"),
   189  			},
   190  		},
   191  	}), "Should have detected different policy value")
   192  
   193  	// One nil value
   194  	require.False(t, comparable{
   195  		ConfigPolicy: &cb.ConfigPolicy{
   196  			Version:   0,
   197  			ModPolicy: "foo",
   198  			Policy: &cb.Policy{
   199  				Type:  1,
   200  				Value: []byte("foo"),
   201  			},
   202  		},
   203  	}.equals(comparable{}), "Should have detected one nil value")
   204  
   205  	// One nil policy
   206  	require.False(t, comparable{
   207  		ConfigPolicy: &cb.ConfigPolicy{
   208  			Version:   0,
   209  			ModPolicy: "foo",
   210  			Policy: &cb.Policy{
   211  				Type:  1,
   212  				Value: []byte("foo"),
   213  			},
   214  		},
   215  	}.equals(comparable{
   216  		ConfigPolicy: &cb.ConfigPolicy{
   217  			Version:   0,
   218  			ModPolicy: "foo",
   219  			Policy: &cb.Policy{
   220  				Type: 1,
   221  			},
   222  		},
   223  	}), "Should have detected one nil policy")
   224  }
   225  
   226  func TestCompareConfigGroup(t *testing.T) {
   227  	// Normal equality
   228  	require.True(t, comparable{
   229  		ConfigGroup: &cb.ConfigGroup{
   230  			Version:   0,
   231  			ModPolicy: "foo",
   232  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   233  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   234  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   235  		},
   236  	}.equals(comparable{
   237  		ConfigGroup: &cb.ConfigGroup{
   238  			Version:   0,
   239  			ModPolicy: "foo",
   240  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   241  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   242  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   243  		},
   244  	}), "Should have found identical config groups to be identical")
   245  
   246  	// Different mod policy
   247  	require.False(t, comparable{
   248  		ConfigGroup: &cb.ConfigGroup{
   249  			Version:   0,
   250  			ModPolicy: "foo",
   251  		},
   252  	}.equals(comparable{
   253  		ConfigGroup: &cb.ConfigGroup{
   254  			Version:   0,
   255  			ModPolicy: "bar",
   256  		},
   257  	}), "Should have detected different mod policy")
   258  
   259  	// Different version
   260  	require.False(t, comparable{
   261  		ConfigGroup: &cb.ConfigGroup{
   262  			Version:   0,
   263  			ModPolicy: "foo",
   264  		},
   265  	}.equals(comparable{
   266  		ConfigGroup: &cb.ConfigGroup{
   267  			Version:   1,
   268  			ModPolicy: "foo",
   269  		},
   270  	}), "Should have detected different version")
   271  
   272  	// Different groups
   273  	require.False(t, comparable{
   274  		ConfigGroup: &cb.ConfigGroup{
   275  			Version:   0,
   276  			ModPolicy: "foo",
   277  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil},
   278  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   279  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   280  		},
   281  	}.equals(comparable{
   282  		ConfigGroup: &cb.ConfigGroup{
   283  			Version:   0,
   284  			ModPolicy: "foo",
   285  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   286  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   287  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   288  		},
   289  	}), "Should have detected different groups entries")
   290  
   291  	// Different values
   292  	require.False(t, comparable{
   293  		ConfigGroup: &cb.ConfigGroup{
   294  			Version:   0,
   295  			ModPolicy: "foo",
   296  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   297  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   298  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   299  		},
   300  	}.equals(comparable{
   301  		ConfigGroup: &cb.ConfigGroup{
   302  			Version:   0,
   303  			ModPolicy: "foo",
   304  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   305  			Values:    map[string]*cb.ConfigValue{"Foo2": nil},
   306  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   307  		},
   308  	}), "Should have detected fifferent values entries")
   309  
   310  	// Different policies
   311  	require.False(t, comparable{
   312  		ConfigGroup: &cb.ConfigGroup{
   313  			Version:   0,
   314  			ModPolicy: "foo",
   315  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   316  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   317  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   318  		},
   319  	}.equals(comparable{
   320  		ConfigGroup: &cb.ConfigGroup{
   321  			Version:   0,
   322  			ModPolicy: "foo",
   323  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   324  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   325  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar4": nil},
   326  		},
   327  	}), "Should have detected fifferent policies entries")
   328  }