merge from latest master

app/main.go

@@ -40,6 +40,7 @@ type Opts struct {
 	BackupLocation string     `long:"backup" env:"BACKUP_PATH" default:"./var/backup" description:"backups location"`
 	MaxBackupFiles int        `long:"max-back" env:"MAX_BACKUP_FILES" default:"10" description:"max backups to keep"`
 	AvatarStore    string     `long:"avatars" env:"AVATAR_STORE" default:"./var/avatars" description:"avatars location"`
+	AvatarRszLmt   int        `long:"avatars-rsz-lmt" env:"AVATAR_RSZ_LMT" default:"0" description:"max image size for resizing avatars on save"`
 	ImageProxy     bool       `long:"img-proxy" env:"IMG_PROXY" description:"enable image proxy"`
 	MaxCommentSize int        `long:"max-comment" env:"MAX_COMMENT_SIZE" default:"2048" description:"max comment size"`
 	MaxCachedItems int        `long:"max-cache-items" env:"MAX_CACHE_ITEMS" default:"1000" description:"max cached items"`
@@ -148,7 +149,7 @@ func New(opts Opts) (*Application, error) {
 	jwtService := auth.NewJWT(opts.SecretKey, strings.HasPrefix(opts.RemarkURL, "https://"), 7*24*time.Hour)
 
 	avatarProxy := &proxy.Avatar{
-		Store:     proxy.NewFSAvatarStore(opts.AvatarStore),
+		Store:     proxy.NewFSAvatarStore(opts.AvatarStore, opts.AvatarRszLmt),
 		RoutePath: "/api/v1/avatar",
 		RemarkURL: strings.TrimSuffix(opts.RemarkURL, "/"),
 	}

app/rest/api/admin.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"compress/gzip"
+	"errors"
 	"fmt"
 	"io"
 	"log"
@@ -25,6 +26,7 @@ type admin struct {
 	exporter      migrator.Exporter
 	cache         cache.LoadingCache
 	authenticator auth.Authenticator
+	readOnlyAge   int
 }
 
 func (a *admin) routes(middlewares ...func(http.Handler) http.Handler) chi.Router {
@@ -128,6 +130,19 @@ func (a *admin) setReadOnlyCtrl(w http.ResponseWriter, r *http.Request) {
 	locator := store.Locator{SiteID: r.URL.Query().Get("site"), URL: r.URL.Query().Get("url")}
 	roStatus := r.URL.Query().Get("ro") == "1"
 
+	isRoByAge := func(info store.PostInfo) bool {
+		return a.readOnlyAge > 0 && !info.FirstTS.IsZero() &&
+			info.FirstTS.AddDate(0, 0, a.readOnlyAge).Before(time.Now())
+	}
+
+	// don't allow to reset ro for posts turned to ro by ReadOnlyAge
+	if !roStatus {
+		if info, e := a.dataService.Info(locator, a.readOnlyAge); e == nil && isRoByAge(info) {
+			rest.SendErrorJSON(w, r, http.StatusForbidden, errors.New("rejected"), "read-only due the age")
+			return
+		}
+	}
+
 	if err := a.dataService.SetReadOnly(locator, roStatus); err != nil {
 		rest.SendErrorJSON(w, r, http.StatusBadRequest, err, "can't set readonly status")
 		return

app/rest/api/admin_test.go

@@ -79,27 +79,27 @@ func TestAdmin_DeleteUser(t *testing.T) {
 	// all 3 comments here, but for id2 they deleted
 	res, code := get(t, ts.URL+"/api/v1/find?site=radio-t&url=https://radio-t.com/blah&sort=+time")
 	assert.Equal(t, 200, code)
-	comments := []store.Comment{}
-	err = json.Unmarshal([]byte(res), &comments)
+	commentsWithInfo := commentsWithInfo{}
+	err = json.Unmarshal([]byte(res), &commentsWithInfo)
 	assert.Nil(t, err)
-	assert.Equal(t, 3, len(comments), "should have 3 comment")
+	assert.Equal(t, 3, len(commentsWithInfo.Comments), "should have 3 comment")
 
 	// id1 comment untouched
-	assert.Equal(t, id1, comments[0].ID)
-	assert.Equal(t, "o test test #1", comments[0].Orig)
-	assert.False(t, comments[0].Deleted)
-	t.Logf("%+v", comments[0].User)
+	assert.Equal(t, id1, commentsWithInfo.Comments[0].ID)
+	assert.Equal(t, "o test test #1", commentsWithInfo.Comments[0].Orig)
+	assert.False(t, commentsWithInfo.Comments[0].Deleted)
+	t.Logf("%+v", commentsWithInfo.Comments[0].User)
 
 	// id2 comments fully deleted
-	assert.Equal(t, "", comments[1].Text)
-	assert.Equal(t, "", comments[1].Orig)
-	assert.Equal(t, store.User{Name: "deleted", ID: "deleted", Picture: "", Admin: false, Blocked: false, IP: ""}, comments[1].User)
-	assert.True(t, comments[1].Deleted)
+	assert.Equal(t, "", commentsWithInfo.Comments[1].Text)
+	assert.Equal(t, "", commentsWithInfo.Comments[1].Orig)
+	assert.Equal(t, store.User{Name: "deleted", ID: "deleted", Picture: "", Admin: false, Blocked: false, IP: ""}, commentsWithInfo.Comments[1].User)
+	assert.True(t, commentsWithInfo.Comments[1].Deleted)
 
-	assert.Equal(t, "", comments[2].Text)
-	assert.Equal(t, "", comments[2].Orig)
-	assert.Equal(t, store.User{Name: "deleted", ID: "deleted", Picture: "", Admin: false, Blocked: false, IP: ""}, comments[1].User)
-	assert.True(t, comments[2].Deleted)
+	assert.Equal(t, "", commentsWithInfo.Comments[2].Text)
+	assert.Equal(t, "", commentsWithInfo.Comments[2].Orig)
+	assert.Equal(t, store.User{Name: "deleted", ID: "deleted", Picture: "", Admin: false, Blocked: false, IP: ""}, commentsWithInfo.Comments[1].User)
+	assert.True(t, commentsWithInfo.Comments[2].Deleted)
 }
 
 func TestAdmin_Pin(t *testing.T) {
@@ -186,12 +186,12 @@ func TestAdmin_Block(t *testing.T) {
 
 	res, code := get(t, ts.URL+"/api/v1/find?site=radio-t&url=https://radio-t.com/blah&sort=+time")
 	assert.Equal(t, 200, code)
-	comments := []store.Comment{}
+	comments := commentsWithInfo{}
 	err = json.Unmarshal([]byte(res), &comments)
 	assert.Nil(t, err)
-	assert.Equal(t, 2, len(comments), "should have 2 comments")
-	assert.Equal(t, "", comments[0].Text)
-	assert.True(t, comments[0].Deleted)
+	assert.Equal(t, 2, len(comments.Comments), "should have 2 comments")
+	assert.Equal(t, "", comments.Comments[0].Text)
+	assert.True(t, comments.Comments[0].Deleted)
 
 	code, body = block(-1)
 	require.Equal(t, 200, code)
@@ -259,8 +259,9 @@ func TestAdmin_ReadOnly(t *testing.T) {
 		fmt.Sprintf("%s/api/v1/admin/readonly?site=radio-t&url=https://radio-t.com/blah&ro=1", ts.URL), nil)
 	assert.Nil(t, err)
 	req.SetBasicAuth("dev", "password")
-	_, err = client.Do(req)
+	resp, err := client.Do(req)
 	require.Nil(t, err)
+	assert.Equal(t, 200, resp.StatusCode)
 	info, err = srv.DataService.Info(store.Locator{SiteID: "radio-t", URL: "https://radio-t.com/blah"}, 0)
 	assert.Nil(t, err)
 	assert.True(t, info.ReadOnly)
@@ -270,13 +271,56 @@ func TestAdmin_ReadOnly(t *testing.T) {
 		fmt.Sprintf("%s/api/v1/admin/readonly?site=radio-t&url=https://radio-t.com/blah&ro=0", ts.URL), nil)
 	assert.Nil(t, err)
 	req.SetBasicAuth("dev", "password")
-	_, err = client.Do(req)
+	resp, err = client.Do(req)
+	assert.Equal(t, 200, resp.StatusCode)
 	require.Nil(t, err)
 	info, err = srv.DataService.Info(store.Locator{SiteID: "radio-t", URL: "https://radio-t.com/blah"}, 0)
 	assert.Nil(t, err)
 	assert.False(t, info.ReadOnly)
 }
 
+func TestAdmin_ReadOnlyWithAge(t *testing.T) {
+	srv, ts := prep(t)
+	assert.NotNil(t, srv)
+	defer cleanup(ts)
+
+	c1 := store.Comment{Text: "test test #1", Locator: store.Locator{SiteID: "radio-t",
+		URL: "https://radio-t.com/blah"}, User: store.User{Name: "user1 name", ID: "user1"},
+		Timestamp: time.Date(2001, 1, 1, 1, 1, 1, 0, time.Local)}
+	_, err := srv.DataService.Create(c1)
+	assert.Nil(t, err)
+
+	info, err := srv.DataService.Info(store.Locator{SiteID: "radio-t", URL: "https://radio-t.com/blah"}, 10)
+	assert.Nil(t, err)
+	assert.True(t, info.ReadOnly, "ro by age")
+
+	client := http.Client{}
+
+	// set post to read-only
+	req, err := http.NewRequest(http.MethodPut,
+		fmt.Sprintf("%s/api/v1/admin/readonly?site=radio-t&url=https://radio-t.com/blah&ro=1", ts.URL), nil)
+	assert.Nil(t, err)
+	req.SetBasicAuth("dev", "password")
+	resp, err := client.Do(req)
+	require.Nil(t, err)
+	assert.Equal(t, 200, resp.StatusCode)
+	info, err = srv.DataService.Info(store.Locator{SiteID: "radio-t", URL: "https://radio-t.com/blah"}, 0)
+	assert.Nil(t, err)
+	assert.True(t, info.ReadOnly)
+
+	// reset post's read-only
+	req, err = http.NewRequest(http.MethodPut,
+		fmt.Sprintf("%s/api/v1/admin/readonly?site=radio-t&url=https://radio-t.com/blah&ro=0", ts.URL), nil)
+	assert.Nil(t, err)
+	req.SetBasicAuth("dev", "password")
+	resp, err = client.Do(req)
+	assert.Equal(t, 403, resp.StatusCode)
+	require.Nil(t, err)
+	info, err = srv.DataService.Info(store.Locator{SiteID: "radio-t", URL: "https://radio-t.com/blah"}, 0)
+	assert.Nil(t, err)
+	assert.True(t, info.ReadOnly)
+
+}
 func TestAdmin_Verify(t *testing.T) {
 	srv, ts := prep(t)
 	assert.NotNil(t, srv)
@@ -307,12 +351,12 @@ func TestAdmin_Verify(t *testing.T) {
 
 	res, code := get(t, ts.URL+"/api/v1/find?site=radio-t&url=https://radio-t.com/blah&sort=+time")
 	assert.Equal(t, 200, code)
-	comments := []store.Comment{}
+	comments := commentsWithInfo{}
 	err = json.Unmarshal([]byte(res), &comments)
 	assert.Nil(t, err)
-	assert.Equal(t, 2, len(comments), "should have 2 comments")
-	assert.Equal(t, "test test #1", comments[0].Text)
-	assert.True(t, comments[0].User.Verified)
+	assert.Equal(t, 2, len(comments.Comments), "should have 2 comments")
+	assert.Equal(t, "test test #1", comments.Comments[0].Text)
+	assert.True(t, comments.Comments[0].User.Verified)
 
 	req, err = http.NewRequest(http.MethodPut,
 		fmt.Sprintf("%s/api/v1/admin/verify/user1?site=radio-t&verified=0", ts.URL), nil)
@@ -325,12 +369,12 @@ func TestAdmin_Verify(t *testing.T) {
 
 	res, code = get(t, ts.URL+"/api/v1/find?site=radio-t&url=https://radio-t.com/blah&sort=+time")
 	assert.Equal(t, 200, code)
-	comments = []store.Comment{}
+	comments = commentsWithInfo{}
 	err = json.Unmarshal([]byte(res), &comments)
 	assert.Nil(t, err)
-	assert.Equal(t, 2, len(comments), "should have 2 comments")
-	assert.Equal(t, "test test #1", comments[0].Text)
-	assert.False(t, comments[0].User.Verified)
+	assert.Equal(t, 2, len(comments.Comments), "should have 2 comments")
+	assert.Equal(t, "test test #1", comments.Comments[0].Text)
+	assert.False(t, comments.Comments[0].User.Verified)
 
 }
 

app/rest/api/rest.go

@@ -57,6 +57,11 @@ var mdExt = blackfriday.NoIntraEmphasis | blackfriday.Tables | blackfriday.Fence
 	blackfriday.Strikethrough | blackfriday.SpaceHeadings | blackfriday.HardLineBreak |
 	blackfriday.BackslashLineBreak | blackfriday.Autolink
 
+type commentsWithInfo struct {
+	Comments []store.Comment `json:"comments"`
+	Info     store.PostInfo  `json:"info,omitempty"`
+}
+
 // Run the lister and request's router, activate rest server
 func (s *Rest) Run(port int) {
 	log.Printf("[INFO] activate rest server on port %d", port)
@@ -105,6 +110,7 @@ func (s *Rest) routes() chi.Router {
 		exporter:      s.Exporter,
 		cache:         s.Cache,
 		authenticator: s.Authenticator,
+		readOnlyAge:   s.ReadOnlyAge,
 	}
 
 	ipFn := func(ip string) string { return store.HashValue(ip, s.DataService.Secret)[:12] } // logger uses it for anonymization

app/rest/api/rest_public.go

@@ -42,7 +42,11 @@ func (s *Rest) findCommentsCtrl(w http.ResponseWriter, r *http.Request) {
 			}
 			b, e = encodeJSONWithHTML(tree)
 		default:
-			b, e = encodeJSONWithHTML(maskedComments)
+			withInfo := commentsWithInfo{Comments: maskedComments}
+			if info, ee := s.DataService.Info(locator, s.ReadOnlyAge); ee == nil {
+				withInfo.Info = info
+			}
+			b, e = encodeJSONWithHTML(withInfo)
 		}
 		return b, e
 	})

app/rest/api/rest_public_test.go

@@ -88,21 +88,25 @@ func TestRest_Find(t *testing.T) {
 	// get sorted by +time
 	res, code := get(t, ts.URL+"/api/v1/find?site=radio-t&url=https://radio-t.com/blah1&sort=+time")
 	assert.Equal(t, 200, code)
-	comments := []store.Comment{}
+	comments := commentsWithInfo{}
 	err := json.Unmarshal([]byte(res), &comments)
 	assert.Nil(t, err)
-	assert.Equal(t, 2, len(comments), "should have 2 comments")
-	assert.Equal(t, id1, comments[0].ID)
-	assert.Equal(t, id2, comments[1].ID)
+	assert.Equal(t, 2, len(comments.Comments), "should have 2 comments")
+	assert.Equal(t, id1, comments.Comments[0].ID)
+	assert.Equal(t, id2, comments.Comments[1].ID)
+	assert.Equal(t, "https://radio-t.com/blah1", comments.Info.URL)
+	assert.Equal(t, 2, comments.Info.Count)
+	assert.Equal(t, false, comments.Info.ReadOnly)
+	assert.True(t, comments.Info.FirstTS.Before(comments.Info.LastTS))
 
 	// get sorted by -time
 	res, code = get(t, ts.URL+"/api/v1/find?site=radio-t&url=https://radio-t.com/blah1&sort=-time")
 	assert.Equal(t, 200, code)
 	err = json.Unmarshal([]byte(res), &comments)
 	assert.Nil(t, err)
-	assert.Equal(t, 2, len(comments), "should have 2 comments")
-	assert.Equal(t, id1, comments[1].ID)
-	assert.Equal(t, id2, comments[0].ID)
+	assert.Equal(t, 2, len(comments.Comments), "should have 2 comments")
+	assert.Equal(t, id1, comments.Comments[1].ID)
+	assert.Equal(t, id2, comments.Comments[0].ID)
 
 	// get in tree mode
 	tree := rest.Tree{}

app/rest/api/rest_test.go

@@ -37,7 +37,7 @@ func TestRest_FileServer(t *testing.T) {
 }
 
 func TestRest_Shutdown(t *testing.T) {
-	srv := Rest{Authenticator: auth.Authenticator{}, AvatarProxy: &proxy.Avatar{Store: proxy.NewFSAvatarStore("/tmp"),
+	srv := Rest{Authenticator: auth.Authenticator{}, AvatarProxy: &proxy.Avatar{Store: proxy.NewFSAvatarStore("/tmp", 300),
 		RoutePath: "/api/v1/avatar"}, ImageProxy: &proxy.Image{}}
 
 	go func() {
@@ -67,7 +67,7 @@ func prep(t *testing.T) (srv *Rest, ts *httptest.Server) {
 		Cache:       &mockCache{},
 		WebRoot:     "/tmp",
 		RemarkURL:   "https://demo.remark42.com",
-		AvatarProxy: &proxy.Avatar{Store: proxy.NewFSAvatarStore("/tmp"), RoutePath: "/api/v1/avatar"},
+		AvatarProxy: &proxy.Avatar{Store: proxy.NewFSAvatarStore("/tmp", 300), RoutePath: "/api/v1/avatar"},
 		ImageProxy:  &proxy.Image{},
 		ReadOnlyAge: 10,
 	}

app/rest/proxy/avatar_store.go

@@ -1,8 +1,11 @@
 package proxy
 
 import (
+	"bytes"
 	"fmt"
 	"hash/crc64"
+	"image"
+	"image/png"
 	"io"
 	"log"
 	"os"
@@ -10,7 +13,12 @@ import (
 	"strings"
 	"sync"
 
+	// Initializing packages for supporting GIF and JPEG formats.
+	_ "image/gif"
+	_ "image/jpeg"
+
 	"github.com/pkg/errors"
+	"golang.org/x/image/draw"
 
 	"github.com/umputun/remark/app/store"
 )
@@ -23,19 +31,19 @@ type AvatarStore interface {
 
 // FSAvatarStore implements AvatarStore for local file system
 type FSAvatarStore struct {
-	storePath string
-	ctcTable  *crc64.Table
-	once      sync.Once
+	storePath   string
+	resizeLimit int
+	ctcTable    *crc64.Table
+	once        sync.Once
 }
 
 // NewFSAvatarStore makes file-system avatar store
-func NewFSAvatarStore(storePath string) *FSAvatarStore {
-	return &FSAvatarStore{storePath: storePath}
+func NewFSAvatarStore(storePath string, resizeLimit int) *FSAvatarStore {
+	return &FSAvatarStore{storePath: storePath, resizeLimit: resizeLimit}
 }
 
 // Put avatar for userID to file and return avatar's file name (base), like 12345678.image
 func (fs *FSAvatarStore) Put(userID string, reader io.Reader) (avatar string, err error) {
-
 	id := store.EncodeID(userID)
 	location := fs.location(id) // location adds partition to path
 
@@ -56,6 +64,11 @@ func (fs *FSAvatarStore) Put(userID string, reader io.Reader) (avatar string, er
 		}
 	}()
 
+	// Trying to resize avatar.
+	if reader = resize(reader, fs.resizeLimit); reader == nil {
+		return "", errors.New("avatar reader is nil")
+	}
+
 	if _, err = io.Copy(fh, reader); err != nil {
 		return "", errors.Wrapf(err, "can't save file %s", avFile)
 	}
@@ -85,3 +98,46 @@ func (fs *FSAvatarStore) location(id string) string {
 	partition := checksum64 % 100
 	return path.Join(fs.storePath, fmt.Sprintf("%02d", partition))
 }
+
+// Resizes an image of supported format (PNG, JPG, GIF) to the size of "limit" px of the biggest side
+// (width or height) preserving aspect ratio.
+// Returns original reader if resizing is not needed or failed.
+func resize(reader io.Reader, limit int) io.Reader {
+	if reader == nil {
+		log.Print("[WARN] avatar resize(): reader is nil")
+		return nil
+	}
+	if limit <= 0 {
+		log.Print("[DEBUG] avatar resize(): limit should be greater than 0")
+		return reader
+	}
+
+	var teeBuf bytes.Buffer
+	tee := io.TeeReader(reader, &teeBuf)
+	src, _, err := image.Decode(tee)
+	if err != nil {
+		log.Printf("[WARN] avatar resize(): can't decode avatar image, %s", err)
+		return &teeBuf
+	}
+
+	bounds := src.Bounds()
+	w, h := bounds.Dx(), bounds.Dy()
+	if w <= limit && h <= limit || w <= 0 || h <= 0 {
+		log.Print("[DEBUG] resizing image is smaller that the limit or has 0 size")
+		return &teeBuf
+	}
+	newW, newH := w*limit/h, limit
+	if w > h {
+		newW, newH = limit, h*limit/w
+	}
+	m := image.NewRGBA(image.Rect(0, 0, newW, newH))
+	// Slower than `draw.ApproxBiLinear.Scale()` but better quality.
+	draw.BiLinear.Scale(m, m.Bounds(), src, src.Bounds(), draw.Src, nil)
+
+	var out bytes.Buffer
+	if err = png.Encode(&out, m); err != nil {
+		log.Printf("[WARN] avatar resize(): can't encode resized avatar to PNG, %s", err)
+		return &teeBuf
+	}
+	return &out
+}

app/rest/proxy/avatar_store_test.go

@@ -1,6 +1,9 @@
 package proxy
 
 import (
+	"bytes"
+	"image"
+	"io"
 	"io/ioutil"
 	"os"
 	"strings"
@@ -11,11 +14,15 @@ import (
 )
 
 func TestAvatarStore_Put(t *testing.T) {
-	p := NewFSAvatarStore("/tmp/avatars.test")
+	p := NewFSAvatarStore("/tmp/avatars.test", 300)
 	os.MkdirAll("/tmp/avatars.test", 0700)
 	defer os.RemoveAll("/tmp/avatars.test")
 
-	avatar, err := p.Put("user1", strings.NewReader("some picture bin data"))
+	avatar, err := p.Put("user1", nil)
+	assert.Equal(t, "", avatar)
+	assert.EqualError(t, err, "avatar reader is nil")
+
+	avatar, err = p.Put("user1", strings.NewReader("some picture bin data"))
 	require.Nil(t, err)
 	assert.Equal(t, "b3daa77b4c04a9551b8781d03191fe098f325e67.image", avatar)
 	fi, err := os.Stat("/tmp/avatars.test/30/b3daa77b4c04a9551b8781d03191fe098f325e67.image")
@@ -29,13 +36,23 @@ func TestAvatarStore_Put(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, int64(25), fi.Size())
 
-	p = NewFSAvatarStore("/dev/null")
+	// with resize
+	file, e := os.Open("testdata/circles.png")
+	require.Nil(t, e)
+	avatar, err = p.Put("user3", file)
+	require.Nil(t, err)
+	assert.Equal(t, "0b7f849446d3383546d15a480966084442cd2193.image", avatar)
+	fi, err = os.Stat("/tmp/avatars.test/60/0b7f849446d3383546d15a480966084442cd2193.image")
+	assert.NoError(t, err)
+	assert.Equal(t, int64(6986), fi.Size())
+
+	p = NewFSAvatarStore("/dev/null", 300)
 	_, err = p.Put("user1", strings.NewReader("some picture bin data"))
 	assert.EqualError(t, err, "can't create file /dev/null/30/b3daa77b4c04a9551b8781d03191fe098f325e67.image: open /dev/null/30/b3daa77b4c04a9551b8781d03191fe098f325e67.image: not a directory")
 }
 
 func TestAvatarStore_Get(t *testing.T) {
-	p := NewFSAvatarStore("/tmp/avatars.test")
+	p := NewFSAvatarStore("/tmp/avatars.test", 300)
 	os.MkdirAll("/tmp/avatars.test/30", 0700)
 	defer os.RemoveAll("/tmp/avatars.test")
 	ioutil.WriteFile("/tmp/avatars.test/30/b3daa77b4c04a9551b8781d03191fe098f325e67.image", []byte("something"), 0666)
@@ -48,7 +65,7 @@ func TestAvatarStore_Get(t *testing.T) {
 }
 
 func TestAvatarStore_Location(t *testing.T) {
-	p := NewFSAvatarStore("/tmp/avatars.test")
+	p := NewFSAvatarStore("/tmp/avatars.test", 300)
 
 	tbl := []struct {
 		id  string
@@ -63,3 +80,55 @@ func TestAvatarStore_Location(t *testing.T) {
 		assert.Equal(t, tt.res, p.location(tt.id), "test #%d", i)
 	}
 }
+
+func TestAvatarStore_resize(t *testing.T) {
+	checkC := func(t *testing.T, r io.Reader, cExp []byte) {
+		content, err := ioutil.ReadAll(r)
+		require.NoError(t, err)
+		assert.Equal(t, cExp, content)
+	}
+
+	// Reader is nil.
+	resizedR := resize(nil, 100)
+	// assert.EqualError(t, err, "limit should be greater than 0")
+	assert.Nil(t, resizedR)
+
+	// Negative limit error.
+	resizedR = resize(strings.NewReader("some picture bin data"), -1)
+	require.NotNil(t, resizedR)
+	checkC(t, resizedR, []byte("some picture bin data"))
+
+	// Decode error.
+	resizedR = resize(strings.NewReader("invalid image content"), 100)
+	assert.NotNil(t, resizedR)
+	checkC(t, resizedR, []byte("invalid image content"))
+
+	cases := []struct {
+		file   string
+		wr, hr int
+	}{
+		{"testdata/circles.png", 400, 300}, // full size: 800x600 px
+		{"testdata/circles.jpg", 300, 400}, // full size: 600x800 px
+	}
+
+	for _, c := range cases {
+		img, err := ioutil.ReadFile(c.file)
+		require.Nil(t, err, "can't open test file %s", c.file)
+
+		// No need for resize, avatar dimentions are smaller than resize limit.
+		resizedR = resize(bytes.NewReader(img), 800)
+		assert.NotNilf(t, resizedR, "file %s", c.file)
+		checkC(t, resizedR, img)
+
+		// Resizing to half of width. Check resizedR avatar format PNG.
+		resizedR = resize(bytes.NewReader(img), 400)
+		assert.NotNilf(t, resizedR, "file %s", c.file)
+
+		imgRz, format, err := image.Decode(resizedR)
+		assert.Nilf(t, err, "file %s", c.file)
+		assert.Equalf(t, "png", format, "file %s", c.file)
+		bounds := imgRz.Bounds()
+		assert.Equalf(t, c.wr, bounds.Dx(), "file %s", c.file)
+		assert.Equalf(t, c.hr, bounds.Dy(), "file %s", c.file)
+	}
+}

app/rest/proxy/avatar_test.go

@@ -30,7 +30,7 @@ func TestAvatar_Put(t *testing.T) {
 	}))
 	defer ts.Close()
 
-	p := Avatar{RoutePath: "/avatar", RemarkURL: "http://localhost:8080", Store: NewFSAvatarStore("/tmp/avatars.test")}
+	p := Avatar{RoutePath: "/avatar", RemarkURL: "http://localhost:8080", Store: NewFSAvatarStore("/tmp/avatars.test", 300)}
 	os.MkdirAll("/tmp/avatars.test", 0700)
 	defer os.RemoveAll("/tmp/avatars.test")
 
@@ -59,7 +59,7 @@ func TestAvatar_PutFailed(t *testing.T) {
 	}))
 	defer ts.Close()
 
-	p := Avatar{RoutePath: "/avatar", Store: NewFSAvatarStore("/tmp/avatars.test")}
+	p := Avatar{RoutePath: "/avatar", Store: NewFSAvatarStore("/tmp/avatars.test", 300)}
 
 	u := store.User{ID: "user1", Name: "user1 name"}
 	_, err := p.Put(u)
@@ -89,7 +89,7 @@ func TestAvatar_Routes(t *testing.T) {
 	}))
 	defer ts.Close()
 
-	p := Avatar{RoutePath: "/avatar", Store: NewFSAvatarStore("/tmp/avatars.test")}
+	p := Avatar{RoutePath: "/avatar", Store: NewFSAvatarStore("/tmp/avatars.test", 300)}
 	os.MkdirAll("/tmp/avatars.test", 0700)
 	defer os.RemoveAll("/tmp/avatars.test")