github.com/myafeier/fabric@v1.0.1-0.20170722181825-3a4b1f2bce86/common/configtx/compare_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 configtx 18 19 import ( 20 "testing" 21 22 "github.com/stretchr/testify/assert" 23 24 cb "github.com/hyperledger/fabric/protos/common" 25 ) 26 27 func TestCompareConfigValue(t *testing.T) { 28 // Normal equality 29 assert.True(t, comparable{ 30 ConfigValue: &cb.ConfigValue{ 31 Version: 0, 32 ModPolicy: "foo", 33 Value: []byte("bar"), 34 }}.equals(comparable{ 35 ConfigValue: &cb.ConfigValue{ 36 Version: 0, 37 ModPolicy: "foo", 38 Value: []byte("bar"), 39 }}), "Should have found identical config values to be identical") 40 41 // Different Mod Policy 42 assert.False(t, comparable{ 43 ConfigValue: &cb.ConfigValue{ 44 Version: 0, 45 ModPolicy: "foo", 46 Value: []byte("bar"), 47 }}.equals(comparable{ 48 ConfigValue: &cb.ConfigValue{ 49 Version: 0, 50 ModPolicy: "bar", 51 Value: []byte("bar"), 52 }}), "Should have detected different mod policy") 53 54 // Different Value 55 assert.False(t, comparable{ 56 ConfigValue: &cb.ConfigValue{ 57 Version: 0, 58 ModPolicy: "foo", 59 Value: []byte("bar"), 60 }}.equals(comparable{ 61 ConfigValue: &cb.ConfigValue{ 62 Version: 0, 63 ModPolicy: "foo", 64 Value: []byte("foo"), 65 }}), "Should have detected different value") 66 67 // Different Version 68 assert.False(t, comparable{ 69 ConfigValue: &cb.ConfigValue{ 70 Version: 0, 71 ModPolicy: "foo", 72 Value: []byte("bar"), 73 }}.equals(comparable{ 74 ConfigValue: &cb.ConfigValue{ 75 Version: 1, 76 ModPolicy: "foo", 77 Value: []byte("bar"), 78 }}), "Should have detected different version") 79 80 // One nil value 81 assert.False(t, comparable{ 82 ConfigValue: &cb.ConfigValue{ 83 Version: 0, 84 ModPolicy: "foo", 85 Value: []byte("bar"), 86 }}.equals(comparable{}), "Should have detected nil other value") 87 88 } 89 90 func TestCompareConfigPolicy(t *testing.T) { 91 // Normal equality 92 assert.True(t, comparable{ 93 ConfigPolicy: &cb.ConfigPolicy{ 94 Version: 0, 95 ModPolicy: "foo", 96 Policy: &cb.Policy{ 97 Type: 1, 98 Value: []byte("foo"), 99 }, 100 }}.equals(comparable{ 101 ConfigPolicy: &cb.ConfigPolicy{ 102 Version: 0, 103 ModPolicy: "foo", 104 Policy: &cb.Policy{ 105 Type: 1, 106 Value: []byte("foo"), 107 }, 108 }}), "Should have found identical config policies to be identical") 109 110 // Different mod policy 111 assert.False(t, comparable{ 112 ConfigPolicy: &cb.ConfigPolicy{ 113 Version: 0, 114 ModPolicy: "foo", 115 Policy: &cb.Policy{ 116 Type: 1, 117 Value: []byte("foo"), 118 }, 119 }}.equals(comparable{ 120 ConfigPolicy: &cb.ConfigPolicy{ 121 Version: 0, 122 ModPolicy: "bar", 123 Policy: &cb.Policy{ 124 Type: 1, 125 Value: []byte("foo"), 126 }, 127 }}), "Should have detected different mod policy") 128 129 // Different version 130 assert.False(t, comparable{ 131 ConfigPolicy: &cb.ConfigPolicy{ 132 Version: 0, 133 ModPolicy: "foo", 134 Policy: &cb.Policy{ 135 Type: 1, 136 Value: []byte("foo"), 137 }, 138 }}.equals(comparable{ 139 ConfigPolicy: &cb.ConfigPolicy{ 140 Version: 1, 141 ModPolicy: "foo", 142 Policy: &cb.Policy{ 143 Type: 1, 144 Value: []byte("foo"), 145 }, 146 }}), "Should have detected different version") 147 148 // Different policy type 149 assert.False(t, comparable{ 150 ConfigPolicy: &cb.ConfigPolicy{ 151 Version: 0, 152 ModPolicy: "foo", 153 Policy: &cb.Policy{ 154 Type: 1, 155 Value: []byte("foo"), 156 }, 157 }}.equals(comparable{ 158 ConfigPolicy: &cb.ConfigPolicy{ 159 Version: 0, 160 ModPolicy: "foo", 161 Policy: &cb.Policy{ 162 Type: 2, 163 Value: []byte("foo"), 164 }, 165 }}), "Should have detected different policy type") 166 167 // Different policy value 168 assert.False(t, comparable{ 169 ConfigPolicy: &cb.ConfigPolicy{ 170 Version: 0, 171 ModPolicy: "foo", 172 Policy: &cb.Policy{ 173 Type: 1, 174 Value: []byte("foo"), 175 }, 176 }}.equals(comparable{ 177 ConfigPolicy: &cb.ConfigPolicy{ 178 Version: 0, 179 ModPolicy: "foo", 180 Policy: &cb.Policy{ 181 Type: 1, 182 Value: []byte("bar"), 183 }, 184 }}), "Should have detected different policy value") 185 186 // One nil value 187 assert.False(t, comparable{ 188 ConfigPolicy: &cb.ConfigPolicy{ 189 Version: 0, 190 ModPolicy: "foo", 191 Policy: &cb.Policy{ 192 Type: 1, 193 Value: []byte("foo"), 194 }, 195 }}.equals(comparable{}), "Should have detected one nil value") 196 197 // One nil policy 198 assert.False(t, comparable{ 199 ConfigPolicy: &cb.ConfigPolicy{ 200 Version: 0, 201 ModPolicy: "foo", 202 Policy: &cb.Policy{ 203 Type: 1, 204 Value: []byte("foo"), 205 }, 206 }}.equals(comparable{ 207 ConfigPolicy: &cb.ConfigPolicy{ 208 Version: 0, 209 ModPolicy: "foo", 210 Policy: &cb.Policy{ 211 Type: 1, 212 }, 213 }}), "Should have detected one nil policy") 214 } 215 216 func TestCompareConfigGroup(t *testing.T) { 217 // Normal equality 218 assert.True(t, comparable{ 219 ConfigGroup: &cb.ConfigGroup{ 220 Version: 0, 221 ModPolicy: "foo", 222 Groups: map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil}, 223 Values: map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil}, 224 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil}, 225 }}.equals(comparable{ 226 ConfigGroup: &cb.ConfigGroup{ 227 Version: 0, 228 ModPolicy: "foo", 229 Groups: map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil}, 230 Values: map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil}, 231 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil}, 232 }}), "Should have found identical config groups to be identical") 233 234 // Different mod policy 235 assert.False(t, comparable{ 236 ConfigGroup: &cb.ConfigGroup{ 237 Version: 0, 238 ModPolicy: "foo", 239 }}.equals(comparable{ 240 ConfigGroup: &cb.ConfigGroup{ 241 Version: 0, 242 ModPolicy: "bar", 243 }}), "Should have detected different mod policy") 244 245 // Different version 246 assert.False(t, comparable{ 247 ConfigGroup: &cb.ConfigGroup{ 248 Version: 0, 249 ModPolicy: "foo", 250 }}.equals(comparable{ 251 ConfigGroup: &cb.ConfigGroup{ 252 Version: 1, 253 ModPolicy: "foo", 254 }}), "Should have detected different version") 255 256 // Different groups 257 assert.False(t, comparable{ 258 ConfigGroup: &cb.ConfigGroup{ 259 Version: 0, 260 ModPolicy: "foo", 261 Groups: map[string]*cb.ConfigGroup{"Foo1": nil}, 262 Values: map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil}, 263 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil}, 264 }}.equals(comparable{ 265 ConfigGroup: &cb.ConfigGroup{ 266 Version: 0, 267 ModPolicy: "foo", 268 Groups: map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil}, 269 Values: map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil}, 270 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil}, 271 }}), "Should have detected different groups entries") 272 273 // Different values 274 assert.False(t, comparable{ 275 ConfigGroup: &cb.ConfigGroup{ 276 Version: 0, 277 ModPolicy: "foo", 278 Groups: map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil}, 279 Values: map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil}, 280 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil}, 281 }}.equals(comparable{ 282 ConfigGroup: &cb.ConfigGroup{ 283 Version: 0, 284 ModPolicy: "foo", 285 Groups: map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil}, 286 Values: map[string]*cb.ConfigValue{"Foo2": nil}, 287 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil}, 288 }}), "Should have detected fifferent values entries") 289 290 // Different policies 291 assert.False(t, comparable{ 292 ConfigGroup: &cb.ConfigGroup{ 293 Version: 0, 294 ModPolicy: "foo", 295 Groups: map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil}, 296 Values: map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil}, 297 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar3": nil}, 298 }}.equals(comparable{ 299 ConfigGroup: &cb.ConfigGroup{ 300 Version: 0, 301 ModPolicy: "foo", 302 Groups: map[string]*cb.ConfigGroup{"Foo1": nil, "Bar1": nil}, 303 Values: map[string]*cb.ConfigValue{"Foo2": nil, "Bar2": nil}, 304 Policies: map[string]*cb.ConfigPolicy{"Foo3": nil, "Bar4": nil}, 305 }}), "Should have detected fifferent policies entries") 306 }