mirror of
https://github.com/miniflux/v2.git
synced 2025-08-01 17:38:37 +00:00
First commit
This commit is contained in:
Frédéric Guillot
commit
8ffb773f43
2121 changed files with 1118910 additions and 0 deletions
358
vendor/github.com/tdewolff/minify/minify_test.go
generated
vendored
Normal file
358
vendor/github.com/tdewolff/minify/minify_test.go
generated
vendored
Normal file
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue