package main

import (
    "bytes"
    "html" // New import
    "io"
    "log/slog"
    "net/http"
    "net/http/cookiejar"
    "net/http/httptest"
    "regexp" // New import
    "testing"
    "time"

    "snippetbox.alexedwards.net/internal/models/mocks"

    "github.com/alexedwards/scs/v2"
    "github.com/go-playground/form/v4"
)

...

func extractCSRFToken(t *testing.T, body string) string {
    // Define a regular expression which captures the CSRF token value from the
    // HTML for our user signup page.
	csrfTokenRX := regexp.MustCompile(`<input type='hidden' name='csrf_token' value='(.+)'>`)

    // Use the FindStringSubmatch method to extract the token from the HTML body.
    // Note that this returns an slice with the entire matched pattern in the
    // first position, and the values of any captured data in the subsequent
    // positions.
	matches := csrfTokenRX.FindStringSubmatch(body)
	if len(matches) < 2 {
		t.Fatal("no csrf token found in body")
	}

	return html.UnescapeString(matches[1])
}

package main

...

func TestUserSignup(t *testing.T) {
    // Create the application struct containing our mocked dependencies and 
	// establish a new test server.
    app := newTestApplication(t)
    ts := newTestServer(t, app.routes())
    defer ts.Close()

    // Make a GET /user/signup request.
    res := ts.get(t, "/user/signup")

    // Extract the CSRF token from the response body and print it out using the 
    // t.Logf() function. This works in exactly the same way as fmt.Printf(), 
    // but writes the provided message to the test output.
    t.Logf("CSRF token is: %q", extractCSRFToken(t, res.body))

    // And also log the response cookies in the test output too.
    t.Logf("cookies are: %v", res.cookies)
}

package main

import (
    "bytes"
    "html"
    "io"
    "log/slog"
    "net/http"
    "net/http/cookiejar"
    "net/http/httptest"
    "net/url" // New import
    "regexp"
    "strings" // New import
    "testing"
    "time"

    "snippetbox.alexedwards.net/internal/models/mocks"

    "github.com/alexedwards/scs/v2"
    "github.com/go-playground/form/v4"
)

...

// Create a postForm method for sending POST requests to the test server. The
// final parameter to this method is a url.Values map which can contain any
// form data that you want to send in the request body.
func (ts *testServer) postForm(t *testing.T, urlPath string, form url.Values) testResponse {
    req, err := http.NewRequest(http.MethodPost, ts.URL+urlPath, strings.NewReader(form.Encode()))
    if err != nil {
        t.Fatal(err)
    }

    // Set the appropriate Content-Type header for form data and the Sec-Fetch-Site
    // header.
    req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Set("Sec-Fetch-Site", "same-origin")

    res, err := ts.Client().Do(req)
    if err != nil {
        t.Fatal(err)
    }
    defer res.Body.Close()

    body, err := io.ReadAll(res.Body)
    if err != nil {
        t.Fatal(err)
    }

    return testResponse{
        status:  res.StatusCode,
        headers: res.Header,
        cookies: res.Cookies(),
        body:    string(bytes.TrimSpace(body)),
    }
}

package main

import (
    "net/http"
    "net/url" // New import
    "testing"

    "snippetbox.alexedwards.net/internal/assert"
)

...

func TestUserSignup(t *testing.T) {
	app := newTestApplication(t)
	ts := newTestServer(t, app.routes())
    defer ts.Close()

	const (
		validName     = "Bob"
		validPassword = "validPa$$word"
		validEmail    = "bob@example.com"
		formTag       = "<form action='/user/signup' method='POST' novalidate>"
	)

	tests := []struct {
		name              string
		userName          string
		userEmail         string
		userPassword      string
		useValidCSRFToken bool
		wantStatus        int
		wantFormTag       string
	}{
		{
			name:              "Valid submission",
			userName:          validName,
			userEmail:         validEmail,
			userPassword:      validPassword,
			useValidCSRFToken: true,
			wantStatus:        http.StatusSeeOther,
		},
		{
			name:              "Invalid CSRF Token",
			userName:          validName,
			userEmail:         validEmail,
			userPassword:      validPassword,
			useValidCSRFToken: false,
			wantStatus:        http.StatusBadRequest,
		},
		{
			name:              "Empty name",
			userName:          "",
			userEmail:         validEmail,
			userPassword:      validPassword,
			useValidCSRFToken: true,
			wantStatus:        http.StatusUnprocessableEntity,
			wantFormTag:       formTag,
		},
		{
			name:              "Empty email",
			userName:          validName,
			userEmail:         "",
			userPassword:      validPassword,
			useValidCSRFToken: true,
			wantStatus:        http.StatusUnprocessableEntity,
			wantFormTag:       formTag,
		},
		{
			name:              "Empty password",
			userName:          validName,
			userEmail:         validEmail,
			userPassword:      "",
			useValidCSRFToken: true,
			wantStatus:        http.StatusUnprocessableEntity,
			wantFormTag:       formTag,
		},
		{
			name:              "Invalid email",
			userName:          validName,
			userEmail:         "bob@example.",
			userPassword:      validPassword,
			useValidCSRFToken: true,
			wantStatus:        http.StatusUnprocessableEntity,
			wantFormTag:       formTag,
		},
		{
			name:              "Short password",
			userName:          validName,
			userEmail:         validEmail,
			userPassword:      "pa$$",
			useValidCSRFToken: true,
			wantStatus:        http.StatusUnprocessableEntity,
			wantFormTag:       formTag,
		},
		{
			name:              "Duplicate email",
			userName:          validName,
			userEmail:         "dupe@example.com",
			userPassword:      validPassword,
			useValidCSRFToken: true,
			wantStatus:        http.StatusUnprocessableEntity,
			wantFormTag:       formTag,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Reset the cookie jar for each sub-test.
			ts.resetClientCookieJar(t)

			// Make a GET /user/signup signup request. This will automatically 
			// add the CSRF cookie from the response to the test client's cookie 
			// jar, and we can extract the CSRF token from the response body.
			res := ts.get(t, "/user/signup")

			// Build up the form values for the sub-test, including the CSRF 
			// token if appropriate.
			form := url.Values{}
			form.Add("name", tt.userName)
			form.Add("email", tt.userEmail)
			form.Add("password", tt.userPassword)
			if tt.useValidCSRFToken {
				form.Add("csrf_token", extractCSRFToken(t, res.body))
			}

			// Make the POST /user/signup request using the form values we 
			// created above. The request will automatically include the CSRF 
			// cookie from the test client's cookie jar.
			res = ts.postForm(t, "/user/signup", form)

			// And finally, test the response data.
			assert.Equal(t, res.status, tt.wantStatus)
			assert.StringContains(t, res.body, tt.wantFormTag)
		})
	}
}