github.com/defanghe/fabric@v2.1.1+incompatible/core/chaincode/lifecycle/metadata_manager_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package lifecycle_test
     8  
     9  import (
    10  	"github.com/hyperledger/fabric/common/chaincode"
    11  	"github.com/hyperledger/fabric/core/chaincode/lifecycle"
    12  	"github.com/hyperledger/fabric/core/chaincode/lifecycle/mock"
    13  
    14  	. "github.com/onsi/ginkgo"
    15  	. "github.com/onsi/gomega"
    16  )
    17  
    18  var _ = Describe("MetadataManager", func() {
    19  	var (
    20  		metadataManager            *lifecycle.MetadataManager
    21  		fakeMetadataUpdateListener *mock.MetadataUpdateListener
    22  	)
    23  
    24  	BeforeEach(func() {
    25  		metadataManager = lifecycle.NewMetadataManager()
    26  		fakeMetadataUpdateListener = &mock.MetadataUpdateListener{}
    27  		metadataManager.AddListener(lifecycle.HandleMetadataUpdateFunc(fakeMetadataUpdateListener.HandleMetadataUpdate))
    28  	})
    29  
    30  	It("initializes metadata", func() {
    31  		chaincodes := chaincode.MetadataSet{
    32  			{
    33  				Name:    "cc-name",
    34  				Version: "cc-version",
    35  				Policy:  []byte("cc-policy"),
    36  			},
    37  		}
    38  		metadataManager.InitializeMetadata("testchannel", chaincodes)
    39  		Expect(metadataManager.MetadataSet["testchannel"]).To(HaveLen(1))
    40  		Expect(metadataManager.MetadataSet["testchannel"]).To(ConsistOf(
    41  			chaincode.Metadata{
    42  				Name:    "cc-name",
    43  				Version: "cc-version",
    44  				Policy:  []byte("cc-policy"),
    45  			},
    46  		))
    47  	})
    48  
    49  	It("updates metadata and notifies registered listeners", func() {
    50  		chaincodes := chaincode.MetadataSet{
    51  			{
    52  				Name:    "cc-name",
    53  				Version: "cc-version",
    54  				Policy:  []byte("cc-policy"),
    55  			},
    56  		}
    57  
    58  		metadataManager.UpdateMetadata("testchannel", chaincodes)
    59  		Expect(metadataManager.MetadataSet["testchannel"]).To(HaveLen(1))
    60  		Expect(metadataManager.MetadataSet["testchannel"]).To(ConsistOf(
    61  			chaincode.Metadata{
    62  				Name:    "cc-name",
    63  				Version: "cc-version",
    64  				Policy:  []byte("cc-policy"),
    65  			},
    66  		))
    67  		Expect(fakeMetadataUpdateListener.HandleMetadataUpdateCallCount()).To(Equal(1))
    68  	})
    69  
    70  	It("updates legacy metadata and notifies registered listeners", func() {
    71  		chaincodes := chaincode.MetadataSet{
    72  			{
    73  				Name:    "legacy-cc-name",
    74  				Version: "legacy-cc-version",
    75  				Policy:  []byte("legacy-cc-policy"),
    76  			},
    77  		}
    78  
    79  		metadataManager.HandleMetadataUpdate("testchannel", chaincodes)
    80  		Expect(metadataManager.LegacyMetadataSet["testchannel"]).To(HaveLen(1))
    81  		Expect(metadataManager.LegacyMetadataSet["testchannel"]).To(ConsistOf(
    82  			chaincode.Metadata{
    83  				Name:    "legacy-cc-name",
    84  				Version: "legacy-cc-version",
    85  				Policy:  []byte("legacy-cc-policy"),
    86  			},
    87  		))
    88  		Expect(fakeMetadataUpdateListener.HandleMetadataUpdateCallCount()).To(Equal(1))
    89  	})
    90  
    91  	Context("when _lifecycle and lscc chaincodes are both defined and an lscc chaincode is updated", func() {
    92  		var legacyChaincodes chaincode.MetadataSet
    93  
    94  		BeforeEach(func() {
    95  			chaincodes := chaincode.MetadataSet{
    96  				{
    97  					Name:      "cc-name",
    98  					Version:   "cc-version",
    99  					Policy:    []byte("cc-policy"),
   100  					Approved:  true,
   101  					Installed: true,
   102  				},
   103  			}
   104  			legacyChaincodes = chaincode.MetadataSet{
   105  				{
   106  					Name:    "legacy-cc-name",
   107  					Version: "legacy-cc-version",
   108  					Policy:  []byte("legacy-cc-policy"),
   109  				},
   110  			}
   111  			metadataManager.InitializeMetadata("testchannel", chaincodes)
   112  			Expect(metadataManager.MetadataSet["testchannel"]).To(HaveLen(1))
   113  			Expect(metadataManager.MetadataSet["testchannel"]).To(ConsistOf(
   114  				chaincode.Metadata{
   115  					Name:      "cc-name",
   116  					Version:   "cc-version",
   117  					Policy:    []byte("cc-policy"),
   118  					Approved:  true,
   119  					Installed: true,
   120  				},
   121  			))
   122  		})
   123  
   124  		It("aggregates the chaincode metadata", func() {
   125  			metadataManager.HandleMetadataUpdate("testchannel", legacyChaincodes)
   126  			Expect(fakeMetadataUpdateListener.HandleMetadataUpdateCallCount()).To(Equal(1))
   127  			channelArg, metadataSetArg := fakeMetadataUpdateListener.HandleMetadataUpdateArgsForCall(0)
   128  			Expect(channelArg).To(Equal("testchannel"))
   129  			Expect(metadataSetArg).To(HaveLen(2))
   130  			Expect(metadataSetArg).To(ConsistOf(
   131  				chaincode.Metadata{
   132  					Name:      "cc-name",
   133  					Version:   "cc-version",
   134  					Policy:    []byte("cc-policy"),
   135  					Approved:  true,
   136  					Installed: true,
   137  				},
   138  				chaincode.Metadata{
   139  					Name:    "legacy-cc-name",
   140  					Version: "legacy-cc-version",
   141  					Policy:  []byte("legacy-cc-policy"),
   142  				},
   143  			))
   144  		})
   145  	})
   146  
   147  	Context("when _lifecycle and lscc chaincodes are both for the same chaincode", func() {
   148  		var legacyChaincodes chaincode.MetadataSet
   149  
   150  		BeforeEach(func() {
   151  			chaincodes := chaincode.MetadataSet{
   152  				{
   153  					Name:      "cc-name",
   154  					Version:   "cc-version",
   155  					Policy:    []byte("cc-policy"),
   156  					Approved:  true,
   157  					Installed: true,
   158  				},
   159  			}
   160  			legacyChaincodes = chaincode.MetadataSet{
   161  				{
   162  					Name:    "cc-name",
   163  					Version: "legacy-cc-version",
   164  					Policy:  []byte("legacy-cc-policy"),
   165  				},
   166  			}
   167  			metadataManager.InitializeMetadata("testchannel", chaincodes)
   168  			Expect(metadataManager.MetadataSet["testchannel"]).To(HaveLen(1))
   169  			Expect(metadataManager.MetadataSet["testchannel"]).To(ConsistOf(
   170  				chaincode.Metadata{
   171  					Name:      "cc-name",
   172  					Version:   "cc-version",
   173  					Policy:    []byte("cc-policy"),
   174  					Approved:  true,
   175  					Installed: true,
   176  				},
   177  			))
   178  		})
   179  
   180  		It("returns the version from _lifecycle", func() {
   181  			metadataManager.HandleMetadataUpdate("testchannel", legacyChaincodes)
   182  			Expect(fakeMetadataUpdateListener.HandleMetadataUpdateCallCount()).To(Equal(1))
   183  			channelArg, metadataSetArg := fakeMetadataUpdateListener.HandleMetadataUpdateArgsForCall(0)
   184  			Expect(channelArg).To(Equal("testchannel"))
   185  			Expect(metadataSetArg).To(HaveLen(1))
   186  			Expect(metadataSetArg).To(ConsistOf(
   187  				chaincode.Metadata{
   188  					Name:      "cc-name",
   189  					Version:   "cc-version",
   190  					Policy:    []byte("cc-policy"),
   191  					Approved:  true,
   192  					Installed: true,
   193  				},
   194  			))
   195  		})
   196  	})
   197  
   198  	Context("when _lifecycle and lscc chaincodes are both for the same chaincode but has not been approved/installed in _lifecycle", func() {
   199  		var legacyChaincodes chaincode.MetadataSet
   200  
   201  		BeforeEach(func() {
   202  			chaincodes := chaincode.MetadataSet{
   203  				{
   204  					Name:      "notapproved",
   205  					Version:   "na-version",
   206  					Policy:    []byte("na-policy"),
   207  					Approved:  false,
   208  					Installed: true,
   209  				},
   210  				{
   211  					Name:      "notinstalled",
   212  					Version:   "ni-version",
   213  					Policy:    []byte("ni-policy"),
   214  					Approved:  true,
   215  					Installed: false,
   216  				},
   217  			}
   218  			legacyChaincodes = chaincode.MetadataSet{
   219  				{
   220  					Name:    "notapproved",
   221  					Version: "na-version",
   222  					Policy:  []byte("legacy-na-policy"),
   223  				},
   224  				{
   225  					Name:    "notinstalled",
   226  					Version: "ni-version",
   227  					Policy:  []byte("legacy-ni-policy"),
   228  				},
   229  			}
   230  			metadataManager.InitializeMetadata("testchannel", chaincodes)
   231  			Expect(metadataManager.MetadataSet["testchannel"]).To(HaveLen(2))
   232  			Expect(metadataManager.MetadataSet["testchannel"]).To(ConsistOf(
   233  				chaincode.Metadata{
   234  					Name:      "notapproved",
   235  					Version:   "na-version",
   236  					Policy:    []byte("na-policy"),
   237  					Approved:  false,
   238  					Installed: true,
   239  				},
   240  				chaincode.Metadata{
   241  					Name:      "notinstalled",
   242  					Version:   "ni-version",
   243  					Policy:    []byte("ni-policy"),
   244  					Approved:  true,
   245  					Installed: false,
   246  				},
   247  			))
   248  		})
   249  
   250  		It("does not include stale definitions from lscc", func() {
   251  			metadataManager.HandleMetadataUpdate("testchannel", legacyChaincodes)
   252  			Expect(fakeMetadataUpdateListener.HandleMetadataUpdateCallCount()).To(Equal(1))
   253  			channelArg, metadataSetArg := fakeMetadataUpdateListener.HandleMetadataUpdateArgsForCall(0)
   254  			Expect(channelArg).To(Equal("testchannel"))
   255  			Expect(metadataSetArg).To(BeEmpty())
   256  		})
   257  	})
   258  })