start sync test

plan/command/sync.go

@@ -3,6 +3,7 @@ package command
 import (
 	"encoding/json"
 	"fmt"
+	"time"
 
 	"github.com/urfave/cli/v2"
 	"go-mod.ewintr.nl/planner/item"
@@ -22,14 +23,14 @@ var SyncCmd = &cli.Command{
 	},
 }
 
-func NewSyncCmd(client *client.Client, syncRepo storage.Sync, localIDRepo storage.LocalID, eventRepo storage.Event) *cli.Command {
+func NewSyncCmd(client client.Client, syncRepo storage.Sync, localIDRepo storage.LocalID, eventRepo storage.Event) *cli.Command {
 	SyncCmd.Action = func(cCtx *cli.Context) error {
 		return Sync(client, syncRepo, localIDRepo, eventRepo, cCtx.Bool("full"))
 	}
 	return SyncCmd
 }
 
-func Sync(client *client.Client, syncRepo storage.Sync, localIDRepo storage.LocalID, eventRepo storage.Event, full bool) error {
+func Sync(client client.Client, syncRepo storage.Sync, localIDRepo storage.LocalID, eventRepo storage.Event, full bool) error {
 	// find local new and updated
 	sendItems, err := syncRepo.FindAll()
 	if err != nil {
@@ -45,8 +46,10 @@ func Sync(client *client.Client, syncRepo storage.Sync, localIDRepo storage.Loca
 		return fmt.Errorf("could not clear updated items: %v", err)
 	}
 
+	// get last updated time
+
 	// get new/updated items
-	recItems, err := client.Updated(item.KindEvent)
+	recItems, err := client.Updated([]item.Kind{item.KindEvent}, time.Time{})
 	if err != nil {
 		return fmt.Errorf("could not receive updates: %v", err)
 	}

plan/command/sync_test.go

@@ -0,0 +1,41 @@
+package command_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"go-mod.ewintr.nl/planner/item"
+	"go-mod.ewintr.nl/planner/plan/command"
+	"go-mod.ewintr.nl/planner/plan/storage/memory"
+	"go-mod.ewintr.nl/planner/sync/client"
+)
+
+func TestSync(t *testing.T) {
+	t.Parallel()
+
+	syncClient := client.NewMemory()
+	syncRepo := memory.NewSync()
+	localIDRepo := memory.NewLocalID()
+	eventRepo := memory.NewEvent()
+
+	//  now := time.Now()
+
+	it := item.Item{
+		ID:   "a",
+		Kind: item.KindEvent,
+		Body: `{}`,
+	}
+	syncClient.Update([]item.Item{it})
+
+	if err := command.Sync(syncClient, syncRepo, localIDRepo, eventRepo, false); err != nil {
+		t.Errorf("exp nil, got %v", err)
+	}
+	actItems, actErr := syncClient.Updated([]item.Kind{item.KindEvent}, time.Time{})
+	if actErr != nil {
+		t.Errorf("exp nil, got %v", actErr)
+	}
+	if diff := cmp.Diff([]item.Item{it}, actItems); diff != "" {
+		t.Errorf("(exp +, got -)\n%s", diff)
+	}
+}

sync/client/client.go

@@ -1,89 +1,12 @@
 package client
 
 import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
 	"time"
 
 	"go-mod.ewintr.nl/planner/item"
 )
 
-type Client struct {
+type Client interface {
-	baseURL string
+	Update(items []item.Item) error
-	apiKey  string
+	Updated(ks []item.Kind, ts time.Time) ([]item.Item, error)
-	c       *http.Client
-}
-
-func New(url, apiKey string) *Client {
-	return &Client{
-		baseURL: url,
-		apiKey:  apiKey,
-		c: &http.Client{
-			Timeout: 10 * time.Second,
-		},
-	}
-}
-
-func (c *Client) Update(items []item.Item) error {
-	body, err := json.Marshal(items)
-	if err != nil {
-		return fmt.Errorf("could not marhal body: %v", err)
-	}
-	req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/sync", c.baseURL), bytes.NewReader(body))
-	if err != nil {
-		return fmt.Errorf("could not create request: %v", err)
-	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.apiKey))
-
-	res, err := c.c.Do(req)
-	if err != nil {
-		return fmt.Errorf("could not make request: %v", err)
-	}
-	if res.StatusCode != http.StatusNoContent {
-		return fmt.Errorf("server returned status %d", res.StatusCode)
-	}
-
-	return nil
-}
-
-func (c *Client) Updated(ks []item.Kind, ts time.Time) ([]item.Item, error) {
-	ksStr := make([]string, 0, len(ks))
-	for _, k := range ks {
-		ksStr = append(ksStr, string(k))
-	}
-	u := fmt.Sprintf("%s/sync?ks=%s", c.baseURL, strings.Join(ksStr, ","))
-	if !ts.IsZero() {
-		u = fmt.Sprintf("%s&ts=", url.QueryEscape(ts.Format(time.RFC3339)))
-	}
-	req, err := http.NewRequest(http.MethodGet, u, nil)
-	if err != nil {
-		return nil, fmt.Errorf("could not create request: %v", err)
-	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.apiKey))
-
-	res, err := c.c.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("could not get response: %v", err)
-	}
-	if res.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("server returned status %d", res.StatusCode)
-	}
-
-	defer res.Body.Close()
-	body, err := io.ReadAll(res.Body)
-	if err != nil {
-		return nil, fmt.Errorf("could not read response body: %v", err)
-	}
-
-	var items []item.Item
-	if err := json.Unmarshal(body, &items); err != nil {
-		return nil, fmt.Errorf("could not unmarshal response body: %v", err)
-	}
-
-	return items, nil
 }

