github.com/hyperledger/aries-framework-go@v0.3.2/pkg/client/presentproof/client_test.go (about)

     1  /*
     2  Copyright SecureKey Technologies Inc. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package presentproof
     8  
     9  import (
    10  	"errors"
    11  	"testing"
    12  
    13  	"github.com/golang/mock/gomock"
    14  	"github.com/google/uuid"
    15  	"github.com/stretchr/testify/require"
    16  
    17  	"github.com/hyperledger/aries-framework-go/pkg/didcomm/common/service"
    18  	"github.com/hyperledger/aries-framework-go/pkg/didcomm/protocol/presentproof"
    19  	mocks "github.com/hyperledger/aries-framework-go/pkg/internal/gomocks/client/presentproof"
    20  	"github.com/hyperledger/aries-framework-go/pkg/store/connection"
    21  )
    22  
    23  const (
    24  	Alice = "Alice"
    25  	Bob   = "Bob"
    26  )
    27  
    28  func TestNew(t *testing.T) {
    29  	const errMsg = "test err"
    30  
    31  	ctrl := gomock.NewController(t)
    32  	defer ctrl.Finish()
    33  
    34  	t.Run("get service error", func(t *testing.T) {
    35  		provider := mocks.NewMockProvider(ctrl)
    36  		provider.EXPECT().Service(gomock.Any()).Return(nil, errors.New(errMsg))
    37  		_, err := New(provider)
    38  		require.EqualError(t, err, errMsg)
    39  	})
    40  
    41  	t.Run("cast service error", func(t *testing.T) {
    42  		provider := mocks.NewMockProvider(ctrl)
    43  		provider.EXPECT().Service(gomock.Any()).Return(nil, nil)
    44  		_, err := New(provider)
    45  		require.EqualError(t, err, "cast service to presentproof service failed")
    46  	})
    47  }
    48  
    49  func TestClient_SendRequestPresentation(t *testing.T) {
    50  	ctrl := gomock.NewController(t)
    51  	defer ctrl.Finish()
    52  
    53  	t.Run("Success", func(t *testing.T) {
    54  		provider := mocks.NewMockProvider(ctrl)
    55  		thid := uuid.New().String()
    56  
    57  		svc := mocks.NewMockProtocolService(ctrl)
    58  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
    59  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
    60  				require.Equal(t, msg.Type(), presentproof.RequestPresentationMsgTypeV2)
    61  
    62  				return thid, nil
    63  			})
    64  
    65  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
    66  		client, err := New(provider)
    67  		require.NoError(t, err)
    68  
    69  		conn := connection.Record{
    70  			ConnectionID: uuid.New().String(),
    71  			MyDID:        Alice,
    72  			TheirDID:     Bob,
    73  		}
    74  
    75  		result, err := client.SendRequestPresentation(&RequestPresentation{}, &conn)
    76  		require.NoError(t, err)
    77  		require.Equal(t, thid, result)
    78  	})
    79  
    80  	t.Run("Empty Invitation Presentation", func(t *testing.T) {
    81  		provider := mocks.NewMockProvider(ctrl)
    82  
    83  		provider.EXPECT().Service(gomock.Any()).Return(mocks.NewMockProtocolService(ctrl), nil)
    84  		client, err := New(provider)
    85  		require.NoError(t, err)
    86  
    87  		conn := connection.Record{
    88  			ConnectionID: uuid.New().String(),
    89  			MyDID:        Alice,
    90  			TheirDID:     Bob,
    91  		}
    92  
    93  		_, err = client.SendRequestPresentation(nil, &conn)
    94  		require.EqualError(t, err, errEmptyRequestPresentation.Error())
    95  	})
    96  }
    97  
    98  func TestClient_SendRequestPresentationV3(t *testing.T) {
    99  	ctrl := gomock.NewController(t)
   100  	defer ctrl.Finish()
   101  
   102  	t.Run("Success", func(t *testing.T) {
   103  		provider := mocks.NewMockProvider(ctrl)
   104  		thid := uuid.New().String()
   105  
   106  		svc := mocks.NewMockProtocolService(ctrl)
   107  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
   108  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
   109  				require.Equal(t, msg.Type(), presentproof.RequestPresentationMsgTypeV3)
   110  
   111  				return thid, nil
   112  			})
   113  
   114  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   115  		client, err := New(provider)
   116  		require.NoError(t, err)
   117  
   118  		conn := connection.Record{
   119  			ConnectionID:   uuid.New().String(),
   120  			MyDID:          Alice,
   121  			TheirDID:       Bob,
   122  			DIDCommVersion: service.V2,
   123  		}
   124  
   125  		result, err := client.SendRequestPresentation(&RequestPresentation{}, &conn)
   126  		require.NoError(t, err)
   127  		require.Equal(t, thid, result)
   128  	})
   129  
   130  	t.Run("Empty Invitation Presentation", func(t *testing.T) {
   131  		provider := mocks.NewMockProvider(ctrl)
   132  
   133  		provider.EXPECT().Service(gomock.Any()).Return(mocks.NewMockProtocolService(ctrl), nil)
   134  		client, err := New(provider)
   135  		require.NoError(t, err)
   136  
   137  		conn := connection.Record{
   138  			ConnectionID:   uuid.New().String(),
   139  			MyDID:          Alice,
   140  			TheirDID:       Bob,
   141  			DIDCommVersion: service.V2,
   142  		}
   143  
   144  		_, err = client.SendRequestPresentation(nil, &conn)
   145  		require.EqualError(t, err, errEmptyRequestPresentation.Error())
   146  	})
   147  }
   148  
   149  func TestClient_SendProposePresentation(t *testing.T) {
   150  	ctrl := gomock.NewController(t)
   151  	defer ctrl.Finish()
   152  
   153  	t.Run("Success", func(t *testing.T) {
   154  		provider := mocks.NewMockProvider(ctrl)
   155  		thid := uuid.New().String()
   156  
   157  		svc := mocks.NewMockProtocolService(ctrl)
   158  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
   159  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
   160  				require.Equal(t, msg.Type(), presentproof.ProposePresentationMsgTypeV2)
   161  
   162  				return thid, nil
   163  			})
   164  
   165  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   166  		client, err := New(provider)
   167  		require.NoError(t, err)
   168  
   169  		conn := connection.Record{
   170  			ConnectionID: uuid.New().String(),
   171  			MyDID:        Alice,
   172  			TheirDID:     Bob,
   173  		}
   174  
   175  		result, err := client.SendProposePresentation(&ProposePresentation{}, &conn)
   176  		require.NoError(t, err)
   177  		require.Equal(t, thid, result)
   178  	})
   179  
   180  	t.Run("Empty Invitation Presentation", func(t *testing.T) {
   181  		provider := mocks.NewMockProvider(ctrl)
   182  
   183  		provider.EXPECT().Service(gomock.Any()).Return(mocks.NewMockProtocolService(ctrl), nil)
   184  		client, err := New(provider)
   185  		require.NoError(t, err)
   186  
   187  		conn := connection.Record{
   188  			ConnectionID: uuid.New().String(),
   189  			MyDID:        Alice,
   190  			TheirDID:     Bob,
   191  		}
   192  
   193  		_, err = client.SendProposePresentation(nil, &conn)
   194  		require.EqualError(t, err, errEmptyProposePresentation.Error())
   195  	})
   196  }
   197  
   198  func TestClient_SendProposePresentationV3(t *testing.T) {
   199  	ctrl := gomock.NewController(t)
   200  	defer ctrl.Finish()
   201  
   202  	t.Run("Success", func(t *testing.T) {
   203  		provider := mocks.NewMockProvider(ctrl)
   204  		thid := uuid.New().String()
   205  
   206  		svc := mocks.NewMockProtocolService(ctrl)
   207  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
   208  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
   209  				require.Equal(t, msg.Type(), presentproof.ProposePresentationMsgTypeV3)
   210  
   211  				return thid, nil
   212  			})
   213  
   214  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   215  		client, err := New(provider)
   216  		require.NoError(t, err)
   217  
   218  		conn := connection.Record{
   219  			ConnectionID:   uuid.New().String(),
   220  			MyDID:          Alice,
   221  			TheirDID:       Bob,
   222  			DIDCommVersion: service.V2,
   223  		}
   224  
   225  		result, err := client.SendProposePresentation(&ProposePresentation{}, &conn)
   226  		require.NoError(t, err)
   227  		require.Equal(t, thid, result)
   228  	})
   229  
   230  	t.Run("Empty Invitation Presentation", func(t *testing.T) {
   231  		provider := mocks.NewMockProvider(ctrl)
   232  
   233  		provider.EXPECT().Service(gomock.Any()).Return(mocks.NewMockProtocolService(ctrl), nil)
   234  		client, err := New(provider)
   235  		require.NoError(t, err)
   236  
   237  		conn := connection.Record{
   238  			ConnectionID:   uuid.New().String(),
   239  			MyDID:          Alice,
   240  			TheirDID:       Bob,
   241  			DIDCommVersion: service.V2,
   242  		}
   243  
   244  		_, err = client.SendProposePresentation(nil, &conn)
   245  		require.EqualError(t, err, errEmptyProposePresentation.Error())
   246  	})
   247  }
   248  
   249  func TestClient_AcceptRequestPresentation(t *testing.T) {
   250  	ctrl := gomock.NewController(t)
   251  	defer ctrl.Finish()
   252  
   253  	provider := mocks.NewMockProvider(ctrl)
   254  
   255  	svc := mocks.NewMockProtocolService(ctrl)
   256  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   257  
   258  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   259  	client, err := New(provider)
   260  	require.NoError(t, err)
   261  
   262  	require.NoError(t, client.AcceptRequestPresentation("PIID", &Presentation{}, nil))
   263  }
   264  
   265  func TestClient_DeclineRequestPresentation(t *testing.T) {
   266  	ctrl := gomock.NewController(t)
   267  	defer ctrl.Finish()
   268  
   269  	provider := mocks.NewMockProvider(ctrl)
   270  
   271  	svc := mocks.NewMockProtocolService(ctrl)
   272  	svc.EXPECT().ActionStop("PIID", errors.New("declined"), gomock.Any()).Return(nil)
   273  
   274  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   275  	client, err := New(provider)
   276  	require.NoError(t, err)
   277  
   278  	require.NoError(t, client.DeclineRequestPresentation("PIID", "declined"))
   279  }
   280  
   281  func TestClient_AcceptProposePresentation(t *testing.T) {
   282  	ctrl := gomock.NewController(t)
   283  	defer ctrl.Finish()
   284  
   285  	provider := mocks.NewMockProvider(ctrl)
   286  
   287  	svc := mocks.NewMockProtocolService(ctrl)
   288  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   289  
   290  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   291  	client, err := New(provider)
   292  	require.NoError(t, err)
   293  
   294  	require.NoError(t, client.AcceptProposePresentation("PIID", &RequestPresentation{}))
   295  }
   296  
   297  func TestClient_AcceptProposePresentationV3(t *testing.T) {
   298  	ctrl := gomock.NewController(t)
   299  	defer ctrl.Finish()
   300  
   301  	provider := mocks.NewMockProvider(ctrl)
   302  
   303  	svc := mocks.NewMockProtocolService(ctrl)
   304  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   305  
   306  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   307  	client, err := New(provider)
   308  	require.NoError(t, err)
   309  
   310  	require.NoError(t, client.AcceptProposePresentation("PIID", &RequestPresentation{}))
   311  }
   312  
   313  func TestClient_DeclineProposePresentation(t *testing.T) {
   314  	ctrl := gomock.NewController(t)
   315  	defer ctrl.Finish()
   316  
   317  	provider := mocks.NewMockProvider(ctrl)
   318  
   319  	svc := mocks.NewMockProtocolService(ctrl)
   320  	svc.EXPECT().ActionStop("PIID", errors.New("declined"), gomock.Any()).Return(nil)
   321  
   322  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   323  	client, err := New(provider)
   324  	require.NoError(t, err)
   325  
   326  	require.NoError(t, client.DeclineProposePresentation("PIID", DeclineReason("declined")))
   327  }
   328  
   329  func TestClient_AcceptPresentation(t *testing.T) {
   330  	ctrl := gomock.NewController(t)
   331  	defer ctrl.Finish()
   332  
   333  	provider := mocks.NewMockProvider(ctrl)
   334  
   335  	svc := mocks.NewMockProtocolService(ctrl)
   336  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   337  
   338  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   339  	client, err := New(provider)
   340  	require.NoError(t, err)
   341  
   342  	require.NoError(t, client.AcceptPresentation("PIID"))
   343  }
   344  
   345  func TestClient_AcceptPresentationByRedirect(t *testing.T) {
   346  	ctrl := gomock.NewController(t)
   347  	defer ctrl.Finish()
   348  
   349  	provider := mocks.NewMockProvider(ctrl)
   350  
   351  	svc := mocks.NewMockProtocolService(ctrl)
   352  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   353  
   354  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   355  	client, err := New(provider)
   356  	require.NoError(t, err)
   357  
   358  	require.NoError(t, client.AcceptPresentation("PIID",
   359  		AcceptByRequestingRedirect("https://example.com/success"), AcceptByFriendlyNames("test1")))
   360  }
   361  
   362  func TestClient_DeclinePresentation(t *testing.T) {
   363  	ctrl := gomock.NewController(t)
   364  	defer ctrl.Finish()
   365  
   366  	provider := mocks.NewMockProvider(ctrl)
   367  
   368  	svc := mocks.NewMockProtocolService(ctrl)
   369  	svc.EXPECT().ActionStop("PIID", errors.New("declined"), gomock.Any()).Return(nil)
   370  
   371  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   372  	client, err := New(provider)
   373  	require.NoError(t, err)
   374  
   375  	require.NoError(t, client.DeclinePresentation("PIID", DeclineReason("declined"),
   376  		DeclineRedirect("http://example.com")))
   377  }
   378  
   379  func TestClient_AcceptProblemReport(t *testing.T) {
   380  	ctrl := gomock.NewController(t)
   381  	defer ctrl.Finish()
   382  
   383  	provider := mocks.NewMockProvider(ctrl)
   384  
   385  	svc := mocks.NewMockProtocolService(ctrl)
   386  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   387  
   388  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   389  	client, err := New(provider)
   390  	require.NoError(t, err)
   391  
   392  	require.NoError(t, client.AcceptProblemReport("PIID"))
   393  }
   394  
   395  func TestClient_NegotiateRequestPresentation(t *testing.T) {
   396  	ctrl := gomock.NewController(t)
   397  	defer ctrl.Finish()
   398  
   399  	provider := mocks.NewMockProvider(ctrl)
   400  
   401  	svc := mocks.NewMockProtocolService(ctrl)
   402  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   403  
   404  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   405  	client, err := New(provider)
   406  	require.NoError(t, err)
   407  
   408  	require.NoError(t, client.NegotiateRequestPresentation("PIID", &ProposePresentation{}))
   409  }