diff --git a/.gitignore b/.gitignore index 7e866df4..a18bc99c 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ bin cover.out release_all.sh upload_to_build_agent.sh +.vscode diff --git a/.mockery.yaml b/.mockery.yaml new file mode 100644 index 00000000..5fc8df27 --- /dev/null +++ b/.mockery.yaml @@ -0,0 +1,11 @@ +with-expecter: true +issue-845-fix: True +resolve-type-alias: False +packages: + nebius.ai/slurm-operator/internal/slurmapi: + interfaces: + Client: + config: + dir: "{{.InterfaceDirRelative}}/fake" + outpkg: "fake" + filename: "mock_{{ .InterfaceName | camelcase | firstLower }}.go" diff --git a/cmd/checkcontroller/main.go b/cmd/checkcontroller/main.go index 1446b32f..29bebc08 100644 --- a/cmd/checkcontroller/main.go +++ b/cmd/checkcontroller/main.go @@ -30,6 +30,7 @@ import ( _ "k8s.io/client-go/plugin/pkg/client/auth" "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/types" utilruntime "k8s.io/apimachinery/pkg/util/runtime" clientgoscheme "k8s.io/client-go/kubernetes/scheme" ctrl "sigs.k8s.io/controller-runtime" @@ -40,6 +41,8 @@ import ( slurmv1 "nebius.ai/slurm-operator/api/v1" "nebius.ai/slurm-operator/internal/checkcontroller" + "nebius.ai/slurm-operator/internal/jwt" + "nebius.ai/slurm-operator/internal/slurmapi" //+kubebuilder:scaffold:imports ) @@ -100,15 +103,15 @@ func main() { reconcileTimeout time.Duration maxConcurrency int + cacheSyncTimeout time.Duration ) var watchNsCacheByName = make(map[string]cache.Config) - ns := os.Getenv("WATCH_NAMESPACE") - if ns != "" { + ns := os.Getenv("SLURM_OPERATOR_WATCH_NAMESPACES") + if ns != "" && ns != "*" { + watchNsCacheByName = make(map[string]cache.Config) watchNsCacheByName[ns] = cache.Config{} - } else { - watchNsCacheByName["default"] = cache.Config{} } flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.") @@ -124,6 +127,7 @@ func main() { flag.StringVar(&logLevel, "log-level", "debug", "Log level: debug, info, warn, error, dpanic, panic, fatal") flag.DurationVar(&reconcileTimeout, "reconcile-timeout", 5*time.Minute, "The maximum duration allowed for a single reconcile") flag.IntVar(&maxConcurrency, "max-concurrent-reconciles", 1, "Configures number of concurrent reconciles. It should improve performance for clusters with many objects.") + flag.DurationVar(&cacheSyncTimeout, "cache-sync-timeout", 5*time.Minute, "The maximum duration allowed for caching sync") opts := getZapOpts(logFormat, logLevel) ctrl.SetLogger(zap.New(opts...)) @@ -180,12 +184,33 @@ func main() { os.Exit(1) } + slurmAPIServer := os.Getenv("SLURM_API_SERVER") + if len(slurmAPIServer) == 0 { + slurmAPIServer = "http://localhost:6820" + } + + // TODO: init jwt controller + slurmClusterName := types.NamespacedName{ + Namespace: "soperator", + Name: "soperator", + } + jwtToken := jwt.NewToken(mgr.GetClient()).For(slurmClusterName, "root").WithRegistry(jwt.NewTokenRegistry().Build()) + slurmapiClient, err := slurmapi.NewClient(slurmAPIServer, jwtToken, slurmapi.DefaultHTTPClient()) + if err != nil { + setupLog.Error(err, "unable to create slurm api client") + os.Exit(1) + } + slurmapiClients := map[types.NamespacedName]slurmapi.Client{ + slurmClusterName: slurmapiClient, + } + if err = checkcontroller.NewCheckControllerReconciler( mgr.GetClient(), mgr.GetScheme(), mgr.GetEventRecorderFor(checkcontroller.ControllerName), + slurmapiClients, reconcileTimeout, - ).SetupWithManager(mgr); err != nil { + ).SetupWithManager(mgr, maxConcurrency, cacheSyncTimeout); err != nil { setupLog.Error(err, "unable to create controller", checkcontroller.ControllerName) os.Exit(1) } diff --git a/go.mod b/go.mod index 1175e31f..ecd6fbfb 100644 --- a/go.mod +++ b/go.mod @@ -5,8 +5,10 @@ go 1.23.1 toolchain go1.23.3 require ( + github.com/SlinkyProject/slurm-client v0.1.0-20241108145209-7bfdd4923f75 github.com/go-logr/logr v1.4.2 github.com/golang-jwt/jwt/v5 v5.2.1 + github.com/hashicorp/go-retryablehttp v0.7.7 github.com/kubereboot/kured v0.0.0-20241106074119-94e73465adc3 github.com/mackerelio/go-osstat v0.2.5 github.com/onsi/ginkgo/v2 v2.22.2 @@ -30,19 +32,27 @@ require ( ) require ( + github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect github.com/containers/common v0.59.0 // indirect github.com/distribution/reference v0.6.0 // indirect github.com/fsnotify/fsnotify v1.7.0 // indirect github.com/fxamacker/cbor/v2 v2.7.0 // indirect + github.com/getkin/kin-openapi v0.122.0 // indirect github.com/go-task/slim-sprig/v3 v3.0.0 // indirect github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect + github.com/hashicorp/go-cleanhttp v0.5.2 // indirect + github.com/invopop/yaml v0.2.0 // indirect github.com/klauspost/compress v1.17.11 // indirect + github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect + github.com/oapi-codegen/runtime v1.1.1 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/runtime-spec v1.2.0 // indirect + github.com/perimeterx/marshmallow v1.1.5 // indirect github.com/robfig/cron/v3 v3.0.1 // indirect github.com/seccomp/libseccomp-golang v0.10.0 // indirect github.com/sethvargo/go-envconfig v1.1.0 // indirect github.com/sirupsen/logrus v1.9.3 // indirect + github.com/stretchr/objx v0.5.2 // indirect github.com/x448/float16 v0.8.4 // indirect gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect sigs.k8s.io/release-utils v0.8.1 // indirect diff --git a/go.sum b/go.sum index e6632743..c1c66f0f 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,11 @@ +github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk= +github.com/SlinkyProject/slurm-client v0.1.0-20241108145209-7bfdd4923f75 h1:80rOE0Eq5yhuFhI4sJJaHXTgZdGEyKP4MbsS9n6R1u8= +github.com/SlinkyProject/slurm-client v0.1.0-20241108145209-7bfdd4923f75/go.mod h1:c5gOa+wkxqqDZ5tJbhT7Rwe0yogivqWaKm4vQxudfO0= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/containers/common v0.59.0 h1:fy9Jz0B7Qs1C030bm73YJtVddaiFSZD3558EV1tgN2g= @@ -16,10 +22,14 @@ github.com/evanphx/json-patch v5.9.0+incompatible h1:fBXyNpNMuTTDdquAq/uisOr2lSh github.com/evanphx/json-patch v5.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch/v5 v5.9.0 h1:kcBlZQbplgElYIlo/n1hJbls2z/1awpXxpRi0/FOJfg= github.com/evanphx/json-patch/v5 v5.9.0/go.mod h1:VNkHZ/282BpEyt/tObQO8s5CMPmYYq14uClGH4abBuQ= +github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= +github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E= github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ= +github.com/getkin/kin-openapi v0.122.0 h1:WB9Jbl0Hp/T79/JF9xlSW5Kl9uYdk/AWD0yAd9HOM10= +github.com/getkin/kin-openapi v0.122.0/go.mod h1:PCWw/lfBrJY4HcdqE3jj+QFkaFK8ABoqo7PvqVhXXqw= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= @@ -35,6 +45,8 @@ github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+Gr github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= +github.com/go-test/deep v1.0.8 h1:TDsG77qcSprGbC6vTN8OuXp5g+J+b5Pcguhf7Zt61VM= +github.com/go-test/deep v1.0.8/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk= @@ -55,10 +67,19 @@ github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaU github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= +github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= +github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k= +github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= +github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU= +github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk= +github.com/invopop/yaml v0.2.0 h1:7zky/qH+O0DwAyoobXUqvVBwgBFRxKoQ/3FjcVpjTMY= +github.com/invopop/yaml v0.2.0/go.mod h1:2XuRLgs/ouIrW3XNzuNj7J3Nvu/Dig5MXvbCEdiBN3Q= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc= @@ -77,13 +98,21 @@ github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/mariadb-operator/mariadb-operator v0.36.0 h1:Z2dto//llEbQukOM229gs8cyjW3M87q7amHikOK2Scs= github.com/mariadb-operator/mariadb-operator v0.36.0/go.mod h1:n+jScQlveXPHWWpG2+vRVJx53HF/+94SpVacF2vh5+o= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw= +github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/oapi-codegen/runtime v1.1.1 h1:EXLHh0DXIJnWhdRPN2w4MXAzFyE4CskzhNLUmtpMYro= +github.com/oapi-codegen/runtime v1.1.1/go.mod h1:SK9X900oXmPWilYR5/WKPzt3Kqxn/uS/+lbpREv+eCg= github.com/onsi/ginkgo/v2 v2.22.2 h1:/3X8Panh8/WwhU/3Ssa6rCKqPLuAkVY2I0RoyDLySlU= github.com/onsi/ginkgo/v2 v2.22.2/go.mod h1:oeMosUL+8LtarXBHu/c0bx2D/K9zyQ6uX3cTyztHwsk= github.com/onsi/gomega v1.36.2 h1:koNYke6TVk6ZmnyHrCXba/T/MoLBXFjeC1PtvYgw0A8= @@ -96,6 +125,8 @@ github.com/opencontainers/runtime-spec v1.2.0 h1:z97+pHb3uELt/yiAWD691HNHQIF07bE github.com/opencontainers/runtime-spec v1.2.0/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/opencontainers/runtime-tools v0.9.1-0.20230914150019-408c51e934dc h1:d2hUh5O6MRBvStV55MQ8we08t42zSTqBbscoQccWmMc= github.com/opencontainers/runtime-tools v0.9.1-0.20230914150019-408c51e934dc/go.mod h1:8tx1helyqhUC65McMm3x7HmOex8lO2/v9zPuxmKHurs= +github.com/perimeterx/marshmallow v1.1.5 h1:a2LALqQ1BlHM8PZblsDdidgv1mWi1DgC2UmX50IvK2s= +github.com/perimeterx/marshmallow v1.1.5/go.mod h1:dsXbUu8CRzfYP5a87xpp0xq9S3u0Vchtcl8we9tYaXw= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= @@ -125,13 +156,18 @@ github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635 h1:kdXcSzyDtseVEc4yCz2qF8ZrQvIDBJLl4S1c3GCXmoI= github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww= +github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE= +github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= @@ -212,6 +248,7 @@ gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= istio.io/pkg v0.0.0-20241216214326-d70796207df3 h1:RVGgJ/Bipm3ekfiiFzkaorjjNzJH8lpVU9SlGkRDg6w= diff --git a/internal/checkcontroller/reconcile.go b/internal/checkcontroller/reconcile.go index 99fa8add..0ae35bf1 100644 --- a/internal/checkcontroller/reconcile.go +++ b/internal/checkcontroller/reconcile.go @@ -3,19 +3,25 @@ package checkcontroller import ( "context" "fmt" + "maps" "time" corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/types" "k8s.io/client-go/tools/record" ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/builder" "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/event" "sigs.k8s.io/controller-runtime/pkg/log" "sigs.k8s.io/controller-runtime/pkg/predicate" - slurmv1 "nebius.ai/slurm-operator/api/v1" + "nebius.ai/slurm-operator/internal/consts" "nebius.ai/slurm-operator/internal/controller/reconciler" + "nebius.ai/slurm-operator/internal/controllerconfig" + "nebius.ai/slurm-operator/internal/slurmapi" ) //+kubebuilder:rbac:groups=core,resources=pods,verbs=get;list;watch;create;delete;update @@ -29,15 +35,22 @@ var ( type CheckControllerReconciler struct { *reconciler.Reconciler reconcileTimeout time.Duration - ScontrolRunner ScontrolRunner + + slurmWorkersController slurmWorkersController } -func NewCheckControllerReconciler(client client.Client, scheme *runtime.Scheme, recorder record.EventRecorder, reconcileTimeout time.Duration) *CheckControllerReconciler { +func NewCheckControllerReconciler( + client client.Client, + scheme *runtime.Scheme, + recorder record.EventRecorder, + slurmAPIClients map[types.NamespacedName]slurmapi.Client, + reconcileTimeout time.Duration, +) *CheckControllerReconciler { r := reconciler.NewReconciler(client, scheme, recorder) return &CheckControllerReconciler{ - Reconciler: r, - reconcileTimeout: reconcileTimeout, - ScontrolRunner: ScontrolRunner{}, + Reconciler: r, + reconcileTimeout: reconcileTimeout, + slurmWorkersController: *newSlurmWorkersController(client, slurmAPIClients), } } @@ -45,31 +58,9 @@ func (r *CheckControllerReconciler) Reconcile(ctx context.Context, req ctrl.Requ logger := log.FromContext(ctx).WithName(ControllerName) logger.Info(fmt.Sprintf("Reconciling %s/%s", req.Namespace, req.Name)) - logger.V(1).Info("Running scontrol command") - output, err := r.ScontrolRunner.ShowNodes(ctx) - if err != nil { - return ctrl.Result{}, fmt.Errorf("error running scontrol command: %w", err) - } - - logger.V(1).Info("Unmarshaling JSON") - slurmData, err := unmarshalSlurmJSON(output) - if err != nil { - return ctrl.Result{RequeueAfter: r.reconcileTimeout}, fmt.Errorf("error unmarshaling JSON: %w", err) - } - if len(slurmData) == 0 { - logger.V(1).Info("No data found") - return ctrl.Result{RequeueAfter: r.reconcileTimeout}, nil - } - - logger.V(1).Info("Finding nodes by state and reason") - matchingNodes, err := findNodesByStateAndReason(slurmData) - if err != nil { - return ctrl.Result{RequeueAfter: r.reconcileTimeout}, fmt.Errorf("error finding nodes by state and reason: %w", err) - } - - logger.V(1).Info("Matching nodes", "nodes", matchingNodes) - if len(matchingNodes) == 0 { - logger.V(1).Info("No matching nodes") + logger.V(1).Info("Running slurm workers controller") + if err := r.slurmWorkersController.reconcile(ctx, req); err != nil { + logger.V(1).Error(err, "Reconcile slurm workers controller produced an error") return ctrl.Result{RequeueAfter: r.reconcileTimeout}, nil } @@ -77,46 +68,18 @@ func (r *CheckControllerReconciler) Reconcile(ctx context.Context, req ctrl.Requ return ctrl.Result{RequeueAfter: r.reconcileTimeout}, nil } -// GetPodNodeName gets the node name of the pod with the given name in the given namespace. -func (r *CheckControllerReconciler) GetPodNodeName(ctx context.Context, podName, namespace string) (string, error) { - pod := &corev1.Pod{} - err := r.Get(ctx, client.ObjectKey{Name: podName, Namespace: namespace}, pod) - if err != nil { - return "", fmt.Errorf("error getting pod: %w", err) - } - if pod.Spec.NodeName == "" { - return "", fmt.Errorf("pod has no pod name") - } - return pod.Spec.NodeName, nil -} - -// GetNode gets the node with the given name. -func (r *CheckControllerReconciler) GetNode(ctx context.Context, nodeName string) (*corev1.Node, error) { +func getK8SNode(ctx context.Context, c client.Client, nodeName string) (*corev1.Node, error) { node := &corev1.Node{} - err := r.Get(ctx, client.ObjectKey{Name: nodeName}, node) + err := c.Get(ctx, client.ObjectKey{Name: nodeName}, node) if err != nil { return nil, fmt.Errorf("error getting node: %w", err) } return node, nil } -// ListNodes lists all nodes in the cluster. -func (r *CheckControllerReconciler) ListNodes(ctx context.Context) ([]string, error) { - nodes := &corev1.NodeList{} - if err := r.List(ctx, nodes); err != nil { - return nil, fmt.Errorf("error listing nodes: %w", err) - } - - var nodeNames []string - for _, node := range nodes.Items { - nodeNames = append(nodeNames, node.Name) - } - - return nodeNames, nil -} - // SetupWithManager sets up the controller with the Manager. -func (r *CheckControllerReconciler) SetupWithManager(mgr ctrl.Manager) error { +func (r *CheckControllerReconciler) SetupWithManager(mgr ctrl.Manager, + maxConcurrency int, cacheSyncTimeout time.Duration) error { ctx := context.Background() // Index pods by node name. This is used to list and evict pods from a specific node. @@ -127,7 +90,107 @@ func (r *CheckControllerReconciler) SetupWithManager(mgr ctrl.Manager) error { return fmt.Errorf("failed to setup field indexer: %w", err) } + // TODO: common code for predicates return ctrl.NewControllerManagedBy(mgr). - For(&slurmv1.SlurmCluster{}, builder.WithPredicates(predicate.GenerationChangedPredicate{})). + For(&corev1.Node{}, builder.WithPredicates(predicate.Funcs{ + UpdateFunc: func(e event.UpdateEvent) bool { + oldNode := e.ObjectOld.(*corev1.Node) + newNode := e.ObjectNew.(*corev1.Node) + + // Extract the desired conditions from both old and new nodes + // and compare them to determine if reconciliation is needed + // based on the conditions changing + populateConditions := func(conditions []corev1.NodeCondition) map[corev1.NodeConditionType]corev1.NodeCondition { + condMap := make(map[corev1.NodeConditionType]corev1.NodeCondition) + + for _, condition := range conditions { + switch condition.Type { + case consts.SlurmNodeDrain, consts.SlurmNodeReboot, consts.K8SNodeMaintenanceScheduled, consts.K8SNodeDegraded: + condition := condition + condMap[condition.Type] = condition + } + } + + return condMap + } + + oldConditions := populateConditions(oldNode.Status.Conditions) + newConditions := populateConditions(newNode.Status.Conditions) + + return !maps.Equal(oldConditions, newConditions) + }, + CreateFunc: func(e event.CreateEvent) bool { + return true + }, + DeleteFunc: func(e event.DeleteEvent) bool { + return false + }, + GenericFunc: func(e event.GenericEvent) bool { + return true + }, + })). + WithOptions(controllerconfig.ControllerOptions(maxConcurrency, cacheSyncTimeout)). Complete(r) } + +func setK8SNodeCondition( + ctx context.Context, + c client.Client, + nodeName string, + condition corev1.NodeCondition, +) error { + logger := log.FromContext(ctx).WithName("SetNodeCondition").WithValues("nodeName", nodeName).V(1) + + node, err := getK8SNode(ctx, c, nodeName) + if err != nil { + return err + } + + // The field node.Status.Conditions belongs to the status of the Node resource. + // In Kubernetes, the status is considered a "system-owned" object and cannot be + // modified using a regular Update call. + // Instead, changes to the status must be made using the Status().Update method. + for _, cond := range node.Status.Conditions { + if cond.Type == condition.Type { + + if cond.Status == condition.Status && cond.Reason == string(condition.Reason) { + logger.Info(fmt.Sprintf("Node already has condition %s, set to %s", condition.Type, condition.Status)) + // TODO: update the LastHeartbeatTime + return nil + } + + logger.Info("Updating existing condition on node") + patch := client.MergeFrom(node.DeepCopy()) + + return c.Status().Patch(ctx, node, patch) + } + } + + logger.Info("Adding new condition to node") + node.Status.Conditions = append(node.Status.Conditions, condition) + if err := c.Status().Update(ctx, node); err != nil { + return fmt.Errorf("failed to update object status: %w", err) + } + + return nil +} + +func newNodeCondition( + conditionType corev1.NodeConditionType, + status corev1.ConditionStatus, + reason consts.ReasonConditionType, + message consts.MessageConditionType, +) corev1.NodeCondition { + return corev1.NodeCondition{ + Type: conditionType, + Status: status, + Reason: string(reason), + Message: string(message), + LastTransitionTime: metav1.Time{ + Time: time.Now(), + }, + LastHeartbeatTime: metav1.Time{ + Time: time.Now(), + }, + } +} diff --git a/internal/checkcontroller/scontrol_runner.go b/internal/checkcontroller/scontrol_runner.go deleted file mode 100644 index 77bb4343..00000000 --- a/internal/checkcontroller/scontrol_runner.go +++ /dev/null @@ -1,13 +0,0 @@ -package checkcontroller - -import ( - "context" - "os/exec" -) - -type ScontrolRunner struct{} - -func (s *ScontrolRunner) ShowNodes(ctx context.Context) ([]byte, error) { - cmd := exec.CommandContext(ctx, "scontrol", "show", "nodes", "--json") - return cmd.Output() -} diff --git a/internal/checkcontroller/slurm_worker.go b/internal/checkcontroller/slurm_worker.go deleted file mode 100644 index e7f030b3..00000000 --- a/internal/checkcontroller/slurm_worker.go +++ /dev/null @@ -1,45 +0,0 @@ -package checkcontroller - -import ( - "encoding/json" - "fmt" - "strings" -) - -// unmarshalSlurmJSON unmarshals the JSON output from scontrol show nodes --json -func unmarshalSlurmJSON(output []byte) (map[string]interface{}, error) { - var slurmData map[string]interface{} - err := json.Unmarshal(output, &slurmData) - if err != nil { - return nil, fmt.Errorf("error unmarshaling JSON: %w", err) - } - return slurmData, nil -} - -// findNodesByStateAndReason finds nodes in the DRAIN state with the reason "Kill task failed" -func findNodesByStateAndReason(slurmData map[string]interface{}) ([]string, error) { - var matchingNodes []string - nodes, ok := slurmData["nodes"].([]interface{}) - if !ok { - return nil, fmt.Errorf("error extracting nodes from JSON") - } - - for _, node := range nodes { - nodeData, ok := node.(map[string]interface{}) - if !ok { - continue - } - state, stateOk := nodeData["state"].([]interface{}) - reason, reasonOk := nodeData["reason"].(string) - if stateOk && reasonOk { - for _, s := range state { - if s == "DRAIN" && strings.Contains(reason, "Kill task failed") { - name, _ := nodeData["name"].(string) - matchingNodes = append(matchingNodes, name) - } - } - } - } - - return matchingNodes, nil -} diff --git a/internal/checkcontroller/slurm_worker_test.go b/internal/checkcontroller/slurm_worker_test.go deleted file mode 100644 index 776be323..00000000 --- a/internal/checkcontroller/slurm_worker_test.go +++ /dev/null @@ -1,106 +0,0 @@ -package checkcontroller - -import ( - "encoding/json" - "testing" -) - -// TestFindNodesByStateAndReason tests the findNodesByStateAndReason function -func TestFindNodesByStateAndReason(t *testing.T) { - // Example JSON data as if it was received from scontrol show nodes --json - jsonData := []byte(` - { - "nodes": [ - { - "name": "worker-0", - "state": ["IDLE", "DRAIN", "DYNAMIC_NORM"], - "reason": "Kill task failed : Not responding" - }, - { - "name": "worker-1", - "state": ["IDLE", "DYNAMIC_NORM"], - "reason": "Normal" - }, - { - "name": "worker-2", - "state": ["IDLE", "DRAIN", "DYNAMIC_NORM"], - "reason": "Kill task failed : Not responding" - } - ] - } - `) - - expected := []string{"worker-0", "worker-2"} - - slurmData, err := unmarshalSlurmJSON(jsonData) - if err != nil { - t.Fatalf("Error unmarshaling JSON: %v", err) - } - - result, err := findNodesByStateAndReason(slurmData) - if err != nil { - t.Fatalf("Error finding nodes: %v", err) - } - - if len(result) != len(expected) { - t.Errorf("Expected %v, but got %v", expected, result) - } - - for i, name := range expected { - if result[i] != name { - t.Errorf("Expected node '%s', but got '%s'", name, result[i]) - } - } -} - -// TestUnmarshalSlurmJSON tests the unmarshalSlurmJSON function -func TestUnmarshalSlurmJSON(t *testing.T) { - // Example JSON data as if it was received from scontrol show nodes --json - jsonData := []byte(` - { - "nodes": [ - { - "name": "worker-0", - "state": ["IDLE", "DRAIN", "DYNAMIC_NORM"], - "reason": "Kill task failed" - }, - { - "name": "worker-1", - "state": ["IDLE", "DYNAMIC_NORM"], - "reason": "Normal" - } - ] - } - `) - - expected := map[string]interface{}{ - "nodes": []interface{}{ - map[string]interface{}{ - "name": "worker-0", - "state": []interface{}{"IDLE", "DRAIN", "DYNAMIC_NORM"}, - "reason": "Kill task failed", - }, - map[string]interface{}{ - "name": "worker-1", - "state": []interface{}{"IDLE", "DYNAMIC_NORM"}, - "reason": "Normal", - }, - }, - } - - result, err := unmarshalSlurmJSON(jsonData) - if err != nil { - t.Fatalf("Error unmarshaling JSON: %v", err) - } - - if !compareJSON(result, expected) { - t.Errorf("Expected %+v, but got %+v", expected, result) - } -} - -// Func compareJSON compares two JSON objects -func compareJSON(a, b interface{}) bool { - aBytes, _ := json.Marshal(a) - bBytes, _ := json.Marshal(b) - return string(aBytes) == string(bBytes) -} diff --git a/internal/checkcontroller/slurm_workers_controller.go b/internal/checkcontroller/slurm_workers_controller.go new file mode 100644 index 00000000..628b36e0 --- /dev/null +++ b/internal/checkcontroller/slurm_workers_controller.go @@ -0,0 +1,420 @@ +package checkcontroller + +import ( + "context" + "errors" + "fmt" + "strings" + + slurmapispec "github.com/SlinkyProject/slurm-client/api/v0041" + corev1 "k8s.io/api/core/v1" + "k8s.io/apimachinery/pkg/types" + "k8s.io/utils/ptr" + "nebius.ai/slurm-operator/internal/consts" + ctrl "sigs.k8s.io/controller-runtime" + "sigs.k8s.io/controller-runtime/pkg/client" + "sigs.k8s.io/controller-runtime/pkg/log" + + "nebius.ai/slurm-operator/internal/slurmapi" +) + +type slurmWorkersController struct { + client.Client + slurmAPIClients map[types.NamespacedName]slurmapi.Client +} + +// TODO: change clients init to jwtController. +func newSlurmWorkersController(r client.Client, slurmAPIClients map[types.NamespacedName]slurmapi.Client) *slurmWorkersController { + return &slurmWorkersController{ + Client: r, + slurmAPIClients: slurmAPIClients, + } +} + +func (c *slurmWorkersController) reconcile(ctx context.Context, req ctrl.Request) error { + logger := log.FromContext(ctx).WithName("slurmWorkersController.reconcile").V(1). + WithValues("k8sNode", req.Name) + + logger.Info("reconciling k8s node") + k8sNode, err := getK8SNode(ctx, c.Client, req.Name) + if err != nil { + return err + } + + if err := c.processK8SNodeMaintenance(ctx, k8sNode); err != nil { + return err + } + + degradedNodes, err := c.findDegradedNodes(ctx, k8sNode.Name) + if err != nil { + return err + } + + logger.Info(fmt.Sprintf("found %d degraded nodes", len(degradedNodes))) + var errs []error + for slurmClusterName, nodes := range degradedNodes { + for _, node := range nodes { + if err := c.processDegradedNode(ctx, k8sNode, slurmClusterName, node); err != nil { + errs = append(errs, err) + } + } + } + + return errors.Join(errs...) +} + +// TODO: filter also slurmNodes by supported slurm clusters +// in case when 2 slurm nodes are on the same k8s node. +func (c *slurmWorkersController) findDegradedNodes(ctx context.Context, k8sNodeName string) (map[types.NamespacedName][]slurmapi.Node, error) { + degradedNodes := make(map[types.NamespacedName][]slurmapi.Node) + + for slurmClusterName, slurmAPIClient := range c.slurmAPIClients { + slurmNodes, err := slurmAPIClient.ListNodes(ctx) + if err != nil { + return nil, err + } + + for _, node := range slurmNodes { + if node.InstanceID != k8sNodeName { + // Skip, will process during another node reconcilation + continue + } + if _, ok := node.States[slurmapispec.V0041NodeStateDRAIN]; !ok { + // Node is not drained, skipping + continue + } + + if node.Reason == nil { + // Node is drained with no reason, skipping + continue + } + + for wellKnownReason := range consts.SlurmNodeReasonsMap { + if strings.Contains(node.Reason.Reason, wellKnownReason) { + // For simplicity, we keep only well known part + node.Reason.Reason = wellKnownReason + + nodes := degradedNodes[slurmClusterName] + nodes = append(nodes, node) + degradedNodes[slurmClusterName] = nodes + break + } + } + } + } + + return degradedNodes, nil +} + +func (c *slurmWorkersController) processDegradedNode( + ctx context.Context, + k8sNode *corev1.Node, + slurmClusterName types.NamespacedName, + node slurmapi.Node, +) error { + + switch node.Reason.Reason { + case consts.SlurmNodeReasonKillTaskFailed, consts.SlurmNodeReasonDegraded: + return c.processKillTaskFailed(ctx, k8sNode, slurmClusterName, node) + case consts.SlurmNodeReasonMaintenanceScheduled: + return c.processSlurmNodeMaintenance(ctx, k8sNode, slurmClusterName, node.Name) + default: + return fmt.Errorf("unknown node reason: node name %s, reason %s, instance id %s", + node.Name, node.Reason, node.InstanceID) + } +} + +func (c *slurmWorkersController) processKillTaskFailed( + ctx context.Context, + k8sNode *corev1.Node, + slurmClusterName types.NamespacedName, + slurmNode slurmapi.Node, +) error { + + drainWithCondition := func() error { + if err := c.drainSlurmNodesWithConditionUpdate( + ctx, + slurmNode.InstanceID, + consts.SlurmNodeReasonDegraded, + newNodeCondition( + consts.SlurmNodeReboot, + corev1.ConditionTrue, + consts.ReasonNodeNeedReboot, + "", + ), + ); err != nil { + return fmt.Errorf("drain slurm nodes: %w", err) + } + + return nil + } + + var degradedCondition corev1.NodeCondition + for _, cond := range k8sNode.Status.Conditions { + if cond.Type == consts.K8SNodeDegraded { + degradedCondition = cond + break + } + } + + if degradedCondition == (corev1.NodeCondition{}) { + // No degraded condition found + return drainWithCondition() + } + + if degradedCondition.Status == corev1.ConditionTrue { + // Node is still rebooting, skip + return nil + } + if slurmNode.Reason.ChangedAt.Before(degradedCondition.LastTransitionTime.Time) { + return c.undrainSlurmNode(ctx, slurmClusterName, slurmNode.Name) + } + + return drainWithCondition() +} + +func (c *slurmWorkersController) processK8SNodeMaintenance(ctx context.Context, k8sNode *corev1.Node) error { + drainFn := func() error { + return c.drainSlurmNodesWithConditionUpdate( + ctx, + k8sNode.Name, + consts.SlurmNodeReasonMaintenanceScheduled, + newNodeCondition( + consts.SlurmNodeDrain, + corev1.ConditionTrue, + consts.ReasonNodeDraining, + "", + ), + ) + } + + return c.processMaintenance(ctx, k8sNode, drainFn, nil) +} + +func (c *slurmWorkersController) processSlurmNodeMaintenance( + ctx context.Context, + k8sNode *corev1.Node, + slurmClusterName types.NamespacedName, + slurmNodeName string) error { + + undrainFn := func() error { + return c.undrainSlurmNode(ctx, slurmClusterName, slurmNodeName) + } + + return c.processMaintenance(ctx, k8sNode, nil, undrainFn) +} + +func (c *slurmWorkersController) processMaintenance( + _ context.Context, + k8sNode *corev1.Node, + drainFn, undrainFn func() error, +) error { + if drainFn == nil { + drainFn = func() error { return nil } + } + if undrainFn == nil { + undrainFn = func() error { return nil } + } + + var maintenanceCondition corev1.NodeCondition + for _, cond := range k8sNode.Status.Conditions { + if cond.Type == consts.K8SNodeMaintenanceScheduled { + maintenanceCondition = cond + break + } + } + + if maintenanceCondition == (corev1.NodeCondition{}) || maintenanceCondition.Status == corev1.ConditionFalse { + return undrainFn() + } + + return drainFn() +} + +func (c *slurmWorkersController) drainSlurmNodesWithConditionUpdate( + ctx context.Context, + k8sNodeName string, + reason string, + condition corev1.NodeCondition, +) error { + + if err := c.drainSlurmNodes(ctx, k8sNodeName, reason); err != nil { + return fmt.Errorf("drain slurm nodes: %w", err) + } + + slurmNodesAreFullyDrained, err := c.slurmNodesFullyDrained(ctx, k8sNodeName) + if err != nil { + return fmt.Errorf("check that nodes are fully drained: %w", err) + } + + if !slurmNodesAreFullyDrained { + // Wait until all slurm nodes are drained. + return nil + } + + if err := setK8SNodeCondition( + ctx, + c.Client, + k8sNodeName, + condition, + ); err != nil { + return fmt.Errorf("set k8s node condition: %w", err) + } + + return nil +} + +func (c *slurmWorkersController) drainSlurmNodes( + ctx context.Context, + k8sNodeName string, + reason string, +) error { + + podList := &corev1.PodList{} + if err := c.List(ctx, podList, client.MatchingFields{"spec.nodeName": k8sNodeName}); err != nil { + return fmt.Errorf("list pods on node %s: %w", k8sNodeName, err) + } + + var errs []error + for _, pod := range podList.Items { + if strings.Contains(pod.Name, "worker-") { + slurmClusterName := types.NamespacedName{ + Namespace: pod.Namespace, + Name: pod.Labels[consts.LabelInstanceKey], + } + + err := c.drainSlurmNode(ctx, slurmClusterName, pod.Name, reason) + if err != nil { + errs = append(errs, err) + } + } + } + + return errors.Join(errs...) +} + +func (c *slurmWorkersController) drainSlurmNode( + ctx context.Context, + slurmClusterName types.NamespacedName, + slurmNodeName, reason string, +) error { + logger := log.FromContext(ctx).WithName("drainSlurmNode").V(1). + WithValues( + "slurmNodeName", slurmNodeName, + "drainReason", reason, + "slurmCluster", slurmClusterName, + ) + logger.Info("draining slurm node") + + slurmAPIClient, ok := c.slurmAPIClients[slurmClusterName] + if !ok { + return fmt.Errorf("no slurm clusters found with name %s", slurmClusterName) + } + + resp, err := slurmAPIClient.SlurmV0041PostNodeWithResponse(ctx, slurmNodeName, + slurmapispec.V0041UpdateNodeMsg{ + Reason: ptr.To(string(reason)), + State: ptr.To([]slurmapispec.V0041UpdateNodeMsgState{slurmapispec.V0041UpdateNodeMsgStateDRAIN}), + }, + ) + if err != nil { + return fmt.Errorf("post drain slurm node: %w", err) + } + if resp.JSON200.Errors != nil && len(*resp.JSON200.Errors) != 0 { + return fmt.Errorf("post drain returned errors: %v", *resp.JSON200.Errors) + } + + logger.Info("slurm node state is updated to DRAIN") + return nil +} + +func (c *slurmWorkersController) slurmNodesFullyDrained( + ctx context.Context, + k8sNodeName string, +) (bool, error) { + logger := log.FromContext(ctx).WithName("slurmNodesFullyDrained").V(1) + + logger.Info("checking that slurm nodes are fully drained") + podList := &corev1.PodList{} + if err := c.List(ctx, podList, client.MatchingFields{"spec.nodeName": k8sNodeName}); err != nil { + return false, fmt.Errorf("list pods on node %s: %w", k8sNodeName, err) + } + + for _, pod := range podList.Items { + if strings.Contains(pod.Name, "worker-") { + logger = logger.WithValues("slurmNode", pod.Name, "instanceKey", pod.Labels[consts.LabelInstanceKey]) + logger.Info("found slurm node") + + slurmClusterName := types.NamespacedName{ + Namespace: pod.Namespace, + Name: pod.Labels[consts.LabelInstanceKey], + } + + node, err := c.getSlurmNode(ctx, slurmClusterName, pod.Name) + if err != nil { + return false, err + } + logger.Info("slurm node", "nodeStates", node.States, "kekuspekus", node) + if !node.IsIdleDrained() { + logger.Info("slurm node is not fully drained", "nodeStates", node.States) + return false, nil + } + logger.Info("slurm node is fully drained", "nodeStates", node.States, "kekuspekus", node) + } + } + + logger.Info("all slurm nodes are fully drained") + return true, nil +} + +func (c *slurmWorkersController) undrainSlurmNode( + ctx context.Context, + slurmClusterName types.NamespacedName, + slurmNodeName string, +) error { + logger := log.FromContext(ctx).WithName("undrainSlurmNode").V(1). + WithValues( + "slurmNodeName", slurmNodeName, + "slurmCluster", slurmClusterName, + ) + logger.Info("undraining slurm node") + + slurmAPIClient, ok := c.slurmAPIClients[slurmClusterName] + if !ok { + return fmt.Errorf("no slurm clusters with name %s", slurmClusterName) + } + + resp, err := slurmAPIClient.SlurmV0041PostNodeWithResponse(ctx, slurmNodeName, + slurmapispec.V0041UpdateNodeMsg{ + State: ptr.To([]slurmapispec.V0041UpdateNodeMsgState{slurmapispec.V0041UpdateNodeMsgStateRESUME}), + }, + ) + if err != nil { + return fmt.Errorf("post undrain slurm node: %w", err) + } + if resp.JSON200.Errors != nil && len(*resp.JSON200.Errors) != 0 { + return fmt.Errorf("post undrain returned errors: %v", *resp.JSON200.Errors) + } + + logger.Info("slurm node state is updated to RESUME") + return nil +} + +func (c *slurmWorkersController) getSlurmNode( + ctx context.Context, + slurmClusterName types.NamespacedName, + slurmNodeName string, +) (slurmapi.Node, error) { + + slurmAPIClient, ok := c.slurmAPIClients[slurmClusterName] + if !ok { + return slurmapi.Node{}, fmt.Errorf("no slurm clusters with name %s", slurmClusterName) + } + + node, err := slurmAPIClient.GetNode(ctx, slurmNodeName) + if err != nil { + return slurmapi.Node{}, fmt.Errorf("get node: %w", err) + } + + return node, nil +} diff --git a/internal/checkcontroller/slurm_workers_controller_test.go b/internal/checkcontroller/slurm_workers_controller_test.go new file mode 100644 index 00000000..a374dfea --- /dev/null +++ b/internal/checkcontroller/slurm_workers_controller_test.go @@ -0,0 +1,177 @@ +package checkcontroller + +import ( + "context" + "errors" + "testing" + "time" + + slurmapispec "github.com/SlinkyProject/slurm-client/api/v0041" + "github.com/stretchr/testify/require" + "k8s.io/apimachinery/pkg/types" + "k8s.io/utils/ptr" + "nebius.ai/slurm-operator/internal/consts" + "nebius.ai/slurm-operator/internal/slurmapi" + slurmapifake "nebius.ai/slurm-operator/internal/slurmapi/fake" +) + +func Test_slurmWorkersController_findDegradedNodes(t *testing.T) { + tests := []struct { + name string + k8sNodeName string + slurmClusterName types.NamespacedName + + listNodesOut []slurmapi.Node + listNodesErr error + + want map[types.NamespacedName][]slurmapi.Node + wantErr bool + }{ + { + name: "happy-path/found-degraded-node", + k8sNodeName: "k8s-node", + slurmClusterName: types.NamespacedName{ + Namespace: "namespace", + Name: "name", + }, + listNodesOut: []slurmapi.Node{ + { + Name: "node", + ClusterName: "slurm-cluster", + InstanceID: "k8s-node", + States: map[slurmapispec.V0041NodeState]struct{}{ + slurmapispec.V0041NodeStateDRAIN: {}, + }, + Reason: ptr.To(slurmapi.NodeReason{ + Reason: consts.SlurmNodeReasonKillTaskFailed, + ChangedAt: time.Date(2024, time.March, 1, 1, 1, 1, 1, time.UTC), + }), + }, + }, + listNodesErr: nil, + want: map[types.NamespacedName][]slurmapi.Node{ + { + Namespace: "namespace", + Name: "name", + }: { + { + Name: "node", + ClusterName: "slurm-cluster", + InstanceID: "k8s-node", + States: map[slurmapispec.V0041NodeState]struct{}{ + slurmapispec.V0041NodeStateDRAIN: {}, + }, + Reason: ptr.To(slurmapi.NodeReason{ + Reason: consts.SlurmNodeReasonKillTaskFailed, + ChangedAt: time.Date(2024, time.March, 1, 1, 1, 1, 1, time.UTC), + }), + }, + }, + }, + wantErr: false, + }, + { + name: "unhappy-path/slurmapi-error", + k8sNodeName: "k8s-node", + slurmClusterName: types.NamespacedName{ + Namespace: "namespace", + Name: "name", + }, + listNodesErr: errors.New("error"), + wantErr: true, + }, + { + name: "happy-path/skip/different-k8s-node", + k8sNodeName: "k8s-node-1", + slurmClusterName: types.NamespacedName{ + Namespace: "namespace", + Name: "name", + }, + listNodesOut: []slurmapi.Node{ + { + Name: "node", + ClusterName: "slurm-cluster", + InstanceID: "k8s-node-2", + States: map[slurmapispec.V0041NodeState]struct{}{ + slurmapispec.V0041NodeStateDRAIN: {}, + }, + Reason: ptr.To(slurmapi.NodeReason{ + Reason: consts.SlurmNodeReasonKillTaskFailed, + ChangedAt: time.Date(2024, time.March, 1, 1, 1, 1, 1, time.UTC), + }), + }, + }, + listNodesErr: nil, + want: map[types.NamespacedName][]slurmapi.Node{}, + wantErr: false, + }, + { + name: "happy-path/skip/not-drained", + k8sNodeName: "k8s-node", + slurmClusterName: types.NamespacedName{ + Namespace: "namespace", + Name: "name", + }, + listNodesOut: []slurmapi.Node{ + { + Name: "node", + ClusterName: "slurm-cluster", + InstanceID: "k8s-node", + States: map[slurmapispec.V0041NodeState]struct{}{ + slurmapispec.V0041NodeStateIDLE: {}, + }, + Reason: ptr.To(slurmapi.NodeReason{ + Reason: consts.SlurmNodeReasonKillTaskFailed, + ChangedAt: time.Date(2024, time.March, 1, 1, 1, 1, 1, time.UTC), + }), + }, + }, + listNodesErr: nil, + want: map[types.NamespacedName][]slurmapi.Node{}, + wantErr: false, + }, + { + name: "happy-path/skip/no-drain-reason", + k8sNodeName: "k8s-node", + slurmClusterName: types.NamespacedName{ + Namespace: "namespace", + Name: "name", + }, + listNodesOut: []slurmapi.Node{ + { + Name: "node", + ClusterName: "slurm-cluster", + InstanceID: "k8s-node", + States: map[slurmapispec.V0041NodeState]struct{}{ + slurmapispec.V0041NodeStateDRAIN: {}, + }, + Reason: nil, + }, + }, + listNodesErr: nil, + want: map[types.NamespacedName][]slurmapi.Node{}, + wantErr: false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() + + apiClient := slurmapifake.NewMockClient(t) + apiClient.On("ListNodes", ctx).Return(tt.listNodesOut, tt.listNodesErr) + + c := &slurmWorkersController{ + slurmAPIClients: map[types.NamespacedName]slurmapi.Client{ + tt.slurmClusterName: apiClient, + }, + } + got, err := c.findDegradedNodes(ctx, tt.k8sNodeName) + require.Equal(t, tt.wantErr, err != nil) + if !tt.wantErr { + require.EqualValues(t, tt.want, got) + } + }) + } +} + +// TODO: more tests diff --git a/internal/consts/conditions.go b/internal/consts/conditions.go index 5013b7be..ac356189 100644 --- a/internal/consts/conditions.go +++ b/internal/consts/conditions.go @@ -3,20 +3,27 @@ package consts import corev1 "k8s.io/api/core/v1" const ( - SlurmNodeDrain = corev1.NodeConditionType("SlurmNodeDrain") - SlurmNodeReboot = corev1.NodeConditionType("SlurmNodeReboot") + SlurmNodeDrain corev1.NodeConditionType = "SlurmNodeDrain" + SlurmNodeReboot corev1.NodeConditionType = "SlurmNodeReboot" + + K8SNodeDegraded corev1.NodeConditionType = "NodeDegraded" + K8SNodeMaintenanceScheduled corev1.NodeConditionType = "NodeMaintenanceScheduled" ) type ReasonConditionType string type MessageConditionType string const ( + ReasonNodeNeedDrain ReasonConditionType = "NodeNeedDrain" ReasonNodeDraining ReasonConditionType = "NodeDraining" ReasonNodeDrained ReasonConditionType = "NodeDrained" ReasonNodeUndrained ReasonConditionType = "NodeUndrained" + ReasonNodeNeedReboot ReasonConditionType = "NodeNeedReboot" ReasonNodeRebooting ReasonConditionType = "NodeRebooting" ReasonNodeRebooted ReasonConditionType = "NodeRebooted" ReasonNodeNoRebootNeeded ReasonConditionType = "NodeNoRebootNeeded" + + ReasonSlurmNodeDegraded ReasonConditionType = "SlurmNodeDegraded" ) const ( @@ -25,4 +32,6 @@ const ( MessageRebooting MessageConditionType = "Node is rebooting" MessageRebooted MessageConditionType = "Node has been rebooted" MessageUndrained MessageConditionType = "Node has been undrained" + + MessageSlurmNodeDegraded MessageConditionType = "Some slurm nodes on the k8s nod are degraded" ) diff --git a/internal/consts/slurm.go b/internal/consts/slurm.go index 71fd68ff..f2dd4b0a 100644 --- a/internal/consts/slurm.go +++ b/internal/consts/slurm.go @@ -12,3 +12,15 @@ const ( SlurmLogFile = "/dev/null" SlurmDefaultDebugLevel = "debug3" ) + +const ( + SlurmNodeReasonKillTaskFailed string = "Kill task failed" + SlurmNodeReasonMaintenanceScheduled string = "Maintenance scheduled" + SlurmNodeReasonDegraded string = "Compute node is degraded" +) + +var SlurmNodeReasonsMap = map[string]struct{}{ + SlurmNodeReasonKillTaskFailed: {}, + SlurmNodeReasonMaintenanceScheduled: {}, + SlurmNodeReasonDegraded: {}, +} diff --git a/internal/slurmapi/client.go b/internal/slurmapi/client.go new file mode 100644 index 00000000..0f842b56 --- /dev/null +++ b/internal/slurmapi/client.go @@ -0,0 +1,117 @@ +package slurmapi + +import ( + "context" + "fmt" + "net/http" + + api "github.com/SlinkyProject/slurm-client/api/v0041" + slurmapispec "github.com/SlinkyProject/slurm-client/api/v0041" + "github.com/hashicorp/go-retryablehttp" +) + +const ( + headerSlurmUserToken = "X-SLURM-USER-TOKEN" + + headerContentType = "Content-Type" + headerApplicationJson = "application/json" +) + +func DefaultHTTPClient() *http.Client { + retryClient := retryablehttp.NewClient() + retryClient.Logger = nil + return retryClient.StandardClient() +} + +type client struct { + api.ClientWithResponsesInterface + + tokenIssuer tokenIssuer +} + +type tokenIssuer interface { + Issue(ctx context.Context) (string, error) +} + +func NewClient(server string, tokenIssuer tokenIssuer, httpClient *http.Client) (*client, error) { + if httpClient != nil { + httpClient = DefaultHTTPClient() + } + + apiClient := &client{ + tokenIssuer: tokenIssuer, + } + + c, err := api.NewClientWithResponses( + server, + api.WithHTTPClient(httpClient), + api.WithRequestEditorFn(apiClient.setHeaders), + ) + if err != nil { + return nil, fmt.Errorf("unable to create client: %v", err) + } + + apiClient.ClientWithResponsesInterface = c + + return apiClient, nil +} + +func (c *client) setHeaders(ctx context.Context, req *http.Request) error { + token, err := c.tokenIssuer.Issue(ctx) + if err != nil { + return fmt.Errorf("unable to issue jwt: %w", err) + } + + req.Header.Add(headerSlurmUserToken, token) + req.Header.Add(headerContentType, headerApplicationJson) + return nil +} + +func (c *client) ListNodes(ctx context.Context) ([]Node, error) { + getNodesResp, err := c.SlurmV0041GetNodesWithResponse(ctx, &slurmapispec.SlurmV0041GetNodesParams{}) + if err != nil { + return nil, fmt.Errorf("list nodes: %w", err) + } + if getNodesResp.JSON200 == nil { + return nil, fmt.Errorf("json200 field is nil") + } + if getNodesResp.JSON200.Errors != nil && len(*getNodesResp.JSON200.Errors) != 0 { + return nil, fmt.Errorf("list nodes responded with errors: %v", *getNodesResp.JSON200.Errors) + } + + nodes := make([]Node, 0, len(getNodesResp.JSON200.Nodes)) + for _, n := range getNodesResp.JSON200.Nodes { + node, err := NodeFromAPI(n) + if err != nil { + return nil, fmt.Errorf("convert node from api response: %w", err) + } + + nodes = append(nodes, node) + } + + return nodes, nil +} + +func (c *client) GetNode(ctx context.Context, nodeName string) (Node, error) { + getNodesResp, err := c.SlurmV0041GetNodeWithResponse(ctx, nodeName, &slurmapispec.SlurmV0041GetNodeParams{}) + if err != nil { + return Node{}, fmt.Errorf("get node %s: %w", nodeName, err) + } + if getNodesResp.JSON200 == nil { + return Node{}, fmt.Errorf("json200 field is nil, node name %s", nodeName) + } + if getNodesResp.JSON200.Errors != nil && len(*getNodesResp.JSON200.Errors) != 0 { + return Node{}, fmt.Errorf("get node %s responded with errors: %v", nodeName, *getNodesResp.JSON200.Errors) + } + + if nodeLength := len(getNodesResp.JSON200.Nodes); nodeLength != 1 { + return Node{}, fmt.Errorf("expected only one node in response for get %s request, got %d", nodeName, nodeLength) + } + + node, err := NodeFromAPI(getNodesResp.JSON200.Nodes[0]) + if err != nil { + return Node{}, fmt.Errorf("convert node from api response: %w", err) + } + + return node, nil +} diff --git a/internal/slurmapi/fake/mock_client.go b/internal/slurmapi/fake/mock_client.go new file mode 100644 index 00000000..7379e37a --- /dev/null +++ b/internal/slurmapi/fake/mock_client.go @@ -0,0 +1,5514 @@ +// Code generated by mockery v2.52.2. DO NOT EDIT. + +package fake + +import ( + context "context" + io "io" + + mock "github.com/stretchr/testify/mock" + + slurmapi "nebius.ai/slurm-operator/internal/slurmapi" + + v0041 "github.com/SlinkyProject/slurm-client/api/v0041" +) + +// MockClient is an autogenerated mock type for the Client type +type MockClient struct { + mock.Mock +} + +type MockClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockClient) EXPECT() *MockClient_Expecter { + return &MockClient_Expecter{mock: &_m.Mock} +} + +// GetNode provides a mock function with given fields: ctx, nodeName +func (_m *MockClient) GetNode(ctx context.Context, nodeName string) (slurmapi.Node, error) { + ret := _m.Called(ctx, nodeName) + + if len(ret) == 0 { + panic("no return value specified for GetNode") + } + + var r0 slurmapi.Node + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (slurmapi.Node, error)); ok { + return rf(ctx, nodeName) + } + if rf, ok := ret.Get(0).(func(context.Context, string) slurmapi.Node); ok { + r0 = rf(ctx, nodeName) + } else { + r0 = ret.Get(0).(slurmapi.Node) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, nodeName) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_GetNode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNode' +type MockClient_GetNode_Call struct { + *mock.Call +} + +// GetNode is a helper method to define mock.On call +// - ctx context.Context +// - nodeName string +func (_e *MockClient_Expecter) GetNode(ctx interface{}, nodeName interface{}) *MockClient_GetNode_Call { + return &MockClient_GetNode_Call{Call: _e.mock.On("GetNode", ctx, nodeName)} +} + +func (_c *MockClient_GetNode_Call) Run(run func(ctx context.Context, nodeName string)) *MockClient_GetNode_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockClient_GetNode_Call) Return(_a0 slurmapi.Node, _a1 error) *MockClient_GetNode_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_GetNode_Call) RunAndReturn(run func(context.Context, string) (slurmapi.Node, error)) *MockClient_GetNode_Call { + _c.Call.Return(run) + return _c +} + +// ListNodes provides a mock function with given fields: ctx +func (_m *MockClient) ListNodes(ctx context.Context) ([]slurmapi.Node, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for ListNodes") + } + + var r0 []slurmapi.Node + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) ([]slurmapi.Node, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) []slurmapi.Node); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]slurmapi.Node) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_ListNodes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNodes' +type MockClient_ListNodes_Call struct { + *mock.Call +} + +// ListNodes is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockClient_Expecter) ListNodes(ctx interface{}) *MockClient_ListNodes_Call { + return &MockClient_ListNodes_Call{Call: _e.mock.On("ListNodes", ctx)} +} + +func (_c *MockClient_ListNodes_Call) Run(run func(ctx context.Context)) *MockClient_ListNodes_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockClient_ListNodes_Call) Return(_a0 []slurmapi.Node, _a1 error) *MockClient_ListNodes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_ListNodes_Call) RunAndReturn(run func(context.Context) ([]slurmapi.Node, error)) *MockClient_ListNodes_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041DeleteJobWithResponse provides a mock function with given fields: ctx, jobId, params, reqEditors +func (_m *MockClient) SlurmV0041DeleteJobWithResponse(ctx context.Context, jobId string, params *v0041.SlurmV0041DeleteJobParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, jobId, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041DeleteJobWithResponse") + } + + var r0 *v0041.SlurmV0041DeleteJobResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041DeleteJobParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobResponse, error)); ok { + return rf(ctx, jobId, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041DeleteJobParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041DeleteJobResponse); ok { + r0 = rf(ctx, jobId, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041DeleteJobResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmV0041DeleteJobParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, jobId, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041DeleteJobWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041DeleteJobWithResponse' +type MockClient_SlurmV0041DeleteJobWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041DeleteJobWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - jobId string +// - params *v0041.SlurmV0041DeleteJobParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041DeleteJobWithResponse(ctx interface{}, jobId interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041DeleteJobWithResponse_Call { + return &MockClient_SlurmV0041DeleteJobWithResponse_Call{Call: _e.mock.On("SlurmV0041DeleteJobWithResponse", + append([]interface{}{ctx, jobId, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041DeleteJobWithResponse_Call) Run(run func(ctx context.Context, jobId string, params *v0041.SlurmV0041DeleteJobParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041DeleteJobWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmV0041DeleteJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteJobWithResponse_Call) Return(_a0 *v0041.SlurmV0041DeleteJobResponse, _a1 error) *MockClient_SlurmV0041DeleteJobWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteJobWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmV0041DeleteJobParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobResponse, error)) *MockClient_SlurmV0041DeleteJobWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041DeleteJobsWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmV0041DeleteJobsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041DeleteJobsWithBodyWithResponse") + } + + var r0 *v0041.SlurmV0041DeleteJobsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobsResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmV0041DeleteJobsResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041DeleteJobsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041DeleteJobsWithBodyWithResponse' +type MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041DeleteJobsWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041DeleteJobsWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call { + return &MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call{Call: _e.mock.On("SlurmV0041DeleteJobsWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmV0041DeleteJobsResponse, _a1 error) *MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobsResponse, error)) *MockClient_SlurmV0041DeleteJobsWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041DeleteJobsWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmV0041DeleteJobsWithResponse(ctx context.Context, body v0041.SlurmV0041DeleteJobsJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041DeleteJobsWithResponse") + } + + var r0 *v0041.SlurmV0041DeleteJobsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmV0041DeleteJobsJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobsResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmV0041DeleteJobsJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmV0041DeleteJobsResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041DeleteJobsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmV0041DeleteJobsJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041DeleteJobsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041DeleteJobsWithResponse' +type MockClient_SlurmV0041DeleteJobsWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041DeleteJobsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmV0041DeleteJobsJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041DeleteJobsWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041DeleteJobsWithResponse_Call { + return &MockClient_SlurmV0041DeleteJobsWithResponse_Call{Call: _e.mock.On("SlurmV0041DeleteJobsWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041DeleteJobsWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmV0041DeleteJobsJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041DeleteJobsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmV0041DeleteJobsJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteJobsWithResponse_Call) Return(_a0 *v0041.SlurmV0041DeleteJobsResponse, _a1 error) *MockClient_SlurmV0041DeleteJobsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteJobsWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmV0041DeleteJobsJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteJobsResponse, error)) *MockClient_SlurmV0041DeleteJobsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041DeleteNodeWithResponse provides a mock function with given fields: ctx, nodeName, reqEditors +func (_m *MockClient) SlurmV0041DeleteNodeWithResponse(ctx context.Context, nodeName string, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteNodeResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, nodeName) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041DeleteNodeWithResponse") + } + + var r0 *v0041.SlurmV0041DeleteNodeResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteNodeResponse, error)); ok { + return rf(ctx, nodeName, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) *v0041.SlurmV0041DeleteNodeResponse); ok { + r0 = rf(ctx, nodeName, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041DeleteNodeResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, nodeName, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041DeleteNodeWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041DeleteNodeWithResponse' +type MockClient_SlurmV0041DeleteNodeWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041DeleteNodeWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - nodeName string +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041DeleteNodeWithResponse(ctx interface{}, nodeName interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041DeleteNodeWithResponse_Call { + return &MockClient_SlurmV0041DeleteNodeWithResponse_Call{Call: _e.mock.On("SlurmV0041DeleteNodeWithResponse", + append([]interface{}{ctx, nodeName}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041DeleteNodeWithResponse_Call) Run(run func(ctx context.Context, nodeName string, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041DeleteNodeWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteNodeWithResponse_Call) Return(_a0 *v0041.SlurmV0041DeleteNodeResponse, _a1 error) *MockClient_SlurmV0041DeleteNodeWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041DeleteNodeWithResponse_Call) RunAndReturn(run func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmV0041DeleteNodeResponse, error)) *MockClient_SlurmV0041DeleteNodeWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetDiagWithResponse provides a mock function with given fields: ctx, reqEditors +func (_m *MockClient) SlurmV0041GetDiagWithResponse(ctx context.Context, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetDiagResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetDiagWithResponse") + } + + var r0 *v0041.SlurmV0041GetDiagResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetDiagResponse, error)); ok { + return rf(ctx, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetDiagResponse); ok { + r0 = rf(ctx, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetDiagResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetDiagWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetDiagWithResponse' +type MockClient_SlurmV0041GetDiagWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetDiagWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetDiagWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetDiagWithResponse_Call { + return &MockClient_SlurmV0041GetDiagWithResponse_Call{Call: _e.mock.On("SlurmV0041GetDiagWithResponse", + append([]interface{}{ctx}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetDiagWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetDiagWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetDiagWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetDiagResponse, _a1 error) *MockClient_SlurmV0041GetDiagWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetDiagWithResponse_Call) RunAndReturn(run func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetDiagResponse, error)) *MockClient_SlurmV0041GetDiagWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetJobWithResponse provides a mock function with given fields: ctx, jobId, params, reqEditors +func (_m *MockClient) SlurmV0041GetJobWithResponse(ctx context.Context, jobId string, params *v0041.SlurmV0041GetJobParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, jobId, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetJobWithResponse") + } + + var r0 *v0041.SlurmV0041GetJobResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetJobParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobResponse, error)); ok { + return rf(ctx, jobId, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetJobParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetJobResponse); ok { + r0 = rf(ctx, jobId, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetJobResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmV0041GetJobParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, jobId, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetJobWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetJobWithResponse' +type MockClient_SlurmV0041GetJobWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetJobWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - jobId string +// - params *v0041.SlurmV0041GetJobParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetJobWithResponse(ctx interface{}, jobId interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetJobWithResponse_Call { + return &MockClient_SlurmV0041GetJobWithResponse_Call{Call: _e.mock.On("SlurmV0041GetJobWithResponse", + append([]interface{}{ctx, jobId, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetJobWithResponse_Call) Run(run func(ctx context.Context, jobId string, params *v0041.SlurmV0041GetJobParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetJobWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmV0041GetJobParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetJobWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetJobResponse, _a1 error) *MockClient_SlurmV0041GetJobWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetJobWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmV0041GetJobParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobResponse, error)) *MockClient_SlurmV0041GetJobWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetJobsStateWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmV0041GetJobsStateWithResponse(ctx context.Context, params *v0041.SlurmV0041GetJobsStateParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobsStateResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetJobsStateWithResponse") + } + + var r0 *v0041.SlurmV0041GetJobsStateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetJobsStateParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobsStateResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetJobsStateParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetJobsStateResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetJobsStateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmV0041GetJobsStateParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetJobsStateWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetJobsStateWithResponse' +type MockClient_SlurmV0041GetJobsStateWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetJobsStateWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmV0041GetJobsStateParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetJobsStateWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetJobsStateWithResponse_Call { + return &MockClient_SlurmV0041GetJobsStateWithResponse_Call{Call: _e.mock.On("SlurmV0041GetJobsStateWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetJobsStateWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmV0041GetJobsStateParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetJobsStateWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmV0041GetJobsStateParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetJobsStateWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetJobsStateResponse, _a1 error) *MockClient_SlurmV0041GetJobsStateWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetJobsStateWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmV0041GetJobsStateParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobsStateResponse, error)) *MockClient_SlurmV0041GetJobsStateWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetJobsWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmV0041GetJobsWithResponse(ctx context.Context, params *v0041.SlurmV0041GetJobsParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetJobsWithResponse") + } + + var r0 *v0041.SlurmV0041GetJobsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetJobsParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobsResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetJobsParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetJobsResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetJobsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmV0041GetJobsParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetJobsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetJobsWithResponse' +type MockClient_SlurmV0041GetJobsWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetJobsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmV0041GetJobsParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetJobsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetJobsWithResponse_Call { + return &MockClient_SlurmV0041GetJobsWithResponse_Call{Call: _e.mock.On("SlurmV0041GetJobsWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetJobsWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmV0041GetJobsParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetJobsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmV0041GetJobsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetJobsWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetJobsResponse, _a1 error) *MockClient_SlurmV0041GetJobsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetJobsWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmV0041GetJobsParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetJobsResponse, error)) *MockClient_SlurmV0041GetJobsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetLicensesWithResponse provides a mock function with given fields: ctx, reqEditors +func (_m *MockClient) SlurmV0041GetLicensesWithResponse(ctx context.Context, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetLicensesResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetLicensesWithResponse") + } + + var r0 *v0041.SlurmV0041GetLicensesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetLicensesResponse, error)); ok { + return rf(ctx, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetLicensesResponse); ok { + r0 = rf(ctx, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetLicensesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetLicensesWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetLicensesWithResponse' +type MockClient_SlurmV0041GetLicensesWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetLicensesWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetLicensesWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetLicensesWithResponse_Call { + return &MockClient_SlurmV0041GetLicensesWithResponse_Call{Call: _e.mock.On("SlurmV0041GetLicensesWithResponse", + append([]interface{}{ctx}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetLicensesWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetLicensesWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetLicensesWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetLicensesResponse, _a1 error) *MockClient_SlurmV0041GetLicensesWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetLicensesWithResponse_Call) RunAndReturn(run func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetLicensesResponse, error)) *MockClient_SlurmV0041GetLicensesWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetNodeWithResponse provides a mock function with given fields: ctx, nodeName, params, reqEditors +func (_m *MockClient) SlurmV0041GetNodeWithResponse(ctx context.Context, nodeName string, params *v0041.SlurmV0041GetNodeParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetNodeResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, nodeName, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetNodeWithResponse") + } + + var r0 *v0041.SlurmV0041GetNodeResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetNodeParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetNodeResponse, error)); ok { + return rf(ctx, nodeName, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetNodeParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetNodeResponse); ok { + r0 = rf(ctx, nodeName, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetNodeResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmV0041GetNodeParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, nodeName, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetNodeWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetNodeWithResponse' +type MockClient_SlurmV0041GetNodeWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetNodeWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - nodeName string +// - params *v0041.SlurmV0041GetNodeParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetNodeWithResponse(ctx interface{}, nodeName interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetNodeWithResponse_Call { + return &MockClient_SlurmV0041GetNodeWithResponse_Call{Call: _e.mock.On("SlurmV0041GetNodeWithResponse", + append([]interface{}{ctx, nodeName, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetNodeWithResponse_Call) Run(run func(ctx context.Context, nodeName string, params *v0041.SlurmV0041GetNodeParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetNodeWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmV0041GetNodeParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetNodeWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetNodeResponse, _a1 error) *MockClient_SlurmV0041GetNodeWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetNodeWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmV0041GetNodeParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetNodeResponse, error)) *MockClient_SlurmV0041GetNodeWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetNodesWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmV0041GetNodesWithResponse(ctx context.Context, params *v0041.SlurmV0041GetNodesParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetNodesResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetNodesWithResponse") + } + + var r0 *v0041.SlurmV0041GetNodesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetNodesParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetNodesResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetNodesParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetNodesResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetNodesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmV0041GetNodesParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetNodesWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetNodesWithResponse' +type MockClient_SlurmV0041GetNodesWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetNodesWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmV0041GetNodesParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetNodesWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetNodesWithResponse_Call { + return &MockClient_SlurmV0041GetNodesWithResponse_Call{Call: _e.mock.On("SlurmV0041GetNodesWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetNodesWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmV0041GetNodesParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetNodesWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmV0041GetNodesParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetNodesWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetNodesResponse, _a1 error) *MockClient_SlurmV0041GetNodesWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetNodesWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmV0041GetNodesParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetNodesResponse, error)) *MockClient_SlurmV0041GetNodesWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetPartitionWithResponse provides a mock function with given fields: ctx, partitionName, params, reqEditors +func (_m *MockClient) SlurmV0041GetPartitionWithResponse(ctx context.Context, partitionName string, params *v0041.SlurmV0041GetPartitionParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPartitionResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, partitionName, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetPartitionWithResponse") + } + + var r0 *v0041.SlurmV0041GetPartitionResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetPartitionParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPartitionResponse, error)); ok { + return rf(ctx, partitionName, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetPartitionParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetPartitionResponse); ok { + r0 = rf(ctx, partitionName, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetPartitionResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmV0041GetPartitionParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, partitionName, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetPartitionWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetPartitionWithResponse' +type MockClient_SlurmV0041GetPartitionWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetPartitionWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - partitionName string +// - params *v0041.SlurmV0041GetPartitionParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetPartitionWithResponse(ctx interface{}, partitionName interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetPartitionWithResponse_Call { + return &MockClient_SlurmV0041GetPartitionWithResponse_Call{Call: _e.mock.On("SlurmV0041GetPartitionWithResponse", + append([]interface{}{ctx, partitionName, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetPartitionWithResponse_Call) Run(run func(ctx context.Context, partitionName string, params *v0041.SlurmV0041GetPartitionParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetPartitionWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmV0041GetPartitionParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetPartitionWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetPartitionResponse, _a1 error) *MockClient_SlurmV0041GetPartitionWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetPartitionWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmV0041GetPartitionParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPartitionResponse, error)) *MockClient_SlurmV0041GetPartitionWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetPartitionsWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmV0041GetPartitionsWithResponse(ctx context.Context, params *v0041.SlurmV0041GetPartitionsParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPartitionsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetPartitionsWithResponse") + } + + var r0 *v0041.SlurmV0041GetPartitionsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetPartitionsParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPartitionsResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetPartitionsParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetPartitionsResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetPartitionsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmV0041GetPartitionsParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetPartitionsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetPartitionsWithResponse' +type MockClient_SlurmV0041GetPartitionsWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetPartitionsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmV0041GetPartitionsParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetPartitionsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetPartitionsWithResponse_Call { + return &MockClient_SlurmV0041GetPartitionsWithResponse_Call{Call: _e.mock.On("SlurmV0041GetPartitionsWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetPartitionsWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmV0041GetPartitionsParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetPartitionsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmV0041GetPartitionsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetPartitionsWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetPartitionsResponse, _a1 error) *MockClient_SlurmV0041GetPartitionsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetPartitionsWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmV0041GetPartitionsParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPartitionsResponse, error)) *MockClient_SlurmV0041GetPartitionsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetPingWithResponse provides a mock function with given fields: ctx, reqEditors +func (_m *MockClient) SlurmV0041GetPingWithResponse(ctx context.Context, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPingResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetPingWithResponse") + } + + var r0 *v0041.SlurmV0041GetPingResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPingResponse, error)); ok { + return rf(ctx, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetPingResponse); ok { + r0 = rf(ctx, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetPingResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetPingWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetPingWithResponse' +type MockClient_SlurmV0041GetPingWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetPingWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetPingWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetPingWithResponse_Call { + return &MockClient_SlurmV0041GetPingWithResponse_Call{Call: _e.mock.On("SlurmV0041GetPingWithResponse", + append([]interface{}{ctx}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetPingWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetPingWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetPingWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetPingResponse, _a1 error) *MockClient_SlurmV0041GetPingWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetPingWithResponse_Call) RunAndReturn(run func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetPingResponse, error)) *MockClient_SlurmV0041GetPingWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetReconfigureWithResponse provides a mock function with given fields: ctx, reqEditors +func (_m *MockClient) SlurmV0041GetReconfigureWithResponse(ctx context.Context, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReconfigureResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetReconfigureWithResponse") + } + + var r0 *v0041.SlurmV0041GetReconfigureResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReconfigureResponse, error)); ok { + return rf(ctx, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetReconfigureResponse); ok { + r0 = rf(ctx, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetReconfigureResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetReconfigureWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetReconfigureWithResponse' +type MockClient_SlurmV0041GetReconfigureWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetReconfigureWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetReconfigureWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetReconfigureWithResponse_Call { + return &MockClient_SlurmV0041GetReconfigureWithResponse_Call{Call: _e.mock.On("SlurmV0041GetReconfigureWithResponse", + append([]interface{}{ctx}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetReconfigureWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetReconfigureWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetReconfigureWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetReconfigureResponse, _a1 error) *MockClient_SlurmV0041GetReconfigureWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetReconfigureWithResponse_Call) RunAndReturn(run func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReconfigureResponse, error)) *MockClient_SlurmV0041GetReconfigureWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetReservationWithResponse provides a mock function with given fields: ctx, reservationName, params, reqEditors +func (_m *MockClient) SlurmV0041GetReservationWithResponse(ctx context.Context, reservationName string, params *v0041.SlurmV0041GetReservationParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReservationResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, reservationName, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetReservationWithResponse") + } + + var r0 *v0041.SlurmV0041GetReservationResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetReservationParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReservationResponse, error)); ok { + return rf(ctx, reservationName, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmV0041GetReservationParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetReservationResponse); ok { + r0 = rf(ctx, reservationName, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetReservationResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmV0041GetReservationParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reservationName, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetReservationWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetReservationWithResponse' +type MockClient_SlurmV0041GetReservationWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetReservationWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reservationName string +// - params *v0041.SlurmV0041GetReservationParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetReservationWithResponse(ctx interface{}, reservationName interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetReservationWithResponse_Call { + return &MockClient_SlurmV0041GetReservationWithResponse_Call{Call: _e.mock.On("SlurmV0041GetReservationWithResponse", + append([]interface{}{ctx, reservationName, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetReservationWithResponse_Call) Run(run func(ctx context.Context, reservationName string, params *v0041.SlurmV0041GetReservationParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetReservationWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmV0041GetReservationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetReservationWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetReservationResponse, _a1 error) *MockClient_SlurmV0041GetReservationWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetReservationWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmV0041GetReservationParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReservationResponse, error)) *MockClient_SlurmV0041GetReservationWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetReservationsWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmV0041GetReservationsWithResponse(ctx context.Context, params *v0041.SlurmV0041GetReservationsParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReservationsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetReservationsWithResponse") + } + + var r0 *v0041.SlurmV0041GetReservationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetReservationsParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReservationsResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetReservationsParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetReservationsResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetReservationsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmV0041GetReservationsParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetReservationsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetReservationsWithResponse' +type MockClient_SlurmV0041GetReservationsWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetReservationsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmV0041GetReservationsParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetReservationsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetReservationsWithResponse_Call { + return &MockClient_SlurmV0041GetReservationsWithResponse_Call{Call: _e.mock.On("SlurmV0041GetReservationsWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetReservationsWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmV0041GetReservationsParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetReservationsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmV0041GetReservationsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetReservationsWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetReservationsResponse, _a1 error) *MockClient_SlurmV0041GetReservationsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetReservationsWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmV0041GetReservationsParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetReservationsResponse, error)) *MockClient_SlurmV0041GetReservationsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041GetSharesWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmV0041GetSharesWithResponse(ctx context.Context, params *v0041.SlurmV0041GetSharesParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetSharesResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041GetSharesWithResponse") + } + + var r0 *v0041.SlurmV0041GetSharesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetSharesParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetSharesResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmV0041GetSharesParams, ...v0041.RequestEditorFn) *v0041.SlurmV0041GetSharesResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041GetSharesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmV0041GetSharesParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041GetSharesWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041GetSharesWithResponse' +type MockClient_SlurmV0041GetSharesWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041GetSharesWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmV0041GetSharesParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041GetSharesWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041GetSharesWithResponse_Call { + return &MockClient_SlurmV0041GetSharesWithResponse_Call{Call: _e.mock.On("SlurmV0041GetSharesWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041GetSharesWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmV0041GetSharesParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041GetSharesWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmV0041GetSharesParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041GetSharesWithResponse_Call) Return(_a0 *v0041.SlurmV0041GetSharesResponse, _a1 error) *MockClient_SlurmV0041GetSharesWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041GetSharesWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmV0041GetSharesParams, ...v0041.RequestEditorFn) (*v0041.SlurmV0041GetSharesResponse, error)) *MockClient_SlurmV0041GetSharesWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostJobAllocateWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmV0041PostJobAllocateWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobAllocateResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostJobAllocateWithBodyWithResponse") + } + + var r0 *v0041.SlurmV0041PostJobAllocateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobAllocateResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostJobAllocateResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostJobAllocateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostJobAllocateWithBodyWithResponse' +type MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostJobAllocateWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostJobAllocateWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call { + return &MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call{Call: _e.mock.On("SlurmV0041PostJobAllocateWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostJobAllocateResponse, _a1 error) *MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobAllocateResponse, error)) *MockClient_SlurmV0041PostJobAllocateWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostJobAllocateWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmV0041PostJobAllocateWithResponse(ctx context.Context, body v0041.SlurmV0041PostJobAllocateJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobAllocateResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostJobAllocateWithResponse") + } + + var r0 *v0041.SlurmV0041PostJobAllocateResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmV0041PostJobAllocateJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobAllocateResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmV0041PostJobAllocateJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostJobAllocateResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostJobAllocateResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmV0041PostJobAllocateJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostJobAllocateWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostJobAllocateWithResponse' +type MockClient_SlurmV0041PostJobAllocateWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostJobAllocateWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmV0041PostJobAllocateJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostJobAllocateWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostJobAllocateWithResponse_Call { + return &MockClient_SlurmV0041PostJobAllocateWithResponse_Call{Call: _e.mock.On("SlurmV0041PostJobAllocateWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostJobAllocateWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmV0041PostJobAllocateJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostJobAllocateWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmV0041PostJobAllocateJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobAllocateWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostJobAllocateResponse, _a1 error) *MockClient_SlurmV0041PostJobAllocateWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobAllocateWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmV0041PostJobAllocateJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobAllocateResponse, error)) *MockClient_SlurmV0041PostJobAllocateWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostJobSubmitWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmV0041PostJobSubmitWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobSubmitResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostJobSubmitWithBodyWithResponse") + } + + var r0 *v0041.SlurmV0041PostJobSubmitResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobSubmitResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostJobSubmitResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostJobSubmitResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostJobSubmitWithBodyWithResponse' +type MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostJobSubmitWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostJobSubmitWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call { + return &MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call{Call: _e.mock.On("SlurmV0041PostJobSubmitWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostJobSubmitResponse, _a1 error) *MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobSubmitResponse, error)) *MockClient_SlurmV0041PostJobSubmitWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostJobSubmitWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmV0041PostJobSubmitWithResponse(ctx context.Context, body v0041.SlurmV0041PostJobSubmitJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobSubmitResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostJobSubmitWithResponse") + } + + var r0 *v0041.SlurmV0041PostJobSubmitResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmV0041PostJobSubmitJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobSubmitResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmV0041PostJobSubmitJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostJobSubmitResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostJobSubmitResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmV0041PostJobSubmitJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostJobSubmitWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostJobSubmitWithResponse' +type MockClient_SlurmV0041PostJobSubmitWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostJobSubmitWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmV0041PostJobSubmitJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostJobSubmitWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostJobSubmitWithResponse_Call { + return &MockClient_SlurmV0041PostJobSubmitWithResponse_Call{Call: _e.mock.On("SlurmV0041PostJobSubmitWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostJobSubmitWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmV0041PostJobSubmitJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostJobSubmitWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmV0041PostJobSubmitJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobSubmitWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostJobSubmitResponse, _a1 error) *MockClient_SlurmV0041PostJobSubmitWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobSubmitWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmV0041PostJobSubmitJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobSubmitResponse, error)) *MockClient_SlurmV0041PostJobSubmitWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostJobWithBodyWithResponse provides a mock function with given fields: ctx, jobId, contentType, body, reqEditors +func (_m *MockClient) SlurmV0041PostJobWithBodyWithResponse(ctx context.Context, jobId string, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, jobId, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostJobWithBodyWithResponse") + } + + var r0 *v0041.SlurmV0041PostJobResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobResponse, error)); ok { + return rf(ctx, jobId, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostJobResponse); ok { + r0 = rf(ctx, jobId, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostJobResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, jobId, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostJobWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostJobWithBodyWithResponse' +type MockClient_SlurmV0041PostJobWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostJobWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - jobId string +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostJobWithBodyWithResponse(ctx interface{}, jobId interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostJobWithBodyWithResponse_Call { + return &MockClient_SlurmV0041PostJobWithBodyWithResponse_Call{Call: _e.mock.On("SlurmV0041PostJobWithBodyWithResponse", + append([]interface{}{ctx, jobId, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostJobWithBodyWithResponse_Call) Run(run func(ctx context.Context, jobId string, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostJobWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostJobResponse, _a1 error) *MockClient_SlurmV0041PostJobWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobResponse, error)) *MockClient_SlurmV0041PostJobWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostJobWithResponse provides a mock function with given fields: ctx, jobId, body, reqEditors +func (_m *MockClient) SlurmV0041PostJobWithResponse(ctx context.Context, jobId string, body v0041.SlurmV0041PostJobJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, jobId, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostJobWithResponse") + } + + var r0 *v0041.SlurmV0041PostJobResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, v0041.SlurmV0041PostJobJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobResponse, error)); ok { + return rf(ctx, jobId, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, v0041.SlurmV0041PostJobJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostJobResponse); ok { + r0 = rf(ctx, jobId, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostJobResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, v0041.SlurmV0041PostJobJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, jobId, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostJobWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostJobWithResponse' +type MockClient_SlurmV0041PostJobWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostJobWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - jobId string +// - body v0041.SlurmV0041PostJobJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostJobWithResponse(ctx interface{}, jobId interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostJobWithResponse_Call { + return &MockClient_SlurmV0041PostJobWithResponse_Call{Call: _e.mock.On("SlurmV0041PostJobWithResponse", + append([]interface{}{ctx, jobId, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostJobWithResponse_Call) Run(run func(ctx context.Context, jobId string, body v0041.SlurmV0041PostJobJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostJobWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(v0041.SlurmV0041PostJobJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostJobResponse, _a1 error) *MockClient_SlurmV0041PostJobWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostJobWithResponse_Call) RunAndReturn(run func(context.Context, string, v0041.SlurmV0041PostJobJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostJobResponse, error)) *MockClient_SlurmV0041PostJobWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostNodeWithBodyWithResponse provides a mock function with given fields: ctx, nodeName, contentType, body, reqEditors +func (_m *MockClient) SlurmV0041PostNodeWithBodyWithResponse(ctx context.Context, nodeName string, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostNodeResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, nodeName, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostNodeWithBodyWithResponse") + } + + var r0 *v0041.SlurmV0041PostNodeResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostNodeResponse, error)); ok { + return rf(ctx, nodeName, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostNodeResponse); ok { + r0 = rf(ctx, nodeName, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostNodeResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, nodeName, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostNodeWithBodyWithResponse' +type MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostNodeWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - nodeName string +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostNodeWithBodyWithResponse(ctx interface{}, nodeName interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call { + return &MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call{Call: _e.mock.On("SlurmV0041PostNodeWithBodyWithResponse", + append([]interface{}{ctx, nodeName, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call) Run(run func(ctx context.Context, nodeName string, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostNodeResponse, _a1 error) *MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostNodeResponse, error)) *MockClient_SlurmV0041PostNodeWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmV0041PostNodeWithResponse provides a mock function with given fields: ctx, nodeName, body, reqEditors +func (_m *MockClient) SlurmV0041PostNodeWithResponse(ctx context.Context, nodeName string, body v0041.SlurmV0041PostNodeJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostNodeResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, nodeName, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmV0041PostNodeWithResponse") + } + + var r0 *v0041.SlurmV0041PostNodeResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, v0041.SlurmV0041PostNodeJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostNodeResponse, error)); ok { + return rf(ctx, nodeName, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, v0041.SlurmV0041PostNodeJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmV0041PostNodeResponse); ok { + r0 = rf(ctx, nodeName, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmV0041PostNodeResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, v0041.SlurmV0041PostNodeJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, nodeName, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmV0041PostNodeWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmV0041PostNodeWithResponse' +type MockClient_SlurmV0041PostNodeWithResponse_Call struct { + *mock.Call +} + +// SlurmV0041PostNodeWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - nodeName string +// - body v0041.SlurmV0041PostNodeJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmV0041PostNodeWithResponse(ctx interface{}, nodeName interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmV0041PostNodeWithResponse_Call { + return &MockClient_SlurmV0041PostNodeWithResponse_Call{Call: _e.mock.On("SlurmV0041PostNodeWithResponse", + append([]interface{}{ctx, nodeName, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmV0041PostNodeWithResponse_Call) Run(run func(ctx context.Context, nodeName string, body v0041.SlurmV0041PostNodeJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmV0041PostNodeWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(v0041.SlurmV0041PostNodeJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmV0041PostNodeWithResponse_Call) Return(_a0 *v0041.SlurmV0041PostNodeResponse, _a1 error) *MockClient_SlurmV0041PostNodeWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmV0041PostNodeWithResponse_Call) RunAndReturn(run func(context.Context, string, v0041.SlurmV0041PostNodeJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmV0041PostNodeResponse, error)) *MockClient_SlurmV0041PostNodeWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041DeleteAccountWithResponse provides a mock function with given fields: ctx, accountName, reqEditors +func (_m *MockClient) SlurmdbV0041DeleteAccountWithResponse(ctx context.Context, accountName string, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAccountResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, accountName) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041DeleteAccountWithResponse") + } + + var r0 *v0041.SlurmdbV0041DeleteAccountResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAccountResponse, error)); ok { + return rf(ctx, accountName, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041DeleteAccountResponse); ok { + r0 = rf(ctx, accountName, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041DeleteAccountResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, accountName, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041DeleteAccountWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041DeleteAccountWithResponse' +type MockClient_SlurmdbV0041DeleteAccountWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041DeleteAccountWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - accountName string +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041DeleteAccountWithResponse(ctx interface{}, accountName interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041DeleteAccountWithResponse_Call { + return &MockClient_SlurmdbV0041DeleteAccountWithResponse_Call{Call: _e.mock.On("SlurmdbV0041DeleteAccountWithResponse", + append([]interface{}{ctx, accountName}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041DeleteAccountWithResponse_Call) Run(run func(ctx context.Context, accountName string, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041DeleteAccountWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteAccountWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041DeleteAccountResponse, _a1 error) *MockClient_SlurmdbV0041DeleteAccountWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteAccountWithResponse_Call) RunAndReturn(run func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAccountResponse, error)) *MockClient_SlurmdbV0041DeleteAccountWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041DeleteAssociationWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041DeleteAssociationWithResponse(ctx context.Context, params *v0041.SlurmdbV0041DeleteAssociationParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAssociationResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041DeleteAssociationWithResponse") + } + + var r0 *v0041.SlurmdbV0041DeleteAssociationResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041DeleteAssociationParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAssociationResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041DeleteAssociationParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041DeleteAssociationResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041DeleteAssociationResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041DeleteAssociationParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041DeleteAssociationWithResponse' +type MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041DeleteAssociationWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041DeleteAssociationParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041DeleteAssociationWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call { + return &MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call{Call: _e.mock.On("SlurmdbV0041DeleteAssociationWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041DeleteAssociationParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041DeleteAssociationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041DeleteAssociationResponse, _a1 error) *MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041DeleteAssociationParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAssociationResponse, error)) *MockClient_SlurmdbV0041DeleteAssociationWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041DeleteAssociationsWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041DeleteAssociationsWithResponse(ctx context.Context, params *v0041.SlurmdbV0041DeleteAssociationsParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAssociationsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041DeleteAssociationsWithResponse") + } + + var r0 *v0041.SlurmdbV0041DeleteAssociationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041DeleteAssociationsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAssociationsResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041DeleteAssociationsParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041DeleteAssociationsResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041DeleteAssociationsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041DeleteAssociationsParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041DeleteAssociationsWithResponse' +type MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041DeleteAssociationsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041DeleteAssociationsParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041DeleteAssociationsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call { + return &MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call{Call: _e.mock.On("SlurmdbV0041DeleteAssociationsWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041DeleteAssociationsParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041DeleteAssociationsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041DeleteAssociationsResponse, _a1 error) *MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041DeleteAssociationsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteAssociationsResponse, error)) *MockClient_SlurmdbV0041DeleteAssociationsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041DeleteClusterWithResponse provides a mock function with given fields: ctx, clusterName, params, reqEditors +func (_m *MockClient) SlurmdbV0041DeleteClusterWithResponse(ctx context.Context, clusterName string, params *v0041.SlurmdbV0041DeleteClusterParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteClusterResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, clusterName, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041DeleteClusterWithResponse") + } + + var r0 *v0041.SlurmdbV0041DeleteClusterResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041DeleteClusterParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteClusterResponse, error)); ok { + return rf(ctx, clusterName, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041DeleteClusterParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041DeleteClusterResponse); ok { + r0 = rf(ctx, clusterName, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041DeleteClusterResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmdbV0041DeleteClusterParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, clusterName, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041DeleteClusterWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041DeleteClusterWithResponse' +type MockClient_SlurmdbV0041DeleteClusterWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041DeleteClusterWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - clusterName string +// - params *v0041.SlurmdbV0041DeleteClusterParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041DeleteClusterWithResponse(ctx interface{}, clusterName interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041DeleteClusterWithResponse_Call { + return &MockClient_SlurmdbV0041DeleteClusterWithResponse_Call{Call: _e.mock.On("SlurmdbV0041DeleteClusterWithResponse", + append([]interface{}{ctx, clusterName, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041DeleteClusterWithResponse_Call) Run(run func(ctx context.Context, clusterName string, params *v0041.SlurmdbV0041DeleteClusterParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041DeleteClusterWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmdbV0041DeleteClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteClusterWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041DeleteClusterResponse, _a1 error) *MockClient_SlurmdbV0041DeleteClusterWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteClusterWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmdbV0041DeleteClusterParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteClusterResponse, error)) *MockClient_SlurmdbV0041DeleteClusterWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041DeleteSingleQosWithResponse provides a mock function with given fields: ctx, qos, reqEditors +func (_m *MockClient) SlurmdbV0041DeleteSingleQosWithResponse(ctx context.Context, qos string, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteSingleQosResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, qos) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041DeleteSingleQosWithResponse") + } + + var r0 *v0041.SlurmdbV0041DeleteSingleQosResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteSingleQosResponse, error)); ok { + return rf(ctx, qos, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041DeleteSingleQosResponse); ok { + r0 = rf(ctx, qos, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041DeleteSingleQosResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, qos, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041DeleteSingleQosWithResponse' +type MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041DeleteSingleQosWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - qos string +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041DeleteSingleQosWithResponse(ctx interface{}, qos interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call { + return &MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call{Call: _e.mock.On("SlurmdbV0041DeleteSingleQosWithResponse", + append([]interface{}{ctx, qos}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call) Run(run func(ctx context.Context, qos string, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041DeleteSingleQosResponse, _a1 error) *MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call) RunAndReturn(run func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteSingleQosResponse, error)) *MockClient_SlurmdbV0041DeleteSingleQosWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041DeleteUserWithResponse provides a mock function with given fields: ctx, name, reqEditors +func (_m *MockClient) SlurmdbV0041DeleteUserWithResponse(ctx context.Context, name string, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteUserResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041DeleteUserWithResponse") + } + + var r0 *v0041.SlurmdbV0041DeleteUserResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteUserResponse, error)); ok { + return rf(ctx, name, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041DeleteUserResponse); ok { + r0 = rf(ctx, name, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041DeleteUserResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, name, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041DeleteUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041DeleteUserWithResponse' +type MockClient_SlurmdbV0041DeleteUserWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041DeleteUserWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - name string +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041DeleteUserWithResponse(ctx interface{}, name interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041DeleteUserWithResponse_Call { + return &MockClient_SlurmdbV0041DeleteUserWithResponse_Call{Call: _e.mock.On("SlurmdbV0041DeleteUserWithResponse", + append([]interface{}{ctx, name}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041DeleteUserWithResponse_Call) Run(run func(ctx context.Context, name string, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041DeleteUserWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteUserWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041DeleteUserResponse, _a1 error) *MockClient_SlurmdbV0041DeleteUserWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteUserWithResponse_Call) RunAndReturn(run func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteUserResponse, error)) *MockClient_SlurmdbV0041DeleteUserWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041DeleteWckeyWithResponse provides a mock function with given fields: ctx, id, reqEditors +func (_m *MockClient) SlurmdbV0041DeleteWckeyWithResponse(ctx context.Context, id string, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteWckeyResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, id) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041DeleteWckeyWithResponse") + } + + var r0 *v0041.SlurmdbV0041DeleteWckeyResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteWckeyResponse, error)); ok { + return rf(ctx, id, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041DeleteWckeyResponse); ok { + r0 = rf(ctx, id, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041DeleteWckeyResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, id, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041DeleteWckeyWithResponse' +type MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041DeleteWckeyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041DeleteWckeyWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call { + return &MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041DeleteWckeyWithResponse", + append([]interface{}{ctx, id}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call) Run(run func(ctx context.Context, id string, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041DeleteWckeyResponse, _a1 error) *MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call) RunAndReturn(run func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041DeleteWckeyResponse, error)) *MockClient_SlurmdbV0041DeleteWckeyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetAccountWithResponse provides a mock function with given fields: ctx, accountName, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetAccountWithResponse(ctx context.Context, accountName string, params *v0041.SlurmdbV0041GetAccountParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAccountResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, accountName, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetAccountWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetAccountResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetAccountParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAccountResponse, error)); ok { + return rf(ctx, accountName, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetAccountParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetAccountResponse); ok { + r0 = rf(ctx, accountName, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetAccountResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmdbV0041GetAccountParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, accountName, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetAccountWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetAccountWithResponse' +type MockClient_SlurmdbV0041GetAccountWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetAccountWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - accountName string +// - params *v0041.SlurmdbV0041GetAccountParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetAccountWithResponse(ctx interface{}, accountName interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetAccountWithResponse_Call { + return &MockClient_SlurmdbV0041GetAccountWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetAccountWithResponse", + append([]interface{}{ctx, accountName, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetAccountWithResponse_Call) Run(run func(ctx context.Context, accountName string, params *v0041.SlurmdbV0041GetAccountParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetAccountWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmdbV0041GetAccountParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAccountWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetAccountResponse, _a1 error) *MockClient_SlurmdbV0041GetAccountWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAccountWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmdbV0041GetAccountParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAccountResponse, error)) *MockClient_SlurmdbV0041GetAccountWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetAccountsWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetAccountsWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetAccountsParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAccountsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetAccountsWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetAccountsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetAccountsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAccountsResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetAccountsParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetAccountsResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetAccountsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetAccountsParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetAccountsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetAccountsWithResponse' +type MockClient_SlurmdbV0041GetAccountsWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetAccountsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetAccountsParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetAccountsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetAccountsWithResponse_Call { + return &MockClient_SlurmdbV0041GetAccountsWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetAccountsWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetAccountsWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetAccountsParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetAccountsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetAccountsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAccountsWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetAccountsResponse, _a1 error) *MockClient_SlurmdbV0041GetAccountsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAccountsWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetAccountsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAccountsResponse, error)) *MockClient_SlurmdbV0041GetAccountsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetAssociationWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetAssociationWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetAssociationParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAssociationResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetAssociationWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetAssociationResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetAssociationParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAssociationResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetAssociationParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetAssociationResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetAssociationResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetAssociationParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetAssociationWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetAssociationWithResponse' +type MockClient_SlurmdbV0041GetAssociationWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetAssociationWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetAssociationParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetAssociationWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetAssociationWithResponse_Call { + return &MockClient_SlurmdbV0041GetAssociationWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetAssociationWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetAssociationWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetAssociationParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetAssociationWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetAssociationParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAssociationWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetAssociationResponse, _a1 error) *MockClient_SlurmdbV0041GetAssociationWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAssociationWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetAssociationParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAssociationResponse, error)) *MockClient_SlurmdbV0041GetAssociationWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetAssociationsWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetAssociationsWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetAssociationsParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAssociationsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetAssociationsWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetAssociationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetAssociationsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAssociationsResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetAssociationsParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetAssociationsResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetAssociationsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetAssociationsParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetAssociationsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetAssociationsWithResponse' +type MockClient_SlurmdbV0041GetAssociationsWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetAssociationsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetAssociationsParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetAssociationsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetAssociationsWithResponse_Call { + return &MockClient_SlurmdbV0041GetAssociationsWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetAssociationsWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetAssociationsWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetAssociationsParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetAssociationsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetAssociationsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAssociationsWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetAssociationsResponse, _a1 error) *MockClient_SlurmdbV0041GetAssociationsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetAssociationsWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetAssociationsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetAssociationsResponse, error)) *MockClient_SlurmdbV0041GetAssociationsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetClusterWithResponse provides a mock function with given fields: ctx, clusterName, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetClusterWithResponse(ctx context.Context, clusterName string, params *v0041.SlurmdbV0041GetClusterParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetClusterResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, clusterName, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetClusterWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetClusterResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetClusterParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetClusterResponse, error)); ok { + return rf(ctx, clusterName, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetClusterParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetClusterResponse); ok { + r0 = rf(ctx, clusterName, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetClusterResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmdbV0041GetClusterParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, clusterName, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetClusterWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetClusterWithResponse' +type MockClient_SlurmdbV0041GetClusterWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetClusterWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - clusterName string +// - params *v0041.SlurmdbV0041GetClusterParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetClusterWithResponse(ctx interface{}, clusterName interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetClusterWithResponse_Call { + return &MockClient_SlurmdbV0041GetClusterWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetClusterWithResponse", + append([]interface{}{ctx, clusterName, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetClusterWithResponse_Call) Run(run func(ctx context.Context, clusterName string, params *v0041.SlurmdbV0041GetClusterParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetClusterWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmdbV0041GetClusterParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetClusterWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetClusterResponse, _a1 error) *MockClient_SlurmdbV0041GetClusterWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetClusterWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmdbV0041GetClusterParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetClusterResponse, error)) *MockClient_SlurmdbV0041GetClusterWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetClustersWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetClustersWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetClustersParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetClustersResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetClustersWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetClustersResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetClustersParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetClustersResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetClustersParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetClustersResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetClustersResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetClustersParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetClustersWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetClustersWithResponse' +type MockClient_SlurmdbV0041GetClustersWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetClustersWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetClustersParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetClustersWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetClustersWithResponse_Call { + return &MockClient_SlurmdbV0041GetClustersWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetClustersWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetClustersWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetClustersParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetClustersWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetClustersParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetClustersWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetClustersResponse, _a1 error) *MockClient_SlurmdbV0041GetClustersWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetClustersWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetClustersParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetClustersResponse, error)) *MockClient_SlurmdbV0041GetClustersWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetConfigWithResponse provides a mock function with given fields: ctx, reqEditors +func (_m *MockClient) SlurmdbV0041GetConfigWithResponse(ctx context.Context, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetConfigResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetConfigWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetConfigResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetConfigResponse, error)); ok { + return rf(ctx, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetConfigResponse); ok { + r0 = rf(ctx, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetConfigResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetConfigWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetConfigWithResponse' +type MockClient_SlurmdbV0041GetConfigWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetConfigWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetConfigWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetConfigWithResponse_Call { + return &MockClient_SlurmdbV0041GetConfigWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetConfigWithResponse", + append([]interface{}{ctx}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetConfigWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetConfigWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetConfigWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetConfigResponse, _a1 error) *MockClient_SlurmdbV0041GetConfigWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetConfigWithResponse_Call) RunAndReturn(run func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetConfigResponse, error)) *MockClient_SlurmdbV0041GetConfigWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetDiagWithResponse provides a mock function with given fields: ctx, reqEditors +func (_m *MockClient) SlurmdbV0041GetDiagWithResponse(ctx context.Context, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetDiagResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetDiagWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetDiagResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetDiagResponse, error)); ok { + return rf(ctx, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetDiagResponse); ok { + r0 = rf(ctx, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetDiagResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetDiagWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetDiagWithResponse' +type MockClient_SlurmdbV0041GetDiagWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetDiagWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetDiagWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetDiagWithResponse_Call { + return &MockClient_SlurmdbV0041GetDiagWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetDiagWithResponse", + append([]interface{}{ctx}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetDiagWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetDiagWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetDiagWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetDiagResponse, _a1 error) *MockClient_SlurmdbV0041GetDiagWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetDiagWithResponse_Call) RunAndReturn(run func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetDiagResponse, error)) *MockClient_SlurmdbV0041GetDiagWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetInstanceWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetInstanceWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetInstanceParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetInstanceResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetInstanceWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetInstanceResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetInstanceParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetInstanceResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetInstanceParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetInstanceResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetInstanceResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetInstanceParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetInstanceWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetInstanceWithResponse' +type MockClient_SlurmdbV0041GetInstanceWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetInstanceWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetInstanceParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetInstanceWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetInstanceWithResponse_Call { + return &MockClient_SlurmdbV0041GetInstanceWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetInstanceWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetInstanceWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetInstanceParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetInstanceWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetInstanceParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetInstanceWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetInstanceResponse, _a1 error) *MockClient_SlurmdbV0041GetInstanceWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetInstanceWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetInstanceParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetInstanceResponse, error)) *MockClient_SlurmdbV0041GetInstanceWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetInstancesWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetInstancesWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetInstancesParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetInstancesResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetInstancesWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetInstancesResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetInstancesParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetInstancesResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetInstancesParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetInstancesResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetInstancesResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetInstancesParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetInstancesWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetInstancesWithResponse' +type MockClient_SlurmdbV0041GetInstancesWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetInstancesWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetInstancesParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetInstancesWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetInstancesWithResponse_Call { + return &MockClient_SlurmdbV0041GetInstancesWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetInstancesWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetInstancesWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetInstancesParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetInstancesWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetInstancesParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetInstancesWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetInstancesResponse, _a1 error) *MockClient_SlurmdbV0041GetInstancesWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetInstancesWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetInstancesParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetInstancesResponse, error)) *MockClient_SlurmdbV0041GetInstancesWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetJobWithResponse provides a mock function with given fields: ctx, jobId, reqEditors +func (_m *MockClient) SlurmdbV0041GetJobWithResponse(ctx context.Context, jobId string, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetJobResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, jobId) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetJobWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetJobResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetJobResponse, error)); ok { + return rf(ctx, jobId, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetJobResponse); ok { + r0 = rf(ctx, jobId, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetJobResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, jobId, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetJobWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetJobWithResponse' +type MockClient_SlurmdbV0041GetJobWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetJobWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - jobId string +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetJobWithResponse(ctx interface{}, jobId interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetJobWithResponse_Call { + return &MockClient_SlurmdbV0041GetJobWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetJobWithResponse", + append([]interface{}{ctx, jobId}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetJobWithResponse_Call) Run(run func(ctx context.Context, jobId string, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetJobWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetJobWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetJobResponse, _a1 error) *MockClient_SlurmdbV0041GetJobWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetJobWithResponse_Call) RunAndReturn(run func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetJobResponse, error)) *MockClient_SlurmdbV0041GetJobWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetJobsWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetJobsWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetJobsParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetJobsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetJobsWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetJobsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetJobsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetJobsResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetJobsParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetJobsResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetJobsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetJobsParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetJobsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetJobsWithResponse' +type MockClient_SlurmdbV0041GetJobsWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetJobsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetJobsParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetJobsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetJobsWithResponse_Call { + return &MockClient_SlurmdbV0041GetJobsWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetJobsWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetJobsWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetJobsParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetJobsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetJobsParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetJobsWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetJobsResponse, _a1 error) *MockClient_SlurmdbV0041GetJobsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetJobsWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetJobsParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetJobsResponse, error)) *MockClient_SlurmdbV0041GetJobsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetQosWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetQosWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetQosParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetQosResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetQosWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetQosResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetQosParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetQosResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetQosParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetQosResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetQosResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetQosParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetQosWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetQosWithResponse' +type MockClient_SlurmdbV0041GetQosWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetQosWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetQosParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetQosWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetQosWithResponse_Call { + return &MockClient_SlurmdbV0041GetQosWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetQosWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetQosWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetQosParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetQosWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetQosParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetQosWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetQosResponse, _a1 error) *MockClient_SlurmdbV0041GetQosWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetQosWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetQosParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetQosResponse, error)) *MockClient_SlurmdbV0041GetQosWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetSingleQosWithResponse provides a mock function with given fields: ctx, qos, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetSingleQosWithResponse(ctx context.Context, qos string, params *v0041.SlurmdbV0041GetSingleQosParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetSingleQosResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, qos, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetSingleQosWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetSingleQosResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetSingleQosParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetSingleQosResponse, error)); ok { + return rf(ctx, qos, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetSingleQosParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetSingleQosResponse); ok { + r0 = rf(ctx, qos, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetSingleQosResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmdbV0041GetSingleQosParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, qos, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetSingleQosWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetSingleQosWithResponse' +type MockClient_SlurmdbV0041GetSingleQosWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetSingleQosWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - qos string +// - params *v0041.SlurmdbV0041GetSingleQosParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetSingleQosWithResponse(ctx interface{}, qos interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetSingleQosWithResponse_Call { + return &MockClient_SlurmdbV0041GetSingleQosWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetSingleQosWithResponse", + append([]interface{}{ctx, qos, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetSingleQosWithResponse_Call) Run(run func(ctx context.Context, qos string, params *v0041.SlurmdbV0041GetSingleQosParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetSingleQosWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmdbV0041GetSingleQosParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetSingleQosWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetSingleQosResponse, _a1 error) *MockClient_SlurmdbV0041GetSingleQosWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetSingleQosWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmdbV0041GetSingleQosParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetSingleQosResponse, error)) *MockClient_SlurmdbV0041GetSingleQosWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetTresWithResponse provides a mock function with given fields: ctx, reqEditors +func (_m *MockClient) SlurmdbV0041GetTresWithResponse(ctx context.Context, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetTresResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetTresWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetTresResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetTresResponse, error)); ok { + return rf(ctx, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetTresResponse); ok { + r0 = rf(ctx, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetTresResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetTresWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetTresWithResponse' +type MockClient_SlurmdbV0041GetTresWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetTresWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetTresWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetTresWithResponse_Call { + return &MockClient_SlurmdbV0041GetTresWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetTresWithResponse", + append([]interface{}{ctx}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetTresWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetTresWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetTresWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetTresResponse, _a1 error) *MockClient_SlurmdbV0041GetTresWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetTresWithResponse_Call) RunAndReturn(run func(context.Context, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetTresResponse, error)) *MockClient_SlurmdbV0041GetTresWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetUserWithResponse provides a mock function with given fields: ctx, name, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetUserWithResponse(ctx context.Context, name string, params *v0041.SlurmdbV0041GetUserParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetUserResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetUserWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetUserResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetUserParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetUserResponse, error)); ok { + return rf(ctx, name, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, *v0041.SlurmdbV0041GetUserParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetUserResponse); ok { + r0 = rf(ctx, name, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetUserResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, *v0041.SlurmdbV0041GetUserParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, name, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetUserWithResponse' +type MockClient_SlurmdbV0041GetUserWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetUserWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - name string +// - params *v0041.SlurmdbV0041GetUserParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetUserWithResponse(ctx interface{}, name interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetUserWithResponse_Call { + return &MockClient_SlurmdbV0041GetUserWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetUserWithResponse", + append([]interface{}{ctx, name, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetUserWithResponse_Call) Run(run func(ctx context.Context, name string, params *v0041.SlurmdbV0041GetUserParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetUserWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(*v0041.SlurmdbV0041GetUserParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetUserWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetUserResponse, _a1 error) *MockClient_SlurmdbV0041GetUserWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetUserWithResponse_Call) RunAndReturn(run func(context.Context, string, *v0041.SlurmdbV0041GetUserParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetUserResponse, error)) *MockClient_SlurmdbV0041GetUserWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetUsersWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetUsersWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetUsersParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetUsersResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetUsersWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetUsersResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetUsersParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetUsersResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetUsersParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetUsersResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetUsersResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetUsersParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetUsersWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetUsersWithResponse' +type MockClient_SlurmdbV0041GetUsersWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetUsersWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetUsersParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetUsersWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetUsersWithResponse_Call { + return &MockClient_SlurmdbV0041GetUsersWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetUsersWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetUsersWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetUsersParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetUsersWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetUsersParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetUsersWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetUsersResponse, _a1 error) *MockClient_SlurmdbV0041GetUsersWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetUsersWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetUsersParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetUsersResponse, error)) *MockClient_SlurmdbV0041GetUsersWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetWckeyWithResponse provides a mock function with given fields: ctx, id, reqEditors +func (_m *MockClient) SlurmdbV0041GetWckeyWithResponse(ctx context.Context, id string, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetWckeyResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, id) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetWckeyWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetWckeyResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetWckeyResponse, error)); ok { + return rf(ctx, id, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetWckeyResponse); ok { + r0 = rf(ctx, id, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetWckeyResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, id, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetWckeyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetWckeyWithResponse' +type MockClient_SlurmdbV0041GetWckeyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetWckeyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetWckeyWithResponse(ctx interface{}, id interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetWckeyWithResponse_Call { + return &MockClient_SlurmdbV0041GetWckeyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetWckeyWithResponse", + append([]interface{}{ctx, id}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetWckeyWithResponse_Call) Run(run func(ctx context.Context, id string, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetWckeyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetWckeyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetWckeyResponse, _a1 error) *MockClient_SlurmdbV0041GetWckeyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetWckeyWithResponse_Call) RunAndReturn(run func(context.Context, string, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetWckeyResponse, error)) *MockClient_SlurmdbV0041GetWckeyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041GetWckeysWithResponse provides a mock function with given fields: ctx, params, reqEditors +func (_m *MockClient) SlurmdbV0041GetWckeysWithResponse(ctx context.Context, params *v0041.SlurmdbV0041GetWckeysParams, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetWckeysResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041GetWckeysWithResponse") + } + + var r0 *v0041.SlurmdbV0041GetWckeysResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetWckeysParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetWckeysResponse, error)); ok { + return rf(ctx, params, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041GetWckeysParams, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041GetWckeysResponse); ok { + r0 = rf(ctx, params, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041GetWckeysResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041GetWckeysParams, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041GetWckeysWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041GetWckeysWithResponse' +type MockClient_SlurmdbV0041GetWckeysWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041GetWckeysWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041GetWckeysParams +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041GetWckeysWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041GetWckeysWithResponse_Call { + return &MockClient_SlurmdbV0041GetWckeysWithResponse_Call{Call: _e.mock.On("SlurmdbV0041GetWckeysWithResponse", + append([]interface{}{ctx, params}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041GetWckeysWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041GetWckeysParams, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041GetWckeysWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041GetWckeysParams), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetWckeysWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041GetWckeysResponse, _a1 error) *MockClient_SlurmdbV0041GetWckeysWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041GetWckeysWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041GetWckeysParams, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041GetWckeysResponse, error)) *MockClient_SlurmdbV0041GetWckeysWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostAccountsAssociationWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostAccountsAssociationWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsAssociationResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostAccountsAssociationWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostAccountsAssociationResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsAssociationResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostAccountsAssociationResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostAccountsAssociationResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostAccountsAssociationWithBodyWithResponse' +type MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostAccountsAssociationWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostAccountsAssociationWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostAccountsAssociationWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostAccountsAssociationResponse, _a1 error) *MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsAssociationResponse, error)) *MockClient_SlurmdbV0041PostAccountsAssociationWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostAccountsAssociationWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostAccountsAssociationWithResponse(ctx context.Context, body v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsAssociationResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostAccountsAssociationWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostAccountsAssociationResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsAssociationResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostAccountsAssociationResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostAccountsAssociationResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostAccountsAssociationWithResponse' +type MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostAccountsAssociationWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostAccountsAssociationWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call { + return &MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostAccountsAssociationWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostAccountsAssociationResponse, _a1 error) *MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmdbV0041PostAccountsAssociationJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsAssociationResponse, error)) *MockClient_SlurmdbV0041PostAccountsAssociationWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostAccountsWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostAccountsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostAccountsWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostAccountsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostAccountsResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostAccountsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostAccountsWithBodyWithResponse' +type MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostAccountsWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostAccountsWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostAccountsWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostAccountsResponse, _a1 error) *MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsResponse, error)) *MockClient_SlurmdbV0041PostAccountsWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostAccountsWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostAccountsWithResponse(ctx context.Context, body v0041.SlurmdbV0041PostAccountsJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostAccountsWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostAccountsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostAccountsJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostAccountsJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostAccountsResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostAccountsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmdbV0041PostAccountsJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostAccountsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostAccountsWithResponse' +type MockClient_SlurmdbV0041PostAccountsWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostAccountsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmdbV0041PostAccountsJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostAccountsWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostAccountsWithResponse_Call { + return &MockClient_SlurmdbV0041PostAccountsWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostAccountsWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostAccountsWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmdbV0041PostAccountsJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostAccountsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmdbV0041PostAccountsJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostAccountsResponse, _a1 error) *MockClient_SlurmdbV0041PostAccountsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAccountsWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmdbV0041PostAccountsJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAccountsResponse, error)) *MockClient_SlurmdbV0041PostAccountsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostAssociationsWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostAssociationsWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAssociationsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostAssociationsWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostAssociationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAssociationsResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostAssociationsResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostAssociationsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostAssociationsWithBodyWithResponse' +type MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostAssociationsWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostAssociationsWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostAssociationsWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostAssociationsResponse, _a1 error) *MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAssociationsResponse, error)) *MockClient_SlurmdbV0041PostAssociationsWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostAssociationsWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostAssociationsWithResponse(ctx context.Context, body v0041.SlurmdbV0041PostAssociationsJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAssociationsResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostAssociationsWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostAssociationsResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostAssociationsJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAssociationsResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostAssociationsJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostAssociationsResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostAssociationsResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmdbV0041PostAssociationsJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostAssociationsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostAssociationsWithResponse' +type MockClient_SlurmdbV0041PostAssociationsWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostAssociationsWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmdbV0041PostAssociationsJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostAssociationsWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostAssociationsWithResponse_Call { + return &MockClient_SlurmdbV0041PostAssociationsWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostAssociationsWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostAssociationsWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmdbV0041PostAssociationsJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostAssociationsWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmdbV0041PostAssociationsJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAssociationsWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostAssociationsResponse, _a1 error) *MockClient_SlurmdbV0041PostAssociationsWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostAssociationsWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmdbV0041PostAssociationsJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostAssociationsResponse, error)) *MockClient_SlurmdbV0041PostAssociationsWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostClustersWithBodyWithResponse provides a mock function with given fields: ctx, params, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostClustersWithBodyWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostClustersParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostClustersResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostClustersWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostClustersResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostClustersParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostClustersResponse, error)); ok { + return rf(ctx, params, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostClustersParams, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostClustersResponse); ok { + r0 = rf(ctx, params, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostClustersResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostClustersParams, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostClustersWithBodyWithResponse' +type MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostClustersWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostClustersParams +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostClustersWithBodyWithResponse(ctx interface{}, params interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostClustersWithBodyWithResponse", + append([]interface{}{ctx, params, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostClustersParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostClustersParams), args[2].(string), args[3].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostClustersResponse, _a1 error) *MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostClustersParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostClustersResponse, error)) *MockClient_SlurmdbV0041PostClustersWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostClustersWithResponse provides a mock function with given fields: ctx, params, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostClustersWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostClustersParams, body v0041.SlurmdbV0041PostClustersJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostClustersResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostClustersWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostClustersResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostClustersParams, v0041.SlurmdbV0041PostClustersJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostClustersResponse, error)); ok { + return rf(ctx, params, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostClustersParams, v0041.SlurmdbV0041PostClustersJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostClustersResponse); ok { + r0 = rf(ctx, params, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostClustersResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostClustersParams, v0041.SlurmdbV0041PostClustersJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostClustersWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostClustersWithResponse' +type MockClient_SlurmdbV0041PostClustersWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostClustersWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostClustersParams +// - body v0041.SlurmdbV0041PostClustersJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostClustersWithResponse(ctx interface{}, params interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostClustersWithResponse_Call { + return &MockClient_SlurmdbV0041PostClustersWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostClustersWithResponse", + append([]interface{}{ctx, params, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostClustersWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostClustersParams, body v0041.SlurmdbV0041PostClustersJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostClustersWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostClustersParams), args[2].(v0041.SlurmdbV0041PostClustersJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostClustersWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostClustersResponse, _a1 error) *MockClient_SlurmdbV0041PostClustersWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostClustersWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostClustersParams, v0041.SlurmdbV0041PostClustersJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostClustersResponse, error)) *MockClient_SlurmdbV0041PostClustersWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostConfigWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostConfigWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostConfigResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostConfigWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostConfigResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostConfigResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostConfigResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostConfigResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostConfigWithBodyWithResponse' +type MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostConfigWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostConfigWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostConfigWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostConfigResponse, _a1 error) *MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostConfigResponse, error)) *MockClient_SlurmdbV0041PostConfigWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostConfigWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostConfigWithResponse(ctx context.Context, body v0041.SlurmdbV0041PostConfigJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostConfigResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostConfigWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostConfigResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostConfigJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostConfigResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostConfigJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostConfigResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostConfigResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmdbV0041PostConfigJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostConfigWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostConfigWithResponse' +type MockClient_SlurmdbV0041PostConfigWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostConfigWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmdbV0041PostConfigJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostConfigWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostConfigWithResponse_Call { + return &MockClient_SlurmdbV0041PostConfigWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostConfigWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostConfigWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmdbV0041PostConfigJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostConfigWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmdbV0041PostConfigJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostConfigWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostConfigResponse, _a1 error) *MockClient_SlurmdbV0041PostConfigWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostConfigWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmdbV0041PostConfigJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostConfigResponse, error)) *MockClient_SlurmdbV0041PostConfigWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostQosWithBodyWithResponse provides a mock function with given fields: ctx, params, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostQosWithBodyWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostQosParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostQosResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostQosWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostQosResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostQosParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostQosResponse, error)); ok { + return rf(ctx, params, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostQosParams, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostQosResponse); ok { + r0 = rf(ctx, params, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostQosResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostQosParams, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostQosWithBodyWithResponse' +type MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostQosWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostQosParams +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostQosWithBodyWithResponse(ctx interface{}, params interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostQosWithBodyWithResponse", + append([]interface{}{ctx, params, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostQosParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostQosParams), args[2].(string), args[3].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostQosResponse, _a1 error) *MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostQosParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostQosResponse, error)) *MockClient_SlurmdbV0041PostQosWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostQosWithResponse provides a mock function with given fields: ctx, params, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostQosWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostQosParams, body v0041.SlurmdbV0041PostQosJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostQosResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostQosWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostQosResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostQosParams, v0041.SlurmdbV0041PostQosJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostQosResponse, error)); ok { + return rf(ctx, params, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostQosParams, v0041.SlurmdbV0041PostQosJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostQosResponse); ok { + r0 = rf(ctx, params, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostQosResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostQosParams, v0041.SlurmdbV0041PostQosJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostQosWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostQosWithResponse' +type MockClient_SlurmdbV0041PostQosWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostQosWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostQosParams +// - body v0041.SlurmdbV0041PostQosJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostQosWithResponse(ctx interface{}, params interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostQosWithResponse_Call { + return &MockClient_SlurmdbV0041PostQosWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostQosWithResponse", + append([]interface{}{ctx, params, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostQosWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostQosParams, body v0041.SlurmdbV0041PostQosJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostQosWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostQosParams), args[2].(v0041.SlurmdbV0041PostQosJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostQosWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostQosResponse, _a1 error) *MockClient_SlurmdbV0041PostQosWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostQosWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostQosParams, v0041.SlurmdbV0041PostQosJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostQosResponse, error)) *MockClient_SlurmdbV0041PostQosWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostTresWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostTresWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostTresResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostTresWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostTresResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostTresResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostTresResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostTresResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostTresWithBodyWithResponse' +type MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostTresWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostTresWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostTresWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostTresResponse, _a1 error) *MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostTresResponse, error)) *MockClient_SlurmdbV0041PostTresWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostTresWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostTresWithResponse(ctx context.Context, body v0041.SlurmdbV0041PostTresJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostTresResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostTresWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostTresResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostTresJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostTresResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostTresJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostTresResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostTresResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmdbV0041PostTresJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostTresWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostTresWithResponse' +type MockClient_SlurmdbV0041PostTresWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostTresWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmdbV0041PostTresJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostTresWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostTresWithResponse_Call { + return &MockClient_SlurmdbV0041PostTresWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostTresWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostTresWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmdbV0041PostTresJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostTresWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmdbV0041PostTresJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostTresWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostTresResponse, _a1 error) *MockClient_SlurmdbV0041PostTresWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostTresWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmdbV0041PostTresJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostTresResponse, error)) *MockClient_SlurmdbV0041PostTresWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostUsersAssociationWithBodyWithResponse provides a mock function with given fields: ctx, params, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostUsersAssociationWithBodyWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostUsersAssociationParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersAssociationResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostUsersAssociationWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostUsersAssociationResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersAssociationResponse, error)); ok { + return rf(ctx, params, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostUsersAssociationResponse); ok { + r0 = rf(ctx, params, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostUsersAssociationResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostUsersAssociationWithBodyWithResponse' +type MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostUsersAssociationWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostUsersAssociationParams +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostUsersAssociationWithBodyWithResponse(ctx interface{}, params interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostUsersAssociationWithBodyWithResponse", + append([]interface{}{ctx, params, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostUsersAssociationParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostUsersAssociationParams), args[2].(string), args[3].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostUsersAssociationResponse, _a1 error) *MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersAssociationResponse, error)) *MockClient_SlurmdbV0041PostUsersAssociationWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostUsersAssociationWithResponse provides a mock function with given fields: ctx, params, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostUsersAssociationWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostUsersAssociationParams, body v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersAssociationResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostUsersAssociationWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostUsersAssociationResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersAssociationResponse, error)); ok { + return rf(ctx, params, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostUsersAssociationResponse); ok { + r0 = rf(ctx, params, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostUsersAssociationResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostUsersAssociationWithResponse' +type MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostUsersAssociationWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostUsersAssociationParams +// - body v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostUsersAssociationWithResponse(ctx interface{}, params interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call { + return &MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostUsersAssociationWithResponse", + append([]interface{}{ctx, params, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostUsersAssociationParams, body v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostUsersAssociationParams), args[2].(v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostUsersAssociationResponse, _a1 error) *MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostUsersAssociationParams, v0041.SlurmdbV0041PostUsersAssociationJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersAssociationResponse, error)) *MockClient_SlurmdbV0041PostUsersAssociationWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostUsersWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostUsersWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostUsersWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostUsersResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersResponse, error)); ok { + return rf(ctx, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostUsersResponse); ok { + r0 = rf(ctx, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostUsersResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostUsersWithBodyWithResponse' +type MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostUsersWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostUsersWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostUsersWithBodyWithResponse", + append([]interface{}{ctx, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostUsersResponse, _a1 error) *MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersResponse, error)) *MockClient_SlurmdbV0041PostUsersWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostUsersWithResponse provides a mock function with given fields: ctx, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostUsersWithResponse(ctx context.Context, body v0041.SlurmdbV0041PostUsersJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostUsersWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostUsersResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostUsersJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersResponse, error)); ok { + return rf(ctx, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, v0041.SlurmdbV0041PostUsersJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostUsersResponse); ok { + r0 = rf(ctx, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostUsersResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, v0041.SlurmdbV0041PostUsersJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostUsersWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostUsersWithResponse' +type MockClient_SlurmdbV0041PostUsersWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostUsersWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - body v0041.SlurmdbV0041PostUsersJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostUsersWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostUsersWithResponse_Call { + return &MockClient_SlurmdbV0041PostUsersWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostUsersWithResponse", + append([]interface{}{ctx, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostUsersWithResponse_Call) Run(run func(ctx context.Context, body v0041.SlurmdbV0041PostUsersJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostUsersWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(v0041.SlurmdbV0041PostUsersJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostUsersResponse, _a1 error) *MockClient_SlurmdbV0041PostUsersWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostUsersWithResponse_Call) RunAndReturn(run func(context.Context, v0041.SlurmdbV0041PostUsersJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostUsersResponse, error)) *MockClient_SlurmdbV0041PostUsersWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostWckeysWithBodyWithResponse provides a mock function with given fields: ctx, params, contentType, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostWckeysWithBodyWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostWckeysParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostWckeysResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, contentType, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostWckeysWithBodyWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostWckeysResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostWckeysResponse, error)); ok { + return rf(ctx, params, contentType, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, string, io.Reader, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostWckeysResponse); ok { + r0 = rf(ctx, params, contentType, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostWckeysResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, string, io.Reader, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, contentType, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostWckeysWithBodyWithResponse' +type MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostWckeysWithBodyWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostWckeysParams +// - contentType string +// - body io.Reader +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostWckeysWithBodyWithResponse(ctx interface{}, params interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call { + return &MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostWckeysWithBodyWithResponse", + append([]interface{}{ctx, params, contentType, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostWckeysParams, contentType string, body io.Reader, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-4) + for i, a := range args[4:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostWckeysParams), args[2].(string), args[3].(io.Reader), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostWckeysResponse, _a1 error) *MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, string, io.Reader, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostWckeysResponse, error)) *MockClient_SlurmdbV0041PostWckeysWithBodyWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// SlurmdbV0041PostWckeysWithResponse provides a mock function with given fields: ctx, params, body, reqEditors +func (_m *MockClient) SlurmdbV0041PostWckeysWithResponse(ctx context.Context, params *v0041.SlurmdbV0041PostWckeysParams, body v0041.SlurmdbV0041PostWckeysJSONRequestBody, reqEditors ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostWckeysResponse, error) { + _va := make([]interface{}, len(reqEditors)) + for _i := range reqEditors { + _va[_i] = reqEditors[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params, body) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SlurmdbV0041PostWckeysWithResponse") + } + + var r0 *v0041.SlurmdbV0041PostWckeysResponse + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, v0041.SlurmdbV0041PostWckeysJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostWckeysResponse, error)); ok { + return rf(ctx, params, body, reqEditors...) + } + if rf, ok := ret.Get(0).(func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, v0041.SlurmdbV0041PostWckeysJSONRequestBody, ...v0041.RequestEditorFn) *v0041.SlurmdbV0041PostWckeysResponse); ok { + r0 = rf(ctx, params, body, reqEditors...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*v0041.SlurmdbV0041PostWckeysResponse) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, v0041.SlurmdbV0041PostWckeysJSONRequestBody, ...v0041.RequestEditorFn) error); ok { + r1 = rf(ctx, params, body, reqEditors...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockClient_SlurmdbV0041PostWckeysWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SlurmdbV0041PostWckeysWithResponse' +type MockClient_SlurmdbV0041PostWckeysWithResponse_Call struct { + *mock.Call +} + +// SlurmdbV0041PostWckeysWithResponse is a helper method to define mock.On call +// - ctx context.Context +// - params *v0041.SlurmdbV0041PostWckeysParams +// - body v0041.SlurmdbV0041PostWckeysJSONRequestBody +// - reqEditors ...v0041.RequestEditorFn +func (_e *MockClient_Expecter) SlurmdbV0041PostWckeysWithResponse(ctx interface{}, params interface{}, body interface{}, reqEditors ...interface{}) *MockClient_SlurmdbV0041PostWckeysWithResponse_Call { + return &MockClient_SlurmdbV0041PostWckeysWithResponse_Call{Call: _e.mock.On("SlurmdbV0041PostWckeysWithResponse", + append([]interface{}{ctx, params, body}, reqEditors...)...)} +} + +func (_c *MockClient_SlurmdbV0041PostWckeysWithResponse_Call) Run(run func(ctx context.Context, params *v0041.SlurmdbV0041PostWckeysParams, body v0041.SlurmdbV0041PostWckeysJSONRequestBody, reqEditors ...v0041.RequestEditorFn)) *MockClient_SlurmdbV0041PostWckeysWithResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]v0041.RequestEditorFn, len(args)-3) + for i, a := range args[3:] { + if a != nil { + variadicArgs[i] = a.(v0041.RequestEditorFn) + } + } + run(args[0].(context.Context), args[1].(*v0041.SlurmdbV0041PostWckeysParams), args[2].(v0041.SlurmdbV0041PostWckeysJSONRequestBody), variadicArgs...) + }) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostWckeysWithResponse_Call) Return(_a0 *v0041.SlurmdbV0041PostWckeysResponse, _a1 error) *MockClient_SlurmdbV0041PostWckeysWithResponse_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockClient_SlurmdbV0041PostWckeysWithResponse_Call) RunAndReturn(run func(context.Context, *v0041.SlurmdbV0041PostWckeysParams, v0041.SlurmdbV0041PostWckeysJSONRequestBody, ...v0041.RequestEditorFn) (*v0041.SlurmdbV0041PostWckeysResponse, error)) *MockClient_SlurmdbV0041PostWckeysWithResponse_Call { + _c.Call.Return(run) + return _c +} + +// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockClient { + mock := &MockClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/internal/slurmapi/interface.go b/internal/slurmapi/interface.go new file mode 100644 index 00000000..71949e2a --- /dev/null +++ b/internal/slurmapi/interface.go @@ -0,0 +1,13 @@ +package slurmapi + +import ( + "context" + + api "github.com/SlinkyProject/slurm-client/api/v0041" +) + +type Client interface { + api.ClientWithResponsesInterface + ListNodes(ctx context.Context) ([]Node, error) + GetNode(ctx context.Context, nodeName string) (Node, error) +} diff --git a/internal/slurmapi/node.go b/internal/slurmapi/node.go new file mode 100644 index 00000000..9b01c249 --- /dev/null +++ b/internal/slurmapi/node.go @@ -0,0 +1,83 @@ +package slurmapi + +import ( + "errors" + "time" + + slurmapispec "github.com/SlinkyProject/slurm-client/api/v0041" +) + +type Node struct { + Name string + ClusterName string + InstanceID string + States map[slurmapispec.V0041NodeState]struct{} + Reason *NodeReason +} + +type NodeReason struct { + Reason string + ChangedAt time.Time +} + +func validateAPINode(node slurmapispec.V0041Node) error { + var errs []error + + if node.State == nil || len(*node.State) == 0 { + errs = append(errs, errors.New("node doesn't have any state")) + } + + if node.Name == nil { + errs = append(errs, errors.New("node doesn't have name")) + } + + if node.ClusterName == nil { + errs = append(errs, errors.New("node doesn't have cluster name")) + } + + if node.InstanceId == nil { + errs = append(errs, errors.New("node doesn't have instance id")) + } + + if node.Reason != nil && len(*node.Reason) != 0 && (node.ReasonChangedAt == nil || node.ReasonChangedAt.Number == nil) { + errs = append(errs, errors.New("node doesn't have reasonChangedAt or reasonChangedAt.number, but has reason")) + } + + return errors.Join(errs...) +} + +func NodeFromAPI(node slurmapispec.V0041Node) (Node, error) { + if err := validateAPINode(node); err != nil { + return Node{}, err + } + + var res Node + + nodeStates := make(map[slurmapispec.V0041NodeState]struct{}, len(*node.State)) + for _, state := range *node.State { + nodeStates[state] = struct{}{} + } + + res = Node{ + Name: *node.Name, + ClusterName: *node.ClusterName, + InstanceID: *node.InstanceId, + States: nodeStates, + } + + if node.Reason != nil && len(*node.Reason) != 0 { + res.Reason = &NodeReason{ + Reason: *node.Reason, + ChangedAt: time.Unix(*node.ReasonChangedAt.Number, 0), + } + } + + return res, nil +} + +func (n *Node) IsIdleDrained() bool { + _, drained := n.States[slurmapispec.V0041NodeStateDRAIN] + _, idle := n.States[slurmapispec.V0041NodeStateIDLE] + + return drained && idle +}