github.com/hellofresh/janus@v0.0.0-20230925145208-ce8de8183c67/pkg/plugin/requesttransformer/middleware_test.go (about)

     1  package requesttransformer
     2  
     3  import (
     4  	"net/http"
     5  	"net/http/httptest"
     6  	"testing"
     7  
     8  	"github.com/hellofresh/janus/pkg/test"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestAddHeader(t *testing.T) {
    13  	config := Config{
    14  		Add: Options{
    15  			Headers: map[string]string{
    16  				"Test": "Test",
    17  			},
    18  		},
    19  	}
    20  	req, err := http.NewRequest(http.MethodGet, "/", nil)
    21  	assert.NoError(t, err)
    22  
    23  	w := httptest.NewRecorder()
    24  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
    25  	assert.Equal(t, "Test", req.Header.Get("Test"))
    26  }
    27  
    28  func TestAddHeaderThatAlreadyExists(t *testing.T) {
    29  	config := Config{
    30  		Add: Options{
    31  			Headers: map[string]string{
    32  				"Test": "New value",
    33  			},
    34  		},
    35  	}
    36  	req, err := http.NewRequest(http.MethodGet, "/", nil)
    37  	req.Header.Add("Test", "Original value")
    38  	assert.NoError(t, err)
    39  
    40  	w := httptest.NewRecorder()
    41  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
    42  	assert.Equal(t, "Original value", req.Header.Get("Test"))
    43  }
    44  
    45  func TestAppendHeader(t *testing.T) {
    46  	config := Config{
    47  		Append: Options{
    48  			Headers: map[string]string{
    49  				"Test": "New value",
    50  			},
    51  		},
    52  	}
    53  	req, err := http.NewRequest(http.MethodGet, "/", nil)
    54  	req.Header.Add("Test2", "Original value")
    55  	assert.NoError(t, err)
    56  
    57  	w := httptest.NewRecorder()
    58  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
    59  	assert.Equal(t, "New value", req.Header.Get("Test"))
    60  	assert.Equal(t, "Original value", req.Header.Get("Test2"))
    61  }
    62  
    63  func TestReplaceHeader(t *testing.T) {
    64  	config := Config{
    65  		Replace: Options{
    66  			Headers: map[string]string{
    67  				"Test": "New value",
    68  			},
    69  		},
    70  	}
    71  	req, err := http.NewRequest(http.MethodGet, "/", nil)
    72  	req.Header.Add("Test", "Original value")
    73  	assert.NoError(t, err)
    74  
    75  	w := httptest.NewRecorder()
    76  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
    77  	assert.Equal(t, "New value", req.Header.Get("Test"))
    78  }
    79  
    80  func TestReplaceHeaderThatDoesntExist(t *testing.T) {
    81  	config := Config{
    82  		Replace: Options{
    83  			Headers: map[string]string{
    84  				"Test": "New value",
    85  			},
    86  		},
    87  	}
    88  	req, err := http.NewRequest(http.MethodGet, "/", nil)
    89  	assert.NoError(t, err)
    90  
    91  	w := httptest.NewRecorder()
    92  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
    93  	assert.Equal(t, "", req.Header.Get("Test"))
    94  }
    95  
    96  func TestRemoveHeaderThatDoesntExist(t *testing.T) {
    97  	config := Config{
    98  		Remove: Options{
    99  			Headers: map[string]string{
   100  				"Test": "New value",
   101  			},
   102  		},
   103  	}
   104  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   105  	assert.NoError(t, err)
   106  
   107  	w := httptest.NewRecorder()
   108  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   109  	assert.Equal(t, "", req.Header.Get("Test"))
   110  }
   111  
   112  func TestRemoveHeader(t *testing.T) {
   113  	config := Config{
   114  		Remove: Options{
   115  			Headers: map[string]string{
   116  				"Test": "New value",
   117  			},
   118  		},
   119  	}
   120  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   121  	req.Header.Add("Test", "Original value")
   122  	assert.NoError(t, err)
   123  
   124  	w := httptest.NewRecorder()
   125  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   126  	assert.Equal(t, "", req.Header.Get("Test"))
   127  }
   128  
   129  func TestAddQueryString(t *testing.T) {
   130  	config := Config{
   131  		Add: Options{
   132  			QueryString: map[string]string{
   133  				"test": "value",
   134  			},
   135  		},
   136  	}
   137  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   138  	assert.NoError(t, err)
   139  
   140  	w := httptest.NewRecorder()
   141  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   142  	assert.Equal(t, "value", req.URL.Query().Get("test"))
   143  }
   144  
   145  func TestAddQueryStringThatAlreadyExists(t *testing.T) {
   146  	config := Config{
   147  		Add: Options{
   148  			QueryString: map[string]string{
   149  				"test": "new-value",
   150  			},
   151  		},
   152  	}
   153  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   154  	q := req.URL.Query()
   155  	q.Add("test", "original-value")
   156  	assert.NoError(t, err)
   157  
   158  	w := httptest.NewRecorder()
   159  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   160  	assert.Equal(t, "original-value", q.Get("test"))
   161  }
   162  
   163  func TestAppendQueryString(t *testing.T) {
   164  	config := Config{
   165  		Append: Options{
   166  			QueryString: map[string]string{
   167  				"test": "value",
   168  			},
   169  		},
   170  	}
   171  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   172  	assert.NoError(t, err)
   173  
   174  	w := httptest.NewRecorder()
   175  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   176  
   177  	q := req.URL.Query()
   178  	q.Add("test2", "value")
   179  
   180  	assert.Equal(t, "value", q.Get("test"))
   181  	assert.Equal(t, "value", q.Get("test2"))
   182  }
   183  
   184  func TestReplaceQueryString(t *testing.T) {
   185  	config := Config{
   186  		Replace: Options{
   187  			QueryString: map[string]string{
   188  				"test": "new-value",
   189  			},
   190  		},
   191  	}
   192  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   193  	assert.NoError(t, err)
   194  
   195  	q := req.URL.Query()
   196  	q.Add("test", "original-value")
   197  	req.URL.RawQuery = q.Encode()
   198  
   199  	w := httptest.NewRecorder()
   200  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   201  	assert.Equal(t, "new-value", req.URL.Query().Get("test"))
   202  }
   203  
   204  func TestReplaceQueryStringThatDoesntExists(t *testing.T) {
   205  	config := Config{
   206  		Replace: Options{
   207  			QueryString: map[string]string{
   208  				"test": "new-value",
   209  			},
   210  		},
   211  	}
   212  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   213  	assert.NoError(t, err)
   214  
   215  	w := httptest.NewRecorder()
   216  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   217  	assert.Equal(t, "", req.URL.Query().Get("test"))
   218  }
   219  
   220  func TestRemoveQueryString(t *testing.T) {
   221  	config := Config{
   222  		Remove: Options{
   223  			QueryString: map[string]string{
   224  				"test": "",
   225  			},
   226  		},
   227  	}
   228  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   229  	assert.NoError(t, err)
   230  
   231  	q := req.URL.Query()
   232  	q.Add("test", "original-value")
   233  	req.URL.RawQuery = q.Encode()
   234  
   235  	w := httptest.NewRecorder()
   236  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   237  	assert.Equal(t, "", req.URL.Query().Get("test"))
   238  }
   239  
   240  func TestRemoveQueryStringthatDoesntExists(t *testing.T) {
   241  	config := Config{
   242  		Remove: Options{
   243  			QueryString: map[string]string{
   244  				"test": "",
   245  			},
   246  		},
   247  	}
   248  	req, err := http.NewRequest(http.MethodGet, "/", nil)
   249  	assert.NoError(t, err)
   250  
   251  	w := httptest.NewRecorder()
   252  	NewRequestTransformer(config)(http.HandlerFunc(test.Ping)).ServeHTTP(w, req)
   253  	assert.Equal(t, "", req.URL.Query().Get("test"))
   254  }