status-im/status-go

package protocol

import (
    "encoding/json"
    "fmt"
    "strings"
    "testing"

    "github.com/stretchr/testify/require"

    "github.com/status-im/status-go/eth-node/crypto"
    "github.com/status-im/status-go/protocol/common"
    "github.com/status-im/status-go/protocol/protobuf"
)

type contactTest struct {
    actualLocalState    ContactRequestState
    expectedLocalState  ContactRequestState
    actualRemoteState   ContactRequestState
    expectedRemoteState ContactRequestState
    expectedAdded       bool
    expectedHasAddedUs  bool
    expectedMutual      bool
}

func (ct contactTest) Contact() Contact {
    return Contact{
        ContactRequestLocalState:  ct.actualLocalState,
        ContactRequestRemoteState: ct.actualRemoteState,
    }
}

func validateContactTest(t *testing.T, contact Contact, tc contactTest, testNum int) {
    failedMessage := fmt.Sprintf("test failed: %d", testNum)
    require.Equal(t, tc.expectedLocalState, contact.ContactRequestLocalState, failedMessage+", contact request local state not matching")
    require.Equal(t, tc.expectedRemoteState, contact.ContactRequestRemoteState, failedMessage+", contact request remote state not matching")

    require.Equal(t, tc.expectedAdded, contact.added(), failedMessage+", added() not matching")
    require.Equal(t, tc.expectedHasAddedUs, contact.hasAddedUs(), failedMessage+", hasAddedUs() not matching")
    require.Equal(t, tc.expectedMutual, contact.mutual(), failedMessage+", mutual() not matching")
}

/*
none/none
sent/none
dismissed/none
none/received
sent/received
dismissed/received
*/

func TestContactContactRequestSent(t *testing.T) {

    clock := uint64(1)

    /* Cases to consider are:
       Local = none Remote = none
       Local = none Remote = received
       Local = sent Remote = none
       Local = sent Remote = received
       Local = dismissed Remote = none
       Local = dismissed Remote = received
    */

    tests := []contactTest{
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       true,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       true,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       true,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
    }

    for testNum, tc := range tests {
        contact := tc.Contact()

        contact.ContactRequestSent(clock)
        validateContactTest(t, contact, tc, testNum+1)

    }
}

func TestContactAcceptContactRequest(t *testing.T) {

    clock := uint64(1)

    tests := []contactTest{
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       true,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       true,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       true,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
    }

    for testNum, tc := range tests {
        contact := tc.Contact()

        contact.AcceptContactRequest(clock)
        validateContactTest(t, contact, tc, testNum+1)

    }
}

func TestContactRetractContactRequest(t *testing.T) {

    clock := uint64(1)

    tests := []contactTest{
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
    }

    for testNum, tc := range tests {
        contact := tc.Contact()

        contact.RetractContactRequest(clock)
        validateContactTest(t, contact, tc, testNum+1)

    }
}

func TestContactDismissContactRequest(t *testing.T) {

    clock := uint64(1)

    tests := []contactTest{
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
    }

    for testNum, tc := range tests {
        contact := tc.Contact()

        contact.DismissContactRequest(clock)
        validateContactTest(t, contact, tc, testNum+1)

    }
}

func TestContactContactRequestRetracted(t *testing.T) {

    clock := uint64(1)

    tests := []contactTest{
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateNone,
            expectedAdded:       false,
            expectedHasAddedUs:  false,
            expectedMutual:      false,
        },
    }

    for testNum, tc := range tests {
        contact := tc.Contact()

        contact.ContactRequestRetracted(clock, false)
        validateContactTest(t, contact, tc, testNum+1)

    }
}

func TestContactContactRequestReceived(t *testing.T) {

    clock := uint64(1)

    tests := []contactTest{
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
    }

    for testNum, tc := range tests {
        contact := tc.Contact()

        contact.ContactRequestReceived(clock)
        validateContactTest(t, contact, tc, testNum+1)

    }
}

