Iter8

.gitignore

@@ -21,3 +21,8 @@ vendor/
 # IDEs directories
 .idea
 .vscode
+/temp
+
+#Temporary files
+$TEMP_FILE
+*.json

cmd/shortener/main.go

@@ -3,12 +3,15 @@ package main
 import (
 	"log"
 	"net/http"
+	"shortURL/internal/config"
 	"shortURL/internal/handlers"
+	"shortURL/internal/storage"
 )
 
 func main() {
-	r := handlers.NewRouter()
+	params := config.NewEnv()
+	storage := storage.NewStorager(params)
+	r := handlers.NewRouter(params, storage)
 
-	// http.HandleFunc("/", handlers.ShortenerURL)
-	log.Fatal(http.ListenAndServe("localhost:8080", r))
+	log.Fatal(http.ListenAndServe(params.Server, r))
 }

go.mod

@@ -3,6 +3,7 @@ module shortURL
 go 1.19
 
 require (
+	github.com/caarlos0/env/v6 v6.10.1
 	github.com/go-chi/chi/v5 v5.0.7
 	github.com/stretchr/testify v1.8.1
 )

go.sum

@@ -1,3 +1,5 @@
+github.com/caarlos0/env/v6 v6.10.1 h1:t1mPSxNpei6M5yAeu1qtRdPAK29Nbcf/n3G7x+b3/II=
+github.com/caarlos0/env/v6 v6.10.1/go.mod h1:hvp/ryKXKipEkcuYjs9mI4bBCg+UI0Yhgm5Zu0ddvwc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

internal/config/config.go

@@ -0,0 +1,30 @@
+package config
+
+import (
+	"log"
+
+	"github.com/caarlos0/env/v6"
+)
+
+type Param struct {
+	Server   string `env:"SERVER_ADDRESS"`
+	URL      string `env:"BASE_URL"`
+	Storage  string `env:"FILE_STORAGE_PATH"`
+	SaveFile int
+}
+
+func NewEnv() *Param {
+	var Params Param
+
+	err := env.Parse(&Params)
+	if err != nil {
+		log.Fatal(err)
+	}
+	ReadFlags(&Params)
+
+if Params.Storage != "" {
+	Params.SaveFile = 1
+}
+
+	return &Params
+}

internal/config/config_test.go

