github.com/hyperledger/aries-framework-go@v0.3.2/pkg/client/issuecredential/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 issuecredential
     8  
     9  import (
    10  	"errors"
    11  	"testing"
    12  
    13  	"github.com/golang/mock/gomock"
    14  	"github.com/stretchr/testify/require"
    15  
    16  	"github.com/hyperledger/aries-framework-go/pkg/didcomm/common/service"
    17  	"github.com/hyperledger/aries-framework-go/pkg/didcomm/protocol/issuecredential"
    18  	mocks "github.com/hyperledger/aries-framework-go/pkg/internal/gomocks/client/issuecredential"
    19  	"github.com/hyperledger/aries-framework-go/pkg/store/connection"
    20  )
    21  
    22  const (
    23  	Alice = "Alice"
    24  	Bob   = "Bob"
    25  
    26  	expectedPiid = "piid"
    27  )
    28  
    29  func TestNew(t *testing.T) {
    30  	const errMsg = "test err"
    31  
    32  	ctrl := gomock.NewController(t)
    33  	defer ctrl.Finish()
    34  
    35  	t.Run("get service error", func(t *testing.T) {
    36  		provider := mocks.NewMockProvider(ctrl)
    37  		provider.EXPECT().Service(gomock.Any()).Return(nil, errors.New(errMsg))
    38  		_, err := New(provider)
    39  		require.EqualError(t, err, errMsg)
    40  	})
    41  
    42  	t.Run("cast service error", func(t *testing.T) {
    43  		provider := mocks.NewMockProvider(ctrl)
    44  		provider.EXPECT().Service(gomock.Any()).Return(nil, nil)
    45  		_, err := New(provider)
    46  		require.EqualError(t, err, "cast service to issuecredential service failed")
    47  	})
    48  }
    49  
    50  func TestClient_SendOffer(t *testing.T) {
    51  	ctrl := gomock.NewController(t)
    52  	defer ctrl.Finish()
    53  
    54  	t.Run("Success", func(t *testing.T) {
    55  		provider := mocks.NewMockProvider(ctrl)
    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(), issuecredential.OfferCredentialMsgTypeV2)
    61  
    62  				return expectedPiid, nil
    63  			})
    64  
    65  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
    66  		client, err := New(provider)
    67  		require.NoError(t, err)
    68  
    69  		piid, err := client.SendOffer(&OfferCredential{}, &connection.Record{
    70  			MyDID:    Alice,
    71  			TheirDID: Bob,
    72  		})
    73  		require.Equal(t, expectedPiid, piid)
    74  		require.NoError(t, err)
    75  	})
    76  
    77  	t.Run("Success v3", func(t *testing.T) {
    78  		provider := mocks.NewMockProvider(ctrl)
    79  
    80  		svc := mocks.NewMockProtocolService(ctrl)
    81  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
    82  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
    83  				require.Equal(t, msg.Type(), issuecredential.OfferCredentialMsgTypeV3)
    84  
    85  				return expectedPiid, nil
    86  			})
    87  
    88  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
    89  		client, err := New(provider)
    90  		require.NoError(t, err)
    91  
    92  		piid, err := client.SendOffer(&OfferCredential{}, &connection.Record{
    93  			MyDID:          Alice,
    94  			TheirDID:       Bob,
    95  			DIDCommVersion: service.V2,
    96  		})
    97  		require.Equal(t, expectedPiid, piid)
    98  		require.NoError(t, err)
    99  	})
   100  
   101  	t.Run("Empty offer", func(t *testing.T) {
   102  		provider := mocks.NewMockProvider(ctrl)
   103  
   104  		provider.EXPECT().Service(gomock.Any()).Return(mocks.NewMockProtocolService(ctrl), nil)
   105  		client, err := New(provider)
   106  		require.NoError(t, err)
   107  
   108  		piid, err := client.SendOffer(nil, &connection.Record{
   109  			MyDID:    Alice,
   110  			TheirDID: Bob,
   111  		})
   112  		require.Empty(t, piid)
   113  		require.EqualError(t, err, errEmptyOffer.Error())
   114  	})
   115  }
   116  
   117  func TestClient_SendProposal(t *testing.T) {
   118  	ctrl := gomock.NewController(t)
   119  	defer ctrl.Finish()
   120  
   121  	t.Run("Success", func(t *testing.T) {
   122  		provider := mocks.NewMockProvider(ctrl)
   123  
   124  		svc := mocks.NewMockProtocolService(ctrl)
   125  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
   126  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
   127  				require.Equal(t, msg.Type(), issuecredential.ProposeCredentialMsgTypeV2)
   128  
   129  				return expectedPiid, nil
   130  			})
   131  
   132  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   133  		client, err := New(provider)
   134  		require.NoError(t, err)
   135  
   136  		piid, err := client.SendProposal(&ProposeCredential{}, &connection.Record{
   137  			MyDID:    Alice,
   138  			TheirDID: Bob,
   139  		})
   140  		require.Equal(t, expectedPiid, piid)
   141  		require.NoError(t, err)
   142  	})
   143  
   144  	t.Run("Success v3", func(t *testing.T) {
   145  		provider := mocks.NewMockProvider(ctrl)
   146  
   147  		svc := mocks.NewMockProtocolService(ctrl)
   148  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
   149  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
   150  				require.Equal(t, msg.Type(), issuecredential.ProposeCredentialMsgTypeV3)
   151  
   152  				return expectedPiid, nil
   153  			})
   154  
   155  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   156  		client, err := New(provider)
   157  		require.NoError(t, err)
   158  
   159  		piid, err := client.SendProposal(&ProposeCredential{}, &connection.Record{
   160  			MyDID:          Alice,
   161  			TheirDID:       Bob,
   162  			DIDCommVersion: service.V2,
   163  		})
   164  		require.Equal(t, expectedPiid, piid)
   165  		require.NoError(t, err)
   166  	})
   167  
   168  	t.Run("Empty offer", func(t *testing.T) {
   169  		provider := mocks.NewMockProvider(ctrl)
   170  		provider.EXPECT().Service(gomock.Any()).Return(mocks.NewMockProtocolService(ctrl), nil)
   171  
   172  		client, err := New(provider)
   173  		require.NoError(t, err)
   174  
   175  		piid, err := client.SendProposal(nil, &connection.Record{
   176  			MyDID:    Alice,
   177  			TheirDID: Bob,
   178  		})
   179  		require.Empty(t, piid)
   180  		require.EqualError(t, err, errEmptyProposal.Error())
   181  	})
   182  }
   183  
   184  func TestClient_SendRequest(t *testing.T) {
   185  	ctrl := gomock.NewController(t)
   186  	defer ctrl.Finish()
   187  
   188  	t.Run("Success", func(t *testing.T) {
   189  		provider := mocks.NewMockProvider(ctrl)
   190  
   191  		svc := mocks.NewMockProtocolService(ctrl)
   192  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
   193  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
   194  				require.Equal(t, msg.Type(), issuecredential.RequestCredentialMsgTypeV2)
   195  
   196  				return expectedPiid, nil
   197  			})
   198  
   199  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   200  		client, err := New(provider)
   201  		require.NoError(t, err)
   202  
   203  		piid, err := client.SendRequest(&RequestCredential{}, &connection.Record{
   204  			MyDID:    Alice,
   205  			TheirDID: Bob,
   206  		})
   207  		require.Equal(t, expectedPiid, piid)
   208  		require.NoError(t, err)
   209  	})
   210  
   211  	t.Run("Success v3", func(t *testing.T) {
   212  		provider := mocks.NewMockProvider(ctrl)
   213  
   214  		svc := mocks.NewMockProtocolService(ctrl)
   215  		svc.EXPECT().HandleOutbound(gomock.Any(), Alice, Bob).
   216  			DoAndReturn(func(msg service.DIDCommMsg, _, _ string) (string, error) {
   217  				require.Equal(t, msg.Type(), issuecredential.RequestCredentialMsgTypeV3)
   218  
   219  				return expectedPiid, nil
   220  			})
   221  
   222  		provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   223  		client, err := New(provider)
   224  		require.NoError(t, err)
   225  
   226  		piid, err := client.SendRequest(&RequestCredential{}, &connection.Record{
   227  			MyDID:          Alice,
   228  			TheirDID:       Bob,
   229  			DIDCommVersion: service.V2,
   230  		})
   231  		require.Equal(t, expectedPiid, piid)
   232  		require.NoError(t, err)
   233  	})
   234  
   235  	t.Run("Empty offer", func(t *testing.T) {
   236  		provider := mocks.NewMockProvider(ctrl)
   237  		provider.EXPECT().Service(gomock.Any()).Return(mocks.NewMockProtocolService(ctrl), nil)
   238  
   239  		client, err := New(provider)
   240  		require.NoError(t, err)
   241  
   242  		piid, err := client.SendRequest(nil, &connection.Record{
   243  			MyDID:    Alice,
   244  			TheirDID: Bob,
   245  		})
   246  		require.Empty(t, piid)
   247  		require.EqualError(t, err, errEmptyRequest.Error())
   248  	})
   249  }
   250  
   251  func TestClient_AcceptProposal(t *testing.T) {
   252  	ctrl := gomock.NewController(t)
   253  	defer ctrl.Finish()
   254  
   255  	provider := mocks.NewMockProvider(ctrl)
   256  
   257  	svc := mocks.NewMockProtocolService(ctrl)
   258  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   259  
   260  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   261  	client, err := New(provider)
   262  	require.NoError(t, err)
   263  
   264  	require.NoError(t, client.AcceptProposal("PIID", &OfferCredential{}))
   265  }
   266  
   267  func TestClient_DeclineProposal(t *testing.T) {
   268  	ctrl := gomock.NewController(t)
   269  	defer ctrl.Finish()
   270  
   271  	provider := mocks.NewMockProvider(ctrl)
   272  
   273  	svc := mocks.NewMockProtocolService(ctrl)
   274  	svc.EXPECT().ActionStop("PIID", errors.New("the reason"), gomock.Any()).Return(nil)
   275  
   276  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   277  	client, err := New(provider)
   278  	require.NoError(t, err)
   279  
   280  	require.NoError(t, client.DeclineProposal("PIID", "the reason"))
   281  }
   282  
   283  func TestClient_DeclineProposalRedirect(t *testing.T) {
   284  	ctrl := gomock.NewController(t)
   285  	defer ctrl.Finish()
   286  
   287  	provider := mocks.NewMockProvider(ctrl)
   288  
   289  	svc := mocks.NewMockProtocolService(ctrl)
   290  	svc.EXPECT().ActionStop("PIID", errors.New("the reason"), gomock.Any()).Return(nil)
   291  
   292  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   293  	client, err := New(provider)
   294  	require.NoError(t, err)
   295  
   296  	require.NoError(t, client.DeclineProposal("PIID", "the reason"), RequestRedirect("https://example.com"))
   297  }
   298  
   299  func TestClient_AcceptOffer(t *testing.T) {
   300  	ctrl := gomock.NewController(t)
   301  	defer ctrl.Finish()
   302  
   303  	provider := mocks.NewMockProvider(ctrl)
   304  
   305  	svc := mocks.NewMockProtocolService(ctrl)
   306  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   307  
   308  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   309  	client, err := New(provider)
   310  	require.NoError(t, err)
   311  
   312  	require.NoError(t, client.AcceptOffer("PIID", &RequestCredential{}))
   313  }
   314  
   315  func TestClient_DeclineOffer(t *testing.T) {
   316  	ctrl := gomock.NewController(t)
   317  	defer ctrl.Finish()
   318  
   319  	provider := mocks.NewMockProvider(ctrl)
   320  
   321  	svc := mocks.NewMockProtocolService(ctrl)
   322  	svc.EXPECT().ActionStop("PIID", errors.New("the reason")).Return(nil)
   323  
   324  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   325  	client, err := New(provider)
   326  	require.NoError(t, err)
   327  
   328  	require.NoError(t, client.DeclineOffer("PIID", "the reason"))
   329  }
   330  
   331  func TestClient_AcceptRequest(t *testing.T) {
   332  	ctrl := gomock.NewController(t)
   333  	defer ctrl.Finish()
   334  
   335  	provider := mocks.NewMockProvider(ctrl)
   336  
   337  	svc := mocks.NewMockProtocolService(ctrl)
   338  	svc.EXPECT().ActionContinue("PIID", gomock.Any()).Return(nil)
   339  
   340  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   341  	client, err := New(provider)
   342  	require.NoError(t, err)
   343  
   344  	require.NoError(t, client.AcceptRequest("PIID", &IssueCredential{}))
   345  }
   346  
   347  func TestClient_DeclineRequest(t *testing.T) {
   348  	ctrl := gomock.NewController(t)
   349  	defer ctrl.Finish()
   350  
   351  	provider := mocks.NewMockProvider(ctrl)
   352  
   353  	svc := mocks.NewMockProtocolService(ctrl)
   354  	svc.EXPECT().ActionStop("PIID", errors.New("the reason"), gomock.Any()).Return(nil)
   355  
   356  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   357  	client, err := New(provider)
   358  	require.NoError(t, err)
   359  
   360  	require.NoError(t, client.DeclineRequest("PIID", "the reason"))
   361  }
   362  
   363  func TestClient_DeclineRequestRedirect(t *testing.T) {
   364  	ctrl := gomock.NewController(t)
   365  	defer ctrl.Finish()
   366  
   367  	provider := mocks.NewMockProvider(ctrl)
   368  
   369  	svc := mocks.NewMockProtocolService(ctrl)
   370  	svc.EXPECT().ActionStop("PIID", errors.New("the reason"), gomock.Any()).Return(nil)
   371  
   372  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   373  	client, err := New(provider)
   374  	require.NoError(t, err)
   375  
   376  	require.NoError(t, client.DeclineRequest("PIID", "the reason", RequestRedirect("http://exmaple.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_NegotiateProposal(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.NegotiateProposal("PIID", &ProposeCredential{}))
   409  }
   410  
   411  func TestClient_AcceptCredential(t *testing.T) {
   412  	ctrl := gomock.NewController(t)
   413  	defer ctrl.Finish()
   414  
   415  	provider := mocks.NewMockProvider(ctrl)
   416  
   417  	svc := mocks.NewMockProtocolService(ctrl)
   418  	svc.EXPECT().ActionContinue("PIID1", gomock.Any()).Return(nil)
   419  	svc.EXPECT().ActionContinue("PIID2", gomock.Any()).Return(nil)
   420  
   421  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   422  	client, err := New(provider)
   423  	require.NoError(t, err)
   424  
   425  	require.NoError(t, client.AcceptCredential("PIID1"))
   426  	require.NoError(t, client.AcceptCredential("PIID2", AcceptByFriendlyNames("test"), AcceptBySkippingStorage()))
   427  }
   428  
   429  func TestClient_DeclineCredential(t *testing.T) {
   430  	ctrl := gomock.NewController(t)
   431  	defer ctrl.Finish()
   432  
   433  	provider := mocks.NewMockProvider(ctrl)
   434  
   435  	svc := mocks.NewMockProtocolService(ctrl)
   436  	svc.EXPECT().ActionStop("PIID", errors.New("the reason")).Return(nil)
   437  
   438  	provider.EXPECT().Service(gomock.Any()).Return(svc, nil)
   439  	client, err := New(provider)
   440  	require.NoError(t, err)
   441  
   442  	require.NoError(t, client.DeclineCredential("PIID", "the reason"))
   443  }