refactor with clean code

Author: BWbwchen

addURLHandler.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"net/http"
+	"sync"
+
+	"github.com/gin-gonic/gin"
+)
+
+type POSTData struct {
+	LongURL string `json:"URL"`
+}
+
+type POSTresponse struct {
+	Status    string `json:"status"`
+	ShortName string `json:"short"`
+}
+
+func AddURLHandler(c *gin.Context) {
+	var requestBody POSTData
+	c.ShouldBindJSON(&requestBody)
+
+	var shortName string
+	if db.URLExist(requestBody.LongURL) {
+		shortName = db.GetShortName(requestBody.LongURL)
+	} else {
+		shortName = GenerateShortName(requestBody.LongURL)
+		storeIntoDBRedis(requestBody.LongURL, shortName)
+	}
+
+	c.JSON(http.StatusOK, POSTresponse{
+		Status:    "Exist",
+		ShortName: shortName,
+	})
+}
+
+func storeIntoDBRedis(LongURL, shortName string) {
+	var wg sync.WaitGroup
+	wg.Add(2)
+	// add in database
+	go func(LongURL string, shortName string) {
+		defer wg.Done()
+		db.AddURLPair(LongURL, shortName)
+	}(LongURL, shortName)
+	// add in redis
+	go func(LongURL string, shortName string) {
+		defer wg.Done()
+		RedisAdd(LongURL, shortName)
+	}(LongURL, shortName)
+
+	wg.Wait()
+}

database.go

