reapi: enum type prototype for match_ops and test

Problem: we need to have a faux enum type that is shared
within the Go bindings, and a more reasonable test setup
for arbitrary go_<test>.go files.
Solution: add a pkg subdirectory to our go bindings src,
the idea being that we can eventually move more shared
logic between the cli and modules there. In addition,
add an ability to target a single directory with
a go_<test>.go file that (although not build) can be
tested with go test, which is the standard way to do it
with go. We do not (I think) need to worry about having
a binary built for associated go modules (akin to
types.go) because they will ultimately be included
in the reapi_cli or reapi_module that will be
tested. This is just a prototype, meaning that I have
not added the actual enum to the C code, but just
provided the structure of the module that can be
imported into each of the cli and module and
used when that is done.

Signed-off-by: vsoch <[email protected]>

Author: vsoch

cmake/GolangSimple.cmake

@@ -24,4 +24,4 @@ function(BUILD_GO_PROGRAM NAME MAIN_SRC CGO_CFLAGS CGO_LIBRARY_FLAGS)
 
   add_custom_target(${NAME}_all ALL DEPENDS ${NAME})
   install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${NAME} DESTINATION bin)
-endfunction(BUILD_GO_PROGRAM)
+endfunction(BUILD_GO_PROGRAM)

resource/reapi/bindings/go/src/CMakeLists.txt

@@ -1 +1 @@
-add_subdirectory( test )
+add_subdirectory( test )

resource/reapi/bindings/go/src/fluxcli/reapi_cli.go

