github.com/Unheilbar/quorum@v1.0.0/extension/privacyExtension/state_setter_test.go (about)

     1  package privacyExtension
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/ethereum/go-ethereum/common"
     8  	"github.com/ethereum/go-ethereum/core/mps"
     9  	"github.com/ethereum/go-ethereum/core/state"
    10  	"github.com/ethereum/go-ethereum/core/types"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestExtensionHandler_CheckExtensionAndSetPrivateState_NoLogs(t *testing.T) {
    15  	ptm := &mockPrivateTransactionManager{}
    16  	handler := NewExtensionHandler(ptm)
    17  	statedb := createStateDb(t, &state.PrivacyMetadata{})
    18  
    19  	dbBefore := statedb.Copy()
    20  	rootBeforeExtension, _ := statedb.Commit(true)
    21  
    22  	handler.CheckExtensionAndSetPrivateState(nil, statedb, types.DefaultPrivateStateIdentifier)
    23  
    24  	rootAfterExtension, _ := statedb.Commit(true)
    25  	assert.Equal(t, rootBeforeExtension, rootAfterExtension)
    26  
    27  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
    28  
    29  	beforeManagedParties, _ := dbBefore.GetManagedParties(address)
    30  	afterManagedParties, _ := statedb.GetManagedParties(address)
    31  	assert.Equal(t, beforeManagedParties, afterManagedParties)
    32  
    33  	beforePrivacyMetadata, _ := dbBefore.GetPrivacyMetadata(address)
    34  	afterPrivacyMetadata, _ := statedb.GetPrivacyMetadata(address)
    35  	assert.Equal(t, beforePrivacyMetadata, afterPrivacyMetadata)
    36  }
    37  
    38  func TestExtensionHandler_CheckExtensionAndSetPrivateState_LogsAreNotExtensionLogs(t *testing.T) {
    39  	ptm := &mockPrivateTransactionManager{}
    40  	handler := NewExtensionHandler(ptm)
    41  	statedb := createStateDb(t, &state.PrivacyMetadata{})
    42  
    43  	dbBefore := statedb.Copy()
    44  	rootBeforeExtension, _ := statedb.Commit(true)
    45  
    46  	notExtensionLogs := []*types.Log{
    47  		{
    48  			Address:     common.HexToAddress("0x9ccd1e1089c79fe1cca81601fc9ccfa24f77eb58"),
    49  			Topics:      []common.Hash{common.HexToHash("0x24ec1d3ff24c2f6ff210738839dbc339cd45a5294d85c79361016243157aae7b")},
    50  			Data:        []byte{},
    51  			BlockNumber: 6,
    52  			TxHash:      common.HexToHash("0x5faf9ffe6fedc1139bdc1af20b26a2e113d16d736be872571458f8d4bcc048c7"),
    53  			TxIndex:     0,
    54  			BlockHash:   common.HexToHash("0x7e7fb6985ff7e1c7293b8e3202a2b101458acd0b93b5fbed18aab40e8cbeb587"),
    55  			Index:       0,
    56  			Removed:     false,
    57  			PSI:         types.DefaultPrivateStateIdentifier,
    58  		},
    59  	}
    60  	handler.CheckExtensionAndSetPrivateState(notExtensionLogs, statedb, types.DefaultPrivateStateIdentifier)
    61  
    62  	rootAfterExtension, _ := statedb.Commit(true)
    63  	assert.Equal(t, rootBeforeExtension, rootAfterExtension)
    64  
    65  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
    66  
    67  	beforeManagedParties, _ := dbBefore.GetManagedParties(address)
    68  	afterManagedParties, _ := statedb.GetManagedParties(address)
    69  	assert.Equal(t, beforeManagedParties, afterManagedParties)
    70  
    71  	beforePrivacyMetadata, _ := dbBefore.GetPrivacyMetadata(address)
    72  	afterPrivacyMetadata, _ := statedb.GetPrivacyMetadata(address)
    73  	assert.Equal(t, beforePrivacyMetadata, afterPrivacyMetadata)
    74  }
    75  
    76  func TestExtensionHandler_UuidIsOwn_EmptyUUID(t *testing.T) {
    77  	ptm := &mockPrivateTransactionManager{}
    78  	handler := NewExtensionHandler(ptm)
    79  
    80  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
    81  
    82  	isOwn := handler.UuidIsOwn(address, "", types.DefaultPrivateStateIdentifier)
    83  
    84  	assert.False(t, isOwn)
    85  }
    86  
    87  func TestExtensionHandler_UuidIsOwn_IsSenderIsFalse(t *testing.T) {
    88  	ptm := &mockPrivateTransactionManager{
    89  		returns: map[string][]interface{}{"IsSender": {false, nil}},
    90  	}
    91  	handler := NewExtensionHandler(ptm)
    92  
    93  	const uuid = "0xabcd"
    94  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
    95  
    96  	isOwn := handler.UuidIsOwn(address, uuid, types.DefaultPrivateStateIdentifier)
    97  
    98  	assert.False(t, isOwn)
    99  }
   100  
   101  func TestExtensionHandler_UuidIsOwn_WrongPSIFails(t *testing.T) {
   102  	ptm := &mockPrivateTransactionManager{
   103  		returns: map[string][]interface{}{
   104  			"IsSender": {true, nil},
   105  			"Receive":  {"psi1", nil, []byte{}, nil, nil},
   106  		},
   107  	}
   108  	handler := NewExtensionHandler(ptm)
   109  	psmr := &mockPSMR{
   110  		returns: map[string][]interface{}{
   111  			"ResolveForManagedParty": {&mps.PrivateStateMetadata{ID: "psi1", Type: mps.Resident}, nil},
   112  		},
   113  	}
   114  	handler.SetPSMR(psmr)
   115  
   116  	uuid := "0xabcd"
   117  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
   118  
   119  	isOwn := handler.UuidIsOwn(address, uuid, "other")
   120  
   121  	assert.False(t, isOwn)
   122  }
   123  
   124  func TestExtensionHandler_UuidIsOwn_DecryptPayloadFails(t *testing.T) {
   125  	ptm := &mockPrivateTransactionManager{
   126  		returns: map[string][]interface{}{
   127  			"IsSender":       {true, nil},
   128  			"Receive":        {"psi1", nil, []byte(`{"somedata": "val"}`), nil, nil},
   129  			"DecryptPayload": {nil, nil, errors.New("test error")},
   130  		},
   131  	}
   132  	handler := NewExtensionHandler(ptm)
   133  	psmr := &mockPSMR{
   134  		returns: map[string][]interface{}{
   135  			"ResolveForManagedParty": {&mps.PrivateStateMetadata{ID: "psi1", Type: mps.Resident}, nil},
   136  		},
   137  	}
   138  	handler.SetPSMR(psmr)
   139  
   140  	uuid := "0xabcd"
   141  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
   142  
   143  	isOwn := handler.UuidIsOwn(address, uuid, "psi1")
   144  
   145  	assert.False(t, isOwn)
   146  }
   147  
   148  func TestExtensionHandler_UuidIsOwn_AddressDoesntMatch(t *testing.T) {
   149  	ptm := &mockPrivateTransactionManager{
   150  		returns: map[string][]interface{}{
   151  			"IsSender":       {true, nil},
   152  			"Receive":        {"psi1", nil, []byte(`{"somedata": "val"}`), nil, nil},
   153  			"DecryptPayload": {[]byte(`unknown`), nil, nil},
   154  		},
   155  	}
   156  	handler := NewExtensionHandler(ptm)
   157  	psmr := &mockPSMR{
   158  		returns: map[string][]interface{}{
   159  			"ResolveForManagedParty": {&mps.PrivateStateMetadata{ID: "psi1", Type: mps.Resident}, nil},
   160  		},
   161  	}
   162  	handler.SetPSMR(psmr)
   163  
   164  	uuid := "0xabcd"
   165  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
   166  
   167  	isOwn := handler.UuidIsOwn(address, uuid, "psi1")
   168  
   169  	assert.False(t, isOwn)
   170  }
   171  
   172  func TestExtensionHandler_UuidIsOwn_AddressMatches(t *testing.T) {
   173  	uuid := "0xabcd"
   174  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
   175  
   176  	ptm := &mockPrivateTransactionManager{
   177  		returns: map[string][]interface{}{
   178  			"IsSender":       {true, nil},
   179  			"Receive":        {"psi1", nil, []byte(`{"somedata": "val"}`), nil, nil},
   180  			"DecryptPayload": {address.Bytes(), nil, nil},
   181  		},
   182  	}
   183  	handler := NewExtensionHandler(ptm)
   184  	psmr := &mockPSMR{
   185  		returns: map[string][]interface{}{
   186  			"ResolveForManagedParty": {&mps.PrivateStateMetadata{ID: "psi1", Type: mps.Resident}, nil},
   187  		},
   188  	}
   189  	handler.SetPSMR(psmr)
   190  
   191  	isOwn := handler.UuidIsOwn(address, uuid, "psi1")
   192  
   193  	assert.True(t, isOwn)
   194  }
   195  
   196  func TestExtensionHandler_UuidIsOwn_PrivatePSMRSucceeds(t *testing.T) {
   197  	uuid := "0xabcd"
   198  	address := common.HexToAddress("0x2222222222222222222222222222222222222222")
   199  
   200  	ptm := &mockPrivateTransactionManager{
   201  		returns: map[string][]interface{}{
   202  			"IsSender":       {true, nil},
   203  			"Receive":        {"psi1, private", nil, []byte(`{"somedata": "val"}`), nil, nil},
   204  			"DecryptPayload": {address.Bytes(), nil, nil},
   205  		},
   206  	}
   207  	handler := NewExtensionHandler(ptm)
   208  	psmr := &mockPSMR{
   209  		returns: map[string][]interface{}{
   210  			"ResolveForManagedParty": {&mps.PrivateStateMetadata{ID: "private", Type: mps.Resident}, nil},
   211  		},
   212  	}
   213  	handler.SetPSMR(psmr)
   214  
   215  	isOwn := handler.UuidIsOwn(address, uuid, types.DefaultPrivateStateIdentifier)
   216  
   217  	assert.True(t, isOwn)
   218  }