diff --git a/Makefile b/Makefile
index 1507b38..985fa99 100644
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,8 @@
 
 clean:
 	@rm -fR vendor/ cover.*
-	@docker-compose rm -s -f
+	@docker-compose stop
+	@docker-compose rm -f
 
 configure:
 	@dep ensure -v
diff --git a/README.md b/README.md
index 4822544..7a32078 100644
--- a/README.md
+++ b/README.md
@@ -3,8 +3,10 @@
 [![Build Status](https://img.shields.io/travis/fabiorphp/cachego/master.svg?style=flat-square)](https://travis-ci.org/fabiorphp/cachego)
 [![Coverage Status](https://img.shields.io/coveralls/fabiorphp/cachego/master.svg?style=flat-square)](https://coveralls.io/github/fabiorphp/cachego?branch=master)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-5272B4.svg?style=flat-square)](https://godoc.org/github.com/fabiorphp/cachego)
+[![Go Report Card](https://goreportcard.com/badge/github.com/fabiorphp/cachego?style=flat-square)](https://goreportcard.com/report/github.com/fabiorphp/cachego)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](https://github.com/fabiorphp/cachego/blob/master/LICENSE)
 
-Simple interface around cache drivers
+Simple interface for caching
 
 ## Installation
 
diff --git a/cache.go b/cache.go
index 846600d..25eff46 100644
--- a/cache.go
+++ b/cache.go
@@ -1,29 +1,29 @@
 package cachego
 
 import (
-    "time"
+	"time"
 )
 
 type (
-    // Cache is the top-level cache interface
-    Cache interface {
+	// Cache is the top-level cache interface
+	Cache interface {
 
-        // Contains check if a cached key exists
-        Contains(key string) bool
+		// Contains check if a cached key exists
+		Contains(key string) bool
 
-        // Delete remove the cached key
-        Delete(key string) error
+		// Delete remove the cached key
+		Delete(key string) error
 
-        // Fetch retrieve the cached key value
-        Fetch(key string) (string, error)
+		// Fetch retrieve the cached key value
+		Fetch(key string) (string, error)
 
-        // FetchMulti retrieve multiple cached keys value
-        FetchMulti(keys []string) map[string]string
+		// FetchMulti retrieve multiple cached keys value
+		FetchMulti(keys []string) map[string]string
 
-        // Flush remove all cached keys
-        Flush() error
+		// Flush remove all cached keys
+		Flush() error
 
-        // Save cache a value by key
-        Save(key string, value string, lifeTime time.Duration) error
-    }
+		// Save cache a value by key
+		Save(key string, value string, lifeTime time.Duration) error
+	}
 )
diff --git a/chain.go b/chain.go
index ee5679f..320e3e0 100644
--- a/chain.go
+++ b/chain.go
@@ -1,93 +1,95 @@
 package cachego
 
 import (
-    "fmt"
-    "strings"
-    "time"
+	"fmt"
+	"strings"
+	"time"
 )
 
 type (
-    // Chain storage for dealing with multiple cache storage in the same time
-    Chain struct {
-        drivers []Cache
-    }
+	// Chain storage for dealing with multiple cache storage in the same time
+	Chain struct {
+		drivers []Cache
+	}
 )
 
-// NewChain - Create an instance of Chain
+// NewChain creates an instance of Chain cache driver
 func NewChain(drivers ...Cache) *Chain {
-    return &Chain{drivers}
+	return &Chain{drivers}
 }
 
-// Check if cached key exists in one of cache storage
+// Contains checks if the cached key exists in one of the cache storages
 func (c *Chain) Contains(key string) bool {
-    for _, driver := range c.drivers {
-        if driver.Contains(key) {
-            return true
-        }
-    }
+	for _, driver := range c.drivers {
+		if driver.Contains(key) {
+			return true
+		}
+	}
 
-    return false
+	return false
 }
 
 // Delete the cached key in all cache storages
 func (c *Chain) Delete(key string) error {
-    for _, driver := range c.drivers {
-        if err := driver.Delete(key); err != nil {
-            return err
-        }
-    }
+	for _, driver := range c.drivers {
+		if err := driver.Delete(key); err != nil {
+			return err
+		}
+	}
 
-    return nil
+	return nil
 }
 
-// Retrieves the value of the first cache storage found
+// Fetch retrieves the value of one of the registred cache storages
 func (c *Chain) Fetch(key string) (string, error) {
 
-    errs := []string{}
+	errs := []string{}
 
-    for _, driver := range c.drivers {
-        if value, err := driver.Fetch(key); err == nil {
-            return value, nil
-        } else {
-            errs = append(errs, err.Error())
-        }
-    }
+	for _, driver := range c.drivers {
+		value, err := driver.Fetch(key)
 
-    return "", fmt.Errorf("Key not found in cache chain. Errors: %s", strings.Join(errs, ","))
+		if driver.Fetch(key); err == nil {
+			return value, nil
+		}
+
+		errs = append(errs, err.Error())
+	}
+
+	return "", fmt.Errorf("Key not found in cache chain. Errors: %s", strings.Join(errs, ","))
 }
 
-// Retrieve multiple cached value from keys of the first cache storage found
+// FetchMulti retrieves multiple cached values from one of the registred cache storages
 func (c *Chain) FetchMulti(keys []string) map[string]string {
-    result := make(map[string]string)
+	result := make(map[string]string)
 
-    for _, key := range keys {
-        if value, err := c.Fetch(key); err == nil {
-            result[key] = value
-        }
-    }
+	for _, key := range keys {
+		if value, err := c.Fetch(key); err == nil {
+			result[key] = value
+		}
+	}
 
-    return result
+	return result
 }
 
-// Remove all cached keys of the all cache storages
+// Flush removes all cached keys of the registered cache storages
 func (c *Chain) Flush() error {
-    for _, driver := range c.drivers {
-        if err := driver.Flush(); err != nil {
-            return err
-        }
-    }
+	for _, driver := range c.drivers {
+		if err := driver.Flush(); err != nil {
+			return err
+		}
+	}
 
-    return nil
+	return nil
 }
 
 // Save a value in all cache storages by key
 func (c *Chain) Save(key string, value string, lifeTime time.Duration) error {
 
-    for _, driver := range c.drivers {
-        if err := driver.Save(key, value, lifeTime); err != nil {
-            return err
-        }
-    }
+	for _, driver := range c.drivers {
+		if err := driver.Save(key, value, lifeTime); err != nil {
+			return err
+		}
+	}
 
-    return nil
+	return nil
 }
diff --git a/chain_test.go b/chain_test.go
index ae7b3a4..39f8304 100644
--- a/chain_test.go
+++ b/chain_test.go
@@ -1,121 +1,121 @@
 package cachego
 
 import (
-    "github.com/bradfitz/gomemcache/memcache"
-    "github.com/stretchr/testify/assert"
-    "github.com/stretchr/testify/suite"
-    "testing"
-    "time"
+	"github.com/bradfitz/gomemcache/memcache"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"testing"
+	"time"
 )
 
 type ChainTestSuite struct {
-    suite.Suite
+	suite.Suite
 
-    assert *assert.Assertions
-    cache  Cache
+	assert *assert.Assertions
+	cache  Cache
 }
 
 func (s *ChainTestSuite) SetupTest() {
-    s.cache = NewChain(NewMap())
+	s.cache = NewChain(NewMap())
 
-    s.assert = assert.New(s.T())
+	s.assert = assert.New(s.T())
 }
 
 func (s *ChainTestSuite) TestSaveThrowErrorWhenOneOfDriverFail() {
-    cache := NewChain(
-        NewMap(),
-        NewMemcached(memcache.New("127.0.0.1:22222")),
-    )
+	cache := NewChain(
+		NewMap(),
+		NewMemcached(memcache.New("127.0.0.1:22222")),
+	)
 
-    s.assert.Error(cache.Save("foo", "bar", 0))
+	s.assert.Error(cache.Save("foo", "bar", 0))
 }
 
 func (s *ChainTestSuite) TestSave() {
-    s.assert.Nil(s.cache.Save("foo", "bar", 0))
+	s.assert.Nil(s.cache.Save("foo", "bar", 0))
 }
 
 func (s *ChainTestSuite) TestFetchThrowErrorWhenExpired() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 1*time.Second)
+	s.cache.Save(key, value, 1*time.Second)
 
-    time.Sleep(1 * time.Second)
+	time.Sleep(1 * time.Second)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Regexp("^Key not found in cache chain", err)
-    s.assert.Empty(result)
+	s.assert.Regexp("^Key not found in cache chain", err)
+	s.assert.Empty(result)
 }
 
 func (s *ChainTestSuite) TestFetch() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *ChainTestSuite) TestContains() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.True(s.cache.Contains("foo"))
-    s.assert.False(s.cache.Contains("bar"))
+	s.assert.True(s.cache.Contains("foo"))
+	s.assert.False(s.cache.Contains("bar"))
 }
 
 func (s *ChainTestSuite) TestDeleteThrowErrorWhenOneOfDriverFail() {
-    cache := NewChain(
-        NewMap(),
-        NewMemcached(memcache.New("127.0.0.1:22222")),
-    )
+	cache := NewChain(
+		NewMap(),
+		NewMemcached(memcache.New("127.0.0.1:22222")),
+	)
 
-    s.assert.Error(cache.Delete("foo"))
+	s.assert.Error(cache.Delete("foo"))
 }
 
 func (s *ChainTestSuite) TestDelete() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Delete("foo"))
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *ChainTestSuite) TestFlushThrowErrorWhenOneOfDriverFail() {
-    cache := NewChain(
-        NewMap(),
-        NewMemcached(memcache.New("127.0.0.1:22222")),
-    )
+	cache := NewChain(
+		NewMap(),
+		NewMemcached(memcache.New("127.0.0.1:22222")),
+	)
 
-    s.assert.Error(cache.Flush())
+	s.assert.Error(cache.Flush())
 }
 
 func (s *ChainTestSuite) TestFlush() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Flush())
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Flush())
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *ChainTestSuite) TestFetchMulti() {
-    s.cache.Save("foo", "bar", 0)
-    s.cache.Save("john", "doe", 0)
+	s.cache.Save("foo", "bar", 0)
+	s.cache.Save("john", "doe", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "john"})
+	result := s.cache.FetchMulti([]string{"foo", "john"})
 