func TestContactContactRequestAccepted(t *testing.T) {

    clock := uint64(1)

    tests := []contactTest{
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateNone,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateNone,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateSent,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateSent,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       true,
            expectedHasAddedUs:  true,
            expectedMutual:      true,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateNone,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
        {
            actualLocalState:    ContactRequestStateDismissed,
            actualRemoteState:   ContactRequestStateReceived,
            expectedLocalState:  ContactRequestStateDismissed,
            expectedRemoteState: ContactRequestStateReceived,
            expectedAdded:       false,
            expectedHasAddedUs:  true,
            expectedMutual:      false,
        },
    }

    for testNum, tc := range tests {
        contact := tc.Contact()

        contact.ContactRequestAccepted(clock)
        validateContactTest(t, contact, tc, testNum+1)

    }
}

func TestMarshalContactJSON(t *testing.T) {
    contact := &Contact{
        LocalNickname:             "primary-name",
        Alias:                     "secondary-name",
        ContactRequestLocalState:  ContactRequestStateSent,
        ContactRequestRemoteState: ContactRequestStateReceived,
    }
    id, err := crypto.GenerateKey()
    require.NoError(t, err)
    contact.ID = common.PubkeyToHex(&id.PublicKey)

    encodedContact, err := json.Marshal(contact)

    require.NoError(t, err)

    require.True(t, strings.Contains(string(encodedContact), "compressedKey\":\"zQ"))
    require.True(t, strings.Contains(string(encodedContact), "mutual\":true"))
    require.True(t, strings.Contains(string(encodedContact), "added\":true"))
    require.True(t, strings.Contains(string(encodedContact), "hasAddedUs\":true"))
    require.True(t, strings.Contains(string(encodedContact), "active\":true"))
    require.True(t, strings.Contains(string(encodedContact), "primaryName\":\"primary-name"))
    require.True(t, strings.Contains(string(encodedContact), "secondaryName\":\"secondary-name"))
    require.True(t, strings.Contains(string(encodedContact), "emojiHash"))
}

func TestContactContactRequestPropagatedStateReceivedOutOfDateLocalStateOnTheirSide(t *testing.T) {
    // We receive a message with expected contact request state != our state
    // and clock < our clock, we ping back the user to reach consistency

    c := &Contact{}
    c.ContactRequestLocalState = ContactRequestStateSent
    c.ContactRequestLocalClock = 1

    result := c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateNone),
            RemoteClock: 0,
            LocalState:  uint64(ContactRequestStateNone),
            LocalClock:  1,
        },
    )

    require.True(t, result.sendBackState)

    // if the state is the same, it should not send back a message

    c = &Contact{}
    c.ContactRequestLocalState = ContactRequestStateNone
    c.ContactRequestLocalClock = 1

    result = c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateNone),
            RemoteClock: 0,
            LocalState:  uint64(ContactRequestStateNone),
            LocalClock:  1,
        },
    )

    require.False(t, result.sendBackState)

    // If the clock is the same, it should not send back a message
    c = &Contact{}
    c.ContactRequestLocalState = ContactRequestStateSent
    c.ContactRequestLocalClock = 1

    result = c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateNone),
            RemoteClock: 1,
            LocalState:  uint64(ContactRequestStateNone),
            LocalClock:  1,
        },
    )

    require.False(t, result.sendBackState)

}

