github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/internal/configtxlator/update/update_test.go (about)

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