sync/client/http.go

@@ -0,0 +1,89 @@
+package client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"go-mod.ewintr.nl/planner/item"
+)
+
+type HTTP struct {
+	baseURL string
+	apiKey  string
+	c       *http.Client
+}
+
+func New(url, apiKey string) *HTTP {
+	return &HTTP{
+		baseURL: url,
+		apiKey:  apiKey,
+		c: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+	}
+}
+
+func (c *HTTP) Update(items []item.Item) error {
+	body, err := json.Marshal(items)
+	if err != nil {
+		return fmt.Errorf("could not marhal body: %v", err)
+	}
+	req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/sync", c.baseURL), bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("could not create request: %v", err)
+	}
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.apiKey))
+
+	res, err := c.c.Do(req)
+	if err != nil {
+		return fmt.Errorf("could not make request: %v", err)
+	}
+	if res.StatusCode != http.StatusNoContent {
+		return fmt.Errorf("server returned status %d", res.StatusCode)
+	}
+
+	return nil
+}
+
+func (c *HTTP) Updated(ks []item.Kind, ts time.Time) ([]item.Item, error) {
+	ksStr := make([]string, 0, len(ks))
+	for _, k := range ks {
+		ksStr = append(ksStr, string(k))
+	}
+	u := fmt.Sprintf("%s/sync?ks=%s", c.baseURL, strings.Join(ksStr, ","))
+	if !ts.IsZero() {
+		u = fmt.Sprintf("%s&ts=", url.QueryEscape(ts.Format(time.RFC3339)))
+	}
+	req, err := http.NewRequest(http.MethodGet, u, nil)
+	if err != nil {
+		return nil, fmt.Errorf("could not create request: %v", err)
+	}
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.apiKey))
+
+	res, err := c.c.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("could not get response: %v", err)
+	}
+	if res.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("server returned status %d", res.StatusCode)
+	}
+
+	defer res.Body.Close()
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, fmt.Errorf("could not read response body: %v", err)
+	}
+
+	var items []item.Item
+	if err := json.Unmarshal(body, &items); err != nil {
+		return nil, fmt.Errorf("could not unmarshal response body: %v", err)
+	}
+
+	return items, nil
+}