github.com/defanghe/fabric@v2.1.1+incompatible/internal/peer/gossip/mocks/mocks.go (about)

     1  /*
     2  Copyright IBM Corp. 2017 All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package mocks
     8  
     9  import (
    10  	"bytes"
    11  	"errors"
    12  	"fmt"
    13  	"time"
    14  
    15  	mspproto "github.com/hyperledger/fabric-protos-go/msp"
    16  	"github.com/hyperledger/fabric/common/policies"
    17  	"github.com/hyperledger/fabric/msp"
    18  	"github.com/hyperledger/fabric/protoutil"
    19  	"github.com/stretchr/testify/mock"
    20  )
    21  
    22  type ChannelPolicyManagerGetter struct{}
    23  
    24  func (c *ChannelPolicyManagerGetter) Manager(channelID string) policies.Manager {
    25  	policyMgr := &PolicyManager{}
    26  	policyMgr.GetPolicyReturns(nil, true)
    27  	return policyMgr
    28  }
    29  
    30  type ChannelPolicyManagerGetterWithManager struct {
    31  	Managers map[string]policies.Manager
    32  }
    33  
    34  func (c *ChannelPolicyManagerGetterWithManager) Manager(channelID string) policies.Manager {
    35  	return c.Managers[channelID]
    36  }
    37  
    38  type ChannelPolicyManager struct {
    39  	Policy policies.Policy
    40  }
    41  
    42  func (m *ChannelPolicyManager) GetPolicy(id string) (policies.Policy, bool) {
    43  	return m.Policy, true
    44  }
    45  
    46  func (m *ChannelPolicyManager) Manager(path []string) (policies.Manager, bool) {
    47  	panic("Not implemented")
    48  }
    49  
    50  type Policy struct {
    51  	Deserializer msp.IdentityDeserializer
    52  }
    53  
    54  // EvaluateSignedData takes a set of SignedData and evaluates whether this set of signatures satisfies the policy
    55  func (m *Policy) EvaluateSignedData(signatureSet []*protoutil.SignedData) error {
    56  	fmt.Printf("Evaluate [%s], [% x], [% x]\n", string(signatureSet[0].Identity), string(signatureSet[0].Data), string(signatureSet[0].Signature))
    57  	identity, err := m.Deserializer.DeserializeIdentity(signatureSet[0].Identity)
    58  	if err != nil {
    59  		return err
    60  	}
    61  
    62  	return identity.Verify(signatureSet[0].Data, signatureSet[0].Signature)
    63  }
    64  
    65  // EvaluateIdentities takes an array of identities and evaluates whether
    66  // they satisfy the policy
    67  func (m *Policy) EvaluateIdentities(identities []msp.Identity) error {
    68  	panic("Implement me")
    69  }
    70  
    71  type DeserializersManager struct {
    72  	LocalDeserializer    msp.IdentityDeserializer
    73  	ChannelDeserializers map[string]msp.IdentityDeserializer
    74  }
    75  
    76  func (m *DeserializersManager) Deserialize(raw []byte) (*mspproto.SerializedIdentity, error) {
    77  	return &mspproto.SerializedIdentity{Mspid: "mock", IdBytes: raw}, nil
    78  }
    79  
    80  func (m *DeserializersManager) GetLocalMSPIdentifier() string {
    81  	return "mock"
    82  }
    83  
    84  func (m *DeserializersManager) GetLocalDeserializer() msp.IdentityDeserializer {
    85  	return m.LocalDeserializer
    86  }
    87  
    88  func (m *DeserializersManager) GetChannelDeserializers() map[string]msp.IdentityDeserializer {
    89  	return m.ChannelDeserializers
    90  }
    91  
    92  type IdentityDeserializerWithExpiration struct {
    93  	*IdentityDeserializer
    94  	Expiration time.Time
    95  }
    96  
    97  func (d *IdentityDeserializerWithExpiration) DeserializeIdentity(serializedIdentity []byte) (msp.Identity, error) {
    98  	id, err := d.IdentityDeserializer.DeserializeIdentity(serializedIdentity)
    99  	if err != nil {
   100  		return nil, err
   101  	}
   102  	id.(*Identity).expirationDate = d.Expiration
   103  	return id, nil
   104  }
   105  
   106  type IdentityDeserializer struct {
   107  	Identity []byte
   108  	Msg      []byte
   109  	mock.Mock
   110  }
   111  
   112  func (d *IdentityDeserializer) DeserializeIdentity(serializedIdentity []byte) (msp.Identity, error) {
   113  	fmt.Printf("id : [%s], [%s]\n", string(serializedIdentity), string(d.Identity))
   114  	if bytes.Equal(d.Identity, serializedIdentity) {
   115  		fmt.Printf("GOT : [%s], [%s]\n", string(serializedIdentity), string(d.Identity))
   116  		return &Identity{Msg: d.Msg}, nil
   117  	}
   118  
   119  	return nil, errors.New("Invalid Identity")
   120  }
   121  
   122  func (d *IdentityDeserializer) IsWellFormed(identity *mspproto.SerializedIdentity) error {
   123  	if len(d.ExpectedCalls) == 0 {
   124  		return nil
   125  	}
   126  	return d.Called(identity).Error(0)
   127  }
   128  
   129  type Identity struct {
   130  	expirationDate time.Time
   131  	Msg            []byte
   132  }
   133  
   134  func (id *Identity) Anonymous() bool {
   135  	panic("implement me")
   136  }
   137  
   138  func (id *Identity) ExpiresAt() time.Time {
   139  	return id.expirationDate
   140  }
   141  
   142  func (id *Identity) SatisfiesPrincipal(*mspproto.MSPPrincipal) error {
   143  	return nil
   144  }
   145  
   146  func (id *Identity) GetIdentifier() *msp.IdentityIdentifier {
   147  	return &msp.IdentityIdentifier{Mspid: "mock", Id: "mock"}
   148  }
   149  
   150  func (id *Identity) GetMSPIdentifier() string {
   151  	return "mock"
   152  }
   153  
   154  func (id *Identity) Validate() error {
   155  	return nil
   156  }
   157  
   158  func (id *Identity) GetOrganizationalUnits() []*msp.OUIdentifier {
   159  	return nil
   160  }
   161  
   162  func (id *Identity) Verify(msg []byte, sig []byte) error {
   163  	fmt.Printf("VERIFY [% x], [% x], [% x]\n", string(id.Msg), string(msg), string(sig))
   164  	if bytes.Equal(id.Msg, msg) {
   165  		if bytes.Equal(msg, sig) {
   166  			return nil
   167  		}
   168  	}
   169  
   170  	return errors.New("Invalid Signature")
   171  }
   172  
   173  func (id *Identity) Serialize() ([]byte, error) {
   174  	return []byte("cert"), nil
   175  }