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