Sprint 7, increment 16

.github/workflows/mertricstest.yml

@@ -18,7 +18,7 @@ jobs:
 
   metricstest:
     runs-on: ubuntu-latest
-    container: golang:1.20
+    container: golang:1.21
     needs: branchtest
 
     services:
@@ -38,10 +38,10 @@ jobs:
         uses: actions/checkout@v2
 
       - name: Download autotests binaries
-        uses: robinraju/release-downloader@v1.7
+        uses: robinraju/release-downloader@v1.8
         with:
           repository: Yandex-Practicum/go-autotests
-          tag: refactor
+          latest: true
           fileName: "*"
           out-file-path: .tools
           token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/statictest.yml

@@ -9,16 +9,16 @@ on:
 jobs:
   statictest:
     runs-on: ubuntu-latest
-    container: golang:1.20
+    container: golang:1.21
     steps:
       - name: Checkout code
         uses: actions/checkout@v2
 
       - name: Download statictest binary
-        uses: robinraju/release-downloader@v1.7
+        uses: robinraju/release-downloader@v1.8
         with:
           repository: Yandex-Practicum/go-autotests
-          tag: refactor
+          latest: true
           fileName: statictest
           out-file-path: .tools
           token: ${{ secrets.GITHUB_TOKEN }}

go.mod