-    s.assert.Len(result, 2)
+	s.assert.Len(result, 2)
 }
 
 func (s *ChainTestSuite) TestFetchMultiWhenOnlyOneOfKeysExists() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "alice"})
+	result := s.cache.FetchMulti([]string{"foo", "alice"})
 
-    s.assert.Len(result, 1)
+	s.assert.Len(result, 1)
 }
 
 func TestChainRunSuite(t *testing.T) {
-    suite.Run(t, new(ChainTestSuite))
+	suite.Run(t, new(ChainTestSuite))
 }
diff --git a/doc.go b/doc.go
index 67deadb..59c8645 100644
--- a/doc.go
+++ b/doc.go
@@ -1,4 +1,4 @@
-// This package provide a simple way to use cache drivers.
+// Package cachego provides a simple way to use cache drivers.
 //
 // Example Usage
 //
diff --git a/file.go b/file.go
index 5d32ee7..8db7fe7 100644
--- a/file.go
+++ b/file.go
@@ -1,172 +1,172 @@
 package cachego
 
 import (
-    "crypto/sha256"
-    "encoding/hex"
-    "encoding/json"
-    errors "github.com/pkg/errors"
-    "io/ioutil"
-    "os"
-    "path/filepath"
-    "time"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	errors "github.com/pkg/errors"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"time"
 )
 
 type (
-    // File store for caching data
-    File struct {
-        dir string
-    }
-
-    // File content it's a structure of cached value
-    FileContent struct {
-        Duration int64  `json:"duration"`
-        Data     string `json:"data, omitempty"`
-    }
+	// File store for caching data
+	File struct {
+		dir string
+	}
+
+	// FileContent it's a structure of cached value
+	FileContent struct {
+		Duration int64  `json:"duration"`
+		Data     string `json:"data, omitempty"`
+	}
 )
 
-// NewFile - Create an instance of File
+// NewFile creates an instance of File cache
 func NewFile(dir string) *File {
-    return &File{dir}
+	return &File{dir}
 }
 
 func (f *File) createName(key string) string {
-    h := sha256.New()
-    h.Write([]byte(key))
-    hash := hex.EncodeToString(h.Sum(nil))
+	h := sha256.New()
+	h.Write([]byte(key))
+	hash := hex.EncodeToString(h.Sum(nil))
 
-    filename := hash + ".cachego"
+	filename := hash + ".cachego"
 
-    filePath := filepath.Join(f.dir, filename)
+	filePath := filepath.Join(f.dir, filename)
 
-    return filePath
+	return filePath
 }
 
 func (f *File) read(key string) (*FileContent, error) {
-    value, err := ioutil.ReadFile(
-        f.createName(key),
-    )
+	value, err := ioutil.ReadFile(
+		f.createName(key),
+	)
 
-    if err != nil {
-        return nil, errors.Wrap(err, "Unable to open")
-    }
+	if err != nil {
+		return nil, errors.Wrap(err, "Unable to open")
+	}
 
-    content := &FileContent{}
+	content := &FileContent{}
 
-    err = json.Unmarshal(value, content)
+	err = json.Unmarshal(value, content)
 
-    if err != nil {
-        return nil, errors.Wrap(err, "Unable to decode json data")
-    }
+	if err != nil {
+		return nil, errors.Wrap(err, "Unable to decode json data")
+	}
 
-    if content.Duration == 0 {
-        return content, nil
-    }
+	if content.Duration == 0 {
+		return content, nil
+	}
 
-    if content.Duration <= time.Now().Unix() {
-        f.Delete(key)
-        return nil, errors.New("Cache expired")
-    }
+	if content.Duration <= time.Now().Unix() {
+		f.Delete(key)
+		return nil, errors.New("Cache expired")
+	}
 
-    return content, nil
+	return content, nil
 }
 
-// Check if cached key exists in File storage
+// Contains checks if the cached key exists into the File storage
 func (f *File) Contains(key string) bool {
 
-    if _, err := f.read(key); err != nil {
-        return false
-    }
+	if _, err := f.read(key); err != nil {
+		return false
+	}
 
-    return true
+	return true
 }
 
 // Delete the cached key from File storage
 func (f *File) Delete(key string) error {
-    _, err := os.Stat(
-        f.createName(key),
-    )
+	_, err := os.Stat(
+		f.createName(key),
+	)
 
-    if err != nil && os.IsNotExist(err) {
-        return nil
-    }
+	if err != nil && os.IsNotExist(err) {
+		return nil
+	}
 
-    err = os.Remove(
-        f.createName(key),
-    )
+	err = os.Remove(
+		f.createName(key),
+	)
 
-    if err != nil {
-        return errors.Wrap(err, "Unable to delete")
-    }
+	if err != nil {
+		return errors.Wrap(err, "Unable to delete")
+	}
 
-    return nil
+	return nil
 }
 
