github.com/hellobchain/third_party@v0.0.0-20230331131523-deb0478a2e52/hyperledger/fabric-config/configtx/update_test.go (about)

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