#!/bin/sh

global test_description := ''test git-http-backend-noserver''
source ./test-lib.sh

global HTTPD_DOCUMENT_ROOT_PATH := $TRASH_DIRECTORY

if test_have_prereq GREP_STRIPS_CR
{
	global GREP_OPTIONS := '-U'
	export GREP_OPTIONS
}

proc run_backend {
	echo $2 |
	env QUERY_STRING=$(1#*[?]) \
	PATH_TRANSLATED="$HTTPD_DOCUMENT_ROOT_PATH/$(1%%[?]*)" \
	git http-backend >act.out !2 >act.err
}

proc GET {
	global REQUEST_METHOD := '"GET'" && export REQUEST_METHOD &&
	run_backend "/repo.git/$1" &&
	sane_unset REQUEST_METHOD &&
	if ! grep "Status" act.out >act
	{
		printf "Status: 200 OK\r\n" >act
	}
	printf "Status: $2\r\n" >exp &&
	test_cmp exp act
}

proc POST {
	global REQUEST_METHOD := '"POST'" && export REQUEST_METHOD &&
	global CONTENT_TYPE := ""application/x-$1-request"" && export CONTENT_TYPE &&
	run_backend "/repo.git/$1" $2 &&
	sane_unset REQUEST_METHOD &&
	sane_unset CONTENT_TYPE &&
	if ! grep "Status" act.out >act
	{
		printf "Status: 200 OK\r\n" >act
	}
	printf "Status: $3\r\n" >exp &&
	test_cmp exp act
}

source "$TEST_DIRECTORY"/t556x_common

proc expect_aliased {
	global REQUEST_METHOD := '"GET'" && export REQUEST_METHOD &&
	if test $1 = 0 {
		run_backend $2
	} else {
		run_backend $2 &&
		echo "fatal: '$2': aliased" >exp.err &&
		test_cmp exp.err act.err
	}
	unset REQUEST_METHOD
}

test_expect_success 'http-backend blocks bad PATH_INFO' '
	config http.getanyfile true &&

	expect_aliased 0 /repo.git/HEAD &&

	expect_aliased 1 /repo.git/../HEAD &&
	expect_aliased 1 /../etc/passwd &&
	expect_aliased 1 ../etc/passwd &&
	expect_aliased 1 /etc//passwd &&
	expect_aliased 1 /etc/./passwd &&
	expect_aliased 1 //domain/data.txt
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"test git-http-backend-noserver">)}
          spids: [4]
        )
      ]
      spids: [4]
    )
    (C {(.)} {(./test-lib.sh)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:HTTPD_DOCUMENT_ROOT_PATH)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$TRASH_DIRECTORY"))}
          spids: [14]
        )
      ]
      spids: [14]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test_have_prereq)} {(GREP_STRIPS_CR)})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:GREP_OPTIONS) op:Equal rhs:{(-U)} spids:[29])]
              spids: [29]
            )
            (C {(export)} {(GREP_OPTIONS)})
          ]
          spids: [-1 26]
        )
      ]
      spids: [-1 37]
    )
    (FuncDef
      name: run_backend
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(echo)} {(DQ ($ VSub_Number "$2"))})
                (SimpleCommand
                  words: [{(git)} {(http-backend)}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(act.out)}
                      spids: [84]
                    )
                    (Redir
                      op_id: Redir_Great
                      fd: 2
                      arg_word: {(act.err)}
                      spids: [87]
                    )
                  ]
                  more_env: [
                    (env_pair
                      name: QUERY_STRING
                      val: 
                        {
                          (DQ 
                            (BracedVarSub
                              token: <VSub_Number 1>
                              suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("*[?]")})
                              spids: [58 62]
                            )
                          )
                        }
                      spids: [56]
                    )
                    (env_pair
                      name: PATH_TRANSLATED
                      val: 
                        {
                          (DQ ($ VSub_Name "$HTTPD_DOCUMENT_ROOT_PATH") (/) 
                            (BracedVarSub
                              token: <VSub_Number 1>
                              suffix_op: (StringUnary op_id:VOp1_DPercent arg_word:{("[?]*")})
                              spids: [71 75]
                            )
                          )
                        }
                      spids: [67]
                    )
                  ]
                )
              ]
              negated: False
            )
          ]
          spids: [44]
        )
      spids: [40 43]
    )
    (FuncDef
      name: GET
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:REQUEST_METHOD)
                      op: Equal
                      rhs: {(DQ (GET))}
                      spids: [100]
                    )
                  ]
                  spids: [100]
                )
                (AndOr
                  children: [
                    (C {(export)} {(REQUEST_METHOD)})
                    (AndOr
                      children: [
                        (C {(run_backend)} {(DQ (/repo.git/) ($ VSub_Number "$1"))})
                        (AndOr
                          children: [
                            (C {(sane_unset)} {(REQUEST_METHOD)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Pipeline
                                      children: [
                                        (SimpleCommand
                                          words: [{(grep)} {(DQ (Status))} {(act.out)}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: -1
                                              arg_word: {(act)}
                                              spids: [143]
                                            )
                                          ]
                                        )
                                      ]
                                      negated: True
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(printf)}
                                        {
                                          (DQ ("Status: 200 OK") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\r">
                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(act)}
                                          spids: [158]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 147]
                                )
                              ]
                              spids: [-1 162]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [
                    {(printf)}
                    {
                      (DQ ("Status: ") ($ VSub_Number "$2") 
                        (EscapedLiteralPart token:<Lit_EscapedChar "\\r">) (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                      )
                    }
                  ]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(exp)} spids:[174])]
                )
                (C {(test_cmp)} {(exp)} {(act)})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [97]
        )
      spids: [93 96]
    )
    (FuncDef
      name: POST
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:REQUEST_METHOD)
                      op: Equal
                      rhs: {(DQ (POST))}
                      spids: [196]
                    )
                  ]
                  spids: [196]
                )
                (AndOr
                  children: [
                    (C {(export)} {(REQUEST_METHOD)})
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:CONTENT_TYPE)
                              op: Equal
                              rhs: {(DQ (application/x-) ($ VSub_Number "$1") (-request))}
                              spids: [210]
                            )
                          ]
                          spids: [210]
                        )
                        (AndOr
                          children: [
                            (C {(export)} {(CONTENT_TYPE)})
                            (AndOr
                              children: [
                                (C {(run_backend)} {(DQ (/repo.git/) ($ VSub_Number "$1"))} 
                                  {(DQ ($ VSub_Number "$2"))}
                                )
                                (AndOr
                                  children: [
                                    (C {(sane_unset)} {(REQUEST_METHOD)})
                                    (AndOr
                                      children: [
                                        (C {(sane_unset)} {(CONTENT_TYPE)})
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Pipeline
                                                  children: [
                                                    (SimpleCommand
                                                      words: [{(grep)} {(DQ (Status))} {(act.out)}]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_Great
                                                          fd: -1
                                                          arg_word: {(act)}
                                                          spids: [266]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  negated: True
                                                )
                                              ]
                                              action: [
                                                (SimpleCommand
                                                  words: [
                                                    {(printf)}
                                                    {
                                                      (DQ ("Status: 200 OK") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\r">
                                                        ) (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(act)}
                                                      spids: [281]
                                                    )
                                                  ]
                                                )
                                              ]
                                              spids: [-1 270]
                                            )
                                          ]
                                          spids: [-1 285]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [
                    {(printf)}
                    {
                      (DQ ("Status: ") ($ VSub_Number "$3") 
                        (EscapedLiteralPart token:<Lit_EscapedChar "\\r">) (EscapedLiteralPart token:<Lit_EscapedChar "\\n">)
                      )
                    }
                  ]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(exp)} spids:[297])]
                )
                (C {(test_cmp)} {(exp)} {(act)})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [193]
        )
      spids: [189 192]
    )
    (C {(.)} {(DQ ($ VSub_Name "$TEST_DIRECTORY")) (/t556x_common)})
    (FuncDef
      name: expect_aliased
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:REQUEST_METHOD)
                      op: Equal
                      rhs: {(DQ (GET))}
                      spids: [327]
                    )
                  ]
                  spids: [327]
                )
                (AndOr
                  children: [
                    (C {(export)} {(REQUEST_METHOD)})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: (C {(test)} {($ VSub_Number "$1")} {(Lit_Other "=")} {(0)})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(run_backend)} {(DQ ($ VSub_Number "$2"))})]
                          spids: [-1 352]
                        )
                      ]
                      else_action: [
                        (AndOr
                          children: [
                            (C {(run_backend)} {(DQ ($ VSub_Number "$2"))})
                            (AndOr
                              children: [
                                (SimpleCommand
                                  words: [
                                    {(echo)}
                                    {(DQ ("fatal: '") ($ VSub_Number "$2") ("': aliased"))}
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(exp.err)}
                                      spids: [382]
                                    )
                                  ]
                                )
                                (C {(test_cmp)} {(exp.err)} {(act.err)})
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      spids: [362 395]
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (C {(unset)} {(REQUEST_METHOD)})
          ]
          spids: [324]
        )
      spids: [320 323]
    )
    (C {(test_expect_success)} {(SQ <"http-backend blocks bad PATH_INFO">)} 
      {
        (SQ <"\n"> <"\tconfig http.getanyfile true &&\n"> <"\n"> 
          <"\texpect_aliased 0 /repo.git/HEAD &&\n"> <"\n"> <"\texpect_aliased 1 /repo.git/../HEAD &&\n"> <"\texpect_aliased 1 /../etc/passwd &&\n"> 
          <"\texpect_aliased 1 ../etc/passwd &&\n"> <"\texpect_aliased 1 /etc//passwd &&\n"> <"\texpect_aliased 1 /etc/./passwd &&\n"> 
          <"\texpect_aliased 1 //domain/data.txt\n">
        )
      }
    )
    (C {(test_done)})
  ]
)