@@ -82,23 +82,28 @@ func (cli *ReapiClient) InitContext(jgf string, options string) (err error) {
 
 // Match matches a jobspec to the "best" resources based on match option.
 
-//	The best resources are determined by the selected match policy.
+// The best resources are determined by the selected match policy.
+//
+//	\param match_op	 String to indicate the match type. Options include:
+//	                 allocate, allocate_orelse_reserve, satisfiability,
+//					 allocate_with_satsfiability
 //
-//	\param match_op  String to indicate the match type. Options include:
-//					 allocate, allocate_orelse_reserve, satisfiability,
-// 				     allocate_with_satsfiability
 //	\param jobspec   jobspec string.
 //	\param jobid     jobid of the uint64_t type.
 //	\param reserved  Boolean into which to return true if this job has been
 //	                 reserved instead of allocated.
+//
 //	\param R         String into which to return the resource set either
-//	                 allocated or reserved.
+//					 allocated or reserved.
+//
 //	\param at        If allocated, 0 is returned; if reserved, actual time
-//	                 at which the job is reserved.
-//	\param ov        Double into which to return performance overhead
-//	                 in terms of elapse time needed to complete
-//	                 the match operation.
-//	\return          0 on success; -1 on error.
+//					 at which the job is reserved.
+//
+//	\param ov		 Double into which to return performance overhead
+//	 				 in terms of elapse time needed to complete
+//					 the match operation.
+//
+// \return          0 on success; -1 on error.
 func (cli *ReapiClient) Match(
 	match_op string,
 	jobspec string,

resource/reapi/bindings/go/src/pkg/types/types.go

@@ -0,0 +1,55 @@
+package types
+
+/*****************************************************************************\
+ * Copyright 2024 Lawrence Livermore National Security, LLC
+ * (c.f. AUTHORS, NOTICE.LLNS, LICENSE)
+ *
+ * This file is part of the Flux resource manager framework.
+ * For details, see https://github.com/flux-framework.
+ *
+ * SPDX-License-Identifier: LGPL-3.0
+\*****************************************************************************/
+
+/*
+#include "reapi_cli.h"
+
+typedef enum {
+	MATCH_UNKNOWN = 0
+	MATCH_ALLOCATE = 1
+	MATCH_ALLOCATE_ORELSE_RESERVE = 2
+	MATCH_ALLOCATE_W_SATISFIABILITY = 3
+	MATCH_SATISFIABILITY = 4
+} match_op_enum;
+
+/* usage:
+mt := MatchType
+C.match_op_enum(mt)
+*/
+
+import "C"
+
+type MatchType int
+
+// MatchUnknown serves as a sentinal value that it's undefined
+const (
+	MatchUnknown                    MatchType = iota // unknown
+	MatchAllocate                                    // allocate
+	MatchAllocateOrElseReserve                       // allocate or else reserve
+	MatchAllocateWithSatisfiability                  // allocate with satisfiability
+	MatchSatisfiability                              // satisfiability
+)
+
+// String ensures that the MatchType can be used in string formatting
+func (m MatchType) String() string {
+	switch m {
+	case MatchAllocate:
+		return "allocate"
+	case MatchAllocateOrElseReserve:
+		return "allocate or else reserve"
+	case MatchAllocateWithSatisfiability:
+		return "allocate with satisfiability"
+	case MatchSatisfiability:
+		return "satisfiability"
+	}
+	return "unknown"
+}

resource/reapi/bindings/go/src/pkg/types/types_test.go

@@ -0,0 +1,74 @@
+package types
+
+/*****************************************************************************\
+ * Copyright 2024 Lawrence Livermore National Security, LLC
+ * (c.f. AUTHORS, NOTICE.LLNS, LICENSE)
+ *
+ * This file is part of the Flux resource manager framework.
+ * For details, see https://github.com/flux-framework.
+ *
+ * SPDX-License-Identifier: LGPL-3.0
+\*****************************************************************************/
+
+import (
+	"testing"
+)
+
+// List of match types, purposefully out of order
+var matchTypes = []MatchType{
+	MatchAllocateWithSatisfiability,
+	MatchAllocateOrElseReserve,
+	MatchAllocate,
+	MatchSatisfiability,
+	MatchUnknown,
+}
+
+func TestToString(t *testing.T) {
+	type test struct {
+		description string
+		input       MatchType
+		expected    string
+	}
+
+	tests := []test{
+		{description: "unknown", input: MatchUnknown, expected: "unknown"},
+		{description: "allocate", input: MatchAllocate, expected: "allocate"},
+		{description: "satisfiability", input: MatchSatisfiability, expected: "satisfiability"},
+		{description: "allocate or else reserve", input: MatchAllocateOrElseReserve, expected: "allocate or else reserve"},
+		{description: "allocate with satisfiability", input: MatchAllocateWithSatisfiability, expected: "allocate with satisfiability"},
+	}
+	for _, item := range tests {
+		t.Run(item.description, func(t *testing.T) {
+			value := item.input.String()
+			t.Logf("got %s, want %s", value, item.expected)
+			if item.expected != value {
+				t.Errorf("got %s, want %s", value, item.expected)
+			}
+		})
+	}
+}
+
+func TestAsInt(t *testing.T) {
+	type test struct {
+		description string
+		input       MatchType
+		expected    int
+	}
+
+	tests := []test{
+		{description: "unknown", input: MatchUnknown, expected: 0},
+		{description: "allocate", input: MatchAllocate, expected: 1},
+		{description: "satisfiability", input: MatchSatisfiability, expected: 4},
+		{description: "allocate or else reserve", input: MatchAllocateOrElseReserve, expected: 2},
+		{description: "allocate with satisfiability", input: MatchAllocateWithSatisfiability, expected: 3},
+	}
+	for _, item := range tests {
+		t.Run(item.description, func(t *testing.T) {
+			value := int(item.input)
+			t.Logf("got %d, want %d", value, item.expected)
+			if item.expected != value {
+				t.Errorf("got %d, want %d", value, item.expected)
+			}
+		})
+	}
+}

t/t9001-golang-basic.t

@@ -21,6 +21,7 @@ jgf="${SHARNESS_TEST_SRCDIR}/data/resource/jgfs/tiny.json"
 jobspec1="${SHARNESS_TEST_SRCDIR}/data/resource/jobspecs/basics/test001.yaml"
 jobspec2="${SHARNESS_TEST_SRCDIR}/data/resource/jobspecs/basics/test003.yaml"
 main="../../resource/reapi/bindings/go/src/test/main"
+root="../../resource/reapi/bindings/go/src"
 
 test001_desc="match allocate 1 slot: 1 socket: 1 core (pol=default)"
 test_expect_success "${test001_desc}" '
@@ -36,4 +37,12 @@ test_expect_success "${test002_desc}" '
     test_cmp 002.R.out ${exp_dir}/002.R.out
 '
 
+# Assume running in subshell, don't need to chdir back
+test003_desc="test pkg/types/types_test.go"
+test_expect_success "${test003_desc}" '
+    cd ${root}/pkg/types
+    go test -v
+'
+
+
 test_done