From 0a3f9c1080e23f1da1ad9530be2c04ae40ac6e0c Mon Sep 17 00:00:00 2001 From: dailz Date: Wed, 8 Apr 2026 21:33:09 +0800 Subject: [PATCH] feat(slurmdb): add WckeysService Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent) Co-authored-by: Sisyphus --- internal/slurm/slurmdb_wckeys.go | 125 +++++++++++++++++++++ internal/slurm/slurmdb_wckeys_test.go | 155 ++++++++++++++++++++++++++ 2 files changed, 280 insertions(+) create mode 100644 internal/slurm/slurmdb_wckeys.go create mode 100644 internal/slurm/slurmdb_wckeys_test.go diff --git a/internal/slurm/slurmdb_wckeys.go b/internal/slurm/slurmdb_wckeys.go new file mode 100644 index 0000000..e9c2882 --- /dev/null +++ b/internal/slurm/slurmdb_wckeys.go @@ -0,0 +1,125 @@ +package slurm + +import ( + "context" + "fmt" + "net/url" +) + +// GetWckeysOptions specifies optional parameters for GetWckeys. +type GetWckeysOptions struct { + Cluster *string `url:"cluster,omitempty"` + Format *string `url:"format,omitempty"` + ID *string `url:"id,omitempty"` + Name *string `url:"name,omitempty"` + OnlyDefaults *string `url:"only_defaults,omitempty"` + UsageEnd *string `url:"usage_end,omitempty"` + UsageStart *string `url:"usage_start,omitempty"` + User *string `url:"user,omitempty"` + WithUsage *string `url:"with_usage,omitempty"` + WithDeleted *string `url:"with_deleted,omitempty"` +} + +// GetWckeys lists all wckeys. +func (s *SlurmdbWckeysService) GetWckeys(ctx context.Context, opts *GetWckeysOptions) (*OpenapiWckeyResp, *Response, error) { + path := "slurmdb/v0.0.40/wckeys" + req, err := s.client.NewRequest("GET", path, nil) + if err != nil { + return nil, nil, err + } + + if opts != nil { + u, parseErr := url.Parse(req.URL.String()) + if parseErr != nil { + return nil, nil, parseErr + } + q := u.Query() + if opts.Cluster != nil { + q.Set("cluster", *opts.Cluster) + } + if opts.Format != nil { + q.Set("format", *opts.Format) + } + if opts.ID != nil { + q.Set("id", *opts.ID) + } + if opts.Name != nil { + q.Set("name", *opts.Name) + } + if opts.OnlyDefaults != nil { + q.Set("only_defaults", *opts.OnlyDefaults) + } + if opts.UsageEnd != nil { + q.Set("usage_end", *opts.UsageEnd) + } + if opts.UsageStart != nil { + q.Set("usage_start", *opts.UsageStart) + } + if opts.User != nil { + q.Set("user", *opts.User) + } + if opts.WithUsage != nil { + q.Set("with_usage", *opts.WithUsage) + } + if opts.WithDeleted != nil { + q.Set("with_deleted", *opts.WithDeleted) + } + u.RawQuery = q.Encode() + req.URL = u + } + + var result OpenapiWckeyResp + resp, err := s.client.Do(ctx, req, &result) + if err != nil { + return nil, resp, err + } + return &result, resp, nil +} + +// GetWckey gets a single wckey by ID. +func (s *SlurmdbWckeysService) GetWckey(ctx context.Context, wckeyID string) (*OpenapiWckeyResp, *Response, error) { + path := fmt.Sprintf("slurmdb/v0.0.40/wckey/%s", wckeyID) + req, err := s.client.NewRequest("GET", path, nil) + if err != nil { + return nil, nil, err + } + + var result OpenapiWckeyResp + resp, err := s.client.Do(ctx, req, &result) + if err != nil { + return nil, resp, err + } + return &result, resp, nil +} + +// PostWckeys adds wckeys. +func (s *SlurmdbWckeysService) PostWckeys(ctx context.Context, body *OpenapiWckeyResp) (*OpenapiResp, *Response, error) { + path := "slurmdb/v0.0.40/wckeys" + req, err := s.client.NewRequest("POST", path, body) + if err != nil { + return nil, nil, err + } + + var result OpenapiResp + resp, err := s.client.Do(ctx, req, &result) + if err != nil { + return nil, resp, err + } + return &result, resp, nil +} + +// DeleteWckey deletes a wckey by ID. +func (s *SlurmdbWckeysService) DeleteWckey(ctx context.Context, wckeyID string) (*OpenapiWckeyRemovedResp, *Response, error) { + path := fmt.Sprintf("slurmdb/v0.0.40/wckey/%s", wckeyID) + req, err := s.client.NewRequest("DELETE", path, nil) + if err != nil { + return nil, nil, err + } + + var result OpenapiWckeyRemovedResp + resp, err := s.client.Do(ctx, req, &result) + if err != nil { + return nil, resp, err + } + return &result, resp, nil +} diff --git a/internal/slurm/slurmdb_wckeys_test.go b/internal/slurm/slurmdb_wckeys_test.go new file mode 100644 index 0000000..09de935 --- /dev/null +++ b/internal/slurm/slurmdb_wckeys_test.go @@ -0,0 +1,155 @@ +package slurm + +import ( + "context" + "fmt" + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +func TestSlurmdbWckeysService_GetWckeys(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/slurmdb/v0.0.40/wckeys", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + fmt.Fprint(w, `{"wckeys": []}`) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, _ := NewClient(server.URL, nil) + resp, _, err := client.SlurmdbWckeys.GetWckeys(context.Background(), nil) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp == nil { + t.Fatal("expected non-nil response") + } + if len(resp.Wckeys) != 0 { + t.Errorf("expected empty wckeys, got %d", len(resp.Wckeys)) + } +} + +func TestSlurmdbWckeysService_GetWckeys_WithOptions(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/slurmdb/v0.0.40/wckeys", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + q := r.URL.Query() + if q.Get("cluster") != "test-cluster" { + t.Errorf("expected cluster=test-cluster, got %s", q.Get("cluster")) + } + if q.Get("name") != "mykey" { + t.Errorf("expected name=mykey, got %s", q.Get("name")) + } + if q.Get("with_deleted") != "true" { + t.Errorf("expected with_deleted=true, got %s", q.Get("with_deleted")) + } + fmt.Fprint(w, `{"wckeys": []}`) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, _ := NewClient(server.URL, nil) + opts := &GetWckeysOptions{ + Cluster: Ptr("test-cluster"), + Name: Ptr("mykey"), + WithDeleted: Ptr("true"), + } + resp, _, err := client.SlurmdbWckeys.GetWckeys(context.Background(), opts) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp == nil { + t.Fatal("expected non-nil response") + } +} + +func TestSlurmdbWckeysService_GetWckey(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/slurmdb/v0.0.40/wckey/42", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + fmt.Fprint(w, `{"wckeys": [{"name": "wckey42"}]}`) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, _ := NewClient(server.URL, nil) + resp, _, err := client.SlurmdbWckeys.GetWckey(context.Background(), "42") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp == nil { + t.Fatal("expected non-nil response") + } + if len(resp.Wckeys) != 1 { + t.Fatalf("expected 1 wckey, got %d", len(resp.Wckeys)) + } + if resp.Wckeys[0].Name == nil || *resp.Wckeys[0].Name != "wckey42" { + t.Errorf("expected name=wckey42, got %v", resp.Wckeys[0].Name) + } +} + +func TestSlurmdbWckeysService_PostWckeys(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/slurmdb/v0.0.40/wckeys", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "POST") + if ct := r.Header.Get("Content-Type"); ct != "application/json" { + t.Errorf("expected Content-Type application/json, got %s", ct) + } + fmt.Fprint(w, `{}`) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, _ := NewClient(server.URL, nil) + body := &OpenapiWckeyResp{} + resp, _, err := client.SlurmdbWckeys.PostWckeys(context.Background(), body) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp == nil { + t.Fatal("expected non-nil response") + } +} + +func TestSlurmdbWckeysService_DeleteWckey(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/slurmdb/v0.0.40/wckey/42", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "DELETE") + fmt.Fprint(w, `{"deleted_wckeys": ["wckey42"]}`) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, _ := NewClient(server.URL, nil) + resp, _, err := client.SlurmdbWckeys.DeleteWckey(context.Background(), "42") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp == nil { + t.Fatal("expected non-nil response") + } + if len(resp.DeletedWckeys) != 1 || resp.DeletedWckeys[0] != "wckey42" { + t.Errorf("expected deleted_wckeys=[wckey42], got %v", resp.DeletedWckeys) + } +} + +func TestSlurmdbWckeysService_GetWckey_Error(t *testing.T) { + mux := http.NewServeMux() + mux.HandleFunc("/slurmdb/v0.0.40/wckey/999", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) + fmt.Fprint(w, `{"errors": [{"error": "wckey not found"}]}`) + }) + server := httptest.NewServer(mux) + defer server.Close() + + client, _ := NewClient(server.URL, nil) + _, _, err := client.SlurmdbWckeys.GetWckey(context.Background(), "999") + if err == nil { + t.Fatal("expected error for 404 response") + } + if !strings.Contains(err.Error(), "404") { + t.Errorf("expected error to contain 404, got %v", err) + } +}