func TestAdd(t *testing.T) { mAdd := New() r := bytes.NewBufferString("test") w := &bytes.Buffer{} mAdd.Add("dummy/err", &DummyMinifier{}) test.Error(t, mAdd.Minify("dummy/err", nil, nil), errDummy) mAdd.AddRegexp(regexp.MustCompile("err1$"), &DummyMinifier{}) test.Error(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.Error(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.Error(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.Error(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 TestAppendFloat(t *testing.T) { floatTests := []struct { f float64 prec int expected string }{ {0, 6, "0"}, {1, 6, "1"}, {9, 6, "9"}, {9.99999, 6, "9.99999"}, {123, 6, "123"}, {0.123456, 6, ".123456"}, {0.066, 6, ".066"}, {0.0066, 6, ".0066"}, {12e2, 6, "1200"}, {12e3, 6, "12e3"}, {0.1, 6, ".1"}, {0.001, 6, ".001"}, {0.0001, 6, "1e-4"}, {-1, 6, "-1"}, {-123, 6, "-123"}, {-123.456, 6, "-123.456"}, {-12e3, 6, "-12e3"}, {-0.1, 6, "-.1"}, {-0.0001, 6, "-1e-4"}, {0.000100009, 10, "100009e-9"}, {0.0001000009, 10, "1.000009e-4"}, {1e18, 0, "1e18"}, //{1e19, 0, "1e19"}, //{1e19, 18, "1e19"}, {1e1, 0, "10"}, {1e2, 1, "100"}, {1e3, 2, "1e3"}, {1e10, -1, "1e10"}, {1e15, -1, "1e15"}, {1e-5, 6, "1e-5"}, {math.NaN(), 0, ""}, {math.Inf(1), 0, ""}, {math.Inf(-1), 0, ""}, {0, 19, ""}, {.000923361977200859392, -1, "9.23361977200859392e-4"}, } for _, tt := range floatTests { f, _ := AppendFloat([]byte{}, tt.f, tt.prec) test.String(t, string(f), tt.expected, "for", tt.f) } b := make([]byte, 0, 22) AppendFloat(b, 12.34, -1) test.String(t, string(b[:5]), "12.34", "in buffer") }
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 }) var err error w := &bytes.Buffer{} mw := m.Writer("dummy/dummy", w) _, err = mw.Write([]byte("test")) test.Error(t, err, nil) test.Error(t, mw.Close(), nil) test.String(t, w.String(), "test", "equal input after dummy minify writer") mw = m.Writer("dummy/err", w) _, err = mw.Write([]byte("test")) test.Error(t, err, errDummy) test.Error(t, mw.Close(), errDummy) mw = m.Writer("dummy/late-err", w) _, err = mw.Write([]byte("test")) test.Error(t, err, nil) test.Error(t, mw.Close(), errDummy) }
func TestDataURI(t *testing.T) { dataURITests := []struct { dataURI string expected string }{ {"data:,text", "data:,text"}, {"data:text/plain;charset=us-ascii,text", "data:,text"}, {"data:TEXT/PLAIN;CHARSET=US-ASCII,text", "data:,text"}, {"data:text/plain;charset=us-asciiz,text", "data:;charset=us-asciiz,text"}, {"data:;base64,dGV4dA==", "data:,text"}, {"data:text/svg+xml;base64,PT09PT09", "data:text/svg+xml;base64,PT09PT09"}, {"data:text/xml;version=2.0,content", "data:text/xml;version=2.0,content"}, {"data:text/xml; version = 2.0,content", "data:text/xml;version=2.0,content"}, {"data:,=====", "data:,%3D%3D%3D%3D%3D"}, {"data:,======", "data:;base64,PT09PT09"}, {"data:text/x,<?x?>", "data:text/x,%3C%3Fx%3F%3E"}, } m := New() m.AddFunc("text/x", func(_ *M, w io.Writer, r io.Reader, _ map[string]string) error { b, _ := ioutil.ReadAll(r) test.String(t, string(b), "<?x?>") w.Write(b) return nil }) for _, tt := range dataURITests { test.Minify(t, tt.dataURI, nil, string(DataURI(m, []byte(tt.dataURI))), tt.expected) } }
func TestMinify(t *testing.T) { test.Error(t, m.Minify("?", nil, nil), ErrNotExist, "minifier doesn't exist") test.Error(t, m.Minify("dummy/nil", nil, nil), nil) test.Error(t, m.Minify("dummy/err", nil, nil), errDummy) b := []byte("test") out, err := m.Bytes("dummy/nil", b) test.Error(t, err, nil) test.Bytes(t, out, []byte{}, "dummy/nil returns empty byte slice") out, err = m.Bytes("?", b) test.Error(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.Error(t, err, nil) test.String(t, out2, "", "dummy/nil returns empty string") out2, err = m.String("?", s) test.Error(t, err, ErrNotExist, "minifier doesn't exist") test.String(t, out2, s, "return input when minifier doesn't exist") }
func TestSpecialTagClosing(t *testing.T) { m := minify.New() m.AddFunc("text/html", Minify) m.AddFunc("text/css", func(_ *minify.M, w io.Writer, r io.Reader, _ map[string]string) error { b, err := ioutil.ReadAll(r) test.Error(t, err, nil) test.String(t, string(b), "</script>") _, err = w.Write(b) return err }) html := `<style></script></style>` r := bytes.NewBufferString(html) w := &bytes.Buffer{} test.Minify(t, html, Minify(m, w, r, nil), w.String(), html) }
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, nil) test.String(t, w.String(), "test", "equal input after dummy minify reader") mr = m.Reader("dummy/err", r) _, err = io.Copy(w, mr) test.Error(t, err, errDummy) }