github.com/avenga/couper@v1.12.2/server/testdata/endpoints/14_couper.hcl (about)

     1  server { # error_handler
     2    endpoint "/ok" {
     3      request "resolve" {
     4        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
     5  
     6        expected_status = [200, 204]
     7      }
     8  
     9      custom_log_fields = {
    10        beresp_res = backend_responses.resolve
    11        beresp_def = backend_responses.default
    12      }
    13  
    14      proxy {
    15        url = "${env.COUPER_TEST_BACKEND_ADDR}/reflect"
    16        set_request_headers = {
    17          x = backend_responses.resolve.headers.content-type
    18        }
    19      }
    20  
    21      error_handler "unexpected_status" {
    22        response {
    23          status = 418
    24        }
    25      }
    26    }
    27  
    28    endpoint "/not-ok" {
    29      request {
    30        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
    31  
    32        expected_status = [418]
    33      }
    34  
    35      error_handler "endpoint" {
    36        response {
    37          status = 417
    38        }
    39      }
    40  
    41      error_handler "unexpected_status" {
    42        response {
    43          headers = {
    44            x = backend_responses.default.status
    45            y = backend_responses.default.json_body.JSON.list[0]
    46          }
    47          status = 418
    48        }
    49      }
    50    }
    51  
    52    endpoint "/not-ok-endpoint" {
    53      request {
    54        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
    55  
    56        expected_status = [418]
    57      }
    58  
    59      error_handler "endpoint" {
    60        response {
    61          headers = {
    62            x = backend_responses.default.status
    63            y = backend_responses.default.json_body.JSON.list[0]
    64          }
    65          status = 418
    66        }
    67      }
    68    }
    69  
    70    endpoint "/not-ok-sequence" {
    71      request "resolve" {
    72        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
    73  
    74        expected_status = [200, 204]
    75      }
    76  
    77      proxy {
    78        url = "${env.COUPER_TEST_BACKEND_ADDR}/reflect"
    79        set_request_headers = {
    80          x = backend_responses.resolve.headers.content-type
    81        }
    82        expected_status = [418]
    83      }
    84  
    85      error_handler "unexpected_status" {
    86        response {
    87          headers = {
    88            x = backend_responses.default.headers.x
    89          }
    90          status = 418
    91        }
    92      }
    93    }
    94  
    95    endpoint "/sequence-break-unexpected_status" {
    96      request "resolve" {
    97        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
    98  
    99        expected_status = [418] # break
   100      }
   101  
   102      proxy {
   103        url = "${env.COUPER_TEST_BACKEND_ADDR}/reflect"
   104        set_request_headers = {
   105          x = backend_responses.resolve.headers.content-type
   106        }
   107        expected_status = [200]
   108      }
   109    }
   110  
   111    endpoint "/sequence-break-backend_timeout" {
   112      request "resolve" {
   113        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   114        backend {
   115          timeout = "1ns" # break
   116        }
   117      }
   118  
   119      proxy {
   120        url = "${env.COUPER_TEST_BACKEND_ADDR}/reflect"
   121        set_request_headers = {
   122          x = backend_responses.resolve.headers.content-type
   123        }
   124        expected_status = [200]
   125      }
   126    }
   127  
   128    endpoint "/break-only-one-sequence" {
   129      request "resolve1" {
   130        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   131  
   132        expected_status = [418] # break
   133      }
   134  
   135      proxy {
   136        url = "${env.COUPER_TEST_BACKEND_ADDR}/reflect"
   137        set_request_headers = {
   138          x = backend_responses.resolve1.headers.content-type
   139        }
   140        expected_status = [200]
   141      }
   142  
   143      request "resolve2" {
   144        url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   145        expected_status = [200]
   146      }
   147  
   148      proxy "refl" {
   149        url = "${env.COUPER_TEST_BACKEND_ADDR}/reflect"
   150        set_request_headers = {
   151          x = backend_responses.resolve2.headers.content-type
   152        }
   153        expected_status = [200]
   154      }
   155  
   156      response {
   157        status = 200
   158      }
   159    }
   160  
   161    api {
   162      endpoint "/1.1" {
   163        request "r1" {
   164          url = "${env.COUPER_TEST_BACKEND_ADDR}/not-found"
   165          expected_status = [200]
   166        }
   167  
   168        request "r2" {
   169          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   170          json_body = backend_responses.r1.json_body
   171        }
   172  
   173        response {
   174          json_body = backend_responses.r2.json_body
   175        }
   176  
   177        error_handler "unexpected_status" {
   178          response {
   179            headers = {
   180              handled-by = "unexpected_status"
   181            }
   182          }
   183        }
   184  
   185        error_handler "sequence" {
   186          response {
   187            headers = {
   188              handled-by = "sequence"
   189            }
   190          }
   191        }
   192  
   193        error_handler "endpoint" {  # super-type for unexpected_status and sequence
   194          response {
   195            headers = {
   196              handled-by = "endpoint"
   197            }
   198          }
   199        }
   200      }
   201  
   202      endpoint "/1.2" {
   203        request "r1" {
   204          url = "${env.COUPER_TEST_BACKEND_ADDR}/not-found"
   205          expected_status = [200]
   206        }
   207  
   208        request "r2" {
   209          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   210          json_body = backend_responses.r1.json_body
   211        }
   212  
   213        response {
   214          json_body = backend_responses.r2.json_body
   215        }
   216  
   217        error_handler "sequence" {
   218          response {
   219            headers = {
   220              handled-by = "sequence"
   221            }
   222          }
   223        }
   224  
   225        error_handler "endpoint" {  # super-type for unexpected_status and sequence
   226          response {
   227            headers = {
   228              handled-by = "endpoint"
   229            }
   230          }
   231        }
   232      }
   233  
   234      endpoint "/1.3" {
   235        request "r1" {
   236          url = "${env.COUPER_TEST_BACKEND_ADDR}/not-found"
   237          expected_status = [200]
   238        }
   239  
   240        request "r2" {
   241          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   242          json_body = backend_responses.r1.json_body
   243        }
   244  
   245        response {
   246          json_body = backend_responses.r2.json_body
   247        }
   248  
   249        error_handler "sequence" {
   250          response {
   251            headers = {
   252              handled-by = "sequence"
   253            }
   254          }
   255        }
   256      }
   257  
   258      endpoint "/1.4" {
   259        request "r1" {
   260          url = "${env.COUPER_TEST_BACKEND_ADDR}/not-found"
   261          expected_status = [200]
   262        }
   263  
   264        request "r2" {
   265          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   266          json_body = backend_responses.r1.json_body
   267        }
   268  
   269        response {
   270          json_body = backend_responses.r2.json_body
   271        }
   272  
   273        error_handler "endpoint" {  # super-type for unexpected_status and sequence
   274          response {
   275            headers = {
   276              handled-by = "endpoint"
   277            }
   278          }
   279        }
   280      }
   281  
   282      endpoint "/1.5" {
   283        request "r1" {
   284          url = "${env.COUPER_TEST_BACKEND_ADDR}/not-found"
   285          expected_status = [200]
   286        }
   287  
   288        request "r2" {
   289          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   290          json_body = backend_responses.r1.json_body
   291        }
   292  
   293        response {
   294          json_body = backend_responses.r2.json_body
   295        }
   296      }
   297  
   298      endpoint "/2.1" {
   299        request "r1" {
   300          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   301          backend {
   302            timeout = "1ns"
   303          }
   304        }
   305  
   306        request "r2" {
   307          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   308          json_body = backend_responses.r1.json_body
   309        }
   310  
   311        response {
   312          json_body = backend_responses.r2.json_body
   313        }
   314  
   315        error_handler "backend_timeout" {
   316          response {
   317            headers = {
   318              handled-by = "backend_timeout"
   319            }
   320          }
   321        }
   322  
   323        error_handler "backend" {  # super-type for backend_timeout
   324          response {
   325            headers = {
   326              handled-by = "backend"
   327            }
   328          }
   329        }
   330  
   331        error_handler "sequence" {
   332          response {
   333            headers = {
   334              handled-by = "sequence"
   335            }
   336          }
   337        }
   338  
   339        error_handler "endpoint" {  # super-type for sequence
   340          response {
   341            headers = {
   342              handled-by = "endpoint"
   343            }
   344          }
   345        }
   346      }
   347  
   348      endpoint "/2.2" {
   349        request "r1" {
   350          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   351          backend {
   352            timeout = "1ns"
   353          }
   354        }
   355  
   356        request "r2" {
   357          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   358          json_body = backend_responses.r1.json_body
   359        }
   360  
   361        response {
   362          json_body = backend_responses.r2.json_body
   363        }
   364  
   365        error_handler "backend" {  # super-type for backend_timeout
   366          response {
   367            headers = {
   368              handled-by = "backend"
   369            }
   370          }
   371        }
   372  
   373        error_handler "sequence" {
   374          response {
   375            headers = {
   376              handled-by = "sequence"
   377            }
   378          }
   379        }
   380  
   381        error_handler "endpoint" {  # super-type for sequence
   382          response {
   383            headers = {
   384              handled-by = "endpoint"
   385            }
   386          }
   387        }
   388      }
   389  
   390      endpoint "/2.3" {
   391        request "r1" {
   392          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   393          backend {
   394            timeout = "1ns"
   395          }
   396        }
   397  
   398        request "r2" {
   399          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   400          json_body = backend_responses.r1.json_body
   401        }
   402  
   403        response {
   404          json_body = backend_responses.r2.json_body
   405        }
   406  
   407        error_handler "sequence" {
   408          response {
   409            headers = {
   410              handled-by = "sequence"
   411            }
   412          }
   413        }
   414  
   415        error_handler "endpoint" {  # super-type for sequence
   416          response {
   417            headers = {
   418              handled-by = "endpoint"
   419            }
   420          }
   421        }
   422      }
   423  
   424      endpoint "/2.4" {
   425        request "r1" {
   426          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   427          backend {
   428            timeout = "1ns"
   429          }
   430        }
   431  
   432        request "r2" {
   433          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   434          json_body = backend_responses.r1.json_body
   435        }
   436  
   437        response {
   438          json_body = backend_responses.r2.json_body
   439        }
   440  
   441        error_handler "endpoint" {  # super-type for sequence
   442          response {
   443            headers = {
   444              handled-by = "endpoint"
   445            }
   446          }
   447        }
   448      }
   449  
   450      endpoint "/2.5" {
   451        request "r1" {
   452          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   453          backend {
   454            timeout = "1ns"
   455          }
   456        }
   457  
   458        request "r2" {
   459          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   460          json_body = backend_responses.r1.json_body
   461        }
   462  
   463        response {
   464          json_body = backend_responses.r2.json_body
   465        }
   466      }
   467  
   468      endpoint "/3.1" {
   469        request "r1" {
   470          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   471          backend {
   472            openapi {
   473              file = "14_couper.yaml"
   474            }
   475          }
   476        }
   477  
   478        request "r2" {
   479          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   480          json_body = backend_responses.r1.json_body
   481        }
   482  
   483        response {
   484          json_body = backend_responses.r2.json_body
   485        }
   486  
   487        error_handler "backend_openapi_validation" {
   488          response {
   489            headers = {
   490              handled-by = "backend_openapi_validation"
   491            }
   492          }
   493        }
   494  
   495        error_handler "backend" {  # super-type for backend_openapi_validation
   496          response {
   497            headers = {
   498              handled-by = "backend"
   499            }
   500          }
   501        }
   502  
   503        error_handler "sequence" {
   504          response {
   505            headers = {
   506              handled-by = "sequence"
   507            }
   508          }
   509        }
   510  
   511        error_handler "endpoint" {  # super-type for sequence
   512          response {
   513            headers = {
   514              handled-by = "endpoint"
   515            }
   516          }
   517        }
   518      }
   519  
   520      endpoint "/3.2" {
   521        request "r1" {
   522          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   523          backend {
   524            openapi {
   525              file = "14_couper.yaml"
   526            }
   527          }
   528        }
   529  
   530        request "r2" {
   531          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   532          json_body = backend_responses.r1.json_body
   533        }
   534  
   535        response {
   536          json_body = backend_responses.r2.json_body
   537        }
   538  
   539        error_handler "backend" {  # super-type for backend_openapi_validation
   540          response {
   541            headers = {
   542              handled-by = "backend"
   543            }
   544          }
   545        }
   546  
   547        error_handler "sequence" {
   548          response {
   549            headers = {
   550              handled-by = "sequence"
   551            }
   552          }
   553        }
   554  
   555        error_handler "endpoint" {  # super-type for sequence
   556          response {
   557            headers = {
   558              handled-by = "endpoint"
   559            }
   560          }
   561        }
   562      }
   563  
   564      endpoint "/3.3" {
   565        request "r1" {
   566          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   567          backend {
   568            openapi {
   569              file = "14_couper.yaml"
   570            }
   571          }
   572        }
   573  
   574        request "r2" {
   575          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   576          json_body = backend_responses.r1.json_body
   577        }
   578  
   579        response {
   580          json_body = backend_responses.r2.json_body
   581        }
   582  
   583        error_handler "sequence" {
   584          response {
   585            headers = {
   586              handled-by = "sequence"
   587            }
   588          }
   589        }
   590  
   591        error_handler "endpoint" {  # super-type for sequence
   592          response {
   593            headers = {
   594              handled-by = "endpoint"
   595            }
   596          }
   597        }
   598      }
   599  
   600      endpoint "/3.4" {
   601        request "r1" {
   602          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   603          backend {
   604            openapi {
   605              file = "14_couper.yaml"
   606            }
   607          }
   608        }
   609  
   610        request "r2" {
   611          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   612          json_body = backend_responses.r1.json_body
   613        }
   614  
   615        response {
   616          json_body = backend_responses.r2.json_body
   617        }
   618  
   619        error_handler "endpoint" {  # super-type for sequence
   620          response {
   621            headers = {
   622              handled-by = "endpoint"
   623            }
   624          }
   625        }
   626      }
   627  
   628      endpoint "/3.5" {
   629        request "r1" {
   630          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   631          backend {
   632            openapi {
   633              file = "14_couper.yaml"
   634            }
   635          }
   636        }
   637  
   638        request "r2" {
   639          url = "${env.COUPER_TEST_BACKEND_ADDR}/anything"
   640          json_body = backend_responses.r1.json_body
   641        }
   642  
   643        response {
   644          json_body = backend_responses.r2.json_body
   645        }
   646      }
   647    }
   648  }