diff --git a/cmd/go-semantic-release/commands/changelog.go b/cmd/go-semantic-release/commands/changelog.go
index 98968f1..625b020 100644
--- a/cmd/go-semantic-release/commands/changelog.go
+++ b/cmd/go-semantic-release/commands/changelog.go
@@ -40,12 +40,18 @@ var changelogCmd = &cobra.Command{
 			return err
 		}
 
-		releaseVersion, err := s.GetNextVersion(force)
+		provider, err := s.GetCIProvider()
 		if err != nil {
 			return err
 		}
 
-		generatedChangelog, err := s.GetChangelog(releaseVersion)
+		releaseVersion, commits, err := s.GetNextVersion(provider, force)
+		if err != nil {
+			return err
+		}
+		log.Debugf("Found %d commits till last release", len(commits))
+
+		generatedChangelog, err := s.GetChangelog(commits, releaseVersion)
 		if err != nil {
 			return err
 		}
diff --git a/cmd/go-semantic-release/commands/next.go b/cmd/go-semantic-release/commands/next.go
index 0f64259..65ed0bc 100644
--- a/cmd/go-semantic-release/commands/next.go
+++ b/cmd/go-semantic-release/commands/next.go
@@ -2,8 +2,8 @@ package commands
 
 import (
 	"fmt"
-
 	"github.com/Nightapes/go-semantic-release/pkg/semanticrelease"
+	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )
 
@@ -35,7 +35,15 @@ var nextCmd = &cobra.Command{
 			return err
 		}
 
-		releaseVersion, err := s.GetNextVersion(force)
+		provider, err := s.GetCIProvider()
+
+		if err != nil {
+			log.Infof("Will not calculate version, set fake version. Could not find CI Provider, if running locally, set env CI=true")
+			fmt.Println("0.0.0-fake.0")
+			return nil
+		}
+
+		releaseVersion, _, err := s.GetNextVersion(provider, force)
 		if err != nil {
 			return err
 		}
diff --git a/cmd/go-semantic-release/commands/release.go b/cmd/go-semantic-release/commands/release.go
index 7d981ca..efdd0f8 100644
--- a/cmd/go-semantic-release/commands/release.go
+++ b/cmd/go-semantic-release/commands/release.go
@@ -32,6 +32,12 @@ var releaseCmd = &cobra.Command{
 		if err != nil {
 			return err
 		}
-		return s.Release(force)
+
+		provider, err := s.GetCIProvider()
+		if err != nil {
+			return err
+		}
+
+		return s.Release(provider, force)
 	},
 }
diff --git a/cmd/go-semantic-release/commands/set.go b/cmd/go-semantic-release/commands/set.go
index 2f580fe..e98618d 100644
--- a/cmd/go-semantic-release/commands/set.go
+++ b/cmd/go-semantic-release/commands/set.go
@@ -31,6 +31,11 @@ var setCmd = &cobra.Command{
 			return err
 		}
 
-		return s.SetVersion(args[0])
+		provider, err := s.GetCIProvider()
+		if err != nil {
+			return err
+		}
+
+		return s.SetVersion(provider, args[0])
 	},
 }
diff --git a/internal/cache/cache.go b/internal/cache/cache.go
index d459028..0c33d48 100644
--- a/internal/cache/cache.go
+++ b/internal/cache/cache.go
@@ -47,7 +47,7 @@ func Write(repository string, releaseVersion shared.ReleaseVersion) error {
 		return err
 	}
 
-	log.Debugf("Save %s with hash %s to cache", releaseVersion.Next.Version.String(), releaseVersion.Next.Commit)
+	log.Infof("Save %s with hash %s to cache", releaseVersion.Next.Version.String(), releaseVersion.Next.Commit)
 	return ioutil.WriteFile(completePath, data, 0644)
 }
 
diff --git a/internal/ci/ci.go b/internal/ci/ci.go
index 124e9a9..4f1acd6 100644
--- a/internal/ci/ci.go
+++ b/internal/ci/ci.go
@@ -51,7 +51,7 @@ func GetCIProvider(gitUtil *gitutil.GitUtil, envs map[string]string) (*ProviderC
 			log.Infof("Found CI: %s", config.Name)
 			return config, nil
 		}
-		log.Infof("%s", err.Error())
+		log.Debugf("%s", err.Error())
 	}
 	return nil, fmt.Errorf("could not find any CI, if running locally set env CI=true")
 }
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 62a2a4d..7c08d77 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -55,7 +55,7 @@ func Read(configPath string) (*ReleaseConfig, error) {
 		return &ReleaseConfig{}, err
 	}
 
-	log.Debugf("Found config %+v", releaseConfig)
+	log.Tracef("Found config %+v", releaseConfig)
 
 	return &releaseConfig, nil
 }
diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go
new file mode 100644
index 0000000..ca3cc13
--- /dev/null
+++ b/pkg/config/config_test.go
@@ -0,0 +1,112 @@
+package config_test
+
+import (
+	"testing"
+
+	"github.com/Nightapes/go-semantic-release/pkg/config"
+	"github.com/stretchr/testify/assert"
+	"io/ioutil"
+	"os"
+	"path"
+)
+
+func TestReadCacheNotFound(t *testing.T) {
+
+	_, err := config.Read("notfound/dir")
+	assert.Errorf(t, err, "Read non exsiting file")
+
+}
+
+func TestReadCacheInvalidContent(t *testing.T) {
+
+	dir, err := ioutil.TempDir("", "prefix")
+	assert.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	completePath := path.Join(path.Dir(dir), ".release.yml")
+	brokenContent := []byte("hello broken\ngo: lang\n")
+	err = ioutil.WriteFile(completePath, brokenContent, 0644)
+	assert.NoError(t, err)
+
+	_, readError := config.Read(completePath)
+	assert.Errorf(t, readError, "Should give error, when broken content")
+
+}
+
+func TestWriteAndReadCache(t *testing.T) {
+
+	dir, err := ioutil.TempDir("", "prefix")
+
+	assert.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	completePath := path.Join(path.Dir(dir), ".release.yml")
+	content := []byte(`
+commitFormat: angular
+title: "go-semantic-release release"
+branch:
+  master: release
+  rc: rc
+  beta: beta
+  alpha: alpha
+  add_git_releases: alpha
+changelog:
+  printAll: false
+  template: ''
+  templatePath: ''
+release: 'github'
+assets:
+  - name: ./build/go-semantic-release
+    compress: false
+github:
+  repo: "go-semantic-release"
+  user: "nightapes"
+  customUrl: ""
+`)
+	err = ioutil.WriteFile(completePath, content, 0644)
+	assert.NoError(t, err)
+
+	result, readError := config.Read(completePath)
+	assert.NoErrorf(t, readError, "Should read file")
+
+	assert.EqualValues(t, &config.ReleaseConfig{
+		CommitFormat: "angular",
+		Branch:       map[string]string{"add_git_releases": "alpha", "alpha": "alpha", "beta": "beta", "master": "release", "rc": "rc"},
+		Changelog: config.ChangelogConfig{
+			PrintAll:     false,
+			Template:     "",
+			TemplatePath: ""},
+		Release: "github",
+		GitHubProvider: config.GitHubProvider{
+			Repo:        "go-semantic-release",
+			User:        "nightapes",
+			CustomURL:   "",
+			AccessToken: ""},
+		Assets: []config.Asset{
+			config.Asset{
+				Name:     "./build/go-semantic-release",
+				Compress: false}},
+		ReleaseTitle: "go-semantic-release release",
+		IsPreRelease: false,
+		IsDraft:      false,
+	}, result)
+
+}
+
+// func TestWriteNotFound(t *testing.T) {
+
+// 	err := cache.Write("notfound/dir", shared.ReleaseVersion{
+// 		Last: shared.ReleaseVersionEntry{
+// 			Commit:  "12345",
+// 			Version: createVersion("1.0.0"),
+// 		},
+// 		Next: shared.ReleaseVersionEntry{
+// 			Commit:  "12346",
+// 			Version: createVersion("1.1.0"),
+// 		},
+// 		Branch: "master",
+// 		Draft:  true,
+// 	})
+// 	assert.Errorf(t, err, "Write non exsiting file")
+
+// }
diff --git a/pkg/semanticrelease/semantic-release.go b/pkg/semanticrelease/semantic-release.go
index bbdade5..4d90658 100644
--- a/pkg/semanticrelease/semantic-release.go
+++ b/pkg/semanticrelease/semantic-release.go
@@ -1,7 +1,6 @@
 package semanticrelease
 
 import (
-	"fmt"
 	"io/ioutil"
 	"strings"
 	"time"
@@ -57,36 +56,28 @@ func New(c *config.ReleaseConfig, repository string) (*SemanticRelease, error) {
 	}, nil
 }
 
+//GetCIProvider result with ci config
+func (s *SemanticRelease) GetCIProvider() (*ci.ProviderConfig, error) {
+	return ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
+}
+
 // GetNextVersion from .version or calculate new from commits
