github.com/kaituanwang/hyperledger@v2.0.1+incompatible/internal/configtxlator/update/update_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2017 All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package update
     8  
     9  import (
    10  	"testing"
    11  
    12  	cb "github.com/hyperledger/fabric-protos-go/common"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  func TestNoUpdate(t *testing.T) {
    17  	original := &cb.ConfigGroup{
    18  		Version: 7,
    19  	}
    20  	updated := &cb.ConfigGroup{}
    21  
    22  	_, err := Compute(&cb.Config{
    23  		ChannelGroup: original,
    24  	}, &cb.Config{
    25  		ChannelGroup: updated,
    26  	})
    27  
    28  	assert.Error(t, err)
    29  }
    30  
    31  func TestMissingGroup(t *testing.T) {
    32  	group := &cb.ConfigGroup{}
    33  	t.Run("MissingOriginal", func(t *testing.T) {
    34  		_, err := Compute(&cb.Config{}, &cb.Config{ChannelGroup: group})
    35  
    36  		assert.Error(t, err)
    37  		assert.Regexp(t, "no channel group included for original config", err.Error())
    38  	})
    39  	t.Run("MissingOriginal", func(t *testing.T) {
    40  		_, err := Compute(&cb.Config{ChannelGroup: group}, &cb.Config{})
    41  
    42  		assert.Error(t, err)
    43  		assert.Regexp(t, "no channel group included for updated config", err.Error())
    44  	})
    45  }
    46  
    47  func TestGroupModPolicyUpdate(t *testing.T) {
    48  	original := &cb.ConfigGroup{
    49  		Version:   7,
    50  		ModPolicy: "foo",
    51  	}
    52  	updated := &cb.ConfigGroup{
    53  		ModPolicy: "bar",
    54  	}
    55  
    56  	cu, err := Compute(&cb.Config{
    57  		ChannelGroup: original,
    58  	}, &cb.Config{
    59  		ChannelGroup: updated,
    60  	})
    61  
    62  	assert.NoError(t, err)
    63  
    64  	expectedReadSet := &cb.ConfigGroup{
    65  		Version:  original.Version,
    66  		Groups:   map[string]*cb.ConfigGroup{},
    67  		Policies: map[string]*cb.ConfigPolicy{},
    68  		Values:   map[string]*cb.ConfigValue{},
    69  	}
    70  
    71  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
    72  
    73  	expectedWriteSet := &cb.ConfigGroup{
    74  		Version:   original.Version + 1,
    75  		Groups:    map[string]*cb.ConfigGroup{},
    76  		Policies:  map[string]*cb.ConfigPolicy{},
    77  		Values:    map[string]*cb.ConfigValue{},
    78  		ModPolicy: updated.ModPolicy,
    79  	}
    80  
    81  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
    82  }
    83  
    84  func TestGroupPolicyModification(t *testing.T) {
    85  
    86  	policy1Name := "foo"
    87  	policy2Name := "bar"
    88  	original := &cb.ConfigGroup{
    89  		Version: 4,
    90  		Policies: map[string]*cb.ConfigPolicy{
    91  			policy1Name: {
    92  				Version: 2,
    93  				Policy: &cb.Policy{
    94  					Type: 3,
    95  				},
    96  			},
    97  			policy2Name: {
    98  				Version: 1,
    99  				Policy: &cb.Policy{
   100  					Type: 5,
   101  				},
   102  			},
   103  		},
   104  	}
   105  	updated := &cb.ConfigGroup{
   106  		Policies: map[string]*cb.ConfigPolicy{
   107  			policy1Name: original.Policies[policy1Name],
   108  			policy2Name: {
   109  				Policy: &cb.Policy{
   110  					Type: 9,
   111  				},
   112  			},
   113  		},
   114  	}
   115  
   116  	cu, err := Compute(&cb.Config{
   117  		ChannelGroup: original,
   118  	}, &cb.Config{
   119  		ChannelGroup: updated,
   120  	})
   121  
   122  	assert.NoError(t, err)
   123  
   124  	expectedReadSet := &cb.ConfigGroup{
   125  		Version:  original.Version,
   126  		Policies: map[string]*cb.ConfigPolicy{},
   127  		Values:   map[string]*cb.ConfigValue{},
   128  		Groups:   map[string]*cb.ConfigGroup{},
   129  	}
   130  
   131  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
   132  
   133  	expectedWriteSet := &cb.ConfigGroup{
   134  		Version: original.Version,
   135  		Policies: map[string]*cb.ConfigPolicy{
   136  			policy2Name: {
   137  				Policy: &cb.Policy{
   138  					Type: updated.Policies[policy2Name].Policy.Type,
   139  				},
   140  				Version: original.Policies[policy2Name].Version + 1,
   141  			},
   142  		},
   143  		Values: map[string]*cb.ConfigValue{},
   144  		Groups: map[string]*cb.ConfigGroup{},
   145  	}
   146  
   147  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
   148  }
   149  
   150  func TestGroupValueModification(t *testing.T) {
   151  
   152  	value1Name := "foo"
   153  	value2Name := "bar"
   154  	original := &cb.ConfigGroup{
   155  		Version: 7,
   156  		Values: map[string]*cb.ConfigValue{
   157  			value1Name: {
   158  				Version: 3,
   159  				Value:   []byte("value1value"),
   160  			},
   161  			value2Name: {
   162  				Version: 6,
   163  				Value:   []byte("value2value"),
   164  			},
   165  		},
   166  	}
   167  	updated := &cb.ConfigGroup{
   168  		Values: map[string]*cb.ConfigValue{
   169  			value1Name: original.Values[value1Name],
   170  			value2Name: {
   171  				Value: []byte("updatedValued2Value"),
   172  			},
   173  		},
   174  	}
   175  
   176  	cu, err := Compute(&cb.Config{
   177  		ChannelGroup: original,
   178  	}, &cb.Config{
   179  		ChannelGroup: updated,
   180  	})
   181  
   182  	assert.NoError(t, err)
   183  
   184  	expectedReadSet := &cb.ConfigGroup{
   185  		Version:  original.Version,
   186  		Values:   map[string]*cb.ConfigValue{},
   187  		Policies: map[string]*cb.ConfigPolicy{},
   188  		Groups:   map[string]*cb.ConfigGroup{},
   189  	}
   190  
   191  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
   192  
   193  	expectedWriteSet := &cb.ConfigGroup{
   194  		Version: original.Version,
   195  		Values: map[string]*cb.ConfigValue{
   196  			value2Name: {
   197  				Value:   updated.Values[value2Name].Value,
   198  				Version: original.Values[value2Name].Version + 1,
   199  			},
   200  		},
   201  		Policies: map[string]*cb.ConfigPolicy{},
   202  		Groups:   map[string]*cb.ConfigGroup{},
   203  	}
   204  
   205  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
   206  }
   207  
   208  func TestGroupGroupsModification(t *testing.T) {
   209  
   210  	subGroupName := "foo"
   211  	original := &cb.ConfigGroup{
   212  		Version: 7,
   213  		Groups: map[string]*cb.ConfigGroup{
   214  			subGroupName: {
   215  				Version: 3,
   216  				Values: map[string]*cb.ConfigValue{
   217  					"testValue": {
   218  						Version: 3,
   219  					},
   220  				},
   221  			},
   222  		},
   223  	}
   224  	updated := &cb.ConfigGroup{
   225  		Groups: map[string]*cb.ConfigGroup{
   226  			subGroupName: {},
   227  		},
   228  	}
   229  
   230  	cu, err := Compute(&cb.Config{
   231  		ChannelGroup: original,
   232  	}, &cb.Config{
   233  		ChannelGroup: updated,
   234  	})
   235  
   236  	assert.NoError(t, err)
   237  
   238  	expectedReadSet := &cb.ConfigGroup{
   239  		Version: original.Version,
   240  		Groups: map[string]*cb.ConfigGroup{
   241  			subGroupName: {
   242  				Version:  original.Groups[subGroupName].Version,
   243  				Policies: map[string]*cb.ConfigPolicy{},
   244  				Values:   map[string]*cb.ConfigValue{},
   245  				Groups:   map[string]*cb.ConfigGroup{},
   246  			},
   247  		},
   248  		Policies: map[string]*cb.ConfigPolicy{},
   249  		Values:   map[string]*cb.ConfigValue{},
   250  	}
   251  
   252  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
   253  
   254  	expectedWriteSet := &cb.ConfigGroup{
   255  		Version: original.Version,
   256  		Groups: map[string]*cb.ConfigGroup{
   257  			subGroupName: {
   258  				Version:  original.Groups[subGroupName].Version + 1,
   259  				Groups:   map[string]*cb.ConfigGroup{},
   260  				Policies: map[string]*cb.ConfigPolicy{},
   261  				Values:   map[string]*cb.ConfigValue{},
   262  			},
   263  		},
   264  		Policies: map[string]*cb.ConfigPolicy{},
   265  		Values:   map[string]*cb.ConfigValue{},
   266  	}
   267  
   268  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
   269  }
   270  
   271  func TestGroupValueAddition(t *testing.T) {
   272  
   273  	value1Name := "foo"
   274  	value2Name := "bar"
   275  	original := &cb.ConfigGroup{
   276  		Version: 7,
   277  		Values: map[string]*cb.ConfigValue{
   278  			value1Name: {
   279  				Version: 3,
   280  				Value:   []byte("value1value"),
   281  			},
   282  		},
   283  	}
   284  	updated := &cb.ConfigGroup{
   285  		Values: map[string]*cb.ConfigValue{
   286  			value1Name: original.Values[value1Name],
   287  			value2Name: {
   288  				Version: 9,
   289  				Value:   []byte("newValue2"),
   290  			},
   291  		},
   292  	}
   293  
   294  	cu, err := Compute(&cb.Config{
   295  		ChannelGroup: original,
   296  	}, &cb.Config{
   297  		ChannelGroup: updated,
   298  	})
   299  
   300  	assert.NoError(t, err)
   301  
   302  	expectedReadSet := &cb.ConfigGroup{
   303  		Version: original.Version,
   304  		Values: map[string]*cb.ConfigValue{
   305  			value1Name: {
   306  				Version: original.Values[value1Name].Version,
   307  			},
   308  		},
   309  		Policies: map[string]*cb.ConfigPolicy{},
   310  		Groups:   map[string]*cb.ConfigGroup{},
   311  	}
   312  
   313  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
   314  
   315  	expectedWriteSet := &cb.ConfigGroup{
   316  		Version: original.Version + 1,
   317  		Values: map[string]*cb.ConfigValue{
   318  			value1Name: {
   319  				Version: original.Values[value1Name].Version,
   320  			},
   321  			value2Name: {
   322  				Value:   updated.Values[value2Name].Value,
   323  				Version: 0,
   324  			},
   325  		},
   326  		Policies: map[string]*cb.ConfigPolicy{},
   327  		Groups:   map[string]*cb.ConfigGroup{},
   328  	}
   329  
   330  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
   331  }
   332  
   333  func TestGroupPolicySwap(t *testing.T) {
   334  
   335  	policy1Name := "foo"
   336  	policy2Name := "bar"
   337  	original := &cb.ConfigGroup{
   338  		Version: 4,
   339  		Policies: map[string]*cb.ConfigPolicy{
   340  			policy1Name: {
   341  				Version: 2,
   342  				Policy: &cb.Policy{
   343  					Type: 3,
   344  				},
   345  			},
   346  		},
   347  	}
   348  	updated := &cb.ConfigGroup{
   349  		Policies: map[string]*cb.ConfigPolicy{
   350  			policy2Name: {
   351  				Version: 1,
   352  				Policy: &cb.Policy{
   353  					Type: 5,
   354  				},
   355  			},
   356  		},
   357  	}
   358  
   359  	cu, err := Compute(&cb.Config{
   360  		ChannelGroup: original,
   361  	}, &cb.Config{
   362  		ChannelGroup: updated,
   363  	})
   364  
   365  	assert.NoError(t, err)
   366  
   367  	expectedReadSet := &cb.ConfigGroup{
   368  		Version:  original.Version,
   369  		Policies: map[string]*cb.ConfigPolicy{},
   370  		Values:   map[string]*cb.ConfigValue{},
   371  		Groups:   map[string]*cb.ConfigGroup{},
   372  	}
   373  
   374  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
   375  
   376  	expectedWriteSet := &cb.ConfigGroup{
   377  		Version: original.Version + 1,
   378  		Policies: map[string]*cb.ConfigPolicy{
   379  			policy2Name: {
   380  				Policy: &cb.Policy{
   381  					Type: updated.Policies[policy2Name].Policy.Type,
   382  				},
   383  				Version: 0,
   384  			},
   385  		},
   386  		Values: map[string]*cb.ConfigValue{},
   387  		Groups: map[string]*cb.ConfigGroup{},
   388  	}
   389  
   390  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
   391  }
   392  
   393  func TestComplex(t *testing.T) {
   394  
   395  	existingGroup1Name := "existingGroup1"
   396  	existingGroup2Name := "existingGroup2"
   397  	existingPolicyName := "existingPolicy"
   398  	original := &cb.ConfigGroup{
   399  		Version: 4,
   400  		Groups: map[string]*cb.ConfigGroup{
   401  			existingGroup1Name: {
   402  				Version: 2,
   403  			},
   404  			existingGroup2Name: {
   405  				Version: 2,
   406  			},
   407  		},
   408  		Policies: map[string]*cb.ConfigPolicy{
   409  			existingPolicyName: {
   410  				Version: 8,
   411  				Policy: &cb.Policy{
   412  					Type: 5,
   413  				},
   414  			},
   415  		},
   416  	}
   417  
   418  	newGroupName := "newGroup"
   419  	newPolicyName := "newPolicy"
   420  	newValueName := "newValue"
   421  	updated := &cb.ConfigGroup{
   422  		Groups: map[string]*cb.ConfigGroup{
   423  			existingGroup1Name: {},
   424  			newGroupName: {
   425  				Values: map[string]*cb.ConfigValue{
   426  					newValueName: {},
   427  				},
   428  			},
   429  		},
   430  		Policies: map[string]*cb.ConfigPolicy{
   431  			existingPolicyName: {
   432  				Policy: &cb.Policy{
   433  					Type: 5,
   434  				},
   435  			},
   436  			newPolicyName: {
   437  				Version: 6,
   438  				Policy: &cb.Policy{
   439  					Type: 5,
   440  				},
   441  			},
   442  		},
   443  	}
   444  
   445  	cu, err := Compute(&cb.Config{
   446  		ChannelGroup: original,
   447  	}, &cb.Config{
   448  		ChannelGroup: updated,
   449  	})
   450  
   451  	assert.NoError(t, err)
   452  
   453  	expectedReadSet := &cb.ConfigGroup{
   454  		Version: original.Version,
   455  		Policies: map[string]*cb.ConfigPolicy{
   456  			existingPolicyName: {
   457  				Version: original.Policies[existingPolicyName].Version,
   458  			},
   459  		},
   460  		Values: map[string]*cb.ConfigValue{},
   461  		Groups: map[string]*cb.ConfigGroup{
   462  			existingGroup1Name: {
   463  				Version: original.Groups[existingGroup1Name].Version,
   464  			},
   465  		},
   466  	}
   467  
   468  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
   469  
   470  	expectedWriteSet := &cb.ConfigGroup{
   471  		Version: original.Version + 1,
   472  		Policies: map[string]*cb.ConfigPolicy{
   473  			existingPolicyName: {
   474  				Version: original.Policies[existingPolicyName].Version,
   475  			},
   476  			newPolicyName: {
   477  				Version: 0,
   478  				Policy: &cb.Policy{
   479  					Type: 5,
   480  				},
   481  			},
   482  		},
   483  		Groups: map[string]*cb.ConfigGroup{
   484  			existingGroup1Name: {
   485  				Version: original.Groups[existingGroup1Name].Version,
   486  			},
   487  			newGroupName: {
   488  				Version: 0,
   489  				Values: map[string]*cb.ConfigValue{
   490  					newValueName: {},
   491  				},
   492  				Policies: map[string]*cb.ConfigPolicy{},
   493  				Groups:   map[string]*cb.ConfigGroup{},
   494  			},
   495  		},
   496  		Values: map[string]*cb.ConfigValue{},
   497  	}
   498  
   499  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
   500  }
   501  
   502  func TestTwiceNestedModification(t *testing.T) {
   503  
   504  	subGroupName := "foo"
   505  	subSubGroupName := "bar"
   506  	valueName := "testValue"
   507  	original := &cb.ConfigGroup{
   508  		Groups: map[string]*cb.ConfigGroup{
   509  			subGroupName: {
   510  				Groups: map[string]*cb.ConfigGroup{
   511  					subSubGroupName: {
   512  						Values: map[string]*cb.ConfigValue{
   513  							valueName: {},
   514  						},
   515  					},
   516  				},
   517  			},
   518  		},
   519  	}
   520  	updated := &cb.ConfigGroup{
   521  		Groups: map[string]*cb.ConfigGroup{
   522  			subGroupName: {
   523  				Groups: map[string]*cb.ConfigGroup{
   524  					subSubGroupName: {
   525  						Values: map[string]*cb.ConfigValue{
   526  							valueName: {
   527  								ModPolicy: "new",
   528  							},
   529  						},
   530  					},
   531  				},
   532  			},
   533  		},
   534  	}
   535  
   536  	cu, err := Compute(&cb.Config{
   537  		ChannelGroup: original,
   538  	}, &cb.Config{
   539  		ChannelGroup: updated,
   540  	})
   541  
   542  	assert.NoError(t, err)
   543  
   544  	expectedReadSet := &cb.ConfigGroup{
   545  		Version: original.Version,
   546  		Groups: map[string]*cb.ConfigGroup{
   547  			subGroupName: {
   548  				Groups: map[string]*cb.ConfigGroup{
   549  					subSubGroupName: {
   550  						Policies: map[string]*cb.ConfigPolicy{},
   551  						Values:   map[string]*cb.ConfigValue{},
   552  						Groups:   map[string]*cb.ConfigGroup{},
   553  					},
   554  				},
   555  				Policies: map[string]*cb.ConfigPolicy{},
   556  				Values:   map[string]*cb.ConfigValue{},
   557  			},
   558  		},
   559  		Policies: map[string]*cb.ConfigPolicy{},
   560  		Values:   map[string]*cb.ConfigValue{},
   561  	}
   562  
   563  	assert.Equal(t, expectedReadSet, cu.ReadSet, "Mismatched read set")
   564  
   565  	expectedWriteSet := &cb.ConfigGroup{
   566  		Version: original.Version,
   567  		Groups: map[string]*cb.ConfigGroup{
   568  			subGroupName: {
   569  				Groups: map[string]*cb.ConfigGroup{
   570  					subSubGroupName: {
   571  						Values: map[string]*cb.ConfigValue{
   572  							valueName: {
   573  								Version:   original.Groups[subGroupName].Groups[subSubGroupName].Values[valueName].Version + 1,
   574  								ModPolicy: updated.Groups[subGroupName].Groups[subSubGroupName].Values[valueName].ModPolicy,
   575  							},
   576  						},
   577  						Policies: map[string]*cb.ConfigPolicy{},
   578  						Groups:   map[string]*cb.ConfigGroup{},
   579  					},
   580  				},
   581  				Policies: map[string]*cb.ConfigPolicy{},
   582  				Values:   map[string]*cb.ConfigValue{},
   583  			},
   584  		},
   585  		Policies: map[string]*cb.ConfigPolicy{},
   586  		Values:   map[string]*cb.ConfigValue{},
   587  	}
   588  
   589  	assert.Equal(t, expectedWriteSet, cu.WriteSet, "Mismatched write set")
   590  }