github.com/myafeier/fabric@v1.0.1-0.20170722181825-3a4b1f2bce86/common/configtx/compare_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2017 All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8                   http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package configtx
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/stretchr/testify/assert"
    23  
    24  	cb "github.com/hyperledger/fabric/protos/common"
    25  )
    26  
    27  func TestCompareConfigValue(t *testing.T) {
    28  	// Normal equality
    29  	assert.True(t, comparable{
    30  		ConfigValue: &cb.ConfigValue{
    31  			Version:   0,
    32  			ModPolicy: "foo",
    33  			Value:     []byte("bar"),
    34  		}}.equals(comparable{
    35  		ConfigValue: &cb.ConfigValue{
    36  			Version:   0,
    37  			ModPolicy: "foo",
    38  			Value:     []byte("bar"),
    39  		}}), "Should have found identical config values to be identical")
    40  
    41  	// Different Mod Policy
    42  	assert.False(t, comparable{
    43  		ConfigValue: &cb.ConfigValue{
    44  			Version:   0,
    45  			ModPolicy: "foo",
    46  			Value:     []byte("bar"),
    47  		}}.equals(comparable{
    48  		ConfigValue: &cb.ConfigValue{
    49  			Version:   0,
    50  			ModPolicy: "bar",
    51  			Value:     []byte("bar"),
    52  		}}), "Should have detected different mod policy")
    53  
    54  	// Different Value
    55  	assert.False(t, comparable{
    56  		ConfigValue: &cb.ConfigValue{
    57  			Version:   0,
    58  			ModPolicy: "foo",
    59  			Value:     []byte("bar"),
    60  		}}.equals(comparable{
    61  		ConfigValue: &cb.ConfigValue{
    62  			Version:   0,
    63  			ModPolicy: "foo",
    64  			Value:     []byte("foo"),
    65  		}}), "Should have detected different value")
    66  
    67  	// Different Version
    68  	assert.False(t, comparable{
    69  		ConfigValue: &cb.ConfigValue{
    70  			Version:   0,
    71  			ModPolicy: "foo",
    72  			Value:     []byte("bar"),
    73  		}}.equals(comparable{
    74  		ConfigValue: &cb.ConfigValue{
    75  			Version:   1,
    76  			ModPolicy: "foo",
    77  			Value:     []byte("bar"),
    78  		}}), "Should have detected different version")
    79  
    80  	// One nil value
    81  	assert.False(t, comparable{
    82  		ConfigValue: &cb.ConfigValue{
    83  			Version:   0,
    84  			ModPolicy: "foo",
    85  			Value:     []byte("bar"),
    86  		}}.equals(comparable{}), "Should have detected nil other value")
    87  
    88  }
    89  
    90  func TestCompareConfigPolicy(t *testing.T) {
    91  	// Normal equality
    92  	assert.True(t, comparable{
    93  		ConfigPolicy: &cb.ConfigPolicy{
    94  			Version:   0,
    95  			ModPolicy: "foo",
    96  			Policy: &cb.Policy{
    97  				Type:  1,
    98  				Value: []byte("foo"),
    99  			},
   100  		}}.equals(comparable{
   101  		ConfigPolicy: &cb.ConfigPolicy{
   102  			Version:   0,
   103  			ModPolicy: "foo",
   104  			Policy: &cb.Policy{
   105  				Type:  1,
   106  				Value: []byte("foo"),
   107  			},
   108  		}}), "Should have found identical config policies to be identical")
   109  
   110  	// Different mod policy
   111  	assert.False(t, comparable{
   112  		ConfigPolicy: &cb.ConfigPolicy{
   113  			Version:   0,
   114  			ModPolicy: "foo",
   115  			Policy: &cb.Policy{
   116  				Type:  1,
   117  				Value: []byte("foo"),
   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  		}}), "Should have detected different mod policy")
   128  
   129  	// Different version
   130  	assert.False(t, comparable{
   131  		ConfigPolicy: &cb.ConfigPolicy{
   132  			Version:   0,
   133  			ModPolicy: "foo",
   134  			Policy: &cb.Policy{
   135  				Type:  1,
   136  				Value: []byte("foo"),
   137  			},
   138  		}}.equals(comparable{
   139  		ConfigPolicy: &cb.ConfigPolicy{
   140  			Version:   1,
   141  			ModPolicy: "foo",
   142  			Policy: &cb.Policy{
   143  				Type:  1,
   144  				Value: []byte("foo"),
   145  			},
   146  		}}), "Should have detected different version")
   147  
   148  	// Different policy type
   149  	assert.False(t, comparable{
   150  		ConfigPolicy: &cb.ConfigPolicy{
   151  			Version:   0,
   152  			ModPolicy: "foo",
   153  			Policy: &cb.Policy{
   154  				Type:  1,
   155  				Value: []byte("foo"),
   156  			},
   157  		}}.equals(comparable{
   158  		ConfigPolicy: &cb.ConfigPolicy{
   159  			Version:   0,
   160  			ModPolicy: "foo",
   161  			Policy: &cb.Policy{
   162  				Type:  2,
   163  				Value: []byte("foo"),
   164  			},
   165  		}}), "Should have detected different policy type")
   166  
   167  	// Different policy value
   168  	assert.False(t, comparable{
   169  		ConfigPolicy: &cb.ConfigPolicy{
   170  			Version:   0,
   171  			ModPolicy: "foo",
   172  			Policy: &cb.Policy{
   173  				Type:  1,
   174  				Value: []byte("foo"),
   175  			},
   176  		}}.equals(comparable{
   177  		ConfigPolicy: &cb.ConfigPolicy{
   178  			Version:   0,
   179  			ModPolicy: "foo",
   180  			Policy: &cb.Policy{
   181  				Type:  1,
   182  				Value: []byte("bar"),
   183  			},
   184  		}}), "Should have detected different policy value")
   185  
   186  	// One nil value
   187  	assert.False(t, comparable{
   188  		ConfigPolicy: &cb.ConfigPolicy{
   189  			Version:   0,
   190  			ModPolicy: "foo",
   191  			Policy: &cb.Policy{
   192  				Type:  1,
   193  				Value: []byte("foo"),
   194  			},
   195  		}}.equals(comparable{}), "Should have detected one nil value")
   196  
   197  	// One nil policy
   198  	assert.False(t, comparable{
   199  		ConfigPolicy: &cb.ConfigPolicy{
   200  			Version:   0,
   201  			ModPolicy: "foo",
   202  			Policy: &cb.Policy{
   203  				Type:  1,
   204  				Value: []byte("foo"),
   205  			},
   206  		}}.equals(comparable{
   207  		ConfigPolicy: &cb.ConfigPolicy{
   208  			Version:   0,
   209  			ModPolicy: "foo",
   210  			Policy: &cb.Policy{
   211  				Type: 1,
   212  			},
   213  		}}), "Should have detected one nil policy")
   214  }
   215  
   216  func TestCompareConfigGroup(t *testing.T) {
   217  	// Normal equality
   218  	assert.True(t, comparable{
   219  		ConfigGroup: &cb.ConfigGroup{
   220  			Version:   0,
   221  			ModPolicy: "foo",
   222  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   223  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   224  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   225  		}}.equals(comparable{
   226  		ConfigGroup: &cb.ConfigGroup{
   227  			Version:   0,
   228  			ModPolicy: "foo",
   229  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   230  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   231  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   232  		}}), "Should have found identical config groups to be identical")
   233  
   234  	// Different mod policy
   235  	assert.False(t, comparable{
   236  		ConfigGroup: &cb.ConfigGroup{
   237  			Version:   0,
   238  			ModPolicy: "foo",
   239  		}}.equals(comparable{
   240  		ConfigGroup: &cb.ConfigGroup{
   241  			Version:   0,
   242  			ModPolicy: "bar",
   243  		}}), "Should have detected different mod policy")
   244  
   245  	// Different version
   246  	assert.False(t, comparable{
   247  		ConfigGroup: &cb.ConfigGroup{
   248  			Version:   0,
   249  			ModPolicy: "foo",
   250  		}}.equals(comparable{
   251  		ConfigGroup: &cb.ConfigGroup{
   252  			Version:   1,
   253  			ModPolicy: "foo",
   254  		}}), "Should have detected different version")
   255  
   256  	// Different groups
   257  	assert.False(t, comparable{
   258  		ConfigGroup: &cb.ConfigGroup{
   259  			Version:   0,
   260  			ModPolicy: "foo",
   261  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil},
   262  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   263  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   264  		}}.equals(comparable{
   265  		ConfigGroup: &cb.ConfigGroup{
   266  			Version:   0,
   267  			ModPolicy: "foo",
   268  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   269  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   270  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   271  		}}), "Should have detected different groups entries")
   272  
   273  	// Different values
   274  	assert.False(t, comparable{
   275  		ConfigGroup: &cb.ConfigGroup{
   276  			Version:   0,
   277  			ModPolicy: "foo",
   278  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   279  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   280  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   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},
   287  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   288  		}}), "Should have detected fifferent values entries")
   289  
   290  	// Different policies
   291  	assert.False(t, comparable{
   292  		ConfigGroup: &cb.ConfigGroup{
   293  			Version:   0,
   294  			ModPolicy: "foo",
   295  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   296  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   297  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil},
   298  		}}.equals(comparable{
   299  		ConfigGroup: &cb.ConfigGroup{
   300  			Version:   0,
   301  			ModPolicy: "foo",
   302  			Groups:    map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil},
   303  			Values:    map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil},
   304  			Policies:  map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar4": nil},
   305  		}}), "Should have detected fifferent policies entries")
   306  }