func TestBadTx(t *testing.T) { // get a toy proposal prop, err := getProposal() if err != nil { t.Fatalf("getProposal failed, err %s", err) return } simRes := []byte("simulation_result") // endorse it to get a proposal response presp, err := utils.CreateProposalResponse(prop.Header, prop.Payload, simRes, nil, nil, signer) if err != nil { t.Fatalf("CreateProposalResponse failed, err %s", err) return } // assemble a transaction from that proposal and endorsement tx, err := utils.CreateSignedTx(prop, signer, presp) if err != nil { t.Fatalf("CreateSignedTx failed, err %s", err) return } // mess with the transaction payload corrupt(tx.Payload) // validate the transaction it should fail _, _, err = ValidateTransaction(tx) if err == nil { t.Fatalf("ValidateTransaction should have failed") return } // assemble a transaction from that proposal and endorsement tx, err = utils.CreateSignedTx(prop, signer, presp) if err != nil { t.Fatalf("CreateSignedTx failed, err %s", err) return } // mess with the transaction payload corrupt(tx.Signature) // validate the transaction it should fail _, _, err = ValidateTransaction(tx) if err == nil { t.Fatalf("ValidateTransaction should have failed") return } }
func Test2EndorsersDisagree(t *testing.T) { // get a toy proposal prop, err := getProposal() if err != nil { t.Fatalf("getProposal failed, err %s", err) return } simRes1 := []byte("simulation_result1") // endorse it to get a proposal response presp1, err := utils.CreateProposalResponse(prop.Header, prop.Payload, simRes1, nil, nil, signer) if err != nil { t.Fatalf("CreateProposalResponse failed, err %s", err) return } simRes2 := []byte("simulation_result2") // endorse it to get a proposal response presp2, err := utils.CreateProposalResponse(prop.Header, prop.Payload, simRes2, nil, nil, signer) if err != nil { t.Fatalf("CreateProposalResponse failed, err %s", err) return } // assemble a transaction from that proposal and endorsement _, err = utils.CreateSignedTx(prop, signer, presp1, presp2) if err == nil { t.Fatalf("CreateSignedTx should have failed") return } }
func createTx() (*common.Envelope, error) { cis := &peer.ChaincodeInvocationSpec{ChaincodeSpec: &peer.ChaincodeSpec{ChaincodeID: &peer.ChaincodeID{Name: "foo"}}} uuid := util.GenerateUUID() prop, err := utils.CreateProposalFromCIS(uuid, util.GetTestChainID(), cis, sid) if err != nil { return nil, err } presp, err := utils.CreateProposalResponse(prop.Header, prop.Payload, []byte("res"), nil, nil, id) if err != nil { return nil, err } return utils.CreateSignedTx(prop, id, presp) }
//deploy the command via Endorser func deploy(cmd *cobra.Command, cf *ChaincodeCmdFactory) (*protcommon.Envelope, error) { spec, err := getChaincodeSpecification(cmd) if err != nil { return nil, err } cds, err := getChaincodeBytes(spec) if err != nil { return nil, fmt.Errorf("Error getting chaincode code %s: %s", chainFuncName, err) } creator, err := cf.Signer.Serialize() if err != nil { return nil, fmt.Errorf("Error serializing identity for %s: %s\n", cf.Signer.GetIdentifier(), err) } uuid := util.GenerateUUID() prop, err := utils.CreateDeployProposalFromCDS(uuid, chainID, cds, creator) if err != nil { return nil, fmt.Errorf("Error creating proposal %s: %s\n", chainFuncName, err) } var signedProp *pb.SignedProposal signedProp, err = utils.GetSignedProposal(prop, cf.Signer) if err != nil { return nil, fmt.Errorf("Error creating signed proposal %s: %s\n", chainFuncName, err) } proposalResponse, err := cf.EndorserClient.ProcessProposal(context.Background(), signedProp) if err != nil { return nil, fmt.Errorf("Error endorsing %s: %s\n", chainFuncName, err) } if proposalResponse != nil { // assemble a signed transaction (it's an Envelope message) env, err := utils.CreateSignedTx(prop, cf.Signer, proposalResponse) if err != nil { return nil, fmt.Errorf("Could not assemble transaction, err %s", err) } return env, nil } return nil, nil }
func endTxSimulation(chainID string, txsim ledger.TxSimulator, payload []byte, commit bool, prop *pb.Proposal) error { txsim.Done() if lgr := peer.GetLedger(chainID); lgr != nil { if commit { var txSimulationResults []byte var err error //get simulation results if txSimulationResults, err = txsim.GetTxSimulationResults(); err != nil { return err } // assemble a (signed) proposal response message resp, err := putils.CreateProposalResponse(prop.Header, prop.Payload, txSimulationResults, nil, nil, signer) if err != nil { return err } // get the envelope env, err := putils.CreateSignedTx(prop, signer, resp) if err != nil { return err } envBytes, err := putils.GetBytesEnvelope(env) if err != nil { return err } //create the block with 1 transaction block := common.NewBlock(1, []byte{}) block.Data.Data = [][]byte{envBytes} //commit the block if err := lgr.Commit(block); err != nil { return err } } } return nil }
func Test2EndorsersAgree(t *testing.T) { // get a toy proposal prop, err := getProposal() if err != nil { t.Fatalf("getProposal failed, err %s", err) return } simRes1 := []byte("simulation_result") // endorse it to get a proposal response presp1, err := utils.CreateProposalResponse(prop.Header, prop.Payload, simRes1, nil, nil, signer) if err != nil { t.Fatalf("CreateProposalResponse failed, err %s", err) return } simRes2 := []byte("simulation_result") // endorse it to get a proposal response presp2, err := utils.CreateProposalResponse(prop.Header, prop.Payload, simRes2, nil, nil, signer) if err != nil { t.Fatalf("CreateProposalResponse failed, err %s", err) return } // assemble a transaction from that proposal and endorsement tx, err := utils.CreateSignedTx(prop, signer, presp1, presp2) if err != nil { t.Fatalf("CreateSignedTx failed, err %s", err) return } // validate the transaction _, _, err = ValidateTransaction(tx) if err != nil { t.Fatalf("ValidateTransaction failed, err %s", err) return } }
// ConstructSingedTxEnv constructs a transaction envelop for tests func ConstructSingedTxEnv(txid string, chainID string, ccName string, simulationResults []byte, events []byte, visibility []byte, signer msp.SigningIdentity) (*common.Envelope, error) { ss, err := signer.Serialize() if err != nil { return nil, err } prop, err := putils.CreateChaincodeProposal(txid, chainID, &pb.ChaincodeInvocationSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: &pb.ChaincodeID{Name: ccName}}}, ss) if err != nil { return nil, err } presp, err := putils.CreateProposalResponse(prop.Header, prop.Payload, simulationResults, nil, nil, signer) if err != nil { return nil, err } env, err := putils.CreateSignedTx(prop, signer, presp) if err != nil { return nil, err } return env, nil }
// Only exposed for testing purposes - commit the tx simulation so that // a deploy transaction is persisted and that chaincode can be invoked. // This makes the endorser test self-sufficient func (e *Endorser) commitTxSimulation(proposal *pb.Proposal, chainID string, signer msp.SigningIdentity, pResp *pb.ProposalResponse) error { tx, err := putils.CreateSignedTx(proposal, signer, pResp) if err != nil { return err } lgr := peer.GetLedger(chainID) if lgr == nil { return fmt.Errorf("failure while looking up the ledger") } txBytes, err := proto.Marshal(tx) if err != nil { return err } block := common.NewBlock(1, []byte{}) block.Data.Data = [][]byte{txBytes} block.Header.DataHash = block.Data.Hash() if err = lgr.Commit(block); err != nil { return err } return nil }
// chaincodeInvokeOrQuery invokes or queries the chaincode. If successful, the // INVOKE form prints the ProposalResponse to STDOUT, and the QUERY form prints // the query result on STDOUT. A command-line flag (-r, --raw) determines // whether the query result is output as raw bytes, or as a printable string. // The printable form is optionally (-x, --hex) a hexadecimal representation // of the query response. If the query response is NIL, nothing is output. // // NOTE - Query will likely go away as all interactions with the endorser are // Proposal and ProposalResponses func chaincodeInvokeOrQuery(cmd *cobra.Command, args []string, invoke bool, cf *ChaincodeCmdFactory) (err error) { spec, err := getChaincodeSpecification(cmd) if err != nil { return err } // Build the ChaincodeInvocationSpec message invocation := &pb.ChaincodeInvocationSpec{ChaincodeSpec: spec} if customIDGenAlg != common.UndefinedParamValue { invocation.IdGenerationAlg = customIDGenAlg } creator, err := cf.Signer.Serialize() if err != nil { return fmt.Errorf("Error serializing identity for %s: %s\n", cf.Signer.GetIdentifier(), err) } uuid := cutil.GenerateUUID() var prop *pb.Proposal prop, err = putils.CreateProposalFromCIS(uuid, chainID, invocation, creator) if err != nil { return fmt.Errorf("Error creating proposal %s: %s\n", chainFuncName, err) } var signedProp *pb.SignedProposal signedProp, err = putils.GetSignedProposal(prop, cf.Signer) if err != nil { return fmt.Errorf("Error creating signed proposal %s: %s\n", chainFuncName, err) } var proposalResp *pb.ProposalResponse proposalResp, err = cf.EndorserClient.ProcessProposal(context.Background(), signedProp) if err != nil { return fmt.Errorf("Error endorsing %s: %s\n", chainFuncName, err) } if invoke { if proposalResp != nil { // assemble a signed transaction (it's an Envelope message) env, err := putils.CreateSignedTx(prop, cf.Signer, proposalResp) if err != nil { return fmt.Errorf("Could not assemble transaction, err %s", err) } // send the envelope for ordering if err = cf.BroadcastClient.Send(env); err != nil { return fmt.Errorf("Error sending transaction %s: %s\n", chainFuncName, err) } } logger.Infof("Invoke result: %v", proposalResp) } else { if proposalResp == nil { return fmt.Errorf("Error query %s by endorsing: %s\n", chainFuncName, err) } if chaincodeQueryRaw { if chaincodeQueryHex { err = errors.New("Options --raw (-r) and --hex (-x) are not compatible\n") return } fmt.Print("Query Result (Raw): ") os.Stdout.Write(proposalResp.Response.Payload) } else { if chaincodeQueryHex { fmt.Printf("Query Result: %x\n", proposalResp.Response.Payload) } else { fmt.Printf("Query Result: %s\n", string(proposalResp.Response.Payload)) } } } return nil }
func TestGoodPath(t *testing.T) { // get a toy proposal prop, err := getProposal() if err != nil { t.Fatalf("getProposal failed, err %s", err) return } // sign it sProp, err := utils.GetSignedProposal(prop, signer) if err != nil { t.Fatalf("GetSignedProposal failed, err %s", err) return } // validate it _, _, _, err = ValidateProposalMessage(sProp) if err != nil { t.Fatalf("ValidateProposalMessage failed, err %s", err) return } simRes := []byte("simulation_result") // endorse it to get a proposal response presp, err := utils.CreateProposalResponse(prop.Header, prop.Payload, simRes, nil, nil, signer) if err != nil { t.Fatalf("CreateProposalResponse failed, err %s", err) return } // assemble a transaction from that proposal and endorsement tx, err := utils.CreateSignedTx(prop, signer, presp) if err != nil { t.Fatalf("CreateSignedTx failed, err %s", err) return } // validate the transaction _, act, err := ValidateTransaction(tx) if err != nil { t.Fatalf("ValidateTransaction failed, err %s", err) return } // expect one single action if len(act) != 1 { t.Fatalf("Ivalid number of TransactionAction, expected 1, got %d", len(act)) return } // get the payload of the action _, simResBack, err := utils.GetPayloads(act[0]) if err != nil { t.Fatalf("GetPayloads failed, err %s", err) return } // compare it to the original action and expect it to be equal if string(simRes) != string(simResBack.Results) { t.Fatalf("Simulation results are different") return } }