github.com/adnan-c/fabric_e2e_couchdb@v0.6.1-preview.0.20170228180935-21ce6b23cf91/bddtests/steps/endorser_impl.py (about)

     1  # Copyright IBM Corp. 2016 All Rights Reserved.
     2  #
     3  # Licensed under the Apache License, Version 2.0 (the "License");
     4  # you may not use this file except in compliance with the License.
     5  # You may obtain a copy of the License at
     6  #
     7  #      http://www.apache.org/licenses/LICENSE-2.0
     8  #
     9  # Unless required by applicable law or agreed to in writing, software
    10  # distributed under the License is distributed on an "AS IS" BASIS,
    11  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  # See the License for the specific language governing permissions and
    13  # limitations under the License.
    14  #
    15  
    16  import os
    17  import endorser_util
    18  import bdd_grpc_util
    19  import bdd_test_util
    20  import bootstrap_util
    21  import devops_pb2
    22  
    23  @when(u'user "{userName}" creates a chaincode spec "{ccSpecAlias}" with name "{chaincodeName}" of type "{ccType}" for chaincode "{chaincodePath}" with args')
    24  def step_impl(context, userName, ccType, chaincodeName, chaincodePath, ccSpecAlias):
    25  	directory = bootstrap_util.getDirectory(context=context)
    26  	user = directory.getUser(userName)
    27  	args =  bootstrap_util.getArgsFromContextForUser(context, userName)
    28  	ccSpec = endorser_util.getChaincodeSpec(ccType=ccType, path=chaincodePath, name=chaincodeName, args=bdd_grpc_util.toStringArray(args))
    29  	print("ccSpec = {0}".format(ccSpec))
    30  	user.setTagValue(ccSpecAlias, ccSpec)
    31  
    32  
    33  @when(u'user "{userName}" creates a deployment spec "{ccDeploymentSpecAlias}" using chaincode spec "{ccSpecAlias}" and devops on peer "{devopsComposeService}"')
    34  def step_impl(context, userName, ccDeploymentSpecAlias, ccSpecAlias, devopsComposeService):
    35      directory = bootstrap_util.getDirectory(context=context)
    36      user = directory.getUser(userName=userName)
    37      assert ccSpecAlias in user.tags, "ChaincodeSpec alias '{0}' not found for user '{1}'".format(ccSpecAlias, userName)
    38  
    39      ipAddress = bdd_test_util.ipFromContainerNamePart(devopsComposeService, context.compose_containers)
    40      channel = bdd_grpc_util.getGRPCChannel(ipAddress)
    41      devopsStub = devops_pb2.beta_create_Devops_stub(channel)
    42      deploymentSpec = devopsStub.Build(user.tags[ccSpecAlias],20)
    43      #user.setTagValue(ccDeploymentSpecAlias, deploymentSpec)
    44      user.setTagValue(ccDeploymentSpecAlias, deploymentSpec)
    45  
    46  
    47  @when(u'user "{userName}" using cert alias "{certAlias}" creates a deployment proposal "{proposalAlias}" for channel "{channelName}" using chaincode spec "{ccSpecAlias}"')
    48  def step_impl(context, userName, certAlias, proposalAlias, channelName, ccSpecAlias):
    49          directory = bootstrap_util.getDirectory(context=context)
    50          user = directory.getUser(userName=userName)
    51          assert ccSpecAlias in user.tags, "ChaincodeSpec alias '{0}' not found for user '{1}'".format(ccSpecAlias, userName)
    52          ccSpec = user.tags[ccSpecAlias]
    53  
    54  
    55          ccDeploymentSpec = endorser_util.createDeploymentSpec(context=context, ccSpec=ccSpec)
    56          lcChaincodeSpec = endorser_util.createDeploymentChaincodeSpecForBDD(ccDeploymentSpec=ccDeploymentSpec, chainID=str(channelName))
    57          # Find the cert using the cert tuple information saved for the user under certAlias
    58          nodeAdminTuple = user.tags[certAlias]
    59          signersCert = directory.findCertForNodeAdminTuple(nodeAdminTuple)
    60          mspID = nodeAdminTuple.organization
    61  
    62          proposal = endorser_util.createInvokeProposalForBDD(context, ccSpec=lcChaincodeSpec, chainID=channelName,signersCert=signersCert, Mspid=mspID, type="ENDORSER_TRANSACTION")
    63  
    64          signedProposal = endorser_util.signProposal(proposal=proposal, entity=user, signersCert=signersCert)
    65  
    66          # proposal = endorser_util.createDeploymentProposalForBDD(ccDeploymentSpec)
    67          assert not proposalAlias in user.tags, "Proposal alias '{0}' already exists for '{1}'".format(proposalAlias, userName)
    68          user.setTagValue(proposalAlias, signedProposal)
    69  
    70  
    71  
    72  @when(u'user "{userName}" sends proposal "{proposalAlias}" to endorsers with timeout of "{timeout}" seconds with proposal responses "{proposalResponsesAlias}"')
    73  def step_impl(context, userName, proposalAlias, timeout, proposalResponsesAlias):
    74      assert 'table' in context, "Expected table of endorsers"
    75      directory = bootstrap_util.getDirectory(context=context)
    76      user = directory.getUser(userName=userName)
    77  
    78      assert proposalAlias in user.tags, "Proposal alias '{0}' not found for user '{1}'".format(proposalAlias, userName)
    79      signedProposal = user.tags[proposalAlias]
    80  
    81      # Send proposal to each specified endorser, waiting 'timeout' seconds for response/error
    82      endorsers = [row['Endorser'] for row in context.table.rows]
    83      endorserStubs = endorser_util.getEndorserStubs(context, endorsers)
    84      proposalResponseFutures = [endorserStub.ProcessProposal.future(signedProposal, int(timeout)) for endorserStub in endorserStubs]
    85      resultsDict =  dict(zip(endorsers, [respFuture.result() for respFuture in proposalResponseFutures]))
    86      #user.setTagValue(proposalResponsesAlias, resultsDict)
    87      user.tags[proposalResponsesAlias] = resultsDict
    88  
    89  
    90  @then(u'user "{userName}" expects proposal responses "{proposalResponsesAlias}" with status "{statusCode}" from endorsers')
    91  def step_impl(context, userName, proposalResponsesAlias, statusCode):
    92      assert 'table' in context, "Expected table of endorsers"
    93      directory = bootstrap_util.getDirectory(context=context)
    94      user = directory.getUser(userName=userName)
    95      # Make sure proposalResponseAlias not already defined
    96      assert proposalResponsesAlias in user.tags, "Expected proposal responses at tag '{0}', for user '{1}'".format(proposalResponsesAlias, userName)
    97      proposalRespDict = user.tags[proposalResponsesAlias]
    98  
    99      # Loop through endorser proposal Responses
   100      endorsers = [row['Endorser'] for row in context.table.rows]
   101      print("Endorsers = {0}, rsults keys = {1}".format(endorsers, proposalRespDict.keys()))
   102      for respSatusCode in [proposalRespDict[endorser].response.status for endorser in endorsers]:
   103          assert int(statusCode) == respSatusCode, "Expected proposal response status code of {0} from {1}, received {2}".format(statusCode, endorser, respSatusCode)
   104  
   105  @then(u'user "{userName}" expects proposal responses "{proposalResponsesAlias}" each have the same value from endorsers')
   106  def step_impl(context, userName, proposalResponsesAlias):
   107      directory = bootstrap_util.getDirectory(context=context)
   108      user = directory.getUser(userName=userName)
   109      assert proposalResponsesAlias in user.tags, "Expected proposal responses at tag '{0}', for user '{1}'".format(proposalResponsesAlias, userName)
   110      proposalRespDict = user.tags[proposalResponsesAlias]
   111      assert len(proposalRespDict) > 0, "Expected at least 1 proposal response, found none in proposal responses dictionary"
   112      if len(proposalRespDict) == 1:
   113          pass
   114      else:
   115          endorsers = [row['Endorser'] for row in context.table.rows]
   116          endorserToProposalResponseHashDict = dict(zip(endorsers, [user.computeHash(proposalRespDict[endorser].payload) for endorser in endorsers]))
   117          setOfHashes = set(endorserToProposalResponseHashDict.values())
   118          assert len(setOfHashes) == 1, "Hashes from endorsers did NOT match: {0}".format(endorserToProposalResponseHashDict)