func TestContactContactRequestPropagatedStateReceivedOutOfDateLocalStateOnOurSide(t *testing.T) {
    // We receive a message with expected contact request state == none
    // and clock > our clock. We consider this a retraction, unless we are
    // in the dismissed state, since that should be only changed by a
    // trusted device

    c := &Contact{}
    c.ContactRequestLocalState = ContactRequestStateSent
    c.ContactRequestLocalClock = 1

    c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateNone),
            RemoteClock: 2,
            LocalState:  uint64(ContactRequestStateNone),
            LocalClock:  1,
        },
    )

    require.False(t, c.added())

    // But if it's dismissed, we don't change it
    c = &Contact{}
    c.ContactRequestLocalState = ContactRequestStateDismissed
    c.ContactRequestLocalClock = 1

    c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateNone),
            RemoteClock: 1,
            LocalState:  uint64(ContactRequestStateNone),
            LocalClock:  2,
        },
    )

    require.False(t, c.added())
    require.True(t, c.dismissed())

    // or if it's lower clock

    c = &Contact{}
    c.ContactRequestLocalState = ContactRequestStateSent
    c.ContactRequestLocalClock = 1

    c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateNone),
            RemoteClock: 1,
            LocalState:  uint64(ContactRequestStateNone),
            LocalClock:  0,
        },
    )

    require.True(t, c.added())
}

func TestContactContactRequestPropagatedStateReceivedOutOfDateRemoteState(t *testing.T) {
    // We receive a message with newer remote state, we process it as we would for a normal contact request

    c := &Contact{}

    c.ContactRequestLocalState = ContactRequestStateSent
    c.ContactRequestLocalClock = 1

    c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateSent),
            RemoteClock: 1,
            LocalState:  uint64(ContactRequestStateSent),
            LocalClock:  1,
        },
    )

    require.True(t, c.added())
    require.True(t, c.mutual())

    // and retraction
    c = &Contact{}
    c.ContactRequestLocalState = ContactRequestStateSent
    c.ContactRequestLocalClock = 1
    c.ContactRequestRemoteState = ContactRequestStateReceived
    c.ContactRequestRemoteClock = 1

    c.ContactRequestPropagatedStateReceived(
        &protobuf.ContactRequestPropagatedState{
            RemoteState: uint64(ContactRequestStateSent),
            RemoteClock: 1,
            LocalState:  uint64(ContactRequestStateNone),
            LocalClock:  2,
        },
    )

    require.False(t, c.added())
    require.False(t, c.hasAddedUs())
    require.False(t, c.mutual())
}

func TestPrimaryName(t *testing.T) {
    // Has only Alias

    contact := &Contact{
        Alias: "alias",
    }

    require.Equal(t, "alias", contact.PrimaryName())

    // Has display name

    contact.DisplayName = "display-name"

    require.Equal(t, "display-name", contact.PrimaryName())
    require.Equal(t, "", contact.SecondaryName())

    // Has non verified ens name

    contact.EnsName = "ens-name"
    require.Equal(t, "display-name", contact.PrimaryName())
    require.Equal(t, "", contact.SecondaryName())

    // Has verified ens name
    contact.ENSVerified = true
    require.Equal(t, "ens-name", contact.PrimaryName())
    require.Equal(t, "", contact.SecondaryName())

    contact.LocalNickname = "nickname"
    // Has nickname and ENS name
    require.Equal(t, "nickname", contact.PrimaryName())
    require.Equal(t, "ens-name", contact.SecondaryName())

    // Has nickname and display name
    contact.EnsName = ""
    require.Equal(t, "nickname", contact.PrimaryName())
    require.Equal(t, "display-name", contact.SecondaryName())

    // Has nickname and alias
    contact.DisplayName = ""
    require.Equal(t, "nickname", contact.PrimaryName())
    require.Equal(t, "alias", contact.SecondaryName())
}

func TestProcessSyncContactRequestState(t *testing.T) {
    c := &Contact{}
    c.ContactRequestLocalState = ContactRequestStateNone
    c.ContactRequestLocalClock = 1
    c.ContactRequestRemoteState = ContactRequestStateNone
    c.ContactRequestRemoteClock = 1

    c.ProcessSyncContactRequestState(ContactRequestStateNone, 2, ContactRequestStateSent, 2)

    // Here we need to confirm that resulting Local/RemoteState is equal
    // to what comes from the contact sync message, otherwise it will be inconsistent
    require.Equal(t, ContactRequestStateSent, c.ContactRequestLocalState)
    require.Equal(t, ContactRequestStateNone, c.ContactRequestRemoteState)
}