@@ -0,0 +1,34 @@
+package config
+
+import (
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestGetEnv(t *testing.T) {
+	tests := []struct {
+		name string
+		want *Param
+	}{
+		{
+			name: "test1",
+			want: &Param{
+				Server:   "127.0.0.1:8080",
+				URL:      "http://127.0.0.1:8080",
+				Storage:  "jsonDB.json",
+				SaveFile: 1,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			os.Setenv("SERVER_ADDRESS", "127.0.0.1:8080")
+			os.Setenv("BASE_URL", "http://127.0.0.1:8080")
+			os.Setenv("FILE_STORAGE_PATH", "jsonDB.json")
+			if got := NewEnv(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetEnv() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/config/flags.go

@@ -0,0 +1,18 @@
+package config
+
+import (
+	"flag"
+)
+
+func ReadFlags(P *Param) {
+	if P.Server == "" {
+		flag.StringVar(&P.Server, "a", "127.0.0.1:8080", "Адрес запускаемого сервера")
+	}
+	if P.URL == "" {
+		flag.StringVar(&P.URL, "b", "http://127.0.0.1:8080", "Базовый адрес результирующего URL")
+	}
+	if P.Storage == "" {
+		flag.StringVar(&P.Storage, "f", "", "Хранилище URL")
+	}
+	flag.Parse()
+}

internal/handlers/handlers.go

@@ -1,25 +1,56 @@
 package handlers
 
 import (
+	"encoding/json"
 	"io"
 	"net/http"
 	"net/url"
-	"shortURL/internal/keygen"
+	"shortURL/internal/config"
+	"shortURL/internal/storage"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
 )
 
-var (
-	baseURL = make(map[string]string)
-	key     string
-)
+type PostURL struct {
+	GetURL string `json:"url,omitempty"`
+	SetURL string `json:"result,omitempty"`
+}
 
-func NewRouter() chi.Router {
+func NewRouter(P *config.Param, S storage.Storager) *chi.Mux {
 	r := chi.NewRouter()
 
 	r.Use(middleware.Logger)
 	r.Use(middleware.Recoverer)
+	r.Use(Decompress)
+
+	r.Post("/api/shorten", func(w http.ResponseWriter, r *http.Request) {
+		var Addr PostURL
+		bytes, err := io.ReadAll(r.Body)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		if err = json.Unmarshal(bytes, &Addr); err != nil {
+			http.Error(w, err.Error(), http.StatusUnsupportedMediaType)
+			return
+		}
+		_, err = url.Parse(Addr.GetURL)
+		if err != nil {
+			http.Error(w, "Wrong address!", http.StatusBadRequest)
+			return
+		}
+		key := S.SetShortURL(Addr.GetURL, P)
+		NewAddr := PostURL{SetURL: P.URL + "/" + key}
+		NewAddrBZ, err := json.Marshal(NewAddr)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
+		w.WriteHeader(http.StatusCreated)
+		w.Write(NewAddrBZ)
+	})
 
 	r.Post("/", func(w http.ResponseWriter, r *http.Request) {
 		bytes, err := io.ReadAll(r.Body)
@@ -33,41 +64,19 @@ func NewRouter() chi.Router {
 			http.Error(w, "Wrong address!", http.StatusBadRequest)
 			return
 		}
-		key := SetShortURL(fURL)
+		key := S.SetShortURL(fURL, P)
 		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
 		w.WriteHeader(http.StatusCreated)
-		w.Write([]byte("http://" + r.Host + "/" + key))
+		w.Write([]byte(P.URL + "/" + key))
 	})
+
 	r.Get("/{id}", func(w http.ResponseWriter, r *http.Request) {
 		key := chi.URLParam(r, "id")
-		address := RetFullURL(key)
+		address := S.RetFullURL(key)
 		if address == "" {
 			http.Error(w, "Wrong address!", http.StatusBadRequest)
 		}
 		http.Redirect(w, r, address, http.StatusTemporaryRedirect)
 	})
 	return r
 }
-
-func SetShortURL(fURL string) string {
-
-	for key, addr := range baseURL {
-		if addr == fURL {
-			return key
-		}
-	}
-	for {
-		key = keygen.RandomStr()
-		_, err := baseURL[key]
-		if !err {
-			break
-		}
-	}
-
-	baseURL[key] = fURL
-	return key
-}
-
-func RetFullURL(key string) string {
-	return baseURL[key]
-}

internal/handlers/handlers_test.go

@@ -2,18 +2,35 @@ package handlers
 
 import (
 	"bytes"
+	"encoding/json"
 	"io"
+	"log"
+	"net"
 	"net/http"
 	"net/http/httptest"
+	"shortURL/internal/config"
+	"shortURL/internal/storage"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestRouter(t *testing.T) {
-	r := NewRouter()
-	ts := httptest.NewServer(r)
+	Params := config.NewEnv()
+	storage := storage.NewStorager(Params)
+	r := NewRouter(Params, storage)
+
+	l, err := net.Listen("tcp", Params.Server)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	ts := httptest.NewUnstartedServer(r)
+	ts.Listener.Close()
+	ts.Listener = l
+	ts.Start()
+
 	defer ts.Close()
 
 	type want struct {
@@ -35,38 +52,65 @@ func TestRouter(t *testing.T) {
 				statusCode2: 307,
 			},
 		},
+		{
+			name:    "test #2",
+			request: []byte(`/github.com/Yandex-Practicum/go-autotests`),
+			want: want{
+				contentType: "application/json; charset=utf-8",
+				statusCode1: 201,
+				statusCode2: 307,
+			},
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
 			//POST
-			request1, err := http.NewRequest(http.MethodPost, ts.URL+"/", bytes.NewReader(tt.request))
-			require.NoError(t, err)
+			var request1 *http.Request
+			var err error
+			switch tt.want.contentType {
+			case "text/plain; charset=utf-8":
+				request1, err = http.NewRequest(http.MethodPost, ts.URL+"/", bytes.NewReader(tt.request))
+				require.NoError(t, err)
+			case "application/json; charset=utf-8":
+				var req PostURL
+				req.GetURL = string(tt.request)
+				reqBz, err := json.Marshal(req)
+				if err != nil {
+					panic(err)
+				}
+				request1, err = http.NewRequest(http.MethodPost, ts.URL+"/api/shorten", bytes.NewReader(reqBz))
+				require.NoError(t, err)
+			}
 
 			result, err := http.DefaultClient.Do(request1)
 			require.NoError(t, err)
-			// w := httptest.NewRecorder()
-			// h := http.HandlerFunc(ShortenerURL)
-			// h(w, request)
-			// result := w.Result()
 			assert.Equal(t, tt.want.statusCode1, result.StatusCode)
 			assert.Equal(t, tt.want.contentType, result.Header.Get("Content-Type"))
 			userResult, err := io.ReadAll(result.Body)
 			require.NoError(t, err)
 			err = result.Body.Close()
 			require.NoError(t, err)
-			
+
 			//GET
-			request2, err := http.NewRequest(http.MethodGet, string(userResult), nil)
-			require.NoError(t, err)
+			var request2 *http.Request
+			switch tt.want.contentType {
+			case "text/plain; charset=utf-8":
+				request2, err = http.NewRequest(http.MethodGet, string(userResult), nil)
+				require.NoError(t, err)
+			case "application/json; charset=utf-8":
+				var res PostURL
+				err := json.Unmarshal(userResult, &res)
+				if err != nil {
+					panic(err)
+				}
+				request2, err = http.NewRequest(http.MethodGet, res.SetURL, nil)
+				require.NoError(t, err)
+			}
 
 			result2, err := http.DefaultTransport.RoundTrip(request2)
 			require.NoError(t, err)
-			// w2 := httptest.NewRecorder()
-			// h2 := http.HandlerFunc(ShortenerURL)
-			// h2(w2, request2)
-			// result2 := w2.Result()
 			userResult2 := result2.Header.Get("Location")
 			err = result2.Body.Close()
 			require.NoError(t, err)

internal/handlers/methods.go

@@ -0,0 +1,44 @@
+package handlers
+
+import (
+	"compress/gzip"
+
+	"io"
+	"net/http"
+	"strings"
+)
+
+type gzipWriter struct {
+	http.ResponseWriter
+	Writer io.Writer
+}
+
+func (w gzipWriter) Write(b []byte) (int, error) {
+	return w.Writer.Write(b)
+}
+
+func Decompress(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("Content-Encoding") == "gzip" {
+			gz, err := gzip.NewReader(r.Body)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+			decompressed := gz
+			defer gz.Close()
+			r.Body = io.NopCloser(decompressed)
+			next.ServeHTTP(w, r)
+			return
+		} else if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
+			gz := gzip.NewWriter(w)
+			defer gz.Close()
+			w.Header().Set("Content-Encoding", "gzip")
+			next.ServeHTTP(gzipWriter{ResponseWriter: w, Writer: gz}, r)
+			return
+		} else {
+			next.ServeHTTP(w, r)
+			return
+		}
+	})
+}