Merge branch 'testing'

.github/workflows/tests.yml

@@ -0,0 +1,26 @@
+name: 'Tests & Code coverage'
+
+on:
+    push:
+      branches:
+        - master
+
+jobs:
+  tests: 
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/setup-go@v4
+        with:
+          go-version: "1.20"
+
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: go mod download
+
+      - name: Run test and converage
+        run: go test ./... -v -coverprofile=coverage.out -covermode=atomic 
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v3

client.go → choruspro.go

@@ -18,7 +18,7 @@ import (
 // ClientConfig contains the configuration for the client
 type ClientConfig struct {
 	// Piste URL
-	Url string
+	BaseUrl string
 
 	// Piste OAuth URL
 	AuthUrl string
@@ -40,10 +40,10 @@ type Client struct {
 	client *http.Client
 
 	// Piste URL
-	url string
+	BaseUrl *url.URL
 
 	// Piste OAuth URL
-	authUrl string
+	AuthUrl *url.URL
 
 	// Piste client ID
 	clientId string
@@ -68,29 +68,50 @@ type service struct {
 	client *Client
 }
 
-func NewClient(config *ClientConfig) *Client {
-	c := &Client{
-		client:       http.DefaultClient,
-		url:          config.Url,
-		authUrl:      config.AuthUrl,
-		clientId:     config.ClientId,
-		clientSecret: config.ClientSecret,
-		login:        config.Login,
-	}
-
+func NewClient() *Client {
+	c := &Client{client: http.DefaultClient}
 	c.initialize()
 	return c
 }
 
+func (c *Client) WithConfig(config *ClientConfig) (*Client, error) {
+	var err error
+
+	c.BaseUrl, err = url.Parse(config.BaseUrl)
+	if err != nil {
+		return nil, err
+	}
+
+	c.AuthUrl, err = url.Parse(config.AuthUrl)
+	if err != nil {
+		return nil, err
+	}
+
+	c.clientId = config.ClientId
+	c.clientSecret = config.ClientSecret
+	c.login = config.Login
+
+	return c, err
+}
+
 func (c *Client) initialize() {
 	c.common.client = c
 	c.Transverses = (*TransversesService)(&c.common)
 }
 
 func (c *Client) newRequest(ctx context.Context, method, url string, body interface{}) (*http.Request, error) {
+	if !strings.HasSuffix(c.BaseUrl.Path, "/") {
+		return nil, fmt.Errorf("BaseURL must have a trailing slash, but %q does not", c.BaseUrl)
+	}
+
+	u, err := c.BaseUrl.Parse(url)
+	if err != nil {
+		return nil, err
+	}
+
 	// Check if token is valid, if not, get a new one
 	if !c.token.Valid() {
-		token, err := getOAuthToken(c.authUrl, c.clientId, c.clientSecret)
+		token, err := getOAuthToken(c.clientId, c.clientSecret, c.AuthUrl)
 		if err != nil {
 			return nil, err
 		}
@@ -108,7 +129,7 @@ func (c *Client) newRequest(ctx context.Context, method, url string, body interf
 		return nil, err
 	}
 
-	req, err := http.NewRequestWithContext(ctx, method, c.url+url, bytes.NewBuffer(data))
+	req, err := http.NewRequestWithContext(ctx, method, u.String(), bytes.NewBuffer(data))
 	if err != nil {
 		return nil, err
 	}
@@ -145,7 +166,12 @@ func (c *Client) doRequest(ctx context.Context, req *http.Request, obj interface
 	return json.Unmarshal(data, obj)
 }
 
-func getOAuthToken(authUrl, clientId, clientSecret string) (*oauth2.Token, error) {
+func getOAuthToken(clientId, clientSecret string, authUrl *url.URL) (*oauth2.Token, error) {
+	u, err := authUrl.Parse("api/oauth/token")
+	if err != nil {
+		return nil, err
+	}
+
 	c := http.DefaultClient
 
 	data := url.Values{}
@@ -155,7 +181,7 @@ func getOAuthToken(authUrl, clientId, clientSecret string) (*oauth2.Token, error
 
 	encodedData := data.Encode()
 
-	req, err := http.NewRequest(http.MethodPost, authUrl+"/api/oauth/token", strings.NewReader(encodedData))
+	req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(encodedData))
 	if err != nil {
 		return nil, err
 	}
@@ -174,6 +200,10 @@ func getOAuthToken(authUrl, clientId, clientSecret string) (*oauth2.Token, error
 	}
 	defer res.Body.Close()
 
+	if res.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("choruspro: %v", res.Status)
+	}
+
 	err = json.NewDecoder(res.Body).Decode(&token)
 	if err != nil {
 		return nil, err

choruspro_test.go

@@ -0,0 +1,58 @@
+package choruspro
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func setup() (client *Client, mux *http.ServeMux, teardown func()) {
+	mux = http.NewServeMux()
+
+	// OAuth token
+	mux.HandleFunc("/api/oauth/token", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		fmt.Fprint(w, `{"access_token":"token","token_type":"Bearer","expires_in":3600}`)
+	})
+
+	server := httptest.NewServer(mux)
+
+	client = NewClient()
+	url, _ := client.BaseUrl.Parse(server.URL + "/")
+	client.BaseUrl = url
+	client.AuthUrl = url
+
+	return client, mux, server.Close
+}
+
+// Test function under s.client.DoRequest failure.
+// Method f should be a regular call that would normally succeed, but
+// should return an error when NewRequest or s.client.DoRequest fails.
+func testDoRequestFailure(t *testing.T, methodName string, client *Client, f func() error) {
+	t.Helper()
+	if methodName == "" {
+		t.Error("testNewRequestAndDoFailure : method name should be provided")
+	}
+
+	client.BaseUrl.Path = ""
+	err := f()
+
+	if err == nil {
+		t.Errorf("client.BaseURL.Path='' %v err = nil, want error", methodName)
+	}
+}
+
+func testMethod(t *testing.T, r *http.Request, want string) {
+	t.Helper()
+	if got := r.Method; got != want {
+		t.Errorf("Request method : %v, got %v", got, want)
+	}
+}
+
+func assertNilError(t *testing.T, err error) {
+	t.Helper()
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+}

examples/main.go

@@ -9,20 +9,22 @@ import (
 )
 
 func main() {
-	c := choruspro.NewClient(&choruspro.ClientConfig{
-		Url:          "<piste_url>",
+	cfg := &choruspro.ClientConfig{
+		BaseUrl:      "<piste_url>",
 		AuthUrl:      "<piste_oauth_url>",
 		ClientId:     "<piste_client_id>",
 		ClientSecret: "<piste_client_secret>",
 		Login:        "<chorus_pro_technical_credentials>",
-	})
+	}
 
-	ctx := context.Background()
+	c, err := choruspro.NewClient().WithConfig(cfg)
+	if err != nil {
+		log.Fatalf("Error: %v", err)
+	}
 
-	res, err := c.Transverses.ConsulterCompteRendu(ctx, choruspro.CompteRenduOptions{
-		NumeroFluxDepot: "",
-	})
+	ctx := context.Background()
 
+	res, err := c.Transverses.RecupererDevises(ctx, choruspro.CodeLangueFr)
 	if err != nil {
 		log.Fatalf("Error: %v", err)
 	}

transverses.go

@@ -12,7 +12,10 @@ const (
 	CodeLangueEn CodeLangue = "EN"
 )
 
-// Liste des syntaxes de flux disponibles
+type codeLangueOptions struct {
+	CodeLangue CodeLangue `json:"codeLangue,omitempty"`
+}
+
 type SyntaxeFlux string
 
 const (

transverses_categories.go

@@ -21,7 +21,7 @@ type ListeCategoriesSollicitationOptions struct {
 }
 
 func (s *TransversesService) RechercherCategoriesSollicitation(ctx context.Context, opts ListeCategoriesSollicitationOptions) (*ListeCategoriesSollicitation, error) {
-	req, err := s.client.newRequest(ctx, http.MethodPost, "/cpro/transverses/v1/rechercher/categorieSollicitation", opts)
+	req, err := s.client.newRequest(ctx, http.MethodPost, "cpro/transverses/v1/rechercher/categorieSollicitation", opts)
 	if err != nil {
 		return nil, err
 	}
@@ -70,7 +70,7 @@ type ListeSousCategoriesSollicitationOptions struct {
 }
 
 func (s *TransversesService) RechercherSousCategoriesSollicitation(ctx context.Context, opts ListeSousCategoriesSollicitationOptions) (*ListeSousCategoriesSollicitation, error) {
-	req, err := s.client.newRequest(ctx, http.MethodPost, "/cpro/transverses/v1/rechercher/sousCategorieSollicitation", opts)
+	req, err := s.client.newRequest(ctx, http.MethodPost, "cpro/transverses/v1/rechercher/sousCategorieSollicitation", opts)
 	if err != nil {
 		return nil, err
 	}

transverses_etats.go

@@ -34,7 +34,7 @@ func (s *TransversesService) RecupererEtatParTypeDemandePaiement(ctx context.Con
 		return nil, err
 	}
 
-	req, err := s.client.newRequest(ctx, http.MethodPost, "/cpro/transverses/v1/recuperer/etat/typedp", opts)
+	req, err := s.client.newRequest(ctx, http.MethodPost, "cpro/transverses/v1/recuperer/etat/typedp", opts)
 	if err != nil {
 		return nil, err
 	}
@@ -77,7 +77,7 @@ func (s *TransversesService) RecupererEtatsTraitement(ctx context.Context, opts
 		return nil, err
 	}
 
-	req, err := s.client.newRequest(ctx, http.MethodPost, "/cpro/transverses/v1/recuperer/etats/traitement", opts)
+	req, err := s.client.newRequest(ctx, http.MethodPost, "cpro/transverses/v1/recuperer/etats/traitement", opts)
 	if err != nil {
 		return nil, err
 	}

transverses_flux.go

@@ -21,7 +21,7 @@ type FormatFlux struct {
 func (s *TransversesService) RecupererFormatFlux(ctx context.Context) (*ListeFormatsFlux, error) {
 	opts := struct{}{}
 
-	req, err := s.client.newRequest(ctx, http.MethodPost, "/cpro/transverses/v1/recuperer/formatflux", opts)
+	req, err := s.client.newRequest(ctx, http.MethodPost, "cpro/transverses/v1/recuperer/formatflux", opts)
 	if err != nil {
 		return nil, err
 	}
@@ -70,7 +70,7 @@ func (s *TransversesService) ConsulterCompteRendu(ctx context.Context, opts Comp
 		return nil, err
 	}
 
-	req, err := s.client.newRequest(ctx, http.MethodPost, "/cpro/transverses/v1/consulterCR", opts)
+	req, err := s.client.newRequest(ctx, http.MethodPost, "cpro/transverses/v1/consulterCR", opts)
 	if err != nil {
 		return nil, err
 	}
@@ -116,7 +116,7 @@ func (s *TransversesService) ConsulterCompteRenduDetaille(ctx context.Context, o
 		return nil, err
 	}
 
-	req, err := s.client.newRequest(ctx, http.MethodPost, "/cpro/transverses/v1/consulterCRDetaille", opts)
+	req, err := s.client.newRequest(ctx, http.MethodPost, "cpro/transverses/v1/consulterCRDetaille", opts)
 	if err != nil {
 		return nil, err
 	}