github.com/Hnampk/fabric@v2.1.1+incompatible/common/policies/inquire/merge_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package inquire
     8  
     9  import (
    10  	"testing"
    11  
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  var (
    16  	member1 = NewComparablePrincipal(member("Org1MSP"))
    17  	member2 = NewComparablePrincipal(member("Org2MSP"))
    18  	member3 = NewComparablePrincipal(member("Org3MSP"))
    19  	member4 = NewComparablePrincipal(member("Org4MSP"))
    20  	member5 = NewComparablePrincipal(member("Org5MSP"))
    21  	peer1   = NewComparablePrincipal(peer("Org1MSP"))
    22  	peer2   = NewComparablePrincipal(peer("Org2MSP"))
    23  	peer3   = NewComparablePrincipal(peer("Org3MSP"))
    24  	peer4   = NewComparablePrincipal(peer("Org4MSP"))
    25  	peer5   = NewComparablePrincipal(peer("Org5MSP"))
    26  )
    27  
    28  func TestString(t *testing.T) {
    29  	cps := ComparablePrincipalSet{member1, member2, NewComparablePrincipal(ou("Org3MSP"))}
    30  	assert.Equal(t, "[Org1MSP.MEMBER, Org2MSP.MEMBER, Org3MSP.ou]", cps.String())
    31  }
    32  
    33  func TestClone(t *testing.T) {
    34  	cps := ComparablePrincipalSet{member1, member2}
    35  	clone := cps.Clone()
    36  	assert.Equal(t, cps, clone)
    37  	// Nil out the first entry and ensure that it isn't reflected in the clone
    38  	cps[0] = nil
    39  	assert.False(t, cps[0] == clone[0])
    40  }
    41  
    42  func TestMergeInclusiveWithPlurality(t *testing.T) {
    43  	// Scenario:
    44  	// S1 = {Org1.member, Org2.member, Org2.member}, {Org3.peer, Org4.peer}
    45  	// S2 = {Org1.peer, Org2.peer}, {Org3.member, Org4.member}
    46  	// Expected merge result:
    47  	// {Org1.peer, Org2.peer, Org2.member}, {Org3.peer, Org4.peer}
    48  
    49  	members12 := ComparablePrincipalSet{member1, member2, member2}
    50  	members34 := ComparablePrincipalSet{member3, member4}
    51  	peers12 := ComparablePrincipalSet{peer1, peer2}
    52  	peers34 := ComparablePrincipalSet{peer3, peer4}
    53  
    54  	peers12member2 := ComparablePrincipalSet{peer1, peer2, member2}
    55  
    56  	s1 := ComparablePrincipalSets{members12, peers34}
    57  	s2 := ComparablePrincipalSets{peers12, members34}
    58  
    59  	merged := Merge(s1, s2)
    60  	expected := ComparablePrincipalSets{peers12member2, peers34}
    61  	assert.Equal(t, expected, merged)
    62  
    63  	// Shuffle the order of principal sets and ensure the result is the same
    64  	s1 = ComparablePrincipalSets{peers34, members12}
    65  	s2 = ComparablePrincipalSets{members34, peers12}
    66  	merged = Merge(s1, s2)
    67  	assert.Equal(t, expected, merged)
    68  
    69  	// Shuffle the order to the call
    70  	merged = Merge(s2, s1)
    71  	expected = ComparablePrincipalSets{peers34, peers12member2}
    72  	assert.Equal(t, expected, merged)
    73  }
    74  
    75  func TestMergeExclusiveWithPlurality(t *testing.T) {
    76  	// Scenario:
    77  	// S1 = {Org1.member, Org2.member, Org2.member}, {Org3.peer, Org4.peer}
    78  	// S2 = {Org2.member, Org3.member}, {Org4.peer, Org5.peer}
    79  	// Expected merge result:
    80  	// {Org1.member, Org2.member, Org3.member}, {Org3.peer, Org4.peer, Org5.peer},
    81  	// {Org1.member, Org2.member, Org4.peer, Org5.peer}, {Org3.peer, Org4.peer, Org2.member, Org3.member}
    82  
    83  	members122 := ComparablePrincipalSet{member1, member2, member2}
    84  	members23 := ComparablePrincipalSet{member2, member3}
    85  	peers34 := ComparablePrincipalSet{peer3, peer4}
    86  	peers45 := ComparablePrincipalSet{peer4, peer5}
    87  	members1223 := ComparablePrincipalSet{member1, member2, member2, member3}
    88  	peers345 := ComparablePrincipalSet{peer3, peer4, peer5}
    89  	members122peers45 := ComparablePrincipalSet{member1, member2, member2, peer4, peer5}
    90  	peers34members23 := ComparablePrincipalSet{peer3, peer4, member2, member3}
    91  
    92  	s1 := ComparablePrincipalSets{members122, peers34}
    93  	s2 := ComparablePrincipalSets{members23, peers45}
    94  	merged := Merge(s1, s2)
    95  	expected := ComparablePrincipalSets{members1223, peers345, members122peers45, peers34members23}
    96  	assert.True(t, expected.IsEqual(merged))
    97  }
    98  
    99  func TestMergePartialExclusiveWithPlurality(t *testing.T) {
   100  	// Scenario:
   101  	// S1 = {Org1.member, Org2.member}, {Org3.peer, Org4.peer, Org5.member}
   102  	// S2 = {Org2.member, Org3.member}, {Org3.peer, Org4.member, Org4.member}, {Org4.peer, Org5.member}
   103  	// The naive solution would be:
   104  	// {Org1.member, Org2.member, Org3.member}, {Org3.peer, Org4.peer, Org4.member, Org5.member}, {Org3.peer, Org4.peer, Org5.member}
   105  	// However - {Org3.peer, Org4.peer, Org4.member, Org5.member} contains {Org3.peer, Org4.peer, Org5.member}
   106  	// So the result should be optimized, hence {Org3.peer, Org4.peer, Org4.member, Org5.member} will be omitted.
   107  	// Expected merge result:
   108  	// {Org1.member, Org2.member, Org3.member}, {Org3.peer, Org4.peer, Org5.member}
   109  
   110  	members12 := ComparablePrincipalSet{member1, member2}
   111  	members23 := ComparablePrincipalSet{member2, member3}
   112  	peers34member5 := ComparablePrincipalSet{peer3, peer4, member5}
   113  	peer3members44 := ComparablePrincipalSet{peer3, member4, member4}
   114  	peer4member5 := ComparablePrincipalSet{peer4, member5}
   115  	members123 := ComparablePrincipalSet{member1, member2, member3}
   116  
   117  	s1 := ComparablePrincipalSets{members12, peers34member5}
   118  	s2 := ComparablePrincipalSets{members23, peer3members44, peer4member5}
   119  	merged := Merge(s1, s2)
   120  	expected := ComparablePrincipalSets{members123, peers34member5}
   121  	assert.True(t, expected.IsEqual(merged))
   122  }
   123  
   124  func TestMergeWithPlurality(t *testing.T) {
   125  	pair := comparablePrincipalSetPair{
   126  		contained:  ComparablePrincipalSet{peer3, member4, member4},
   127  		containing: ComparablePrincipalSet{peer3, peer4, member5},
   128  	}
   129  	merged := pair.MergeWithPlurality()
   130  	expected := ComparablePrincipalSet{peer3, peer4, member5, member4}
   131  	assert.Equal(t, expected, merged)
   132  }
   133  
   134  func TestMergeSubsetPrincipalSets(t *testing.T) {
   135  	member1And2 := ComparablePrincipalSets{ComparablePrincipalSet{member1, member2}}
   136  	member1Or2 := ComparablePrincipalSets{ComparablePrincipalSet{member1}, ComparablePrincipalSet{member2}}
   137  	merged := Merge(member1And2, member1Or2)
   138  	expected := member1And2
   139  	assert.True(t, expected.IsEqual(merged))
   140  }
   141  
   142  func TestEqual(t *testing.T) {
   143  	member1 := NewComparablePrincipal(member("Org1MSP"))
   144  	member2 := NewComparablePrincipal(member("Org2MSP"))
   145  	anotherMember1 := NewComparablePrincipal(member("Org1MSP"))
   146  	assert.False(t, member1.Equal(member2))
   147  	assert.True(t, member1.Equal(anotherMember1))
   148  }
   149  
   150  func TestIsSubset(t *testing.T) {
   151  	members12 := ComparablePrincipalSet{member1, member2, member2}
   152  	members321 := ComparablePrincipalSet{member3, member2, member1}
   153  	members13 := ComparablePrincipalSet{member1, member3}
   154  	assert.True(t, members12.IsSubset(members12))
   155  	assert.True(t, members12.IsSubset(members321))
   156  	assert.False(t, members12.IsSubset(members13))
   157  }
   158  
   159  func TestReduce(t *testing.T) {
   160  	members12 := ComparablePrincipalSet{member1, member2}
   161  	members123 := ComparablePrincipalSet{member1, member2, member3}
   162  	members12peers45 := ComparablePrincipalSet{member1, member2, peer4, peer5}
   163  	peers45 := ComparablePrincipalSet{peer4, peer5}
   164  	peers34 := ComparablePrincipalSet{peer3, peer4}
   165  	s := ComparablePrincipalSets{members12, peers34, members123, members123, members12peers45, peers45}
   166  	expected := ComparablePrincipalSets{members12, peers34, peers45}
   167  	assert.Equal(t, expected, s.Reduce())
   168  }
   169  
   170  // IsEqual returns whether this ComparablePrincipalSets contains the elements of the given ComparablePrincipalSets
   171  // in some order
   172  func (cps ComparablePrincipalSets) IsEqual(sets ComparablePrincipalSets) bool {
   173  	return cps.IsSubset(sets) && sets.IsSubset(cps)
   174  }
   175  
   176  // IsSubset returns whether this ComparablePrincipalSets is a subset of the given ComparablePrincipalSets
   177  func (cps ComparablePrincipalSets) IsSubset(sets ComparablePrincipalSets) bool {
   178  	for _, sets1 := range cps {
   179  		var found bool
   180  		for _, sets2 := range sets {
   181  			if sets1.IsEqual(sets2) {
   182  				found = true
   183  			}
   184  		}
   185  		if !found {
   186  			return false
   187  		}
   188  	}
   189  	return true
   190  }
   191  
   192  // IsEqual returns whether this ComparablePrincipalSet contains the elements of the given ComparablePrincipalSet
   193  // in some order
   194  func (cps ComparablePrincipalSet) IsEqual(otherSet ComparablePrincipalSet) bool {
   195  	return cps.IsSubset(otherSet) && otherSet.IsSubset(cps)
   196  }