@@ -11,7 +11,6 @@ require (
 	github.com/shirou/gopsutil/v3 v3.23.8
 	github.com/sirupsen/logrus v1.9.3
 	github.com/stretchr/testify v1.8.4
-	golang.org/x/exp v0.0.0-20230817173708-d852ddb80c63
 )
 
 require (
@@ -24,6 +23,7 @@ require (
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
 	github.com/rogpeppe/go-internal v1.11.0 // indirect
+	github.com/shoenig/go-m1cpu v0.1.6 // indirect
 	github.com/tklauser/go-sysconf v0.3.12 // indirect
 	github.com/tklauser/numcpus v0.6.1 // indirect
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect

go.sum

@@ -39,7 +39,9 @@ github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDN
 github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/shirou/gopsutil/v3 v3.23.8 h1:xnATPiybo6GgdRoC4YoGnxXZFRc3dqQTGi73oLvvBrE=
 github.com/shirou/gopsutil/v3 v3.23.8/go.mod h1:7hmCaBn+2ZwaZOr6jmPBZDfawwMGuo1id3C6aM8EDqQ=
+github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
 github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
+github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
 github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=

internal/infra/compression/middleware.go

@@ -19,13 +19,13 @@ func (w gzipWriter) Write(b []byte) (int, error) {
 
 func MiddlewareWriter(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// TODO: split string and check
+		// todo: split string and check
 		if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
 			next.ServeHTTP(w, r)
 			return
 		}
 
-		gz, err := gzip.NewWriterLevel(w, gzip.BestSpeed)
+		gz, err := gzip.NewWriterLevel(w, gzip.BestCompression)
 		if err != nil {
 			io.WriteString(w, err.Error())
 			return
@@ -39,7 +39,7 @@ func MiddlewareWriter(next http.Handler) http.Handler {
 
 func MiddlewareReader(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// TODO: split string and check
+		// todo: split string and check
 		if !strings.Contains(r.Header.Get("Content-Encoding"), "gzip") {
 			next.ServeHTTP(w, r)
 			return

internal/infra/config/agent/agent.go

@@ -15,6 +15,7 @@ const (
 	DefRetryAttempts        = 3
 	DefRetryIntervalInitial = 1 * time.Second
 	DefRetryIntervalBackoff = 2 * time.Second
+	DefRateLimit            = 1
 )
 
 type Config struct {
@@ -41,7 +42,7 @@ func InitConfig() (*Config, error) {
 	)
 	pollInterval := flag.Uint("p", DefPollInterval, "How often to query metrics, seconds")
 	hmacKey := flag.String("k", "", "HMAC key for integrity checks")
-	rateLimit := flag.Uint("l", 1, "Max number of active workers")
+	rateLimit := flag.Uint("l", DefRateLimit, "Max number of active workers")
 	flag.Parse()
 	if conf.Addr == "" {
 		conf.Addr = *addr

internal/infra/config/agent/agent_test.go

@@ -27,6 +27,7 @@ func TestInitConfig(t *testing.T) {
 				RetryAttempts:        DefRetryAttempts,
 				RetryIntervalBackoff: DefRetryIntervalBackoff,
 				RetryIntervalInitial: DefRetryIntervalInitial,
+				RateLimit:            DefRateLimit,
 			},
 		},
 		{
@@ -41,6 +42,7 @@ func TestInitConfig(t *testing.T) {
 				RetryAttempts:        DefRetryAttempts,
 				RetryIntervalBackoff: DefRetryIntervalBackoff,
 				RetryIntervalInitial: DefRetryIntervalInitial,
+				RateLimit:            DefRateLimit,
 			},
 		},
 		{
@@ -55,6 +57,7 @@ func TestInitConfig(t *testing.T) {
 				RetryAttempts:        DefRetryAttempts,
 				RetryIntervalBackoff: DefRetryIntervalBackoff,
 				RetryIntervalInitial: DefRetryIntervalInitial,
+				RateLimit:            DefRateLimit,
 			},
 		},
 		{
@@ -69,6 +72,7 @@ func TestInitConfig(t *testing.T) {
 				RetryAttempts:        DefRetryAttempts,
 				RetryIntervalBackoff: DefRetryIntervalBackoff,
 				RetryIntervalInitial: DefRetryIntervalInitial,
+				RateLimit:            DefRateLimit,
 			},
 		},
 	}

internal/infra/utils/retry_test.go

@@ -0,0 +1,112 @@
+package utils
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/matthiasBT/monitoring/internal/infra/logging"
+)
+
+var ErrSome = errors.New("some error")
+
+type UnreliableCallCounter struct {
+	called         int
+	stopFailuresAt int
+}
+
+func (cc *UnreliableCallCounter) do() (any, error) {
+	cc.called += 1
+	if cc.called == cc.stopFailuresAt {
+		time.Sleep(100 * time.Millisecond)
+		return 100500, nil
+	}
+	return nil, ErrSome
+}
+
+func TestRetrier_RetryChecked(t *testing.T) {
+	type args struct {
+		timeout    time.Duration
+		f          func() (any, error)
+		checkError func(error) bool
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    any
+		wantErr error
+	}{
+		{
+			name: "success_first_try",
+			args: args{
+				f:          func() (any, error) { return 100500, nil },
+				checkError: nil,
+			},
+			want:    100500,
+			wantErr: nil,
+		},
+		{
+			name: "success_second_try",
+			args: args{
+				f:          (&UnreliableCallCounter{stopFailuresAt: 2}).do,
+				checkError: func(err error) bool { return errors.Is(err, ErrSome) },
+			},
+			want:    100500,
+			wantErr: nil,
+		},
+		{
+			name: "failure_on_unchecked_error",
+			args: args{
+				f:          (&UnreliableCallCounter{stopFailuresAt: 2}).do,
+				checkError: func(err error) bool { return !errors.Is(err, ErrSome) },
+			},
+			want:    nil,
+			wantErr: ErrSome,
+		},
+		{
+			name: "number_of_attempts_exceeded",
+			args: args{
+				f:          (&UnreliableCallCounter{stopFailuresAt: 5}).do,
+				checkError: func(err error) bool { return errors.Is(err, ErrSome) },
+			},
+			want:    nil,
+			wantErr: ErrSome,
+		},
+		{
+			name: "timeout",
+			args: args{
+				f:          (&UnreliableCallCounter{stopFailuresAt: 5}).do,
+				checkError: func(err error) bool { return errors.Is(err, ErrSome) },
+				timeout:    1 * time.Millisecond,
+			},
+			want:    nil,
+			wantErr: ErrRetryAborted,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &Retrier{
+				Attempts:         2,
+				IntervalFirst:    100 * time.Millisecond,
+				IntervalIncrease: 100 * time.Millisecond,
+				Logger:           logging.SetupLogger(),
+			}
+			ctx := context.Background()
+			if tt.args.timeout != 0 {
+				ctxt, cancel := context.WithTimeout(ctx, tt.args.timeout)
+				ctx = ctxt
+				defer cancel()
+			}
+			got, err := r.RetryChecked(ctx, tt.args.f, tt.args.checkError)
+			if err != nil && !errors.Is(err, tt.wantErr) {
+				t.Errorf("RetryChecked() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("RetryChecked() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/server/adapters/filekeeper_test.go

@@ -0,0 +1,61 @@
+package adapters
+
+import (
+	"context"
+	"os"
+	"sync"
+	"testing"
+
+	common "github.com/matthiasBT/monitoring/internal/infra/entities"
+	"github.com/matthiasBT/monitoring/internal/infra/logging"
+)
+
+func TestFileKeeper_Flush(t *testing.T) {
+	tests := []struct {
+		name            string
+		storageSnapshot []*common.Metrics
+		wantErr         bool
+	}{
+		{
+			name: "flush_snapshot",
+			storageSnapshot: []*common.Metrics{
+				{
+					ID:    "BarFoo1",
+					MType: common.TypeGauge,
+					Delta: nil,
+					Value: ptrfloat64(44.1),
+				},
+				{
+					ID:    "BarFoo2",
+					MType: common.TypeGauge,
+					Delta: nil,
+					Value: ptrfloat64(55.5),
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			file, err := os.CreateTemp("", "example")
+			if err != nil {
+				t.Fatal("Failed to create a temporary file")
+			}
+			defer os.Remove(file.Name())
+			defer file.Close()
+			fs := &FileKeeper{
+				Logger: logging.SetupLogger(),
+				Path:   file.Name(),
+				Lock:   &sync.Mutex{},
+			}
+			if err := fs.Flush(context.Background(), tt.storageSnapshot); err != nil {
+				t.Errorf("Flush() error = %v", err)
+			}
+			restoredState := fs.Restore()
+			if len(restoredState) != len(tt.storageSnapshot) ||
+				!compare(restoredState[0], tt.storageSnapshot[0]) ||
+				!compare(restoredState[1], tt.storageSnapshot[1]) {
+				t.Errorf("State after Restore() is not equal")
+			}
+		})
+	}
+}

internal/server/adapters/memstorage.go

@@ -8,7 +8,6 @@ import (
 	common "github.com/matthiasBT/monitoring/internal/infra/entities"
 	"github.com/matthiasBT/monitoring/internal/infra/logging"
 	"github.com/matthiasBT/monitoring/internal/server/entities"
-	"golang.org/x/exp/maps"
 )
 
 type State struct {
@@ -76,9 +75,12 @@ func (storage *MemStorage) GetAll(ctx context.Context) (map[string]*common.Metri
 	return storage.Metrics, nil
 }
 
-func (storage *MemStorage) Snapshot(ctx context.Context) ([]*common.Metrics, error) {
-	data := maps.Values(storage.Metrics)
-	return data, nil
+func (storage *MemStorage) Snapshot(context.Context) ([]*common.Metrics, error) {
+	result := make([]*common.Metrics, 0, len(storage.Metrics))
+	for _, val := range storage.Metrics {
+		result = append(result, val)
+	}
+	return result, nil
 }
 
 func (storage *MemStorage) Init(data []*common.Metrics) {