Gecko [ 167.86.127.34 ]

Name	Size	Permission
edit.html	216 B	-rw-r--r--
final-noclosure.go	2.26 KB	-rw-r--r--
final-noerror.go	1.14 KB	-rw-r--r--
final-parsetemplate.go	2.16 KB	-rw-r--r--
final-template.go	1.49 KB	-rw-r--r--
final.go	2.13 KB	-rw-r--r--
final_test.go	413 B	-rw-r--r--
go.mod	34 B	-rw-r--r--
http-sample.go	277 B	-rw-r--r--
index.html	22.39 KB	-rw-r--r--
notemplate.go	1.29 KB	-rw-r--r--
part1-noerror.go	688 B	-rw-r--r--
part1.go	745 B	-rw-r--r--
part2.go	891 B	-rw-r--r--
part3-errorhandling.go	1.67 KB	-rw-r--r--
part3.go	1.26 KB	-rw-r--r--
test_Test.txt.good	12 B	-rw-r--r--
test_edit.good	183 B	-rw-r--r--
test_view.good	79 B	-rw-r--r--
view.html	100 B	-rw-r--r--
wiki_test.go	4.45 KB	-rw-r--r--

Code Editor : wiki_test.go

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main_test

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
)

func TestSnippetsCompile(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping slow builds in short mode")
	}

goFiles, err := filepath.Glob("*.go")
	if err != nil {
		t.Fatal(err)
	}

for _, f := range goFiles {
		if strings.HasSuffix(f, "_test.go") {
			continue
		}
		f := f
		t.Run(f, func(t *testing.T) {
			t.Parallel()

cmd := exec.Command("go", "build", "-o", os.DevNull, f)
			out, err := cmd.CombinedOutput()
			if err != nil {
				t.Errorf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
			}
		})
	}
}

func TestWikiServer(t *testing.T) {
	must := func(err error) {
		if err != nil {
			t.Helper()
			t.Fatal(err)
		}
	}

dir, err := ioutil.TempDir("", t.Name())
	must(err)
	defer os.RemoveAll(dir)

// We're testing a walkthrough example of how to write a server.
	//
	// That server hard-codes a port number to make the walkthrough simpler, but
	// we can't assume that the hard-coded port is available on an arbitrary
	// builder. So we'll patch out the hard-coded port, and replace it with a
	// function that writes the server's address to stdout
	// so that we can read it and know where to send the test requests.

finalGo, err := ioutil.ReadFile("final.go")
	must(err)
	const patchOld = `log.Fatal(http.ListenAndServe(":8080", nil))`
	patched := bytes.ReplaceAll(finalGo, []byte(patchOld), []byte(`log.Fatal(serve())`))
	if bytes.Equal(patched, finalGo) {
		t.Fatalf("Can't patch final.go: %q not found.", patchOld)
	}
	must(ioutil.WriteFile(filepath.Join(dir, "final_patched.go"), patched, 0644))

// Build the server binary from the patched sources.
	// The 'go' command requires that they all be in the same directory.
	// final_test.go provides the implemtation for our serve function.
	must(copyFile(filepath.Join(dir, "final_srv.go"), "final_test.go"))
	cmd := exec.Command("go", "build",
		"-o", filepath.Join(dir, "final.exe"),
		filepath.Join(dir, "final_patched.go"),
		filepath.Join(dir, "final_srv.go"))
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
	}

// Run the server in our temporary directory so that it can
	// write its content there. It also needs a couple of template files,
	// and looks for them in the same directory.
	must(copyFile(filepath.Join(dir, "edit.html"), "edit.html"))
	must(copyFile(filepath.Join(dir, "view.html"), "view.html"))
	cmd = exec.Command(filepath.Join(dir, "final.exe"))
	cmd.Dir = dir
	stderr := bytes.NewBuffer(nil)
	cmd.Stderr = stderr
	stdout, err := cmd.StdoutPipe()
	must(err)
	must(cmd.Start())

defer func() {
		cmd.Process.Kill()
		err := cmd.Wait()
		if stderr.Len() > 0 {
			t.Logf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, stderr)
		}
	}()

var addr string
	if _, err := fmt.Fscanln(stdout, &addr); err != nil || addr == "" {
		t.Fatalf("Failed to read server address: %v", err)
	}

// The server is up and has told us its address.
	// Make sure that its HTTP API works as described in the article.

r, err := http.Get(fmt.Sprintf("http://%s/edit/Test", addr))
	must(err)
	responseMustMatchFile(t, r, "test_edit.good")

r, err = http.Post(fmt.Sprintf("http://%s/save/Test", addr),
		"application/x-www-form-urlencoded",
		strings.NewReader("body=some%20content"))
	must(err)
	responseMustMatchFile(t, r, "test_view.good")

gotTxt, err := ioutil.ReadFile(filepath.Join(dir, "Test.txt"))
	must(err)
	wantTxt, err := ioutil.ReadFile("test_Test.txt.good")
	must(err)
	if !bytes.Equal(wantTxt, gotTxt) {
		t.Fatalf("Test.txt differs from expected after posting to /save.\ngot:\n%s\nwant:\n%s", gotTxt, wantTxt)
	}

r, err = http.Get(fmt.Sprintf("http://%s/view/Test", addr))
	must(err)
	responseMustMatchFile(t, r, "test_view.good")
}

func responseMustMatchFile(t *testing.T, r *http.Response, filename string) {
	t.Helper()

defer r.Body.Close()
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		t.Fatal(err)
	}

wantBody, err := ioutil.ReadFile(filename)
	if err != nil {
		t.Fatal(err)
	}

if !bytes.Equal(body, wantBody) {
		t.Fatalf("%v: body does not match %s.\ngot:\n%s\nwant:\n%s", r.Request.URL, filename, body, wantBody)
	}
}

func copyFile(dst, src string) error {
	buf, err := ioutil.ReadFile(src)
	if err != nil {
		return err
	}
	return ioutil.WriteFile(dst, buf, 0644)
}

${this.title}

Code Editor : wiki_test.go