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 }