github.com/hellobchain/third_party@v0.0.0-20230331131523-deb0478a2e52/hyperledger/fabric-config/configtx/policies_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  	"github.com/golang/protobuf/proto"
    13  	cb "github.com/hyperledger/fabric-protos-go/common"
    14  	. "github.com/onsi/gomega"
    15  )
    16  
    17  func TestPolicies(t *testing.T) {
    18  	t.Parallel()
    19  	gt := NewGomegaWithT(t)
    20  
    21  	expectedPolicies := map[string]Policy{
    22  		ReadersPolicyKey: {
    23  			Type:      ImplicitMetaPolicyType,
    24  			Rule:      "ALL Member",
    25  			ModPolicy: AdminsPolicyKey,
    26  		},
    27  		WritersPolicyKey: {
    28  			Type:      ImplicitMetaPolicyType,
    29  			Rule:      "ANY Member",
    30  			ModPolicy: AdminsPolicyKey,
    31  		},
    32  		AdminsPolicyKey: {
    33  			Type:      ImplicitMetaPolicyType,
    34  			Rule:      "MAJORITY Member",
    35  			ModPolicy: AdminsPolicyKey,
    36  		},
    37  		"SignaturePolicy": {
    38  			Type:      SignaturePolicyType,
    39  			Rule:      "AND('Org1.member', 'Org2.client', OR('Org3.peer', 'Org3.admin'), OUTOF(2, 'Org4.member', 'Org4.peer', 'Org4.admin'))",
    40  			ModPolicy: AdminsPolicyKey,
    41  		},
    42  	}
    43  	orgGroup := newConfigGroup()
    44  	err := setPolicies(orgGroup, expectedPolicies)
    45  	gt.Expect(err).NotTo(HaveOccurred())
    46  
    47  	policies, err := getPolicies(orgGroup.Policies)
    48  	gt.Expect(err).NotTo(HaveOccurred())
    49  	gt.Expect(expectedPolicies).To(Equal(policies))
    50  
    51  	policies, err = getPolicies(nil)
    52  	gt.Expect(err).NotTo(HaveOccurred())
    53  	gt.Expect(map[string]Policy{}).To(Equal(policies))
    54  }
    55  
    56  func TestSetConsortiumChannelCreationPolicy(t *testing.T) {
    57  	t.Parallel()
    58  
    59  	gt := NewGomegaWithT(t)
    60  
    61  	consortiums, _ := baseConsortiums(t)
    62  
    63  	consortiumsGroup, err := newConsortiumsGroup(consortiums)
    64  	gt.Expect(err).NotTo(HaveOccurred())
    65  
    66  	config := &cb.Config{
    67  		ChannelGroup: &cb.ConfigGroup{
    68  			Groups: map[string]*cb.ConfigGroup{
    69  				ConsortiumsGroupKey: consortiumsGroup,
    70  			},
    71  		},
    72  	}
    73  
    74  	c := New(config)
    75  
    76  	updatedPolicy := Policy{Type: ImplicitMetaPolicyType, Rule: "MAJORITY Admins"}
    77  
    78  	consortium1 := c.Consortium("Consortium1")
    79  	err = consortium1.SetChannelCreationPolicy(updatedPolicy)
    80  	gt.Expect(err).NotTo(HaveOccurred())
    81  
    82  	creationPolicy := consortium1.consortiumGroup.Values[ChannelCreationPolicyKey]
    83  	policy := &cb.Policy{}
    84  	err = proto.Unmarshal(creationPolicy.Value, policy)
    85  	gt.Expect(err).NotTo(HaveOccurred())
    86  	imp := &cb.ImplicitMetaPolicy{}
    87  	err = proto.Unmarshal(policy.Value, imp)
    88  	gt.Expect(err).NotTo(HaveOccurred())
    89  	gt.Expect(imp.Rule).To(Equal(cb.ImplicitMetaPolicy_MAJORITY))
    90  	gt.Expect(imp.SubPolicy).To(Equal("Admins"))
    91  }
    92  
    93  func TestSetConsortiumChannelCreationPolicyFailures(t *testing.T) {
    94  	t.Parallel()
    95  
    96  	gt := NewGomegaWithT(t)
    97  
    98  	consortiums, _ := baseConsortiums(t)
    99  
   100  	consortiumsGroup, err := newConsortiumsGroup(consortiums)
   101  	gt.Expect(err).NotTo(HaveOccurred())
   102  
   103  	config := &cb.Config{
   104  		ChannelGroup: &cb.ConfigGroup{
   105  			Groups: map[string]*cb.ConfigGroup{
   106  				ConsortiumsGroupKey: consortiumsGroup,
   107  			},
   108  		},
   109  	}
   110  
   111  	c := New(config)
   112  
   113  	tests := []struct {
   114  		name           string
   115  		consortiumName string
   116  		updatedpolicy  Policy
   117  		expectedErr    string
   118  	}{
   119  		{
   120  			name:           "when policy is invalid",
   121  			consortiumName: "Consortium1",
   122  			updatedpolicy:  Policy{Type: ImplicitMetaPolicyType, Rule: "Bad Admins"},
   123  			expectedErr:    "invalid implicit meta policy rule 'Bad Admins': unknown rule type 'Bad', expected ALL, ANY, or MAJORITY",
   124  		},
   125  	}
   126  
   127  	for _, tt := range tests {
   128  		tt := tt
   129  		t.Run(tt.name, func(t *testing.T) {
   130  			gt := NewGomegaWithT(t)
   131  			err := c.Consortium(tt.consortiumName).SetChannelCreationPolicy(tt.updatedpolicy)
   132  			gt.Expect(err).To(MatchError(tt.expectedErr))
   133  		})
   134  	}
   135  }