-// Retrieve the cached value from key of the File storage
+// Fetch retrieves the cached value from key of the File storage
 func (f *File) Fetch(key string) (string, error) {
-    content, err := f.read(key)
+	content, err := f.read(key)
 
-    if err != nil {
-        return "", err
-    }
+	if err != nil {
+		return "", err
+	}
 
-    return content.Data, nil
+	return content.Data, nil
 }
 
-// Retrieve multiple cached value from keys of the File storage
+// FetchMulti retrieve multiple cached values from keys of the File storage
 func (f *File) FetchMulti(keys []string) map[string]string {
-    result := make(map[string]string)
+	result := make(map[string]string)
 
-    for _, key := range keys {
-        if value, err := f.Fetch(key); err == nil {
-            result[key] = value
-        }
-    }
+	for _, key := range keys {
+		if value, err := f.Fetch(key); err == nil {
+			result[key] = value
+		}
+	}
 
-    return result
+	return result
 }
 
-// Remove all cached keys in File storage
+// Flush removes all cached keys of the File storage
 func (f *File) Flush() error {
-    dir, err := os.Open(f.dir)
+	dir, err := os.Open(f.dir)
 
-    if err != nil {
-        return errors.Wrap(err, "Unable to open file")
-    }
+	if err != nil {
+		return errors.Wrap(err, "Unable to open file")
+	}
 
-    defer dir.Close()
+	defer dir.Close()
 
-    names, _ := dir.Readdirnames(-1)
+	names, _ := dir.Readdirnames(-1)
 
-    for _, name := range names {
-        os.Remove(filepath.Join(f.dir, name))
-    }
+	for _, name := range names {
+		os.Remove(filepath.Join(f.dir, name))
+	}
 
-    return nil
+	return nil
 }
 
 // Save a value in File storage by key
 func (f *File) Save(key string, value string, lifeTime time.Duration) error {
 
-    duration := int64(0)
+	duration := int64(0)
 
-    if lifeTime > 0 {
-        duration = time.Now().Unix() + int64(lifeTime.Seconds())
-    }
+	if lifeTime > 0 {
+		duration = time.Now().Unix() + int64(lifeTime.Seconds())
+	}
 
-    content := &FileContent{
-        duration,
-        value,
-    }
+	content := &FileContent{
+		duration,
+		value,
+	}
 
-    data, err := json.Marshal(content)
+	data, err := json.Marshal(content)
 
-    if err != nil {
-        return errors.Wrap(err, "Unable to encode json data")
-    }
+	if err != nil {
+		return errors.Wrap(err, "Unable to encode json data")
+	}
 
-    if err := ioutil.WriteFile(f.createName(key), data, 0666); err != nil {
-        return errors.Wrap(err, "Unable to save")
-    }
+	if err := ioutil.WriteFile(f.createName(key), data, 0666); err != nil {
+		return errors.Wrap(err, "Unable to save")
+	}
 
-    return nil
+	return nil
 }
diff --git a/file_test.go b/file_test.go
index 70fa63d..212f297 100644
--- a/file_test.go
+++ b/file_test.go
@@ -1,141 +1,141 @@
 package cachego
 
 import (
-    "github.com/stretchr/testify/assert"
-    "github.com/stretchr/testify/suite"
-    "os"
-    "testing"
-    "time"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"os"
+	"testing"
+	"time"
 )
 
 type FileTestSuite struct {
-    suite.Suite
+	suite.Suite
 
-    assert *assert.Assertions
-    cache  Cache
+	assert *assert.Assertions
+	cache  Cache
 }
 
 func (s *FileTestSuite) SetupTest() {
-    directory := "./cache-dir/"
+	directory := "./cache-dir/"
 
-    os.Mkdir(directory, 0777)
+	os.Mkdir(directory, 0777)
 
-    s.cache = NewFile(directory)
-    s.assert = assert.New(s.T())
+	s.cache = NewFile(directory)
+	s.assert = assert.New(s.T())
 }
 
 func (s *FileTestSuite) TestSaveThrowError() {
-    cache := NewFile("./test/")
+	cache := NewFile("./test/")
 
-    s.assert.Regexp("^Unable to save", cache.Save("foo", "bar", 0))
+	s.assert.Regexp("^Unable to save", cache.Save("foo", "bar", 0))
 }
 
 func (s *FileTestSuite) TestSave() {
-    s.assert.Nil(s.cache.Save("foo", "bar", 0))
+	s.assert.Nil(s.cache.Save("foo", "bar", 0))
 }
 
 func (s *FileTestSuite) TestFetchThrowError() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    cache := NewFile("./test/")
+	cache := NewFile("./test/")
 
-    result, err := cache.Fetch(key)
+	result, err := cache.Fetch(key)
 
-    s.assert.Regexp("^Unable to open", err)
-    s.assert.Empty(result)
+	s.assert.Regexp("^Unable to open", err)
+	s.assert.Empty(result)
 }
 
 func (s *FileTestSuite) TestFetchThrowErrorWhenExpired() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 1*time.Second)
+	s.cache.Save(key, value, 1*time.Second)
 
-    time.Sleep(1 * time.Second)
+	time.Sleep(1 * time.Second)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.EqualError(err, "Cache expired")
-    s.assert.Empty(result)
+	s.assert.EqualError(err, "Cache expired")
+	s.assert.Empty(result)
 }
 
 func (s *FileTestSuite) TestFetch() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
-    result, err := s.cache.Fetch(key)
+	s.cache.Save(key, value, 0)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *FileTestSuite) TestFetchLongCacheDuration() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 10*time.Second)
-    result, err := s.cache.Fetch(key)
+	s.cache.Save(key, value, 10*time.Second)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *FileTestSuite) TestContains() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.True(s.cache.Contains("foo"))
-    s.assert.False(s.cache.Contains("bar"))
+	s.assert.True(s.cache.Contains("foo"))
+	s.assert.False(s.cache.Contains("bar"))
 }
 
 func (s *FileTestSuite) TestDelete() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Delete("foo"))
-    s.assert.False(s.cache.Contains("foo"))
-    s.assert.Nil(s.cache.Delete("bar"))
+	s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Delete("bar"))
 }
 
 func (s *FileTestSuite) TestFlushReturnFalseWhenThrowError() {
-    cache := NewFile("./test/")
+	cache := NewFile("./test/")
 
-    s.assert.Error(cache.Flush(), "OK")
+	s.assert.Error(cache.Flush(), "OK")
 }
 
 func (s *FileTestSuite) TestFlush() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Flush())
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Flush())
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *FileTestSuite) TestFetchMultiReturnNoItemsWhenThrowError() {
-    cache := NewFile("./test/")
-    result := cache.FetchMulti([]string{"foo"})
+	cache := NewFile("./test/")
+	result := cache.FetchMulti([]string{"foo"})
 
-    s.assert.Len(result, 0)
+	s.assert.Len(result, 0)
 }
 
 func (s *FileTestSuite) TestFetchMulti() {
-    s.cache.Save("foo", "bar", 0)
-    s.cache.Save("john", "doe", 0)
+	s.cache.Save("foo", "bar", 0)
+	s.cache.Save("john", "doe", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "john"})
+	result := s.cache.FetchMulti([]string{"foo", "john"})
 
