Implement JSON exporter

Author: orltom

README.md

@@ -18,7 +18,11 @@ Here is an example of how to create an on-call duty plan
 }
 EOL
 
-./ocs create --start "2024-01-01 00:00:00" --end "2024-03-29 00:00:00" --team-file demo.json --output table
+./ocsctl create \
+        --start "2024-01-01 00:00:00" \
+        --end "2024-03-29 00:00:00" \
+        --team-file demo.json \
+        --output table
 ```
 
 ## Contributing

cmd/create_command.go

@@ -24,17 +24,21 @@ type Converter int
 const (
 	CVS Converter = iota
 	Table
+	JSON
 )
 
 func RunCreateShiftPlan(arguments []string) error {
-	enums := map[string]Converter{"CVS": CVS, "Table": Table}
+	enums := map[string]Converter{"CVS": CVS, "Table": Table, "json": JSON}
 	converters := map[Converter]func() apis.Exporter{
 		Table: func() apis.Exporter {
 			return export.NewTableExporter()
 		},
 		CVS: func() apis.Exporter {
 			return export.NewCVSCExporter()
 		},
+		JSON: func() apis.Exporter {
+			return export.NewJSONExporter()
+		},
 	}
 
 	str := new(time.Time)
@@ -50,7 +54,7 @@ func RunCreateShiftPlan(arguments []string) error {
 	createCommand.Func("start", "(required) start time of the schedule plan", cli.TimeValueVar(str))
 	createCommand.Func("end", "(required) end time of the schedule plan", cli.TimeValueVar(end))
 	createCommand.Func("team-file", "(required) path to the file that contain all on-call duties", cli.FilePathVar(teamFilePath))
-	createCommand.Func("output", "output format. One of (cvs, table)", cli.EnumValueVar(enums, &transform))
+	createCommand.Func("output", "output format. One of (cvs, table, json)", cli.EnumValueVar(enums, &transform))
 	createCommand.Usage = func() {
 		fmt.Fprintf(os.Stdout, "Create on-call schedule\n")
 		fmt.Fprintf(os.Stdout, "\nUsage\n")

internal/export/cv.go

@@ -8,6 +8,8 @@ import (
 	"github.com/orltom/on-call-schedule/pkg/apis"
 )
 
+var _ apis.Exporter = &CVSExporter{}
+
 type CVSExporter struct{}
 
 func (c *CVSExporter) Write(shifts []apis.Shift, writer io.Writer) error {

internal/export/json.go

@@ -0,0 +1,35 @@
+package export
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+
+	"github.com/orltom/on-call-schedule/pkg/apis"
+)
+
+var _ apis.Exporter = &JSONExporter{}
+
+type JSONExporter struct{}
+
+func (c *JSONExporter) Write(plan []apis.Shift, writer io.Writer) error {
+	if plan == nil {
+		return fmt.Errorf("plan must not be nil")
+	}
+
+	content, err := json.Marshal(plan)
+	if err != nil {
+		return fmt.Errorf("could not marshal plan: %w", err)
+	}
+
+	_, err = writer.Write(content)
+	if err != nil {
+		return fmt.Errorf("could not write plan: %w", err)
+	}
+
+	return nil
+}
+
+func NewJSONExporter() *JSONExporter {
+	return &JSONExporter{}
+}

internal/export/json_test.go

@@ -0,0 +1,70 @@
+package export
+
+import (
+	"github.com/orltom/on-call-schedule/pkg/apis"
+	"strings"
+	"testing"
+)
+
+func TestJSONExporter_Write(t *testing.T) {
+	type args struct {
+		plan []apis.Shift
+	}
+	tests := []struct {
+		name       string
+		args       args
+		wantWriter string
+		wantErr    bool
+	}{
+		{
+			name: "Should create valid CSV",
+			args: args{
+				plan: []apis.Shift{
+					{
+						Start:     date("2024-12-25"),
+						End:       date("2024-12-26"),
+						Primary:   "a",
+						Secondary: "b",
+					},
+					{
+						Start:     date("2024-12-26"),
+						End:       date("2024-12-27"),
+						Primary:   "c",
+						Secondary: "d",
+					},
+				},
+			},
+			wantWriter: `[{"start":"2024-12-25T00:00:00Z","end":"2024-12-26T00:00:00Z","primary":"a","secondary":"b"},{"start":"2024-12-26T00:00:00Z","end":"2024-12-27T00:00:00Z","primary":"c","secondary":"d"}]`,
+			wantErr:    false,
+		},
+		{
+			name: "When plan is empty, throw an error",
+			args: args{
+				plan: []apis.Shift{},
+			},
+			wantWriter: "[]",
+			wantErr:    false,
+		},
+		{
+			name: "When plan is nil, do nothing",
+			args: args{
+				plan: nil,
+			},
+			wantWriter: "",
+			wantErr:    true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			e := NewJSONExporter()
+			writer := &strings.Builder{}
+			err := e.Write(tt.args.plan, writer)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Write() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if content := writer.String(); content != tt.wantWriter {
+				t.Errorf("Write() json = %v, want = %v", content, tt.wantWriter)
+			}
+		})
+	}
+}

internal/export/table.go

@@ -31,6 +31,10 @@ func NewTableExporter() *TableExporter {
 }
 
 func (e *TableExporter) Write(plan []apis.Shift, writer io.Writer) error {
+	if plan == nil {
+		return fmt.Errorf("shifts must not be nil")
+	}
+
 	if err := e.template.Execute(writer, plan); err != nil {
 		return fmt.Errorf("can not generate CVS: %w", err)
 	}

internal/export/table_test.go

@@ -52,12 +52,12 @@ func TestTableExporter_Write(t *testing.T) {
 			wantErr:    false,
 		},
 		{
-			name: "When plan is nil, print table header",
+			name: "When plan is nil, throw an error",
 			args: args{
 				plan: nil,
 			},
-			wantWriter: "From       | To         | Primary        | Secondary\n----------------------------------------------------------\n\n",
-			wantErr:    false,
+			wantWriter: "",
+			wantErr:    true,
 		},
 	}
 	for _, tt := range tests {

pkg/apis/plan_types.go

@@ -6,16 +6,16 @@ import (
 )
 
 type Shift struct {
-	Start     time.Time
-	End       time.Time
-	Primary   EmployeeID
-	Secondary EmployeeID
+	Start     time.Time  `json:"start"`
+	End       time.Time  `json:"end"`
+	Primary   EmployeeID `json:"primary"`
+	Secondary EmployeeID `json:"secondary"`
 }
 
 type Rule interface {
 	Match(primary Employee, shifts []Shift, start time.Time, end time.Time) bool
 }
 
 type Exporter interface {
-	Write(shifts []Shift, writer io.Writer) error
+	Write(plan []Shift, writer io.Writer) error
 }