-func (s *SemanticRelease) GetNextVersion(force bool) (*shared.ReleaseVersion, error) {
-	provider, err := ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
-
-	if err != nil {
-		fakeVersion, _ := semver.NewVersion("0.0.0-fake.0")
-		log.Warnf("Will not calculate version, set fake version. Could not find CI Provider, if running locally, set env CI=true")
-		return &shared.ReleaseVersion{
-			Next: shared.ReleaseVersionEntry{
-				Commit:  "",
-				Version: fakeVersion,
-			},
-		}, nil
-	}
-
+func (s *SemanticRelease) GetNextVersion(provider *ci.ProviderConfig, force bool) (*shared.ReleaseVersion, map[analyzer.Release][]analyzer.AnalyzedCommit, error) {
 	log.Debugf("Ignore .version file if exits, %t", force)
 	if !force {
 		releaseVersion, err := cache.Read(s.repository)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
 		if releaseVersion.Next.Commit == provider.Commit && releaseVersion != nil {
-			return releaseVersion, nil
+			return releaseVersion, nil, nil
 		}
 	}
 
 	lastVersion, lastVersionHash, err := s.gitutil.GetLastVersion()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	firstRelease := false
@@ -99,22 +90,19 @@ func (s *SemanticRelease) GetNextVersion(force bool) (*shared.ReleaseVersion, er
 
 	commits, err := s.gitutil.GetCommits(lastVersionHash)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	log.Debugf("Found %d commits till last release", len(commits))
 
-	a, err := analyzer.New(s.config.CommitFormat, s.config.Changelog)
-	if err != nil {
-		return nil, err
-	}
+	analyzedCommits := s.analyzer.Analyze(commits)
 
 	isDraft := false
 	var newVersion semver.Version
 	for branch, releaseType := range s.config.Branch {
 		if provider.Branch == branch || strings.HasPrefix(provider.Branch, branch) {
 			log.Debugf("Found branch config for branch %s with release type %s", provider.Branch, releaseType)
-			newVersion, isDraft = s.calculator.CalculateNewVersion(a.Analyze(commits), lastVersion, releaseType, firstRelease)
+			newVersion, isDraft = s.calculator.CalculateNewVersion(analyzedCommits, lastVersion, releaseType, firstRelease)
 			break
 		}
 	}
@@ -135,25 +123,19 @@ func (s *SemanticRelease) GetNextVersion(force bool) (*shared.ReleaseVersion, er
 	log.Infof("New version %s -> %s", lastVersion.String(), newVersion.String())
 	err = cache.Write(s.repository, releaseVersion)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	return &releaseVersion, err
+	return &releaseVersion, analyzedCommits, err
 }
 
 //SetVersion for git repository
-func (s *SemanticRelease) SetVersion(version string) error {
+func (s *SemanticRelease) SetVersion(provider *ci.ProviderConfig, version string) error {
 
 	newVersion, err := semver.NewVersion(version)
 	if err != nil {
 		return err
 	}
 
-	provider, err := ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
-
-	if err != nil {
-		return fmt.Errorf("will not set version. Could not find CI Provider, if running locally, set env CI=true")
-	}
-
 	lastVersion, lastVersionHash, err := s.gitutil.GetLastVersion()
 	if err != nil {
 		return err
@@ -176,23 +158,14 @@ func (s *SemanticRelease) SetVersion(version string) error {
 }
 
 // GetChangelog from last version till now
-func (s *SemanticRelease) GetChangelog(releaseVersion *shared.ReleaseVersion) (*shared.GeneratedChangelog, error) {
-	commits, err := s.gitutil.GetCommits(releaseVersion.Last.Commit)
-	if err != nil {
-		return nil, err
-	}
-
-	result := s.analyzer.Analyze(commits)
-
-	log.Debugf("Found %d commits till last release", len(commits))
-
+func (s *SemanticRelease) GetChangelog(analyzedCommits map[analyzer.Release][]analyzer.AnalyzedCommit, releaseVersion *shared.ReleaseVersion) (*shared.GeneratedChangelog, error) {
 	c := changelog.New(s.config, s.analyzer.GetRules(), time.Now())
 	return c.GenerateChanglog(shared.ChangelogTemplateConfig{
 		Version:    releaseVersion.Next.Version.String(),
 		Hash:       releaseVersion.Last.Commit,
 		CommitURL:  s.releaser.GetCommitURL(),
 		CompareURL: s.releaser.GetCompareURL(releaseVersion.Last.Version.String(), releaseVersion.Next.Version.String()),
-	}, result)
+	}, analyzedCommits)
 
 }
 
@@ -202,14 +175,7 @@ func (s *SemanticRelease) WriteChangeLog(changelogContent, file string) error {
 }
 
 // Release pusblish release to provider
-func (s *SemanticRelease) Release(force bool) error {
-
-	provider, err := ci.GetCIProvider(s.gitutil, ci.ReadAllEnvs())
-
-	if err != nil {
-		log.Debugf("Will not perform a new release. Could not find CI Provider")
-		return nil
-	}
+func (s *SemanticRelease) Release(provider *ci.ProviderConfig, force bool) error {
 
 	if provider.IsPR {
 		log.Debugf("Will not perform a new release. This is a pull request")
@@ -221,13 +187,18 @@ func (s *SemanticRelease) Release(force bool) error {
 		return nil
 	}
 
-	releaseVersion, err := s.GetNextVersion(force)
+	releaseVersion, analyzedCommits, err := s.GetNextVersion(provider, force)
 	if err != nil {
 		log.Debugf("Could not get next version")
 		return err
 	}
 
-	generatedChanglog, err := s.GetChangelog(releaseVersion)
+	if releaseVersion.Next.Version.Equal(releaseVersion.Next.Version) {
+		log.Infof("No new version, no release needed")
+		return nil
+	}
+
+	generatedChanglog, err := s.GetChangelog(analyzedCommits, releaseVersion)
 	if err != nil {
 		log.Debugf("Could not get changelog")
 		return err