-    s.assert.Len(result, 2)
+	s.assert.Len(result, 2)
 }
 
 func (s *FileTestSuite) TestFetchMultiWhenOnlyOneOfKeysExists() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "alice"})
+	result := s.cache.FetchMulti([]string{"foo", "alice"})
 
-    s.assert.Len(result, 1)
+	s.assert.Len(result, 1)
 }
 
 func TestFileRunSuite(t *testing.T) {
-    suite.Run(t, new(FileTestSuite))
+	suite.Run(t, new(FileTestSuite))
 }
diff --git a/map.go b/map.go
index 20bf09f..ced317a 100644
--- a/map.go
+++ b/map.go
@@ -1,104 +1,105 @@
 package cachego
 
 import (
-    "errors"
-    "time"
+	"errors"
+	"time"
 )
 
 type (
-    MapItem struct {
-        data     string
-        duration int64
-    }
-
-    // Map store the data in memory without external server
-    Map struct {
-        storage map[string]*MapItem
-    }
+	// MapItem structure for managing data and lifetime
+	MapItem struct {
+		data     string
+		duration int64
+	}
+
+	// Map store the data in memory without external server
+	Map struct {
+		storage map[string]*MapItem
+	}
 )
 
-// Create an instance of Map storage
+// NewMap creates an instance of Map cache driver
 func NewMap() *Map {
-    storage := make(map[string]*MapItem)
+	storage := make(map[string]*MapItem)
 
-    return &Map{storage}
+	return &Map{storage}
 }
 
 func (m *Map) read(key string) (*MapItem, error) {
-    item, ok := m.storage[key]
+	item, ok := m.storage[key]
 
-    if !ok {
-        return nil, errors.New("Key not found")
-    }
+	if !ok {
+		return nil, errors.New("Key not found")
+	}
 
-    if item.duration == 0 {
-        return item, nil
-    }
+	if item.duration == 0 {
+		return item, nil
+	}
 
-    if item.duration <= time.Now().Unix() {
-        m.Delete(key)
-        return nil, errors.New("Cache expired")
-    }
+	if item.duration <= time.Now().Unix() {
+		m.Delete(key)
+		return nil, errors.New("Cache expired")
+	}
 
-    return item, nil
+	return item, nil
 }
 
-// Check if cached key exists in Map storage
+// Contains checks if cached key exists in Map storage
 func (m *Map) Contains(key string) bool {
-    if _, err := m.Fetch(key); err != nil {
-        return false
-    }
+	if _, err := m.Fetch(key); err != nil {
+		return false
+	}
 
-    return true
+	return true
 }
 
 // Delete the cached key from Map storage
 func (m *Map) Delete(key string) error {
-    delete(m.storage, key)
-    return nil
+	delete(m.storage, key)
+	return nil
 }
 
-// Retrieve the cached value from key of the Map storage
+// Fetch retrieves the cached value from key of the Map storage
 func (m *Map) Fetch(key string) (string, error) {
-    item, err := m.read(key)
+	item, err := m.read(key)
 
-    if err != nil {
-        return "", err
-    }
+	if err != nil {
+		return "", err
+	}
 
-    return item.data, nil
+	return item.data, nil
 }
 
-// Retrieve multiple cached value from keys of the Map storage
+// FetchMulti retrieves multiple cached value from keys of the Map storage
 func (m *Map) FetchMulti(keys []string) map[string]string {
-    result := make(map[string]string)
+	result := make(map[string]string)
 
-    for _, key := range keys {
-        if value, err := m.Fetch(key); err == nil {
-            result[key] = value
-        }
-    }
+	for _, key := range keys {
+		if value, err := m.Fetch(key); err == nil {
+			result[key] = value
+		}
+	}
 
-    return result
+	return result
 }
 
-// Remove all cached keys in Map storage
+// Flush removes all cached keys of the Map storage
 func (m *Map) Flush() error {
-    m.storage = make(map[string]*MapItem)
-    return nil
+	m.storage = make(map[string]*MapItem)
+	return nil
 }
 
 // Save a value in Map storage by key
 func (m *Map) Save(key string, value string, lifeTime time.Duration) error {
-    duration := int64(0)
+	duration := int64(0)
 
-    if lifeTime > 0 {
-        duration = time.Now().Unix() + int64(lifeTime.Seconds())
-    }
+	if lifeTime > 0 {
+		duration = time.Now().Unix() + int64(lifeTime.Seconds())
+	}
 
-    item := &MapItem{value, duration}
+	item := &MapItem{value, duration}
 
-    m.storage[key] = item
+	m.storage[key] = item
 
-    return nil
+	return nil
 }
diff --git a/map_test.go b/map_test.go
index ccc72c0..8e74500 100644
--- a/map_test.go
+++ b/map_test.go
@@ -1,104 +1,104 @@
 package cachego
 
 import (
-    "github.com/stretchr/testify/assert"
-    "github.com/stretchr/testify/suite"
-    "testing"
-    "time"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"testing"
+	"time"
 )
 
 type MapTestSuite struct {
-    suite.Suite
+	suite.Suite
 
-    assert *assert.Assertions
-    cache  Cache
+	assert *assert.Assertions
+	cache  Cache
 }
 
 func (s *MapTestSuite) SetupTest() {
-    s.cache = NewMap()
+	s.cache = NewMap()
 
-    s.assert = assert.New(s.T())
+	s.assert = assert.New(s.T())
 }
 
 func (s *MapTestSuite) TestSave() {
-    s.assert.Nil(s.cache.Save("foo", "bar", 0))
+	s.assert.Nil(s.cache.Save("foo", "bar", 0))
 }
 
 func (s *MapTestSuite) TestFetchThrowErrorWhenExpired() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 1*time.Second)
+	s.cache.Save(key, value, 1*time.Second)
 
-    time.Sleep(1 * time.Second)
+	time.Sleep(1 * time.Second)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.EqualError(err, "Cache expired")
-    s.assert.Empty(result)
+	s.assert.EqualError(err, "Cache expired")
+	s.assert.Empty(result)
 }
 
 func (s *MapTestSuite) TestFetch() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *MapTestSuite) TestFetchLongCacheDuration() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 10*time.Second)
-    result, err := s.cache.Fetch(key)
+	s.cache.Save(key, value, 10*time.Second)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *MapTestSuite) TestContains() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.True(s.cache.Contains("foo"))
-    s.assert.False(s.cache.Contains("bar"))
+	s.assert.True(s.cache.Contains("foo"))
+	s.assert.False(s.cache.Contains("bar"))
 }
 
 func (s *MapTestSuite) TestDelete() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Delete("foo"))
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *MapTestSuite) TestFlush() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Flush())
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Flush())
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *MapTestSuite) TestFetchMulti() {
-    s.cache.Save("foo", "bar", 0)
-    s.cache.Save("john", "doe", 0)
+	s.cache.Save("foo", "bar", 0)
+	s.cache.Save("john", "doe", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "john"})
+	result := s.cache.FetchMulti([]string{"foo", "john"})
 
-    s.assert.Len(result, 2)
+	s.assert.Len(result, 2)
 }
 
 func (s *MapTestSuite) TestFetchMultiWhenOnlyOneOfKeysExists() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "alice"})
+	result := s.cache.FetchMulti([]string{"foo", "alice"})
 
