github.com/Ingenico-ePayments/connect-sdk-go@v0.0.0-20240318153750-1f8cd329b9c9/communicator/Communicator_MultipartFormData_test.go (about)

     1  package communicator
     2  
     3  import (
     4  	"io"
     5  	"net/url"
     6  	"os"
     7  	"strings"
     8  	"testing"
     9  
    10  	"github.com/Ingenico-ePayments/connect-sdk-go/communicator/communication"
    11  	"github.com/Ingenico-ePayments/connect-sdk-go/configuration"
    12  	"github.com/Ingenico-ePayments/connect-sdk-go/defaultimpl"
    13  )
    14  
    15  func TestMultipartFormDataUploadPostMultipartFormDataObjectWithResponse(t *testing.T) {
    16  	communicator, err := createCommunicator()
    17  	if err != nil {
    18  		t.Fatal(err)
    19  	}
    20  	defer communicator.Close()
    21  
    22  	expected := "file-content"
    23  
    24  	content := strings.NewReader(expected)
    25  
    26  	multipart, err := communication.NewMultipartFormDataObject()
    27  	if err != nil {
    28  		t.Fatal(err)
    29  	}
    30  
    31  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
    32  	multipart.AddFile("file", *file)
    33  	multipart.AddValue("value", "Hello World")
    34  
    35  	response := HTTPBinResponse{}
    36  	err = communicator.Post("/post", nil, nil, *multipart, nil, &response)
    37  	if err != nil {
    38  		t.Fatal(err)
    39  	}
    40  
    41  	if len(response.Files) != 1 {
    42  		t.Fatal("Expected 1 file")
    43  	}
    44  	if fileContent, ok := response.Files["file"]; ok {
    45  		if fileContent != expected {
    46  			t.Fatal("Wrong content in file: " + fileContent)
    47  		}
    48  	} else {
    49  		t.Fatal("Expected file with index 'file'")
    50  	}
    51  
    52  	if len(response.Form) != 1 {
    53  		t.Fatal("Expected 1 value")
    54  	}
    55  	if valueContent, ok := response.Form["value"]; ok {
    56  		if valueContent != "Hello World" {
    57  			t.Fatal("Wrong content in value: " + valueContent)
    58  		}
    59  	} else {
    60  		t.Fatal("Expected value with index 'value'")
    61  	}
    62  }
    63  
    64  func TestMultipartFormDataUploadPostMultipartFormDataObjectPointerWithResponse(t *testing.T) {
    65  	communicator, err := createCommunicator()
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  	defer communicator.Close()
    70  
    71  	expected := "file-content"
    72  
    73  	content := strings.NewReader(expected)
    74  
    75  	multipart, err := communication.NewMultipartFormDataObject()
    76  	if err != nil {
    77  		t.Fatal(err)
    78  	}
    79  
    80  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
    81  	multipart.AddFile("file", *file)
    82  	multipart.AddValue("value", "Hello World")
    83  
    84  	response := HTTPBinResponse{}
    85  	err = communicator.Post("/post", nil, nil, multipart, nil, &response)
    86  	if err != nil {
    87  		t.Fatal(err)
    88  	}
    89  
    90  	if len(response.Files) != 1 {
    91  		t.Fatal("Expected 1 file")
    92  	}
    93  	if fileContent, ok := response.Files["file"]; ok {
    94  		if fileContent != expected {
    95  			t.Fatal("Wrong content in file: " + fileContent)
    96  		}
    97  	} else {
    98  		t.Fatal("Expected file with index 'file'")
    99  	}
   100  
   101  	if len(response.Form) != 1 {
   102  		t.Fatal("Expected 1 value")
   103  	}
   104  	if valueContent, ok := response.Form["value"]; ok {
   105  		if valueContent != "Hello World" {
   106  			t.Fatal("Wrong content in value: " + valueContent)
   107  		}
   108  	} else {
   109  		t.Fatal("Expected value with index 'value'")
   110  	}
   111  }
   112  
   113  func TestMultipartFormDataUploadPostMultipartFormDataRequestWithResponse(t *testing.T) {
   114  	communicator, err := createCommunicator()
   115  	if err != nil {
   116  		t.Fatal(err)
   117  	}
   118  	defer communicator.Close()
   119  
   120  	expected := "file-content"
   121  
   122  	content := strings.NewReader(expected)
   123  
   124  	multipart, err := communication.NewMultipartFormDataObject()
   125  	if err != nil {
   126  		t.Fatal(err)
   127  	}
   128  
   129  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   130  	multipart.AddFile("file", *file)
   131  	multipart.AddValue("value", "Hello World")
   132  
   133  	response := HTTPBinResponse{}
   134  	err = communicator.Post("/post", nil, nil, &MultipartFormDataObjectWrapper{multipart}, nil, &response)
   135  	if err != nil {
   136  		t.Fatal(err)
   137  	}
   138  
   139  	if len(response.Files) != 1 {
   140  		t.Fatal("Expected 1 file")
   141  	}
   142  	if fileContent, ok := response.Files["file"]; ok {
   143  		if fileContent != expected {
   144  			t.Fatal("Wrong content in file: " + fileContent)
   145  		}
   146  	} else {
   147  		t.Fatal("Expected file with index 'file'")
   148  	}
   149  
   150  	if len(response.Form) != 1 {
   151  		t.Fatal("Expected 1 value")
   152  	}
   153  	if valueContent, ok := response.Form["value"]; ok {
   154  		if valueContent != "Hello World" {
   155  			t.Fatal("Wrong content in value: " + valueContent)
   156  		}
   157  	} else {
   158  		t.Fatal("Expected value with index 'value'")
   159  	}
   160  }
   161  
   162  func TestMultipartFormDataUploadPostMultipartFormDataObjectWithBodyHandler(t *testing.T) {
   163  	communicator, err := createCommunicator()
   164  	if err != nil {
   165  		t.Fatal(err)
   166  	}
   167  	defer communicator.Close()
   168  
   169  	expected := "file-content"
   170  
   171  	content := strings.NewReader(expected)
   172  
   173  	multipart, err := communication.NewMultipartFormDataObject()
   174  	if err != nil {
   175  		t.Fatal(err)
   176  	}
   177  
   178  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   179  	multipart.AddFile("file", *file)
   180  	multipart.AddValue("value", "Hello World")
   181  
   182  	err = communicator.PostWithHandler("/post", nil, nil, *multipart, nil, BodyHandlerFunc(func(headers []communication.Header, reader io.Reader) error {
   183  		response := HTTPBinResponse{}
   184  		marshaller, err := defaultimpl.NewDefaultMarshaller()
   185  		if err != nil {
   186  			t.Fatal(err)
   187  		}
   188  		err = marshaller.UnmarshalFromReader(reader, &response)
   189  		if err != nil {
   190  			t.Fatal(err)
   191  		}
   192  
   193  		if len(response.Files) != 1 {
   194  			t.Fatal("Expected 1 file")
   195  		}
   196  		if fileContent, ok := response.Files["file"]; ok {
   197  			if fileContent != expected {
   198  				t.Fatal("Wrong content in file: " + fileContent)
   199  			}
   200  		} else {
   201  			t.Fatal("Expected file with index 'file'")
   202  		}
   203  
   204  		if len(response.Form) != 1 {
   205  			t.Fatal("Expected 1 value")
   206  		}
   207  		if valueContent, ok := response.Form["value"]; ok {
   208  			if valueContent != "Hello World" {
   209  				t.Fatal("Wrong content in value: " + valueContent)
   210  			}
   211  		} else {
   212  			t.Fatal("Expected value with index 'value'")
   213  		}
   214  
   215  		return nil
   216  	}))
   217  	if err != nil {
   218  		t.Fatal(err)
   219  	}
   220  }
   221  
   222  func TestMultipartFormDataUploadPostMultipartFormDataObjectPointerWithBodyHandler(t *testing.T) {
   223  	communicator, err := createCommunicator()
   224  	if err != nil {
   225  		t.Fatal(err)
   226  	}
   227  	defer communicator.Close()
   228  
   229  	expected := "file-content"
   230  
   231  	content := strings.NewReader(expected)
   232  
   233  	multipart, err := communication.NewMultipartFormDataObject()
   234  	if err != nil {
   235  		t.Fatal(err)
   236  	}
   237  
   238  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   239  	multipart.AddFile("file", *file)
   240  	multipart.AddValue("value", "Hello World")
   241  
   242  	err = communicator.PostWithHandler("/post", nil, nil, multipart, nil, BodyHandlerFunc(func(headers []communication.Header, reader io.Reader) error {
   243  		response := HTTPBinResponse{}
   244  		marshaller, err := defaultimpl.NewDefaultMarshaller()
   245  		if err != nil {
   246  			t.Fatal(err)
   247  		}
   248  		err = marshaller.UnmarshalFromReader(reader, &response)
   249  		if err != nil {
   250  			t.Fatal(err)
   251  		}
   252  
   253  		if len(response.Files) != 1 {
   254  			t.Fatal("Expected 1 file")
   255  		}
   256  		if fileContent, ok := response.Files["file"]; ok {
   257  			if fileContent != expected {
   258  				t.Fatal("Wrong content in file: " + fileContent)
   259  			}
   260  		} else {
   261  			t.Fatal("Expected file with index 'file'")
   262  		}
   263  
   264  		if len(response.Form) != 1 {
   265  			t.Fatal("Expected 1 value")
   266  		}
   267  		if valueContent, ok := response.Form["value"]; ok {
   268  			if valueContent != "Hello World" {
   269  				t.Fatal("Wrong content in value: " + valueContent)
   270  			}
   271  		} else {
   272  			t.Fatal("Expected value with index 'value'")
   273  		}
   274  
   275  		return nil
   276  	}))
   277  	if err != nil {
   278  		t.Fatal(err)
   279  	}
   280  }
   281  
   282  func TestMultipartFormDataUploadPostMultipartFormDataRequestWithBodyHandler(t *testing.T) {
   283  	communicator, err := createCommunicator()
   284  	if err != nil {
   285  		t.Fatal(err)
   286  	}
   287  	defer communicator.Close()
   288  
   289  	expected := "file-content"
   290  
   291  	content := strings.NewReader(expected)
   292  
   293  	multipart, err := communication.NewMultipartFormDataObject()
   294  	if err != nil {
   295  		t.Fatal(err)
   296  	}
   297  
   298  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   299  	multipart.AddFile("file", *file)
   300  	multipart.AddValue("value", "Hello World")
   301  
   302  	err = communicator.PostWithHandler("/post", nil, nil, &MultipartFormDataObjectWrapper{multipart}, nil, BodyHandlerFunc(func(headers []communication.Header, reader io.Reader) error {
   303  		response := HTTPBinResponse{}
   304  		marshaller, err := defaultimpl.NewDefaultMarshaller()
   305  		if err != nil {
   306  			t.Fatal(err)
   307  		}
   308  		err = marshaller.UnmarshalFromReader(reader, &response)
   309  		if err != nil {
   310  			t.Fatal(err)
   311  		}
   312  
   313  		if len(response.Files) != 1 {
   314  			t.Fatal("Expected 1 file")
   315  		}
   316  		if fileContent, ok := response.Files["file"]; ok {
   317  			if fileContent != expected {
   318  				t.Fatal("Wrong content in file: " + fileContent)
   319  			}
   320  		} else {
   321  			t.Fatal("Expected file with index 'file'")
   322  		}
   323  
   324  		if len(response.Form) != 1 {
   325  			t.Fatal("Expected 1 value")
   326  		}
   327  		if valueContent, ok := response.Form["value"]; ok {
   328  			if valueContent != "Hello World" {
   329  				t.Fatal("Wrong content in value: " + valueContent)
   330  			}
   331  		} else {
   332  			t.Fatal("Expected value with index 'value'")
   333  		}
   334  
   335  		return nil
   336  	}))
   337  	if err != nil {
   338  		t.Fatal(err)
   339  	}
   340  }
   341  
   342  func TestMultipartFormDataUploadPutMultipartFormDataObjectWithResponse(t *testing.T) {
   343  	communicator, err := createCommunicator()
   344  	if err != nil {
   345  		t.Fatal(err)
   346  	}
   347  	defer communicator.Close()
   348  
   349  	expected := "file-content"
   350  
   351  	content := strings.NewReader(expected)
   352  
   353  	multipart, err := communication.NewMultipartFormDataObject()
   354  	if err != nil {
   355  		t.Fatal(err)
   356  	}
   357  
   358  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   359  	multipart.AddFile("file", *file)
   360  	multipart.AddValue("value", "Hello World")
   361  
   362  	response := HTTPBinResponse{}
   363  	err = communicator.Put("/put", nil, nil, *multipart, nil, &response)
   364  	if err != nil {
   365  		t.Fatal(err)
   366  	}
   367  
   368  	if len(response.Files) != 1 {
   369  		t.Fatal("Expected 1 file")
   370  	}
   371  	if fileContent, ok := response.Files["file"]; ok {
   372  		if fileContent != expected {
   373  			t.Fatal("Wrong content in file: " + fileContent)
   374  		}
   375  	} else {
   376  		t.Fatal("Expected file with index 'file'")
   377  	}
   378  
   379  	if len(response.Form) != 1 {
   380  		t.Fatal("Expected 1 value")
   381  	}
   382  	if valueContent, ok := response.Form["value"]; ok {
   383  		if valueContent != "Hello World" {
   384  			t.Fatal("Wrong content in value: " + valueContent)
   385  		}
   386  	} else {
   387  		t.Fatal("Expected value with index 'value'")
   388  	}
   389  }
   390  
   391  func TestMultipartFormDataUploadPutMultipartFormDataObjectPointerWithResponse(t *testing.T) {
   392  	communicator, err := createCommunicator()
   393  	if err != nil {
   394  		t.Fatal(err)
   395  	}
   396  	defer communicator.Close()
   397  
   398  	expected := "file-content"
   399  
   400  	content := strings.NewReader(expected)
   401  
   402  	multipart, err := communication.NewMultipartFormDataObject()
   403  	if err != nil {
   404  		t.Fatal(err)
   405  	}
   406  
   407  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   408  	multipart.AddFile("file", *file)
   409  	multipart.AddValue("value", "Hello World")
   410  
   411  	response := HTTPBinResponse{}
   412  	err = communicator.Put("/put", nil, nil, multipart, nil, &response)
   413  	if err != nil {
   414  		t.Fatal(err)
   415  	}
   416  
   417  	if len(response.Files) != 1 {
   418  		t.Fatal("Expected 1 file")
   419  	}
   420  	if fileContent, ok := response.Files["file"]; ok {
   421  		if fileContent != expected {
   422  			t.Fatal("Wrong content in file: " + fileContent)
   423  		}
   424  	} else {
   425  		t.Fatal("Expected file with index 'file'")
   426  	}
   427  
   428  	if len(response.Form) != 1 {
   429  		t.Fatal("Expected 1 value")
   430  	}
   431  	if valueContent, ok := response.Form["value"]; ok {
   432  		if valueContent != "Hello World" {
   433  			t.Fatal("Wrong content in value: " + valueContent)
   434  		}
   435  	} else {
   436  		t.Fatal("Expected value with index 'value'")
   437  	}
   438  }
   439  
   440  func TestMultipartFormDataUploadPutMultipartFormDataRequestWithResponse(t *testing.T) {
   441  	communicator, err := createCommunicator()
   442  	if err != nil {
   443  		t.Fatal(err)
   444  	}
   445  	defer communicator.Close()
   446  
   447  	expected := "file-content"
   448  
   449  	content := strings.NewReader(expected)
   450  
   451  	multipart, err := communication.NewMultipartFormDataObject()
   452  	if err != nil {
   453  		t.Fatal(err)
   454  	}
   455  
   456  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   457  	multipart.AddFile("file", *file)
   458  	multipart.AddValue("value", "Hello World")
   459  
   460  	response := HTTPBinResponse{}
   461  	err = communicator.Put("/put", nil, nil, &MultipartFormDataObjectWrapper{multipart}, nil, &response)
   462  	if err != nil {
   463  		t.Fatal(err)
   464  	}
   465  
   466  	if len(response.Files) != 1 {
   467  		t.Fatal("Expected 1 file")
   468  	}
   469  	if fileContent, ok := response.Files["file"]; ok {
   470  		if fileContent != expected {
   471  			t.Fatal("Wrong content in file: " + fileContent)
   472  		}
   473  	} else {
   474  		t.Fatal("Expected file with index 'file'")
   475  	}
   476  
   477  	if len(response.Form) != 1 {
   478  		t.Fatal("Expected 1 value")
   479  	}
   480  	if valueContent, ok := response.Form["value"]; ok {
   481  		if valueContent != "Hello World" {
   482  			t.Fatal("Wrong content in value: " + valueContent)
   483  		}
   484  	} else {
   485  		t.Fatal("Expected value with index 'value'")
   486  	}
   487  }
   488  
   489  func TestMultipartFormDataUploadPutMultipartFormDataObjectWithBodyHandler(t *testing.T) {
   490  	communicator, err := createCommunicator()
   491  	if err != nil {
   492  		t.Fatal(err)
   493  	}
   494  	defer communicator.Close()
   495  
   496  	expected := "file-content"
   497  
   498  	content := strings.NewReader(expected)
   499  
   500  	multipart, err := communication.NewMultipartFormDataObject()
   501  	if err != nil {
   502  		t.Fatal(err)
   503  	}
   504  
   505  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   506  	multipart.AddFile("file", *file)
   507  	multipart.AddValue("value", "Hello World")
   508  
   509  	err = communicator.PutWithHandler("/put", nil, nil, *multipart, nil, BodyHandlerFunc(func(headers []communication.Header, reader io.Reader) error {
   510  		response := HTTPBinResponse{}
   511  		marshaller, err := defaultimpl.NewDefaultMarshaller()
   512  		if err != nil {
   513  			t.Fatal(err)
   514  		}
   515  		err = marshaller.UnmarshalFromReader(reader, &response)
   516  		if err != nil {
   517  			t.Fatal(err)
   518  		}
   519  
   520  		if len(response.Files) != 1 {
   521  			t.Fatal("Expected 1 file")
   522  		}
   523  		if fileContent, ok := response.Files["file"]; ok {
   524  			if fileContent != expected {
   525  				t.Fatal("Wrong content in file: " + fileContent)
   526  			}
   527  		} else {
   528  			t.Fatal("Expected file with index 'file'")
   529  		}
   530  
   531  		if len(response.Form) != 1 {
   532  			t.Fatal("Expected 1 value")
   533  		}
   534  		if valueContent, ok := response.Form["value"]; ok {
   535  			if valueContent != "Hello World" {
   536  				t.Fatal("Wrong content in value: " + valueContent)
   537  			}
   538  		} else {
   539  			t.Fatal("Expected value with index 'value'")
   540  		}
   541  
   542  		return nil
   543  	}))
   544  	if err != nil {
   545  		t.Fatal(err)
   546  	}
   547  }
   548  
   549  func TestMultipartFormDataUploadPutMultipartFormDataObjectPointerWithBodyHandler(t *testing.T) {
   550  	communicator, err := createCommunicator()
   551  	if err != nil {
   552  		t.Fatal(err)
   553  	}
   554  	defer communicator.Close()
   555  
   556  	expected := "file-content"
   557  
   558  	content := strings.NewReader(expected)
   559  
   560  	multipart, err := communication.NewMultipartFormDataObject()
   561  	if err != nil {
   562  		t.Fatal(err)
   563  	}
   564  
   565  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   566  	multipart.AddFile("file", *file)
   567  	multipart.AddValue("value", "Hello World")
   568  
   569  	err = communicator.PutWithHandler("/put", nil, nil, multipart, nil, BodyHandlerFunc(func(headers []communication.Header, reader io.Reader) error {
   570  		response := HTTPBinResponse{}
   571  		marshaller, err := defaultimpl.NewDefaultMarshaller()
   572  		if err != nil {
   573  			t.Fatal(err)
   574  		}
   575  		err = marshaller.UnmarshalFromReader(reader, &response)
   576  		if err != nil {
   577  			t.Fatal(err)
   578  		}
   579  
   580  		if len(response.Files) != 1 {
   581  			t.Fatal("Expected 1 file")
   582  		}
   583  		if fileContent, ok := response.Files["file"]; ok {
   584  			if fileContent != expected {
   585  				t.Fatal("Wrong content in file: " + fileContent)
   586  			}
   587  		} else {
   588  			t.Fatal("Expected file with index 'file'")
   589  		}
   590  
   591  		if len(response.Form) != 1 {
   592  			t.Fatal("Expected 1 value")
   593  		}
   594  		if valueContent, ok := response.Form["value"]; ok {
   595  			if valueContent != "Hello World" {
   596  				t.Fatal("Wrong content in value: " + valueContent)
   597  			}
   598  		} else {
   599  			t.Fatal("Expected value with index 'value'")
   600  		}
   601  
   602  		return nil
   603  	}))
   604  	if err != nil {
   605  		t.Fatal(err)
   606  	}
   607  }
   608  
   609  func TestMultipartFormDataUploadPutMultipartFormDataRequestWithBodyHandler(t *testing.T) {
   610  	communicator, err := createCommunicator()
   611  	if err != nil {
   612  		t.Fatal(err)
   613  	}
   614  	defer communicator.Close()
   615  
   616  	expected := "file-content"
   617  
   618  	content := strings.NewReader(expected)
   619  
   620  	multipart, err := communication.NewMultipartFormDataObject()
   621  	if err != nil {
   622  		t.Fatal(err)
   623  	}
   624  
   625  	file, _ := communication.NewUploadableFile("file.txt", content, "text/plain")
   626  	multipart.AddFile("file", *file)
   627  	multipart.AddValue("value", "Hello World")
   628  
   629  	err = communicator.PutWithHandler("/put", nil, nil, &MultipartFormDataObjectWrapper{multipart}, nil, BodyHandlerFunc(func(headers []communication.Header, reader io.Reader) error {
   630  		response := HTTPBinResponse{}
   631  		marshaller, err := defaultimpl.NewDefaultMarshaller()
   632  		if err != nil {
   633  			t.Fatal(err)
   634  		}
   635  		err = marshaller.UnmarshalFromReader(reader, &response)
   636  		if err != nil {
   637  			t.Fatal(err)
   638  		}
   639  
   640  		if len(response.Files) != 1 {
   641  			t.Fatal("Expected 1 file")
   642  		}
   643  		if fileContent, ok := response.Files["file"]; ok {
   644  			if fileContent != expected {
   645  				t.Fatal("Wrong content in file: " + fileContent)
   646  			}
   647  		} else {
   648  			t.Fatal("Expected file with index 'file'")
   649  		}
   650  
   651  		if len(response.Form) != 1 {
   652  			t.Fatal("Expected 1 value")
   653  		}
   654  		if valueContent, ok := response.Form["value"]; ok {
   655  			if valueContent != "Hello World" {
   656  				t.Fatal("Wrong content in value: " + valueContent)
   657  			}
   658  		} else {
   659  			t.Fatal("Expected value with index 'value'")
   660  		}
   661  
   662  		return nil
   663  	}))
   664  	if err != nil {
   665  		t.Fatal(err)
   666  	}
   667  }
   668  
   669  func createCommunicator() (*Communicator, error) {
   670  	httpBinURL := os.Getenv(("httpbin.url"))
   671  	if httpBinURL == "" {
   672  		httpBinURL = "http://httpbin.org"
   673  	}
   674  	apiEndpoint, err := url.Parse(httpBinURL)
   675  	if err != nil {
   676  		return nil, err
   677  	}
   678  
   679  	configuration := configuration.DefaultConfiguration("dummy", "dummy", "ingenico")
   680  	configuration.APIEndpoint = *apiEndpoint
   681  
   682  	builder, err := NewSessionBuilder()
   683  	if err != nil {
   684  		return nil, err
   685  	}
   686  
   687  	connection, err := defaultimpl.NewDefaultConnection(configuration.SocketTimeout,
   688  		configuration.ConnectTimeout,
   689  		configuration.KeepAliveTimeout,
   690  		configuration.IdleTimeout,
   691  		configuration.MaxConnections,
   692  		configuration.Proxy)
   693  	if err != nil {
   694  		return nil, err
   695  	}
   696  
   697  	metaDataProviderBuilder := NewMetaDataProviderBuilder(configuration.Integrator)
   698  	metaDataProviderBuilder.ShoppingCartExtension = configuration.ShoppingCartExtension
   699  
   700  	metaDataProvider, err := metaDataProviderBuilder.Build()
   701  	if err != nil {
   702  		return nil, err
   703  	}
   704  
   705  	authenticator, err := defaultimpl.NewDefaultAuthenticator(configuration.AuthorizationType,
   706  		configuration.APIKeyID,
   707  		configuration.SecretAPIKey)
   708  	if err != nil {
   709  		return nil, err
   710  	}
   711  
   712  	builder.WithAPIEndpoint(&configuration.APIEndpoint).WithConnection(connection).WithMetaDataProvider(metaDataProvider).WithAuthenticator(authenticator)
   713  
   714  	session, err := builder.Build()
   715  	if err != nil {
   716  		return nil, err
   717  	}
   718  
   719  	marshaller, err := defaultimpl.NewDefaultMarshaller()
   720  	if err != nil {
   721  		return nil, err
   722  	}
   723  
   724  	return NewCommunicator(session, marshaller)
   725  }
   726  
   727  type HTTPBinResponse struct {
   728  	Form  map[string]string `json:"form"`
   729  	Files map[string]string `json:"files"`
   730  }
   731  
   732  type MultipartFormDataObjectWrapper struct {
   733  	Multipart *communication.MultipartFormDataObject
   734  }
   735  
   736  func (w *MultipartFormDataObjectWrapper) ToMultipartFormDataObject() *communication.MultipartFormDataObject {
   737  	return w.Multipart
   738  }