diff options
author | Frédéric Guillot <fred@miniflux.net> | 2017-11-19 21:10:04 -0800 |
---|---|---|
committer | Frédéric Guillot <fred@miniflux.net> | 2017-11-19 22:01:46 -0800 |
commit | 8ffb773f43c8dc54801ca1d111854e7e881c93c9 (patch) | |
tree | 38133a2fc612597a75fed1d13e5b4042f58a2b7e /vendor/github.com/tdewolff/minify/minify_test.go |
First commit
Diffstat (limited to 'vendor/github.com/tdewolff/minify/minify_test.go')
-rw-r--r-- | vendor/github.com/tdewolff/minify/minify_test.go | 358 |
1 files changed, 358 insertions, 0 deletions
diff --git a/vendor/github.com/tdewolff/minify/minify_test.go b/vendor/github.com/tdewolff/minify/minify_test.go new file mode 100644 index 0000000..7e2e810 --- /dev/null +++ b/vendor/github.com/tdewolff/minify/minify_test.go @@ -0,0 +1,358 @@ +package minify // import "github.com/tdewolff/minify" + +import ( + "bufio" + "bytes" + "errors" + "fmt" + "io" + "io/ioutil" + "net/http" + "os" + "os/exec" + "regexp" + "strings" + "testing" + + "github.com/tdewolff/test" +) + +var errDummy = errors.New("dummy error") + +// from os/exec/exec_test.go +func helperCommand(t *testing.T, s ...string) *exec.Cmd { + cs := []string{"-test.run=TestHelperProcess", "--"} + cs = append(cs, s...) + cmd := exec.Command(os.Args[0], cs...) + cmd.Env = []string{"GO_WANT_HELPER_PROCESS=1"} + return cmd +} + +//////////////////////////////////////////////////////////////// + +var m *M + +func init() { + m = New() + m.AddFunc("dummy/copy", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + io.Copy(w, r) + return nil + }) + m.AddFunc("dummy/nil", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + return nil + }) + m.AddFunc("dummy/err", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + return errDummy + }) + m.AddFunc("dummy/charset", func(m *M, w io.Writer, r io.Reader, params map[string]string) error { + w.Write([]byte(params["charset"])) + return nil + }) + m.AddFunc("dummy/params", func(m *M, w io.Writer, r io.Reader, params map[string]string) error { + return m.Minify(params["type"]+"/"+params["sub"], w, r) + }) + m.AddFunc("type/sub", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + w.Write([]byte("type/sub")) + return nil + }) + m.AddFuncRegexp(regexp.MustCompile("^type/.+$"), func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + w.Write([]byte("type/*")) + return nil + }) + m.AddFuncRegexp(regexp.MustCompile("^.+/.+$"), func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + w.Write([]byte("*/*")) + return nil + }) +} + +func TestMinify(t *testing.T) { + test.T(t, m.Minify("?", nil, nil), ErrNotExist, "minifier doesn't exist") + test.T(t, m.Minify("dummy/nil", nil, nil), nil) + test.T(t, m.Minify("dummy/err", nil, nil), errDummy) + + b := []byte("test") + out, err := m.Bytes("dummy/nil", b) + test.T(t, err, nil) + test.Bytes(t, out, []byte{}, "dummy/nil returns empty byte slice") + out, err = m.Bytes("?", b) + test.T(t, err, ErrNotExist, "minifier doesn't exist") + test.Bytes(t, out, b, "return input when minifier doesn't exist") + + s := "test" + out2, err := m.String("dummy/nil", s) + test.T(t, err, nil) + test.String(t, out2, "", "dummy/nil returns empty string") + out2, err = m.String("?", s) + test.T(t, err, ErrNotExist, "minifier doesn't exist") + test.String(t, out2, s, "return input when minifier doesn't exist") +} + +type DummyMinifier struct{} + +func (d *DummyMinifier) Minify(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + return errDummy +} + +func TestAdd(t *testing.T) { + mAdd := New() + r := bytes.NewBufferString("test") + w := &bytes.Buffer{} + mAdd.Add("dummy/err", &DummyMinifier{}) + test.T(t, mAdd.Minify("dummy/err", nil, nil), errDummy) + + mAdd.AddRegexp(regexp.MustCompile("err1$"), &DummyMinifier{}) + test.T(t, mAdd.Minify("dummy/err1", nil, nil), errDummy) + + mAdd.AddFunc("dummy/err", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + return errDummy + }) + test.T(t, mAdd.Minify("dummy/err", nil, nil), errDummy) + + mAdd.AddFuncRegexp(regexp.MustCompile("err2$"), func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + return errDummy + }) + test.T(t, mAdd.Minify("dummy/err2", nil, nil), errDummy) + + mAdd.AddCmd("dummy/copy", helperCommand(t, "dummy/copy")) + mAdd.AddCmd("dummy/err", helperCommand(t, "dummy/err")) + mAdd.AddCmdRegexp(regexp.MustCompile("err6$"), helperCommand(t, "werr6")) + test.T(t, mAdd.Minify("dummy/copy", w, r), nil) + test.String(t, w.String(), "test", "dummy/copy command returns input") + test.String(t, mAdd.Minify("dummy/err", w, r).Error(), "exit status 1", "command returns status 1 for dummy/err") + test.String(t, mAdd.Minify("werr6", w, r).Error(), "exit status 2", "command returns status 2 when minifier doesn't exist") + test.String(t, mAdd.Minify("stderr6", w, r).Error(), "exit status 2", "command returns status 2 when minifier doesn't exist") +} + +func TestMatch(t *testing.T) { + pattern, params, _ := m.Match("dummy/copy; a=b") + test.String(t, pattern, "dummy/copy") + test.String(t, params["a"], "b") + + pattern, _, _ = m.Match("type/foobar") + test.String(t, pattern, "^type/.+$") + + _, _, minifier := m.Match("dummy/") + test.That(t, minifier == nil) +} + +func TestWildcard(t *testing.T) { + mimetypeTests := []struct { + mimetype string + expected string + }{ + {"type/sub", "type/sub"}, + {"type/*", "type/*"}, + {"*/*", "*/*"}, + {"type/sub2", "type/*"}, + {"type2/sub", "*/*"}, + {"dummy/charset;charset=UTF-8", "UTF-8"}, + {"dummy/charset; charset = UTF-8 ", "UTF-8"}, + {"dummy/params;type=type;sub=two2", "type/*"}, + } + + for _, tt := range mimetypeTests { + r := bytes.NewBufferString("") + w := &bytes.Buffer{} + err := m.Minify(tt.mimetype, w, r) + test.Error(t, err) + test.Minify(t, tt.mimetype, nil, w.String(), tt.expected) + } +} + +func TestReader(t *testing.T) { + m := New() + m.AddFunc("dummy/dummy", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + _, err := io.Copy(w, r) + return err + }) + m.AddFunc("dummy/err", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + return errDummy + }) + + w := &bytes.Buffer{} + r := bytes.NewBufferString("test") + mr := m.Reader("dummy/dummy", r) + _, err := io.Copy(w, mr) + test.Error(t, err) + test.String(t, w.String(), "test", "equal input after dummy minify reader") + + mr = m.Reader("dummy/err", r) + _, err = io.Copy(w, mr) + test.T(t, err, errDummy) +} + +func TestWriter(t *testing.T) { + m := New() + m.AddFunc("dummy/dummy", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + _, err := io.Copy(w, r) + return err + }) + m.AddFunc("dummy/err", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + return errDummy + }) + m.AddFunc("dummy/late-err", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + _, _ = ioutil.ReadAll(r) + return errDummy + }) + + w := &bytes.Buffer{} + mw := m.Writer("dummy/dummy", w) + _, _ = mw.Write([]byte("test")) + test.Error(t, mw.Close()) + test.String(t, w.String(), "test", "equal input after dummy minify writer") + + w = &bytes.Buffer{} + mw = m.Writer("dummy/err", w) + _, _ = mw.Write([]byte("test")) + test.T(t, mw.Close(), errDummy) + test.String(t, w.String(), "test", "equal input after dummy minify writer") + + w = &bytes.Buffer{} + mw = m.Writer("dummy/late-err", w) + _, _ = mw.Write([]byte("test")) + test.T(t, mw.Close(), errDummy) + test.String(t, w.String(), "") +} + +type responseWriter struct { + writer io.Writer + header http.Header +} + +func (w *responseWriter) Header() http.Header { + return w.header +} + +func (w *responseWriter) WriteHeader(_ int) {} + +func (w *responseWriter) Write(b []byte) (int, error) { + return w.writer.Write(b) +} + +func TestResponseWriter(t *testing.T) { + m := New() + m.AddFunc("text/html", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + _, err := io.Copy(w, r) + return err + }) + + b := &bytes.Buffer{} + w := &responseWriter{b, http.Header{}} + r := &http.Request{RequestURI: "/index.html"} + mw := m.ResponseWriter(w, r) + test.Error(t, mw.Close()) + _, _ = mw.Write([]byte("test")) + test.Error(t, mw.Close()) + test.String(t, b.String(), "test", "equal input after dummy minify response writer") + + b = &bytes.Buffer{} + w = &responseWriter{b, http.Header{}} + r = &http.Request{RequestURI: "/index"} + mw = m.ResponseWriter(w, r) + mw.Header().Add("Content-Type", "text/html") + _, _ = mw.Write([]byte("test")) + test.Error(t, mw.Close()) + test.String(t, b.String(), "test", "equal input after dummy minify response writer") +} + +func TestMiddleware(t *testing.T) { + m := New() + m.AddFunc("text/html", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + _, err := io.Copy(w, r) + return err + }) + + b := &bytes.Buffer{} + w := &responseWriter{b, http.Header{}} + r := &http.Request{RequestURI: "/index.html"} + m.Middleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + _, _ = w.Write([]byte("test")) + })).ServeHTTP(w, r) + test.String(t, b.String(), "test", "equal input after dummy minify middleware") +} + +func TestHelperProcess(*testing.T) { + if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" { + return + } + args := os.Args + for len(args) > 0 { + if args[0] == "--" { + args = args[1:] + break + } + args = args[1:] + } + if len(args) == 0 { + fmt.Fprintf(os.Stderr, "No command\n") + os.Exit(2) + } + + switch args[0] { + case "dummy/copy": + io.Copy(os.Stdout, os.Stdin) + case "dummy/err": + os.Exit(1) + default: + os.Exit(2) + } + os.Exit(0) +} + +//////////////////////////////////////////////////////////////// + +func ExampleM_Minify_custom() { + m := New() + m.AddFunc("text/plain", func(m *M, w io.Writer, r io.Reader, _ map[string]string) error { + // remove all newlines and spaces + rb := bufio.NewReader(r) + for { + line, err := rb.ReadString('\n') + if err != nil && err != io.EOF { + return err + } + if _, errws := io.WriteString(w, strings.Replace(line, " ", "", -1)); errws != nil { + return errws + } + if err == io.EOF { + break + } + } + return nil + }) + + in := "Because my coffee was too cold, I heated it in the microwave." + out, err := m.String("text/plain", in) + if err != nil { + panic(err) + } + fmt.Println(out) + // Output: Becausemycoffeewastoocold,Iheateditinthemicrowave. +} + +func ExampleM_Reader() { + b := bytes.NewReader([]byte("input")) + + m := New() + // add minfiers + + r := m.Reader("mime/type", b) + if _, err := io.Copy(os.Stdout, r); err != nil { + if _, err := io.Copy(os.Stdout, b); err != nil { + panic(err) + } + } +} + +func ExampleM_Writer() { + m := New() + // add minfiers + + w := m.Writer("mime/type", os.Stdout) + if _, err := w.Write([]byte("input")); err != nil { + panic(err) + } + if err := w.Close(); err != nil { + panic(err) + } +} |