-    s.assert.Len(result, 1)
+	s.assert.Len(result, 1)
 }
 
 func TestMapRunSuite(t *testing.T) {
-    suite.Run(t, new(MapTestSuite))
+	suite.Run(t, new(MapTestSuite))
 }
diff --git a/memcached.go b/memcached.go
index 7ff8e0c..b61ddd4 100644
--- a/memcached.go
+++ b/memcached.go
@@ -1,80 +1,80 @@
 package cachego
 
 import (
-    "github.com/bradfitz/gomemcache/memcache"
-    "time"
+	"github.com/bradfitz/gomemcache/memcache"
+	"time"
 )
 
 type (
-    // Memcached it's a wrap around the memcached driver
-    Memcached struct {
-        driver *memcache.Client
-    }
+	// Memcached it's a wrap around the memcached driver
+	Memcached struct {
+		driver *memcache.Client
+	}
 )
 
-// NewMemcached - Create an instance of Memcached
+// NewMemcached creates an instance of Memcached cache driver
 func NewMemcached(driver *memcache.Client) *Memcached {
-    return &Memcached{driver}
+	return &Memcached{driver}
 }
 
-// Check if cached key exists in Memcached storage
+// Contains checks if cached key exists in Memcached storage
 func (m *Memcached) Contains(key string) bool {
-    if _, err := m.Fetch(key); err != nil {
-        return false
-    }
+	if _, err := m.Fetch(key); err != nil {
+		return false
+	}
 
-    return true
+	return true
 }
 
 // Delete the cached key from Memcached storage
 func (m *Memcached) Delete(key string) error {
-    return m.driver.Delete(key)
+	return m.driver.Delete(key)
 }
 
-// Retrieve the cached value from key of the Memcached storage
+// Fetch retrieves the cached value from key of the Memcached storage
 func (m *Memcached) Fetch(key string) (string, error) {
-    item, err := m.driver.Get(key)
+	item, err := m.driver.Get(key)
 
-    if err != nil {
-        return "", err
-    }
+	if err != nil {
+		return "", err
+	}
 
-    value := string(item.Value[:])
+	value := string(item.Value[:])
 
-    return value, nil
+	return value, nil
 }
 
-// Retrieve multiple cached value from keys of the Memcached storage
+// FetchMulti retrieves multiple cached value from keys of the Memcached storage
 func (m *Memcached) FetchMulti(keys []string) map[string]string {
-    result := make(map[string]string)
+	result := make(map[string]string)
 
-    items, err := m.driver.GetMulti(keys)
+	items, err := m.driver.GetMulti(keys)
 
-    if err != nil {
-        return result
-    }
+	if err != nil {
+		return result
+	}
 
-    for _, i := range items {
-        result[i.Key] = string(i.Value[:])
-    }
+	for _, i := range items {
+		result[i.Key] = string(i.Value[:])
+	}
 
-    return result
+	return result
 }
 
-// Remove all cached keys in Memcached storage
+// Flush removes all cached keys of the Memcached storage
 func (m *Memcached) Flush() error {
-    return m.driver.FlushAll()
+	return m.driver.FlushAll()
 }
 
 // Save a value in Memcached storage by key
 func (m *Memcached) Save(key string, value string, lifeTime time.Duration) error {
-    err := m.driver.Set(
-        &memcache.Item{
-            Key:        key,
-            Value:      []byte(value),
-            Expiration: int32(lifeTime.Seconds()),
-        },
-    )
-
-    return err
+	err := m.driver.Set(
+		&memcache.Item{
+			Key:        key,
+			Value:      []byte(value),
+			Expiration: int32(lifeTime.Seconds()),
+		},
+	)
+
+	return err
 }
diff --git a/memcached_test.go b/memcached_test.go
index 1cac170..da28773 100644
--- a/memcached_test.go
+++ b/memcached_test.go
@@ -1,130 +1,130 @@
 package cachego
 
 import (
-    "github.com/bradfitz/gomemcache/memcache"
-    "github.com/stretchr/testify/assert"
-    "github.com/stretchr/testify/suite"
-    "net"
-    "testing"
+	"github.com/bradfitz/gomemcache/memcache"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"net"
+	"testing"
 )
 
 type MemcachedTestSuite struct {
-    suite.Suite
+	suite.Suite
 
-    assert *assert.Assertions
-    cache  Cache
+	assert *assert.Assertions
+	cache  Cache
 }
 
 func (s *MemcachedTestSuite) SetupTest() {
-    address := "localhost:11211"
-    conn := memcache.New(address)
+	address := "localhost:11211"
+	conn := memcache.New(address)
 
-    if _, err := net.Dial("tcp", address); err != nil {
-        s.T().Skip()
-    }
+	if _, err := net.Dial("tcp", address); err != nil {
+		s.T().Skip()
+	}
 
-    s.cache = NewMemcached(conn)
+	s.cache = NewMemcached(conn)
 
-    s.assert = assert.New(s.T())
+	s.assert = assert.New(s.T())
 }
 
 func (s *MemcachedTestSuite) TestSaveThrowError() {
-    memcached := memcache.New("127.0.0.1:22222")
+	memcached := memcache.New("127.0.0.1:22222")
 
-    cache := NewMemcached(memcached)
+	cache := NewMemcached(memcached)
 
-    s.assert.Error(cache.Save("foo", "bar", 0))
+	s.assert.Error(cache.Save("foo", "bar", 0))
 }
 
 func (s *MemcachedTestSuite) TestSave() {
-    s.assert.Nil(s.cache.Save("foo", "bar", 0))
+	s.assert.Nil(s.cache.Save("foo", "bar", 0))
 }
 
 func (s *MemcachedTestSuite) TestFetchThrowError() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    memcached := memcache.New("127.0.0.1:22222")
-    cache := NewMemcached(memcached)
+	memcached := memcache.New("127.0.0.1:22222")
+	cache := NewMemcached(memcached)
 
-    result, err := cache.Fetch(key)
+	result, err := cache.Fetch(key)
 
-    s.assert.Error(err)
-    s.assert.Empty(result)
+	s.assert.Error(err)
+	s.assert.Empty(result)
 }
 
 func (s *MemcachedTestSuite) TestFetch() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *MemcachedTestSuite) TestContains() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.True(s.cache.Contains("foo"))
-    s.assert.False(s.cache.Contains("bar"))
+	s.assert.True(s.cache.Contains("foo"))
+	s.assert.False(s.cache.Contains("bar"))
 }
 
 func (s *MemcachedTestSuite) TestDeleteThrowError() {
-    s.assert.Error(s.cache.Delete("bar"))
+	s.assert.Error(s.cache.Delete("bar"))
 }
 
 func (s *MemcachedTestSuite) TestDelete() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Delete("foo"))
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *MemcachedTestSuite) TestFlushThrowError() {
-    memcached := memcache.New("127.0.0.1:22222")
+	memcached := memcache.New("127.0.0.1:22222")
 
-    cache := NewMemcached(memcached)
+	cache := NewMemcached(memcached)
 
-    s.assert.Error(cache.Flush())
+	s.assert.Error(cache.Flush())
 }
 
 func (s *MemcachedTestSuite) TestFlush() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Flush())
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Flush())
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *MemcachedTestSuite) TestFetchMultiReturnNoItemsWhenThrowError() {
-    cache := NewMemcached(memcache.New("127.0.0.1:22222"))
+	cache := NewMemcached(memcache.New("127.0.0.1:22222"))
 
-    result := cache.FetchMulti([]string{"foo"})
+	result := cache.FetchMulti([]string{"foo"})
 
-    s.assert.Len(result, 0)
+	s.assert.Len(result, 0)
 }
 
 func (s *MemcachedTestSuite) TestFetchMulti() {
-    s.cache.Save("foo", "bar", 0)
-    s.cache.Save("john", "doe", 0)
+	s.cache.Save("foo", "bar", 0)
+	s.cache.Save("john", "doe", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "john"})
+	result := s.cache.FetchMulti([]string{"foo", "john"})
 
