Merge pull request #15 from luizvnasc/issue_13

Criado package config

config/config.go

@@ -0,0 +1,58 @@
+// Package config obtém as configurações da app que estão nas variáveis de ambiente
+package config
+
+import "os"
+
+const (
+	prefix     = "CWBUS_"
+	serviceURL = "URBS_SERVICE_URL"
+	urbsCode   = "URBS_CODE"
+	dbStrConn  = "DB_URL"
+	dbName     = "DB_HIST"
+	wakeUpURL  = "WAKEUP_URL"
+)
+
+// Configurer é a interface que define um configurador no sistema.
+type Configurer interface {
+	ServiceURL() string
+	UrbsCode() string
+	DBName() string
+	DBStrConn() string
+	WakeUpURL() string
+}
+
+// EnvConfigurer é um confiurador que  capitura as configurações das variáveis de ambiente.
+type EnvConfigurer struct{}
+
+func (ec EnvConfigurer) key(name string) string {
+	return prefix + name
+}
+
+func (ec EnvConfigurer) getValue(name string) string {
+	return os.Getenv(ec.key(name))
+}
+
+// ServiceURL retorna a URL dos serviços da urbs.
+func (ec EnvConfigurer) ServiceURL() string {
+	return ec.getValue(serviceURL)
+}
+
+// UrbsCode retorna o código urbs de acesso aos serviços.
+func (ec EnvConfigurer) UrbsCode() string {
+	return ec.getValue(urbsCode)
+}
+
+// DBStrConn retorna a string de conexão do banco de dados.
+func (ec EnvConfigurer) DBStrConn() string {
+	return ec.getValue(dbStrConn)
+}
+
+// DBName retorna o nome do banco de dados.
+func (ec EnvConfigurer) DBName() string {
+	return ec.getValue(dbName)
+}
+
+// WakeUpURL retorna a url utilizada para acordar o dyno do heroku
+func (ec EnvConfigurer) WakeUpURL() string {
+	return ec.getValue(wakeUpURL)
+}

config/config_test.go

@@ -0,0 +1,42 @@
+package config
+
+import (
+	"os"
+	"testing"
+
+	"github.com/luizvnasc/cwbus-hist/test"
+)
+
+func TestConfig(t *testing.T) {
+	ec := EnvConfigurer{}
+	t.Run("Obtendo url de serviços da urbs", func(t *testing.T) {
+		want := os.Getenv("CWBUS_URBS_SERVICE_URL")
+		got := ec.ServiceURL()
+		test.AssertStringsEqual(t, want, got)
+	})
+
+	t.Run("Obtendo codigo urbs", func(t *testing.T) {
+		want := os.Getenv("CWBUS_URBS_CODE")
+		got := ec.UrbsCode()
+		test.AssertStringsEqual(t, want, got)
+	})
+
+	t.Run("Obtendo conexão com o banco", func(t *testing.T) {
+		want := os.Getenv("CWBUS_DB_URL")
+		got := ec.DBStrConn()
+		test.AssertStringsEqual(t, want, got)
+	})
+
+	t.Run("Obtendo nome do banco", func(t *testing.T) {
+		want := os.Getenv("CWBUS_DB_HIST")
+		got := ec.DBName()
+		test.AssertStringsEqual(t, want, got)
+	})
+
+	t.Run("Obtendo url para acordar dyno", func(t *testing.T) {
+		want := os.Getenv("CWBUS_WAKEUP_URL")
+		got := ec.WakeUpURL()
+		test.AssertStringsEqual(t, want, got)
+	})
+
+}

main.go