@@ -11,73 +11,93 @@ import (
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
 
-/* Used to create a singleton object of MongoDB client.
-Initialized and exposed through  GetMongoClient().*/
-var clientInstance *mongo.Client
-
-//Used during creation of singleton client object in GetMongoClient().
-var clientInstanceError error
-
-//Used to execute client creation procedure only once.
-var mongoOnce sync.Once
-
-var collection *mongo.Collection
-
-//I have used below constants just to hold required database config's.
-var (
-	CONNECTIONSTRING = "mongodb://" + os.Getenv("DB_URL")
-)
+type DBStruct struct {
+	Client     *mongo.Client
+	Collection *mongo.Collection
+}
 
-type data struct {
-	LongURL   string `json:"longurl"`
-	ShortName string `json:"shortname"`
+type DB interface {
+	GetURL(string) string
+	GetShortName(string) string
+	AddURLPair(string, string)
+	URLExist(string) bool
+	ShortNameExist(string) bool
 }
 
+var db DB
+
 //GetMongoClient - Return mongodb connection to work with
 func InitDatabase() {
+	client := connectDB()
+	_db := DBStruct{
+		Client:     client,
+		Collection: client.Database("url").Collection("url"),
+	}
+	db = _db
+}
+
+func connectDB() *mongo.Client {
+	var mongoOnce sync.Once
+	var client *mongo.Client
+	var clientInstanceError error
+	var CONNECTIONSTRING = "mongodb://" + os.Getenv("DB_URL")
 	//Perform connection creation operation only once.
 	mongoOnce.Do(func() {
 		// Set client options
 		clientOptions := options.Client().ApplyURI(CONNECTIONSTRING)
 		// Connect to MongoDB
-		client, err := mongo.Connect(context.TODO(), clientOptions)
+		_client, err := mongo.Connect(context.TODO(), clientOptions)
 		if err != nil {
 			clientInstanceError = err
 		}
 		// Check the connection
-		err = client.Ping(context.TODO(), nil)
+		err = _client.Ping(context.TODO(), nil)
 		if err != nil {
 			clientInstanceError = err
 		}
-		clientInstance = client
+		client = _client
 	})
 	if clientInstanceError != nil {
-		fmt.Println("Connection error")
+		panic("DB connection error")
 	}
-	collection = clientInstance.Database("url").Collection("url")
-	//return clientInstance, clientInstanceError
+	return client
 }
 
-func DatabaseAdd(LongURL string, shortName string) {
+type data struct {
+	LongURL   string `json:"longurl"`
+	ShortName string `json:"shortname"`
+}
+
+func (dbs DBStruct) AddURLPair(LongURL string, shortName string) {
 	toInsert := data{LongURL: LongURL, ShortName: shortName}
-	_, err := collection.InsertOne(context.TODO(), toInsert)
+	_, err := dbs.Collection.InsertOne(context.TODO(), toInsert)
 	if err != nil {
 		fmt.Println("Insert Error")
 	}
-	//id := res.InsertedID
-	//fmt.Println("Insert " + fmt.Sprintf("%v", id) + " record !")
 }
 
-func DatabaseGet(shortName string) (string, error) {
-	var result data
+func (dbs DBStruct) GetURL(shortName string) string {
+	result, _ := dbs.find("shortname", shortName)
+	return result.LongURL
+}
 
-	err := collection.FindOne(context.TODO(), bson.M{"shortname": shortName}).Decode(&result)
-	return result.LongURL, err
+func (dbs DBStruct) URLExist(LongURL string) bool {
+	_, err := dbs.find("longurl", LongURL)
+	return err == nil
 }
 
-func DatabaseURLExist(LongURL string) (string, bool) {
-	var result data
+func (dbs DBStruct) ShortNameExist(shortName string) bool {
+	_, err := dbs.find("shortname", shortName)
+	return err == nil
+}
 
-	err := collection.FindOne(context.TODO(), bson.M{"longurl": LongURL}).Decode(&result)
-	return result.ShortName, (err == nil)
+func (dbs DBStruct) GetShortName(LongURL string) string {
+	result, _ := dbs.find("longurl", LongURL)
+	return result.ShortName
+}
+
+func (dbs DBStruct) find(columnName, value string) (data, error) {
+	var result data
+	err := dbs.Collection.FindOne(context.TODO(), bson.M{columnName: value}).Decode(&result)
+	return result, err
 }

getURLHandler.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type GETresponse struct {
+	Status string `json:"status"`
+	URL    string `json:"url"`
+}
+
+func GetURLHandler(c *gin.Context) {
+	shortNameQuery := c.Param("shortName")
+
+	LongURL, err := RedisGet(shortNameQuery)
+	if err != nil {
+		DatabaseLongURL := db.GetURL(shortNameQuery)
+		if DatabaseLongURL == "" {
+			c.JSON(http.StatusNotFound, GETresponse{
+				Status: "Not OK",
+				URL:    "",
+			})
+		} else {
+			RedisAdd(DatabaseLongURL, shortNameQuery)
+			c.JSON(http.StatusOK, GETresponse{
+				Status: "(Database)OK",
+				URL:    DatabaseLongURL,
+			})
+		}
+	} else {
+		c.JSON(http.StatusOK, GETresponse{
+			Status: "(Redis)OK",
+			URL:    LongURL,
+		})
+	}
+}

main.go

@@ -1,9 +1,6 @@
 package main
 
 import (
-	"net/http"
-	"sync"
-
 	"github.com/gin-gonic/gin"
 )
 
@@ -13,85 +10,14 @@ func init() {
 	InitZookeeper()
 }
 
-type POSTData struct {
-	LongURL string `json:"URL"`
-}
-
-type POSTresponse struct {
-	Status    string `json:"status"`
-	ShortName string `json:"short"`
-}
-type GETresponse struct {
-	Status string `json:"status"`
-	URL    string `json:"url"`
-}
-
 func main() {
 	r := setupRouter()
 	r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
 }
+
 func setupRouter() *gin.Engine {
 	r := gin.Default()
-	r.POST("/add", func(c *gin.Context) {
-		var body POSTData
-		c.ShouldBindJSON(&body)
-		// validate it
-		// generate the corresponding short name
-		shortName, isExist := DatabaseURLExist(body.LongURL)
-		if isExist {
-			c.JSON(http.StatusOK, POSTresponse{
-				Status:    "Exist",
-				ShortName: shortName,
-			})
-		} else {
-			var wg sync.WaitGroup
-			wg.Add(2)
-			shortName := GetShortName(body.LongURL)
-			// add in database
-			go func(LongURL string, shortName string) {
-				defer wg.Done()
-				DatabaseAdd(LongURL, shortName)
-			}(body.LongURL, shortName)
-			// add in redis
-			go func(LongURL string, shortName string) {
-				defer wg.Done()
-				RedisAdd(LongURL, shortName)
-			}(body.LongURL, shortName)
-
-			wg.Wait()
-
-			c.JSON(http.StatusOK, POSTresponse{
-				Status:    "OK",
-				ShortName: shortName,
-			})
-		}
-	})
-	r.GET("/:shortName", func(c *gin.Context) {
-		shortName := c.Param("shortName")
-		// find in redis first
-		LongURL, err := RedisGet(shortName)
-		//LongURL, err := DatabaseGet(shortName)
-		if err != nil {
-			// if not found, find in database
-			DatabaseLongURL, err_ := DatabaseGet(shortName)
-			if err_ != nil {
-				c.JSON(http.StatusNotFound, GETresponse{
-					Status: "Not OK",
-					URL:    "",
-				})
-			} else {
-				RedisAdd(DatabaseLongURL, shortName)
-				c.JSON(http.StatusOK, GETresponse{
-					Status: "(Database)OK",
-					URL:    DatabaseLongURL,
-				})
-			}
-		} else {
-			c.JSON(http.StatusOK, GETresponse{
-				Status: "(Redis)OK",
-				URL:    LongURL,
-			})
-		}
-	})
+	r.POST("/add", AddURLHandler)
+	r.GET("/:shortName", GetURLHandler)
 	return r
 }

main_test.go

@@ -26,19 +26,33 @@ type testingSuite struct {
 	Router  *gin.Engine
 }
 
+type tinyURLTesting interface {
+	Test(string)
+}
+
+var tb tinyURLTesting
+
 func TestShortURLService(t *testing.T) {
-	tb := testingSuite{
+	_tb := testingSuite{
 		TestBed: t,
 		Router:  setupRouter(),
 	}
+	tb = _tb
+
+	tb.Test("https://www.google.com")
 	for i := 0; i < 10; i++ {
 		originalURL := "https://" + randomString(30)
-		shortURL := tb.requestShortURL(originalURL)
-		URL := tb.requestLongURL(shortURL)
-		assert.Equal(t, originalURL, URL)
+		tb.Test(originalURL)
 	}
+	tb.Test("https://www.google.com")
+}
 
+func (tb testingSuite) Test(originalURL string) {
+	shortURL := tb.requestShortURL(originalURL)
+	URL := tb.requestLongURL(shortURL)
+	assert.Equal(tb.TestBed, originalURL, URL)
 }
+
 func (tb testingSuite) requestShortURL(originalURL string) string {
 	gin.SetMode(gin.TestMode)
 	postBody, _ := json.Marshal(map[string]string{