-    s.assert.Len(result, 2)
+	s.assert.Len(result, 2)
 }
 
 func (s *MemcachedTestSuite) TestFetchMultiWhenOnlyOneOfKeysExists() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "alice"})
+	result := s.cache.FetchMulti([]string{"foo", "alice"})
 
-    s.assert.Len(result, 1)
+	s.assert.Len(result, 1)
 }
 
 func TestMemcachedRunSuite(t *testing.T) {
-    suite.Run(t, new(MemcachedTestSuite))
+	suite.Run(t, new(MemcachedTestSuite))
 }
diff --git a/mongo.go b/mongo.go
index 9a79321..1d7a6f5 100644
--- a/mongo.go
+++ b/mongo.go
@@ -1,106 +1,106 @@
 package cachego
 
 import (
-    "errors"
-    "gopkg.in/mgo.v2"
-    "gopkg.in/mgo.v2/bson"
-    "time"
+	"errors"
+	"gopkg.in/mgo.v2"
+	"gopkg.in/mgo.v2/bson"
+	"time"
 )
 
 type (
-    // Mongo it's a wrap around the mgo driver
-    Mongo struct {
-        collection *mgo.Collection
-    }
-
-    // MongoContent it's a bson structure of cached value
-    MongoContent struct {
-        Duration int64
-        Key      string `bson:"_id"`
-        Value    string
-    }
+	// Mongo it's a wrap around the mgo driver
+	Mongo struct {
+		collection *mgo.Collection
+	}
+
+	// MongoContent it's a bson structure of cached value
+	MongoContent struct {
+		Duration int64
+		Key      string `bson:"_id"`
+		Value    string
+	}
 )
 
-// NewMongo - Create an instance of Mongo
+// NewMongo creates an instance of Mongo cache driver
 func NewMongo(collection *mgo.Collection) *Mongo {
-    return &Mongo{collection}
+	return &Mongo{collection}
 }
 
-// Check if cached key exists in Mongo storage
+// Contains checks if cached key exists in Mongo storage
 func (m *Mongo) Contains(key string) bool {
-    if _, err := m.Fetch(key); err != nil {
-        return false
-    }
+	if _, err := m.Fetch(key); err != nil {
+		return false
+	}
 
-    return true
+	return true
 }
 
 // Delete the cached key from Mongo storage
 func (m *Mongo) Delete(key string) error {
-    return m.collection.Remove(bson.M{"_id": key})
+	return m.collection.Remove(bson.M{"_id": key})
 }
 
-// Retrieve the cached value from key of the Mongo storage
+// Fetch retrieves the cached value from key of the Mongo storage
 func (m *Mongo) Fetch(key string) (string, error) {
-    content := &MongoContent{}
+	content := &MongoContent{}
 
-    err := m.collection.Find(bson.M{"_id": key}).One(content)
+	err := m.collection.Find(bson.M{"_id": key}).One(content)
 
-    if err != nil {
-        return "", err
-    }
+	if err != nil {
+		return "", err
+	}
 
-    if content.Duration == 0 {
-        return content.Value, nil
-    }
+	if content.Duration == 0 {
+		return content.Value, nil
+	}
 
-    if content.Duration <= time.Now().Unix() {
-        m.Delete(key)
-        return "", errors.New("Cache expired")
-    }
+	if content.Duration <= time.Now().Unix() {
+		m.Delete(key)
+		return "", errors.New("Cache expired")
+	}
 
-    return content.Value, nil
+	return content.Value, nil
 }
 
-// Retrieve multiple cached value from keys of the Mongo storage
+// FetchMulti retrieves multiple cached value from keys of the Mongo storage
 func (m *Mongo) FetchMulti(keys []string) map[string]string {
-    result := make(map[string]string)
+	result := make(map[string]string)
 
-    iter := m.collection.Find(bson.M{"_id": bson.M{"$in": keys}}).Iter()
+	iter := m.collection.Find(bson.M{"_id": bson.M{"$in": keys}}).Iter()
 
-    content := &MongoContent{}
+	content := &MongoContent{}
 
-    for iter.Next(content) {
-        result[content.Key] = content.Value
-    }
+	for iter.Next(content) {
+		result[content.Key] = content.Value
+	}
 
-    return result
+	return result
 }
 
-// Remove all cached keys in Mongo storage
+// Flush removes all cached keys of the Mongo storage
 func (m *Mongo) Flush() error {
-    _, err := m.collection.RemoveAll(bson.M{})
+	_, err := m.collection.RemoveAll(bson.M{})
 
-    return err
+	return err
 }
 
 // Save a value in Mongo storage by key
 func (m *Mongo) Save(key string, value string, lifeTime time.Duration) error {
-    duration := int64(0)
+	duration := int64(0)
 
-    if lifeTime > 0 {
-        duration = time.Now().Unix() + int64(lifeTime.Seconds())
-    }
+	if lifeTime > 0 {
+		duration = time.Now().Unix() + int64(lifeTime.Seconds())
+	}
 
-    content := &MongoContent{
-        duration,
-        key,
-        value,
-    }
+	content := &MongoContent{
+		duration,
+		key,
+		value,
+	}
 
-    if _, err := m.collection.Upsert(bson.M{"_id": key}, content); err != nil {
-        return err
-    }
+	if _, err := m.collection.Upsert(bson.M{"_id": key}, content); err != nil {
+		return err
+	}
 
-    return nil
+	return nil
 }
diff --git a/mongo_test.go b/mongo_test.go
index 94f9413..e352305 100644
--- a/mongo_test.go
+++ b/mongo_test.go
@@ -1,130 +1,130 @@
 package cachego
 
 import (
-    "github.com/stretchr/testify/assert"
-    "github.com/stretchr/testify/suite"
-    "gopkg.in/mgo.v2"
-    "net"
-    "testing"
-    "time"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"gopkg.in/mgo.v2"
+	"net"
+	"testing"
+	"time"
 )
 
 type MongoTestSuite struct {
-    suite.Suite
+	suite.Suite
 
-    assert  *assert.Assertions
-    cache   Cache
-    session *mgo.Session
+	assert  *assert.Assertions
+	cache   Cache
+	session *mgo.Session
 }
 
 func (s *MongoTestSuite) SetupTest() {
-    address := "localhost:27017"
+	address := "localhost:27017"
 
-    if _, err := net.Dial("tcp", address); err != nil {
-        s.T().Skip()
-    }
+	if _, err := net.Dial("tcp", address); err != nil {
+		s.T().Skip()
+	}
 
-    session, err := mgo.Dial(address)
+	session, err := mgo.Dial(address)
 
-    if err != nil {
-        s.T().Skip()
-    }
+	if err != nil {
+		s.T().Skip()
+	}
 
-    s.cache = NewMongo(session.DB("cache").C("cache"))
+	s.cache = NewMongo(session.DB("cache").C("cache"))
 
-    s.assert = assert.New(s.T())
+	s.assert = assert.New(s.T())
 }
 
 func (s *MongoTestSuite) TestSave() {
-    s.assert.Nil(s.cache.Save("foo", "bar", 10))
+	s.assert.Nil(s.cache.Save("foo", "bar", 10))
 }
 
 func (s *MongoTestSuite) TestFetchThrowError() {
-    result, err := s.cache.Fetch("bar")
+	result, err := s.cache.Fetch("bar")
 
-    s.assert.Error(err)
-    s.assert.Empty(result)
+	s.assert.Error(err)
+	s.assert.Empty(result)
 }
 
 func (s *MongoTestSuite) TestFetchThrowErrorWhenExpired() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 1*time.Second)
