github.com/Ingenico-ePayments/connect-sdk-go@v0.0.0-20240318153750-1f8cd329b9c9/logging/obfuscation/BodyObfuscator_test.go (about)

     1  package obfuscation
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  	"unicode/utf8"
     7  )
     8  
     9  func TestObfuscateBodyWithEmptyBody(t *testing.T) {
    10  	emptyString := ""
    11  	obfuscatedBody, err := DefaultBodyObfuscator().ObfuscateBody(emptyString)
    12  
    13  	if err != nil {
    14  		t.Fatal(err)
    15  	}
    16  
    17  	if obfuscatedBody != emptyString {
    18  		t.Fatalf("TestObfuscateBodyWithEmptyBody : expected '%s' got '%s'", emptyString, obfuscatedBody)
    19  	}
    20  }
    21  
    22  func TestObfuscateBodyWithCard(t *testing.T) {
    23  	cardObfuscated := `{
    24      "cardPaymentMethodSpecificInput": {
    25          "card": {
    26              "cardNumber": "************3456",
    27              "cvv": "***",
    28              "expiryDate": "**20"
    29          },
    30          "paymentProductId": 1
    31      },
    32      "order": {
    33          "amountOfMoney": {
    34              "amount": 2345,
    35              "currencyCode": "CAD"
    36          },
    37          "customer": {
    38              "billingAddress": {
    39                  "countryCode": "CA"
    40              }
    41          }
    42      }
    43  }`
    44  
    45  	cardUnObfuscated := `{
    46  	    "order": {
    47  	        "amountOfMoney": {
    48  	            "currencyCode": "CAD",
    49  	            "amount": 2345
    50  	        },
    51  	        "customer": {
    52  	            "billingAddress": {
    53  	                "countryCode": "CA"
    54  	            }
    55  	        }
    56  	    },
    57  	    "cardPaymentMethodSpecificInput": {
    58  	        "paymentProductId": 1,
    59  	        "card": {
    60  	            "cvv": "123",
    61  	            "cardNumber": "1234567890123456",
    62  	            "expiryDate": "1220"
    63  	        }
    64  	    }
    65  	}`
    66  
    67  	obfuscatedBody, err := DefaultBodyObfuscator().ObfuscateBody(cardUnObfuscated)
    68  
    69  	if err != nil {
    70  		t.Fatal(err)
    71  	}
    72  
    73  	if cardObfuscated != obfuscatedBody {
    74  		t.Fatalf("TestObfuscateBodyWithCard : expected \n%s\ngot\n%s", cardObfuscated, obfuscatedBody)
    75  	}
    76  }
    77  
    78  func TestObfuscateBodyWithCustomCardRule(t *testing.T) {
    79  	cardObfuscated := `{
    80      "cardPaymentMethodSpecificInput": {
    81          "card": {
    82              "cardNumber": "123456******3456",
    83              "cvv": "***",
    84              "expiryDate": "**20"
    85          },
    86          "paymentProductId": 1
    87      },
    88      "order": {
    89          "amountOfMoney": {
    90              "amount": 2345,
    91              "currencyCode": "CAD"
    92          },
    93          "customer": {
    94              "billingAddress": {
    95                  "countryCode": "CA"
    96              }
    97          }
    98      }
    99  }`
   100  
   101  	cardUnObfuscated := `{
   102  	    "order": {
   103  	        "amountOfMoney": {
   104  	            "currencyCode": "CAD",
   105  	            "amount": 2345
   106  	        },
   107  	        "customer": {
   108  	            "billingAddress": {
   109  	                "countryCode": "CA"
   110  	            }
   111  	        }
   112  	    },
   113  	    "cardPaymentMethodSpecificInput": {
   114  	        "paymentProductId": 1,
   115  	        "card": {
   116  	            "cvv": "123",
   117  	            "cardNumber": "1234567890123456",
   118  	            "expiryDate": "1220"
   119  	        }
   120  	    }
   121  	}`
   122  
   123  	rule := func(value string) string {
   124  		valueLength := utf8.RuneCountInString(value)
   125  		var chars bytes.Buffer
   126  		i := 0
   127  		for _, r := range value {
   128  			if i < 6 || i >= valueLength - 4 {
   129  				chars.WriteRune(r)
   130  			} else {
   131  				chars.WriteRune('*')
   132  			}
   133  			i++
   134  		}
   135  		return chars.String()
   136  	}
   137  	bodyObfuscator := NewBodyObfuscator(ruleMap{
   138  		"cardNumber": rule,
   139  	})
   140  	obfuscatedBody, err := bodyObfuscator.ObfuscateBody(cardUnObfuscated)
   141  
   142  	if err != nil {
   143  		t.Fatal(err)
   144  	}
   145  
   146  	if cardObfuscated != obfuscatedBody {
   147  		t.Fatalf("TestObfuscateBodyWithCustomCardRule : expected \n%s\ngot\n%s", cardObfuscated, obfuscatedBody)
   148  	}
   149  }
   150  
   151  func TestObfuscateBodyWithIban(t *testing.T) {
   152  	ibanObfuscated := `{
   153      "paymentProductId": 770,
   154      "sepaDirectDebit": {
   155          "customer": {
   156              "billingAddress": {
   157                  "countryCode": "NL"
   158              }
   159          },
   160          "mandate": {
   161              "bankAccountIban": {
   162                  "iban": "**************4567"
   163              },
   164              "debtor": {
   165                  "surname": "Jones"
   166              },
   167              "isRecurring": false
   168          }
   169      }
   170  }`
   171  	ibanUnobfuscated := `{
   172      "sepaDirectDebit": {
   173          "mandate": {
   174              "bankAccountIban": {
   175                  "iban": "NL00INGB0001234567"
   176              },
   177              "debtor": {
   178                  "surname": "Jones"
   179              },
   180              "isRecurring": false
   181          },
   182          "customer": {
   183              "billingAddress": {
   184                  "countryCode": "NL"
   185              }
   186          }
   187      },
   188      "paymentProductId": 770
   189  }`
   190  	obfuscatedBody, err := DefaultBodyObfuscator().ObfuscateBody(ibanUnobfuscated)
   191  
   192  	if err != nil {
   193  		t.Fatal(err)
   194  	}
   195  
   196  	if ibanObfuscated != obfuscatedBody {
   197  		t.Fatalf("TestObfuscateBodyWithIban : expected \n%s\ngot\n%s", ibanObfuscated, obfuscatedBody)
   198  	}
   199  }
   200  
   201  func TestObfuscateBodyWithBin(t *testing.T) {
   202  	binObfuscated := `{
   203      "bin": "123456**"
   204  }`
   205  	binUnobfuscated := `{
   206      "bin": "12345678"
   207  }`
   208  
   209  	obfuscatedBody, err := DefaultBodyObfuscator().ObfuscateBody(binUnobfuscated)
   210  
   211  	if err != nil {
   212  		t.Fatal(err)
   213  	}
   214  
   215  	if binObfuscated != obfuscatedBody {
   216  		t.Fatalf("TestObfuscateBodyWithBin : expected \n%s\ngot\n%s", binObfuscated, obfuscatedBody)
   217  	}
   218  }
   219  
   220  func TestObfuscateBodyWithNoMatches(t *testing.T) {
   221  	noObfuscation := `{
   222      "order": {
   223          "amountOfMoney": {
   224              "currencyCode": "EUR",
   225              "amount": 1000
   226          },
   227          "customer": {
   228              "locale": "nl_NL",
   229              "billingAddress": {
   230                  "countryCode": "NL"
   231              }
   232          }
   233      },
   234      "bankTransferPaymentMethodSpecificInput": {
   235          "paymentProductId": 11
   236      }
   237  }`
   238  	postObfuscation := `{
   239      "bankTransferPaymentMethodSpecificInput": {
   240          "paymentProductId": 11
   241      },
   242      "order": {
   243          "amountOfMoney": {
   244              "amount": 1000,
   245              "currencyCode": "EUR"
   246          },
   247          "customer": {
   248              "billingAddress": {
   249                  "countryCode": "NL"
   250              },
   251              "locale": "nl_NL"
   252          }
   253      }
   254  }`
   255  
   256  	obfuscatedBody, err := DefaultBodyObfuscator().ObfuscateBody(noObfuscation)
   257  
   258  	if err != nil {
   259  		t.Fatal(err)
   260  	}
   261  
   262  	if postObfuscation != obfuscatedBody {
   263  		t.Fatalf("TestObfuscateBodyWithNoMatches : expected \n%s\ngot\n%s", postObfuscation, obfuscatedBody)
   264  	}
   265  }
   266  
   267  func TestObfuscateBodyWithObject(t *testing.T) {
   268  	jsonObfuscated := `[
   269      {
   270          "value": "****"
   271      },
   272      {
   273          "value": {}
   274      }
   275  ]`
   276  	jsonUnobfuscated := `[ {
   277  	"value": true
   278  }, {
   279  	"value": {
   280  	}
   281  } ]`
   282  
   283  	obfuscatedBody, err := DefaultBodyObfuscator().ObfuscateBody(jsonUnobfuscated)
   284  
   285  	if err != nil {
   286  		t.Fatal(err)
   287  	}
   288  
   289  	if jsonObfuscated != obfuscatedBody {
   290  		t.Fatalf("TestObfuscateBodyWithObject : expected \n%s\ngot\n%s", jsonObfuscated, obfuscatedBody)
   291  	}
   292  }