@@ -7,26 +7,30 @@ import (
 	"log"
 	"os"
 
+	"github.com/luizvnasc/cwbus-hist/config"
 	"github.com/luizvnasc/cwbus-hist/db"
 	"github.com/luizvnasc/cwbus-hist/scheduler"
 	"github.com/luizvnasc/cwbus-hist/server"
 	"github.com/luizvnasc/cwbus-hist/store"
 )
 
 func main() {
+	config := &config.EnvConfigurer{}
+
 	log.Println("Criando cliente mongodb")
 	ctx := context.Background()
-	client, err := db.NewMongoClient(ctx, os.Getenv("CWBUS_DB_URL"))
+	client, err := db.NewMongoClient(ctx, config.DBStrConn())
 	if err != nil {
 		log.Fatalf("Erro ao conectar no banco: %q", err)
 		os.Exit(1)
 	}
+
 	log.Println("Criando store")
-	s := store.NewMongoStore(ctx, client)
+	s := store.NewMongoStore(ctx, client, config)
 
 	log.Println("Iniciando Schedulers")
-	appScheduler := scheduler.NewAppScheduler()
-	urbsScheduler, err := scheduler.NewUrbsScheduler(s)
+	appScheduler := scheduler.NewAppScheduler(config)
+	urbsScheduler, err := scheduler.NewUrbsScheduler(s, config)
 	if err != nil {
 		log.Fatalf("Erro ao iniciar o schduler da urbs")
 	}

scheduler/app.go

@@ -3,20 +3,20 @@ package scheduler
 import (
 	"log"
 	"net/http"
-	"os"
 
+	"github.com/luizvnasc/cwbus-hist/config"
 	"github.com/robfig/cron/v3"
 )
 
 // AppScheduler é um scheduler para jobs da aplicação que não são referentes aos serviços da urbs.
 type AppScheduler struct {
-	cron *cron.Cron
-	jobs Jobs
+	cron      *cron.Cron
+	jobs      Jobs
+	wakeUpURL string
 }
 
 func (as *AppScheduler) wakeUpDyno() {
-	url := os.Getenv("CWBUS_WAKEUP_URL")
-	res, err := http.Get(url)
+	res, err := http.Get(as.wakeUpURL)
 	if err != nil {
 		log.Printf("Erro ao acordar o dyno: %q", err)
 		return
@@ -44,9 +44,9 @@ func (as *AppScheduler) Terminate() {
 }
 
 // NewAppScheduler é um construtor de um AppScheduler
-func NewAppScheduler() *AppScheduler {
+func NewAppScheduler(config config.Configurer) *AppScheduler {
 	c := cron.New()
-	appScheduler := &AppScheduler{cron: c}
+	appScheduler := &AppScheduler{cron: c, wakeUpURL: config.WakeUpURL()}
 	appScheduler.jobs = append(appScheduler.jobs, NewJob("*/3 * * * *", appScheduler.wakeUpDyno))
 	return appScheduler
 }

scheduler/app_test.go

@@ -2,67 +2,59 @@ package scheduler
 
 import (
 	"bytes"
+	"fmt"
 	"log"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"strings"
 	"testing"
+
+	"github.com/luizvnasc/cwbus-hist/config"
+	"github.com/luizvnasc/cwbus-hist/test/mock"
 )
 
 func TestAppScheduler(t *testing.T) {
+	config := &config.EnvConfigurer{}
+	mockConfig := &mock.MockConfigurer{}
 	t.Run("Cria um scheduler da aplicação", func(t *testing.T) {
-		s := NewAppScheduler()
+		s := NewAppScheduler(config)
 		if s == nil {
 			t.Errorf("Scheduler não foi criado.")
 		}
 	})
 
-	t.Run("Teste acordar dyno com erro de url", func(t *testing.T) {
-		var buf bytes.Buffer
-		log.SetOutput(&buf)
-		defer func() {
-			log.SetOutput(os.Stderr)
-		}()
-		s := NewAppScheduler()
-		s.wakeUpDyno()
-		got := buf.String()
-		if !strings.Contains(got, "Erro ao acordar o dyno:") {
-			t.Errorf("Erro ao validar url na task wakeup.")
-		}
-	})
-
-	t.Run("Teste acordar dyno com erro de statuscode", func(t *testing.T) {
-		var buf bytes.Buffer
-
-		log.SetOutput(&buf)
-		defer func() {
-			log.SetOutput(os.Stderr)
-		}()
-
-		os.Setenv("CWBUS_WAKEUP_URL", "https://httpstat.us/400")
-
-		s := NewAppScheduler()
-		s.wakeUpDyno()
-		got := buf.String()
-		if !strings.Contains(got, "Erro ao acordar o dyno, Status:") {
-			t.Errorf("Erro ao validar status na task wakeup.")
-		}
-	})
-
-	t.Run("Teste acordar dyno", func(t *testing.T) {
-		var buf bytes.Buffer
-
-		log.SetOutput(&buf)
-		defer func() {
-			log.SetOutput(os.Stderr)
-		}()
-
-		os.Setenv("CWBUS_WAKEUP_URL", "https://httpstat.us/200")
-
-		s := NewAppScheduler()
-		s.wakeUpDyno()
-		got := buf.String()
-		if !strings.Contains(got, "Trabalho...") {
-			t.Errorf("Erro ao validar status na task wakeup.")
-		}
-	})
+	cases := []struct {
+		status int
+		want   string
+	}{
+		{0, "Erro ao acordar o dyno:"},
+		{http.StatusBadRequest, "Erro ao acordar o dyno, Status:"},
+		{http.StatusOK, "Trabalho..."},
+	}
+	for _, test := range cases {
+		t.Run(fmt.Sprintf("Teste ao acordar dyno retornando status: %d", test.status), func(t *testing.T) {
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(test.status)
+			}))
+			// Close the server when test finishes
+			defer server.Close()
+
+			var buf bytes.Buffer
+			log.SetOutput(&buf)
+			defer func() {
+				log.SetOutput(os.Stderr)
+			}()
+
+			mockConfig.SetWakeUpURL(server.URL)
+
+			s := NewAppScheduler(mockConfig)
+			s.wakeUpDyno()
+			got := buf.String()
+			if !strings.Contains(got, test.want) {
+				t.Errorf("Erro ao validar url na task wakeup. Log deveria conter %q mas retornou %q", test.want, got)
+			}
+		})
+	}
 }

scheduler/urbs.go

@@ -6,10 +6,10 @@ import (
 	"io/ioutil"
 	"log"
 	"net/http"
-	"os"
 	"sync"
 	"time"
 
+	"github.com/luizvnasc/cwbus-hist/config"
 	"github.com/luizvnasc/cwbus-hist/model"
 	"github.com/luizvnasc/cwbus-hist/store"
 	"github.com/robfig/cron/v3"
@@ -222,19 +222,18 @@ func (us *UrbsScheduler) Terminate() {
 }
 
 // NewUrbsScheduler é um construtor da estrutura UrbsScheduler
-func NewUrbsScheduler(store store.Storer) (*UrbsScheduler, error) {
-	code := os.Getenv("CWBUS_URBS_CODE")
-	serviceURL := os.Getenv("CWBUS_URBS_SERVICE_URL")
-	if len(code) == 0 {
+func NewUrbsScheduler(store store.Storer, config config.Configurer) (*UrbsScheduler, error) {
+
+	if len(config.UrbsCode()) == 0 {
 		return nil, ErrNoUrbsCode
 	}
-	if len(serviceURL) == 0 {
+	if len(config.ServiceURL()) == 0 {
 		return nil, ErrNoServiceURL
 	}
 	scheduler := &UrbsScheduler{cron: cron.New(),
 		store:      store,
-		code:       code,
-		serviceURL: serviceURL,
+		code:       config.UrbsCode(),
+		serviceURL: config.ServiceURL(),
 	}
 	scheduler.jobs = append(scheduler.jobs, NewJob("0 5 * * *", scheduler.getLinhas))
 	scheduler.jobs = append(scheduler.jobs, NewJob("*/2 * * * *", scheduler.getVeiculos))