+	s.cache.Save(key, value, 1*time.Second)
 
-    time.Sleep(1 * time.Second)
+	time.Sleep(1 * time.Second)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.EqualError(err, "Cache expired")
-    s.assert.Empty(result)
+	s.assert.EqualError(err, "Cache expired")
+	s.assert.Empty(result)
 }
 
 func (s *MongoTestSuite) TestFetch() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *MongoTestSuite) TestFetchLongCacheDuration() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 10*time.Second)
-    result, err := s.cache.Fetch(key)
+	s.cache.Save(key, value, 10*time.Second)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *MongoTestSuite) TestContains() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.True(s.cache.Contains("foo"))
-    s.assert.False(s.cache.Contains("bar"))
+	s.assert.True(s.cache.Contains("foo"))
+	s.assert.False(s.cache.Contains("bar"))
 }
 
 func (s *MongoTestSuite) TestDeleteThrowError() {
-    s.assert.Error(s.cache.Delete("bar"))
+	s.assert.Error(s.cache.Delete("bar"))
 }
 
 func (s *MongoTestSuite) TestDelete() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Delete("foo"))
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *MongoTestSuite) TestFlush() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Flush())
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Flush())
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *MongoTestSuite) TestFetchMulti() {
-    s.cache.Save("foo", "bar", 0)
-    s.cache.Save("john", "doe", 0)
+	s.cache.Save("foo", "bar", 0)
+	s.cache.Save("john", "doe", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "john"})
+	result := s.cache.FetchMulti([]string{"foo", "john"})
 
-    s.assert.Len(result, 2)
+	s.assert.Len(result, 2)
 }
 
 func (s *MongoTestSuite) TestFetchMultiWhenOnlyOneOfKeysExists() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "alice"})
+	result := s.cache.FetchMulti([]string{"foo", "alice"})
 
-    s.assert.Len(result, 1)
+	s.assert.Len(result, 1)
 }
 
 func TestMongoRunSuite(t *testing.T) {
-    suite.Run(t, new(MongoTestSuite))
+	suite.Run(t, new(MongoTestSuite))
 }
diff --git a/redis.go b/redis.go
index bbc6234..7a29fa6 100644
--- a/redis.go
+++ b/redis.go
@@ -1,74 +1,74 @@
 package cachego
 
 import (
-    "gopkg.in/redis.v4"
-    "time"
+	"gopkg.in/redis.v4"
+	"time"
 )
 
 type (
-    // Redis it's a wrap around the redis driver
-    Redis struct {
-        driver *redis.Client
-    }
+	// Redis it's a wrap around the redis driver
+	Redis struct {
+		driver *redis.Client
+	}
 )
 
-// NewRedis - Create an instance of Redis
+// NewRedis creates an instance of Redis cache driver
 func NewRedis(driver *redis.Client) *Redis {
-    return &Redis{driver}
+	return &Redis{driver}
 }
 
-// Check if cached key exists in Redis storage
+// Contains checks if cached key exists in Redis storage
 func (r *Redis) Contains(key string) bool {
-    status, err := r.driver.Exists(key).Result()
+	status, err := r.driver.Exists(key).Result()
 
-    if err != nil {
-        return false
-    }
+	if err != nil {
+		return false
+	}
 
-    return status
+	return status
 }
 
 // Delete the cached key from Redis storage
 func (r *Redis) Delete(key string) error {
-    return r.driver.Del(key).Err()
+	return r.driver.Del(key).Err()
 }
 
-// Retrieve the cached value from key of the Redis storage
+// Fetch retrieves the cached value from key of the Redis storage
 func (r *Redis) Fetch(key string) (string, error) {
-    value, err := r.driver.Get(key).Result()
+	value, err := r.driver.Get(key).Result()
 
-    if err != nil {
-        return "", err
-    }
+	if err != nil {
+		return "", err
+	}
 
-    return value, nil
+	return value, nil
 }
 
-// Retrieve multiple cached value from keys of the Redis storage
+// FetchMulti retrieves multiple cached value from keys of the Redis storage
 func (r *Redis) FetchMulti(keys []string) map[string]string {
-    result := make(map[string]string)
+	result := make(map[string]string)
 
-    items, err := r.driver.MGet(keys...).Result()
+	items, err := r.driver.MGet(keys...).Result()
 
-    if err != nil {
-        return result
-    }
+	if err != nil {
+		return result
+	}
 
-    for i := 0; i < len(keys); i++ {
-        if items[i] != nil {
-            result[keys[i]] = items[i].(string)
-        }
-    }
+	for i := 0; i < len(keys); i++ {
+		if items[i] != nil {
+			result[keys[i]] = items[i].(string)
+		}
+	}
 
-    return result
+	return result
 }
 
-// Remove all cached keys in Redis storage
+// Flush removes all cached keys of the Redis storage
 func (r *Redis) Flush() error {
-    return r.driver.FlushAll().Err()
+	return r.driver.FlushAll().Err()
 }
 
 // Save a value in Redis storage by key
 func (r *Redis) Save(key string, value string, lifeTime time.Duration) error {
-    return r.driver.Set(key, value, lifeTime).Err()
+	return r.driver.Set(key, value, lifeTime).Err()
 }
diff --git a/redis_test.go b/redis_test.go
index f7a7072..4530924 100644
--- a/redis_test.go
+++ b/redis_test.go
@@ -1,155 +1,155 @@
 package cachego
 
 import (
-    "github.com/stretchr/testify/assert"
-    "github.com/stretchr/testify/suite"
-    "gopkg.in/redis.v4"
-    "net"
-    "testing"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+	"gopkg.in/redis.v4"
+	"net"
+	"testing"
 )
 
 type RedisTestSuite struct {
-    suite.Suite
+	suite.Suite
 
-    assert *assert.Assertions
-    cache  Cache
+	assert *assert.Assertions
+	cache  Cache
 }
 
 func (s *RedisTestSuite) SetupTest() {
-    conn := redis.NewClient(&redis.Options{
-        Addr: ":6379",
-    })
+	conn := redis.NewClient(&redis.Options{
+		Addr: ":6379",
+	})
 
-    if _, err := net.Dial("tcp", "localhost:6379"); err != nil {
-        s.T().Skip()
-    }
+	if _, err := net.Dial("tcp", "localhost:6379"); err != nil {
+		s.T().Skip()
+	}
 
-    s.cache = NewRedis(conn)
-    s.assert = assert.New(s.T())
+	s.cache = NewRedis(conn)
+	s.assert = assert.New(s.T())
 }
 
 func (s *RedisTestSuite) TestSaveThrowError() {
-    redis := redis.NewClient(&redis.Options{
-        Addr: ":6380",
-    })
+	redis := redis.NewClient(&redis.Options{
+		Addr: ":6380",
+	})
 
-    cache := NewRedis(redis)
+	cache := NewRedis(redis)
 
-    s.assert.Error(cache.Save("foo", "bar", 0))
+	s.assert.Error(cache.Save("foo", "bar", 0))
 }
 
 func (s *RedisTestSuite) TestSave() {
-    s.assert.Nil(s.cache.Save("foo", "bar", 0))
+	s.assert.Nil(s.cache.Save("foo", "bar", 0))
 }
 
 func (s *RedisTestSuite) TestFetchThrowError() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    redis := redis.NewClient(&redis.Options{
-        Addr: ":6380",
-    })
+	redis := redis.NewClient(&redis.Options{
+		Addr: ":6380",
+	})
 
