move storage/internal/test to storage/test

storage/file/queue_test.go

@@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/micromdm/nanomdm/storage/internal/test"
+	"github.com/micromdm/nanomdm/storage/test"
 )
 
 func TestQueue(t *testing.T) {

storage/mysql/queue_test.go

@@ -4,7 +4,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/micromdm/nanomdm/storage/internal/test"
+	"github.com/micromdm/nanomdm/storage/test"
 
 	_ "github.com/go-sql-driver/mysql"
 )

storage/test/queue.go

@@ -0,0 +1,154 @@
+package test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/groob/plist"
+	"github.com/micromdm/nanomdm/mdm"
+	"github.com/micromdm/nanomdm/storage"
+)
+
+// QueueInterfaces are the storage interfaces needed for testing queue operations.
+type QueueInterfaces interface {
+	storage.CommandEnqueuer
+	storage.CommandAndReportResultsStore
+}
+
+// newCommand assembles a fake command including the plist raw value
+func newCommand(cmd string) (*mdm.Command, error) {
+	// assemble a fake struct just for marshalling to plist
+	fCmd := &struct {
+		CommandUUID string
+		Command     struct {
+			RequestType string
+		}
+	}{
+		CommandUUID: cmd,
+		Command:     struct{ RequestType string }{cmd},
+	}
+	// marshal it to plist
+	rawBytes, err := plist.Marshal(fCmd)
+	if err != nil {
+		return nil, err
+	}
+	// return a real *mdm.Command which includes the marshalled JSON
+	return &mdm.Command{
+		CommandUUID: fCmd.CommandUUID,
+		Command:     fCmd.Command,
+		Raw:         rawBytes,
+	}, nil
+}
+
+// enqueue queues a new command
+func enqueue(t *testing.T, q QueueInterfaces, ctx context.Context, id, cmdStr string) {
+	cmd, err := newCommand(cmdStr)
+	if err != nil {
+		t.Fatal(err)
+	}
+	res, err := q.EnqueueCommand(ctx, []string{id}, cmd)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for k, v := range res {
+		t.Fatalf("enqueuing to ID %s: %v", k, v)
+	}
+}
+
+// compareCommand compares makes sure cmd looks similar to newCommand(cmdStr)
+func compareCommand(t *testing.T, cmdStr string, cmd *mdm.Command) {
+	if cmdStr != "" && cmd == nil {
+		t.Errorf("expected next command, but got empty response. wanted: %q", cmdStr)
+		return
+	}
+	if cmdStr == "" && cmd != nil {
+		t.Errorf("expected empty next command, but got: %q", cmd.CommandUUID)
+	}
+	if cmd == nil {
+		return
+	}
+	if cmd.CommandUUID != cmdStr {
+		t.Errorf("mismatched command UUID. want: %q, have: %q", cmdStr, cmd.CommandUUID)
+	}
+	if cmd.Command.RequestType != cmdStr {
+		t.Errorf("mismatched command RequestType. want: %q, have: %q", cmdStr, cmd.Command.RequestType)
+	}
+}
+
+// retrieve retrieves the next command from the backend
+func retrieve(t *testing.T, q QueueInterfaces, r *mdm.Request, cmdStr string, skipNotNow bool) {
+	retCmd, err := q.RetrieveNextCommand(r, skipNotNow)
+	if err != nil {
+		t.Fatal(err)
+	}
+	compareCommand(t, cmdStr, retCmd)
+}
+
+// report fakes a command result and reports it to the backend
+func report(t *testing.T, q QueueInterfaces, r *mdm.Request, cmdStr, status string) {
+	fReport := &struct {
+		CommandUUID string `plist:",omitempty"`
+		Status      string
+		RequestType string `plist:",omitempty"`
+	}{CommandUUID: cmdStr, Status: status, RequestType: cmdStr}
+	rawBytes, err := plist.Marshal(fReport)
+	if err != nil {
+		t.Fatal(err)
+	}
+	results := &mdm.CommandResults{
+		CommandUUID: fReport.CommandUUID,
+		Status:      fReport.Status,
+		RequestType: fReport.RequestType,
+		Raw:         rawBytes,
+	}
+	err = q.StoreCommandReport(r, results)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+// reportRetrieve behaves similarly to an MDM client: it first reports
+// the results and then retrieves the next command.
+func reportRetrieve(t *testing.T, q QueueInterfaces, r *mdm.Request, reportCmd, reportStatus, expectedCmd string) {
+	report(t, q, r, reportCmd, reportStatus)
+	skipNotNow := false
+	if reportStatus == "NotNow" {
+		skipNotNow = true
+	}
+	retrieve(t, q, r, expectedCmd, skipNotNow)
+}
+
+// TestQueue performs basic testing of the storage queue
+func TestQueue(t *testing.T, id string, q QueueInterfaces) {
+	ctx := context.Background()
+
+	// build a fake MDM request object
+	r := &mdm.Request{
+		EnrollID: &mdm.EnrollID{
+			Type:     mdm.Device,
+			ID:       id,
+			ParentID: "",
+		},
+		Context: ctx,
+	}
+
+	t.Run("basic", func(t *testing.T) {
+		reportRetrieve(t, q, r, "", "Idle", "")
+		enqueue(t, q, ctx, id, "CMD1")
+		enqueue(t, q, ctx, id, "CMD2")
+		reportRetrieve(t, q, r, "", "Idle", "CMD1")
+		reportRetrieve(t, q, r, "CMD1", "Acknowledged", "CMD2")
+		reportRetrieve(t, q, r, "CMD2", "Acknowledged", "")
+		reportRetrieve(t, q, r, "", "Idle", "")
+	})
+
+	t.Run("notnow", func(t *testing.T) {
+		reportRetrieve(t, q, r, "", "Idle", "")
+		enqueue(t, q, ctx, id, "CMD3")
+		reportRetrieve(t, q, r, "", "Idle", "CMD3")
+		reportRetrieve(t, q, r, "CMD3", "NotNow", "")
+		reportRetrieve(t, q, r, "", "Idle", "CMD3")
+		reportRetrieve(t, q, r, "CMD3", "Acknowledged", "")
+		reportRetrieve(t, q, r, "", "Idle", "")
+	})
+}