-    cache := NewRedis(redis)
+	cache := NewRedis(redis)
 
-    result, err := cache.Fetch(key)
+	result, err := cache.Fetch(key)
 
-    s.assert.Error(err)
-    s.assert.Empty(result)
+	s.assert.Error(err)
+	s.assert.Empty(result)
 }
 
 func (s *RedisTestSuite) TestFetch() {
-    key := "foo"
-    value := "bar"
+	key := "foo"
+	value := "bar"
 
-    s.cache.Save(key, value, 0)
+	s.cache.Save(key, value, 0)
 
-    result, err := s.cache.Fetch(key)
+	result, err := s.cache.Fetch(key)
 
-    s.assert.Nil(err)
-    s.assert.Equal(value, result)
+	s.assert.Nil(err)
+	s.assert.Equal(value, result)
 }
 
 func (s *RedisTestSuite) TestContainsThrowError() {
-    redis := redis.NewClient(&redis.Options{
-        Addr: ":6380",
-    })
+	redis := redis.NewClient(&redis.Options{
+		Addr: ":6380",
+	})
 
-    cache := NewRedis(redis)
+	cache := NewRedis(redis)
 
-    s.assert.False(cache.Contains("bar"))
+	s.assert.False(cache.Contains("bar"))
 }
 
 func (s *RedisTestSuite) TestContains() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.True(s.cache.Contains("foo"))
-    s.assert.False(s.cache.Contains("bar"))
+	s.assert.True(s.cache.Contains("foo"))
+	s.assert.False(s.cache.Contains("bar"))
 }
 
 func (s *RedisTestSuite) TestDeleteThrowError() {
-    redis := redis.NewClient(&redis.Options{
-        Addr: ":6380",
-    })
+	redis := redis.NewClient(&redis.Options{
+		Addr: ":6380",
+	})
 
-    cache := NewRedis(redis)
-    s.assert.Error(cache.Delete("bar"))
+	cache := NewRedis(redis)
+	s.assert.Error(cache.Delete("bar"))
 }
 
 func (s *RedisTestSuite) TestDelete() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Delete("foo"))
-    s.assert.False(s.cache.Contains("foo"))
-    s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.Nil(s.cache.Delete("foo"))
+	s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Delete("foo"))
 }
 
 func (s *RedisTestSuite) TestFlushThrowError() {
-    redis := redis.NewClient(&redis.Options{
-        Addr: ":6380",
-    })
+	redis := redis.NewClient(&redis.Options{
+		Addr: ":6380",
+	})
 
-    cache := NewRedis(redis)
+	cache := NewRedis(redis)
 
-    s.assert.Error(cache.Flush())
+	s.assert.Error(cache.Flush())
 }
 
 func (s *RedisTestSuite) TestFlush() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    s.assert.Nil(s.cache.Flush())
-    s.assert.False(s.cache.Contains("foo"))
+	s.assert.Nil(s.cache.Flush())
+	s.assert.False(s.cache.Contains("foo"))
 }
 
 func (s *RedisTestSuite) TestFetchMultiReturnNoItemsWhenThrowError() {
-    cache := NewRedis(redis.NewClient(&redis.Options{
-        Addr: ":6380",
-    }))
+	cache := NewRedis(redis.NewClient(&redis.Options{
+		Addr: ":6380",
+	}))
 
-    result := cache.FetchMulti([]string{"foo"})
+	result := cache.FetchMulti([]string{"foo"})
 
-    s.assert.Len(result, 0)
+	s.assert.Len(result, 0)
 }
 
 func (s *RedisTestSuite) TestFetchMulti() {
-    s.cache.Save("foo", "bar", 0)
-    s.cache.Save("john", "doe", 0)
+	s.cache.Save("foo", "bar", 0)
+	s.cache.Save("john", "doe", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "john"})
+	result := s.cache.FetchMulti([]string{"foo", "john"})
 
-    s.assert.Len(result, 2)
+	s.assert.Len(result, 2)
 }
 
 func (s *RedisTestSuite) TestFetchMultiWhenOnlyOneOfKeysExists() {
-    s.cache.Save("foo", "bar", 0)
+	s.cache.Save("foo", "bar", 0)
 
-    result := s.cache.FetchMulti([]string{"foo", "alice"})
+	result := s.cache.FetchMulti([]string{"foo", "alice"})
 
-    s.assert.Len(result, 1)
+	s.assert.Len(result, 1)
 }
 
 func TestRedisRunSuite(t *testing.T) {
-    suite.Run(t, new(RedisTestSuite))
+	suite.Run(t, new(RedisTestSuite))
 }
diff --git a/sqlite3.go b/sqlite3.go
index 1cd2264..56faef2 100644
--- a/sqlite3.go
+++ b/sqlite3.go
@@ -8,14 +8,14 @@ import (
 )
 
 type (
-	// Sqlite3 store for caching data
+	// Sqlite3 it's a wrap around the sqlite3 driver
 	Sqlite3 struct {
 		db    *sql.DB
 		table string
 	}
 )
 
-// NewSqlite3 - Create an instance of Sqlite3
+// NewSqlite3 creates an instance of Sqlite3 cache driver
 func NewSqlite3(db *sql.DB, table string) (*Sqlite3, error) {
 	if err := createTable(db, table); err != nil {
 		return nil, errors.Wrap(err, "Unable to create database table")
@@ -36,7 +36,7 @@ func createTable(db *sql.DB, table string) error {
 	return err
 }
 
-// Check if cached key exists in SQL storage
+// Contains checks if cached key exists in Sqlite3 storage
 func (s *Sqlite3) Contains(key string) bool {
 	if _, err := s.Fetch(key); err != nil {
 		return false
@@ -74,7 +74,7 @@ func (s *Sqlite3) Delete(key string) error {
 	return nil
 }
 
-// Retrieve the cached value from key of the Sqlite3 storage
+// Fetch retrieves the cached value from key of the Sqlite3 storage
 func (s *Sqlite3) Fetch(key string) (string, error) {
 	stmt, err := s.db.Prepare(
 		fmt.Sprintf("SELECT value, lifetime FROM %s WHERE key = ?", s.table),
@@ -108,7 +108,7 @@ func (s *Sqlite3) Fetch(key string) (string, error) {
 	return value, nil
 }
 
-// Retrieve multiple cached value from keys of the Sqlite3 storage
+// FetchMulti retrieves multiple cached value from keys of the Sqlite3 storage
 func (s *Sqlite3) FetchMulti(keys []string) map[string]string {
 	result := make(map[string]string)
 
@@ -121,7 +121,7 @@ func (s *Sqlite3) FetchMulti(keys []string) map[string]string {
 	return result
 }
 
-// Remove all cached keys in Sqlite3 storage
+// Flush removes all cached keys of the Sqlite3 storage
 func (s *Sqlite3) Flush() error {
 	tx, err := s.db.Begin()