jobs_crud.yml

---
"Test get all jobs and stats given no job exists":

  - do:
      ml.get_jobs:
        job_id: "_all"
  - match: { count: 0 }
  - match: { jobs: [] }

  - do:
      ml.get_job_stats:
        job_id: "_all"
  - match: { count: 0 }
  - match: { jobs: [] }

---
"Test get jobs with expression that does not match and allow_no_match":
  - skip:
      features:
        - "warnings"

  - do:
      ml.get_jobs:
        job_id: "missing-*"
        allow_no_match: true
  - match: { count: 0 }
  - match: { jobs: [] }

  - do:
      warnings:
        - 'Deprecated field [allow_no_jobs] used, expected [allow_no_match] instead'
      ml.get_jobs:
        job_id: "missing-*"
        allow_no_jobs: true
  - match: { count: 0 }
  - match: { jobs: [] }

---
"Test get jobs with expression that does not match and not allow_no_match":
  - skip:
      features:
        - "warnings"

  - do:
      catch: missing
      ml.get_jobs:
        job_id: "missing-*"
        allow_no_match: false

  - do:
      warnings:
        - 'Deprecated field [allow_no_jobs] used, expected [allow_no_match] instead'
      catch: missing
      ml.get_jobs:
        job_id: "missing-*"
        allow_no_jobs: false

---
"Test job crud apis":

  - do:
      ml.put_job:
        job_id: job-crud-test-apis
        body:  >
          {
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "field_delimiter":",",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }
  - match: { job_id: "job-crud-test-apis" }
  - match: { analysis_limits.model_memory_limit: "1024mb" }
  - match: { analysis_limits.categorization_examples_limit: 4 }

  - do:
      ml.get_jobs:
        job_id: "job-crud-test-apis"
  - match: { count: 1 }
  - match: { jobs.0.job_id: "job-crud-test-apis" }
  - match: { jobs.0.analysis_limits.model_memory_limit: "1024mb" }

  - do:
      ml.delete_job:
        job_id: "job-crud-test-apis"
  - match: { acknowledged: true }

---
"Test put job with model_memory_limit as number":

  - do:
      ml.put_job:
        job_id: job-model-memory-limit-as-number
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "data_description" : {
            },
            "analysis_limits": {
                "model_memory_limit": 2048
            }
          }
  - match: { job_id: "job-model-memory-limit-as-number" }
  - match: { analysis_limits.model_memory_limit: "2048mb" }

---
"Test put job with model_memory_limit as string and lazy open":
  - skip:
      features: headers
  - do:
      ml.put_job:
        job_id: job-model-memory-limit-as-string
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "data_description" : {
            },
            "analysis_limits": {
                "model_memory_limit": "3000g"
            },
            "allow_lazy_open": true
          }
  - match: { job_id: "job-model-memory-limit-as-string" }
  - match: { analysis_limits.model_memory_limit: "3072000mb" }

  # The assumption here is that a 3000GB job will not fit on the test
  # node - increase in future if the test ever fails because of this!
  # But because the job is allowed to open lazily, opening it shouldn't
  # throw an exception - it should wait for a big enough node to be
  # added to the cluster.
  - do:
      ml.open_job:
        job_id: job-model-memory-limit-as-string
  - match: { opened: true }
  - match: { node: "" }

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      ml.get_job_stats:
        job_id: job-model-memory-limit-as-string
  - match: {"jobs.0.state": opening}

  # Despite never being assigned to a node the job should close gracefully
  - do:
      ml.close_job:
        job_id: job-model-memory-limit-as-string
  - match: { closed: true }

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      ml.get_job_stats:
        job_id: job-model-memory-limit-as-string
  - match: {"jobs.0.state": closed}

---
"Test get job API with non existing job id":
  - do:
      catch: missing
      ml.get_jobs:
        job_id: "non-existing"

---
"Test put job with inconsistent model snapshot settings":
  - do:
      catch: /The value of daily_model_snapshot_retention_after_days \[4\] cannot be greater than model_snapshot_retention_days \[3\]/
      ml.put_job:
        job_id: inconsistent-snapshot-settings-1
        body:  >
          {
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "time_field":"@timestamp"
            },
            "model_snapshot_retention_days": 3,
            "daily_model_snapshot_retention_after_days": 4
          }

  - do:
      catch: /daily_model_snapshot_retention_after_days cannot be less than 0. Value = -1/
      ml.put_job:
        job_id: inconsistent-snapshot-settings-2
        body:  >
          {
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "time_field":"@timestamp"
            },
            "model_snapshot_retention_days": 3,
            "daily_model_snapshot_retention_after_days": -1
          }

---
"Test put job with inconsistent body/param ids":
  - do:
      catch: /illegal_argument_exception/
      ml.put_job:
        job_id: an_id
        body:  >
          {
            "job_id":"a_different_id",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "field_delimiter":",",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }

  - do:
      catch: /Inconsistent job_id; 'a_different_id' specified in the body differs from 'an_id' specified as a URL argument/
      ml.put_job:
        job_id: an_id
        body:  >
          {
            "job_id":"a_different_id",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "3600s",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "field_delimiter":",",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }

---
"Test put job with id that is already taken":
  - do:
      ml.put_job:
        job_id: jobs-crud-id-already-taken
        body:  >
          {
            "job_id":"jobs-crud-id-already-taken",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "3600000ms",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "field_delimiter":",",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }
  - match: { job_id: "jobs-crud-id-already-taken" }

  - do:
      catch: /resource_already_exists_exception/
      ml.put_job:
        job_id: jobs-crud-id-already-taken
        body:  >
          {
            "job_id":"jobs-crud-id-already-taken",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "field_delimiter":",",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }
  - do:
      catch: /The job cannot be created with the Id 'jobs-crud-id-already-taken'. The Id is already used./
      ml.put_job:
        job_id: jobs-crud-id-already-taken
        body:  >
          {
            "job_id":"jobs-crud-id-already-taken",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "field_delimiter":",",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }

---
"Test update job":
  - do:
      ml.put_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "description":"Pre update description",
            "analysis_config" : {
                "detectors" :[{"function":"mean","field_name":"responsetime","by_field_name":"airline"},
                    {"function":"count","by_field_name":"mlcategory"}],
                "categorization_field_name": "some_category",
                "categorization_filters" : ["cat1.*", "cat2.*"]
            },
            "data_description" : {
              "field_delimiter":","
            },
            "model_plot_config": {
              "enabled": true,
              "terms": "foo,bar"
            },
            "analysis_limits": {
              "model_memory_limit": "10mb"
            },
            "renormalization_window_days": 1,
            "background_persist_interval": "2h",
            "model_snapshot_retention_days": 3,
            "daily_model_snapshot_retention_after_days": 2,
            "results_retention_days": 4,
            "custom_settings": {
              "setting1": "custom1",
              "setting2": "custom2"
            }
          }
  - match: { job_id: "jobs-crud-update-job" }

  - do:
      ml.open_job:
        job_id: jobs-crud-update-job

  - do:
      ml.update_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "groups": ["group-1", "group-2"],
            "description":"Post update description",
            "detectors": [
              {
                "detector_index": 0,
                "custom_rules":[
                  {
                    "conditions": [
                      {
                        "applies_to": "actual",
                        "operator": "gt",
                        "value": 10
                      }
                    ]
                  }
                ]
              },
              {
                "detector_index": 1,
                "description": "updated description"
              }
            ],
            "model_plot_config": {
              "enabled": false,
              "terms": "foobar"
            },
            "renormalization_window_days": 10,
            "background_persist_interval": "3h",
            "model_snapshot_retention_days": 30,
            "results_retention_days": 40,
            "categorization_filters" : ["cat3.*"],
            "custom_settings": {
              "setting3": "custom3"
            }
          }
  - match: { job_id: "jobs-crud-update-job" }
  - match: { groups: ["group-1", "group-2"] }
  - match: { description: "Post update description" }
  - match: { model_plot_config.enabled: false }
  - match: { model_plot_config.terms: "foobar" }
  - match: { model_plot_config.annotations_enabled: false }
  - match: { analysis_config.categorization_filters: ["cat3.*"] }
  - match: { analysis_config.detectors.0.custom_rules.0.actions: ["skip_result"] }
  - length: { analysis_config.detectors.0.custom_rules.0.conditions: 1 }
  - match: { analysis_config.detectors.0.detector_index: 0 }
  - match: { analysis_config.detectors.1.detector_description: "updated description" }
  - match: { analysis_config.detectors.1.detector_index: 1 }
  - match: { renormalization_window_days: 10 }
  - match: { background_persist_interval: "3h" }
  - match: { model_snapshot_retention_days: 30 }
  - match: { daily_model_snapshot_retention_after_days: 2 }
  - match: { results_retention_days: 40 }

  - do:
      catch: "/Cannot update analysis_limits while the job is open/"
      ml.update_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "analysis_limits": {
              "model_memory_limit": "20mb"
            }
          }

  - do:
      ml.close_job:
        job_id: jobs-crud-update-job
  - match: { closed: true }

  - do:
      ml.update_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "analysis_limits": {
              "model_memory_limit": "20mb"
            }
          }
  - match: { analysis_limits.model_memory_limit: "20mb" }

  - do:
      ml.update_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "analysis_limits": {
              "model_memory_limit": "15mb"
            }
          }
  - match: { analysis_limits.model_memory_limit: "15mb" }

  - do:
      catch: /The value of daily_model_snapshot_retention_after_days \[31\] cannot be greater than model_snapshot_retention_days \[30\]/
      ml.update_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "daily_model_snapshot_retention_after_days": 31
          }

  - do:
      catch: /The value of daily_model_snapshot_retention_after_days \[2\] cannot be greater than model_snapshot_retention_days \[1\]/
      ml.update_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "model_snapshot_retention_days": 1
          }

  - do:
      catch: bad_request
      ml.update_job:
        job_id: _all
        body:  >
          {
            "description":"Can't update all description"
          }

  - do:
      ml.put_job:
        job_id: job-crud-update-group-name-clash
        body:  >
          {
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
            }
          }

  - do:
      catch: "/job and group names must be unique/"
      ml.update_job:
        job_id: jobs-crud-update-job
        body:  >
          {
            "groups": ["job-crud-update-group-name-clash"]
          }

---
"Test delete job that does not exist":
  - do:
      catch: missing
      ml.delete_job:
        job_id: not-a-job

---
"Test delete job that is referred by a datafeed":
  - do:
      ml.put_job:
        job_id: jobs-crud-datafeed-job
        body:  >
          {
            "job_id":"jobs-crud-datafeed-job",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "format":"xcontent",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }
  - match: { job_id: "jobs-crud-datafeed-job" }

  - do:
      ml.put_datafeed:
        datafeed_id: jobs-crud-test-datafeed-1
        body:  >
          {
            "job_id":"jobs-crud-datafeed-job",
            "indexes":["index-foo"]
          }
  - match: { datafeed_id: "jobs-crud-test-datafeed-1" }

  - do:
      catch: /Cannot delete job \[jobs-crud-datafeed-job\] because datafeed \[jobs-crud-test-datafeed-1\] refers to it/
      ml.delete_job:
        job_id: jobs-crud-datafeed-job

---
"Test delete job that is opened":
  - do:
      ml.put_job:
        job_id: delete-opened-job
        body:  >
          {
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {
                "time_field":"time"
            }
          }
  - match: { job_id: "delete-opened-job" }

  - do:
      ml.open_job:
        job_id: delete-opened-job
  - match: { opened: true }
  - match: { node: /\S+/ }

  - do:
      catch: /Cannot delete job \[delete-opened-job\] because the job is opened/
      ml.delete_job:
        job_id: delete-opened-job

---
"Test close job":
  - skip:
      features:
        - "headers"
  - do:
      ml.put_job:
        job_id: jobs-crud-close-job
        body:  >
          {
            "job_id":"jobs-crud-close-job",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span":"1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "format":"xcontent",
                "time_field":"time",
                "time_format":"epoch"
            }
          }
  - match: { job_id: "jobs-crud-close-job" }

  - do:
      ml.open_job:
        job_id: jobs-crud-close-job

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      ml.get_job_stats:
        job_id: jobs-crud-close-job
  - match: {"jobs.0.state": opened}

  - do:
      ml.close_job:
        job_id: jobs-crud-close-job
  - match: { closed: true }

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      ml.get_job_stats:
        job_id: jobs-crud-close-job
  - match: {"jobs.0.state": closed}

---
"Test closing a closed job isn't an error":
  - do:
      ml.put_job:
        job_id: jobs-crud-close-a-closed-job
        body:  >
          {
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {
                "format":"xcontent"
            }
          }
  - match: { job_id: "jobs-crud-close-a-closed-job" }

  - do:
      ml.open_job:
        job_id: jobs-crud-close-a-closed-job

  - do:
      ml.close_job:
        job_id: jobs-crud-close-a-closed-job
  - match: { closed: true }

  - do:
      ml.close_job:
        job_id: jobs-crud-close-a-closed-job
  - match: { closed: true }

---
"Test close all jobs":
  - do:
      ml.put_job:
        job_id: jobs-crud-close-all-1
        body:  >
          {
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {
                "format":"xcontent"
            }
          }
  - match: { job_id: "jobs-crud-close-all-1" }

  - do:
      ml.put_job:
        job_id: jobs-crud-close-all-2
        body:  >
          {
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {
                "format":"xcontent"
            }
          }
  - match: { job_id: "jobs-crud-close-all-2" }

  - do:
      ml.open_job:
        job_id: jobs-crud-close-all-2

  - do:
      ml.close_job:
        job_id: _all
  - match: { closed: true }

  - do:
      ml.get_job_stats:
        job_id: _all
  - match: { jobs.0.state: closed }
  - match: { jobs.1.state: closed }

---
"Test close jobs with expression that matches":
  - do:
      ml.put_job:
        job_id: jobs-crud-with-expression-that-matches-foo-1
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {}
          }

  - do:
      ml.put_job:
        job_id: jobs-crud-with-expression-that-matches-foo-2
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {}
          }

  - do:
      ml.put_job:
        job_id: jobs-crud-with-expression-that-matches-bar-1
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {}
          }

  - do:
      ml.open_job:
        job_id: jobs-crud-with-expression-that-matches-foo-1

  - do:
      ml.open_job:
        job_id: jobs-crud-with-expression-that-matches-foo-2

  - do:
      ml.open_job:
        job_id: jobs-crud-with-expression-that-matches-bar-1

  - do:
      ml.close_job:
        job_id: "*foo-*"
  - match: { closed: true }

  - do:
      ml.get_job_stats:
        job_id: "*foo-*"
  - match: { jobs.0.state: closed }
  - match: { jobs.1.state: closed }

  - do:
      ml.get_job_stats:
        job_id: "*bar-1"
  - match: { jobs.0.state: opened }

---
"Test close jobs with expression that does not match and allow_no_match":
  - skip:
      features:
        - "warnings"
  - do:
      ml.close_job:
        job_id: "missing-*"
        allow_no_match: true
  - match: { closed: true }

  - do:
      warnings:
        - 'Deprecated field [allow_no_jobs] used, expected [allow_no_match] instead'
      ml.close_job:
        job_id: "missing-*"
        allow_no_jobs: true
  - match: { closed: true }

---
"Test close jobs with expression that does not match and not allow_no_match":
  - skip:
      features:
        - "warnings"
  - do:
      catch: missing
      ml.close_job:
        job_id: "missing-*"
        allow_no_match: false

  - do:
      warnings:
        - 'Deprecated field [allow_no_jobs] used, expected [allow_no_match] instead'
      catch: missing
      ml.close_job:
        job_id: "missing-*"
        allow_no_jobs: false

---
"Test force close job":
  - skip:
      features:
        - "headers"
  - do:
      ml.put_job:
        job_id: jobs-crud-force-close-job
        body:  >
          {
            "job_id":"jobs-crud-force-close-job",
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "bucket_span":"1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {
                "format":"xcontent",
                "time_field":"time",
                "time_format":"epoch"
            }
          }
  - match: { job_id: "jobs-crud-force-close-job" }

  - do:
      ml.open_job:
        job_id: jobs-crud-force-close-job

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      ml.get_job_stats:
        job_id: jobs-crud-force-close-job
  - match: {"jobs.0.state": opened}

  - do:
      ml.close_job:
        job_id: jobs-crud-force-close-job
        force: true
  - match: { closed: true }

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      ml.get_job_stats:
        job_id: jobs-crud-force-close-job
  - match: {"jobs.0.state": closed}

---
"Test force closing a closed job isn't an error":
  - do:
      ml.put_job:
        job_id: jobs-crud-close-a-closed-job
        body:  >
          {
            "description":"Analysis of response time by airline",
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "analysis_limits" : {
                "model_memory_limit": "20mb"
            },
            "data_description" : {
                "format":"xcontent"
            }
          }
  - match: { job_id: "jobs-crud-close-a-closed-job" }

  - do:
      ml.open_job:
        job_id: jobs-crud-close-a-closed-job

  - do:
      ml.close_job:
        job_id: jobs-crud-close-a-closed-job
        force: true
  - match: { closed: true }

  - do:
      ml.close_job:
        job_id: jobs-crud-close-a-closed-job
        force: true
  - match: { closed: true }

---
"Test open and close an unknown job is resource not found":
  - do:
      catch: missing
      ml.open_job:
        job_id: jobs-crud-some-missing-job-i-made-up

  - do:
      catch: missing
      ml.close_job:
        job_id: jobs-crud-some-missing-job-i-made-up

---
"Test cannot create job with model snapshot id set":

  - do:
      catch: /illegal_argument_exception/
      ml.put_job:
        job_id: has-model-snapshot-id
        body:  >
          {
            "model_snapshot_id": "wont-create-with-this-setting",
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
            }
          }

---
"Test put job with time field in analysis_config":

  - do:
      catch: /illegal_argument_exception/
      ml.put_job:
        job_id: jobs-crud-time-field-in-analysis_config
        body:  >
          {
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"rare","by_field_name":"@timestamp"}]
            },
            "data_description" : {
                "time_field":"@timestamp"
            }
          }

  - do:
      catch: /data_description.time_field may not be used in the analysis_config/
      ml.put_job:
        job_id: jobs-crud-time-field-in-analysis_config
        body:  >
          {
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"mean","field_name":"time"}]
            },
            "data_description" : {}
          }

---
"Test put job with duplicate detector configurations":

  - do:
      catch: /illegal_argument_exception.*Duplicate detectors are not allowed/
      ml.put_job:
        job_id: jobs-crud-duplicate-detectors
        body:  >
          {
            "analysis_config": {
                "bucket_span": "1h",
                "detectors": [
                    {"function":"max", "field_name":"responsetime"},
                    {"function":"max", "field_name":"responsetime"}
                ]
            },
            "data_description": {
                "time_field": "@timestamp"
            }
          }

  - do:
      catch: /illegal_argument_exception.*Duplicate detectors are not allowed/
      ml.put_job:
        job_id: jobs-crud-duplicate-detectors-with-explicit-indices
        body:  >
          {
            "analysis_config": {
                "bucket_span": "1h",
                "detectors": [
                    {"function":"max", "field_name":"responsetime", "detector_index": 0},
                    {"function":"max", "field_name":"responsetime", "detector_index": 1}
                ]
            },
            "data_description": {
                "time_field": "@timestamp"
            }
          }

---
"Test max model memory limit":
  - skip:
      features: headers
  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      cluster.put_settings:
        body:
          transient:
            xpack.ml.max_model_memory_limit: "9g"
  - match: {transient.xpack.ml.max_model_memory_limit: "9g"}

  - do:
      ml.put_job:
        job_id: job-model-memory-limit-below-global-max
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "data_description" : {
            },
            "analysis_limits": {
                "model_memory_limit": "8g"
            }
          }
  - match: { job_id: "job-model-memory-limit-below-global-max" }
  - match: { analysis_limits.model_memory_limit: "8192mb" }

  - do:
      catch: /model_memory_limit \[10gb\] must be less than the value of the xpack.ml.max_model_memory_limit setting \[9gb\]/
      ml.put_job:
        job_id: job-model-memory-limit-above-global-max
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "data_description" : {
            },
            "analysis_limits": {
                "model_memory_limit": "10g"
            }
          }

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      cluster.put_settings:
        body:
          transient:
            xpack.ml.max_model_memory_limit: null
  - match: {transient: {}}

  - do:
      ml.put_job:
        job_id: job-model-memory-limit-above-removed-global-max
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "data_description" : {
            },
            "analysis_limits": {
                "model_memory_limit": "10g"
            }
          }
  - match: { job_id: "job-model-memory-limit-above-removed-global-max" }
  - match: { analysis_limits.model_memory_limit: "10240mb" }

---
"Test create job with delimited format":

  - skip:
      features: "warnings"
      reason: deprecation logging for delimited format was introduced in 5.4.0

  - do:
      warnings:
          - Creating jobs with delimited data format is deprecated. Please use xcontent instead.
      ml.put_job:
        job_id: delimited-format-job
        body:  >
          {
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"metric","field_name":"responsetime","by_field_name":"airline"}]
            },
            "data_description" : {
                "format":"delimited",
                "field_delimiter":",",
                "time_field":"time",
                "time_format":"yyyy-MM-dd HH:mm:ssX"
            }
          }
  - match: { job_id: "delimited-format-job" }

---
"Test jobs with named and custom categorization_analyzer":
# Check named and custom configs can share the same index & mappings
  - do:
      ml.put_job:
        job_id: jobs-crud-named-categorization-analyzer-job
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"mean","field_name":"responsetime","by_field_name":"airline"},
                    {"function":"count","by_field_name":"mlcategory"}],
                "categorization_field_name": "some_category",
                "categorization_analyzer" : "standard"
            },
            "data_description" : {
            }
          }
  - match: { job_id: "jobs-crud-named-categorization-analyzer-job" }
  - match: { analysis_config.categorization_analyzer: "standard" }

  - do:
      ml.put_job:
        job_id: jobs-crud-custom-categorization-analyzer-job
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"mean","field_name":"responsetime","by_field_name":"airline"},
                    {"function":"count","by_field_name":"mlcategory"}],
                "categorization_field_name": "some_category",
                "categorization_analyzer" : {
                    "char_filter" : ["html_strip"],
                    "tokenizer" : "classic",
                    "filter" : ["stop"]
                }
            },
            "data_description" : {
            }
          }
  - match: { job_id: "jobs-crud-custom-categorization-analyzer-job" }
  - match: { analysis_config.categorization_analyzer.char_filter.0: "html_strip" }
  - match: { analysis_config.categorization_analyzer.tokenizer: "classic" }
  - match: { analysis_config.categorization_analyzer.filter.0: "stop" }

---
"Test job with categorization_analyzer and categorization_filters":
  - do:
      catch: /categorization_filters cannot be used with categorization_analyzer - instead specify them as pattern_replace char_filters in the analyzer/
      ml.put_job:
        job_id: jobs-crud-categorization-analyzer-job
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"mean","field_name":"responsetime","by_field_name":"airline"},
                    {"function":"count","by_field_name":"mlcategory"}],
                "categorization_field_name": "some_category",
                "categorization_analyzer" : {
                    "char_filter" : ["html_strip"],
                    "tokenizer" : "classic",
                    "filter" : ["stop"]
                },
                "categorization_filters" : ["cat1.*", "cat2.*"]
            },
            "data_description" : {
            }
          }

---
"Test job with rules":

  - do:
      ml.put_job:
        job_id: jobs-crud-rules
        body:  >
          {
            "analysis_config": {
              "detectors": [
                {
                  "function": "count",
                  "by_field_name": "country",
                  "custom_rules": [
                    {
                      "actions": ["skip_result", "skip_model_update"],
                      "scope": {
                        "country": {"filter_id": "safe_countries"}
                      },
                      "conditions": [
                        {
                          "applies_to":"actual",
                          "operator":"lt",
                          "value": 33.3
                        },
                        {
                          "applies_to":"typical",
                          "operator":"lte",
                          "value": 42.0
                        }
                      ]
                    }
                  ]
                }
              ]
            },
            "data_description" : {}
          }

  - do:
      ml.get_jobs:
        job_id: jobs-crud-rules
  - match: { count: 1 }
  - match: {
      jobs.0.analysis_config.detectors.0.custom_rules: [
        {
          "actions": ["skip_result", "skip_model_update"],
          "scope": {
            "country": {"filter_id": "safe_countries", "filter_type": "include"}
          },
          "conditions": [
            {
              "applies_to":"actual",
              "operator":"lt",
              "value": 33.3
            },
            {
              "applies_to":"typical",
              "operator":"lte",
              "value": 42.0
            }
          ]
        }
      ]
    }

---
"Test function shortcut expansion":
  - do:
      ml.put_job:
        job_id: jobs-function-shortcut-expansion
        body:  >
          {
            "analysis_config" : {
                "bucket_span": "1h",
                "detectors" :[{"function":"nzc","by_field_name":"airline"}]
            },
            "data_description" : {}
          }
  - match: { job_id: "jobs-function-shortcut-expansion" }
  - match: { analysis_config.detectors.0.function: "non_zero_count"}

---
"Test open job when persistent task allocation disabled":
  - skip:
      features: headers
  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      cluster.put_settings:
        body:
          transient:
            cluster.persistent_tasks.allocation.enable: "none"
  - match: {transient.cluster.persistent_tasks.allocation.enable: "none"}

  - do:
      ml.put_job:
        job_id: persistent-task-allocation-allowed-test
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "data_description" : {
            },
            "analysis_limits": {
                "model_memory_limit": "10m"
            }
          }
  - match: { job_id: "persistent-task-allocation-allowed-test" }

  - do:
      catch: /Cannot open jobs because persistent task assignment is disabled by the \[cluster.persistent_tasks.allocation.enable\] setting/
      ml.open_job:
        job_id: persistent-task-allocation-allowed-test

  - do:
      headers:
        Authorization: "Basic eF9wYWNrX3Jlc3RfdXNlcjp4LXBhY2stdGVzdC1wYXNzd29yZA==" # run as x_pack_rest_user, i.e. the test setup superuser
      cluster.put_settings:
        body:
          transient:
            cluster.persistent_tasks.allocation.enable: "all"
  - match: {transient.cluster.persistent_tasks.allocation.enable: "all"}

  - do:
      ml.open_job:
        job_id: persistent-task-allocation-allowed-test
  - match: { opened: true }
  - match: { node: /\S+/ }

---
"Test reopen job resets the finished time":
  - do:
      ml.put_job:
        job_id: jobs-crud-reset-finished-time
        body:  >
          {
            "analysis_config" : {
                "detectors" :[{"function":"count"}]
            },
            "data_description" : {
            }
          }
  - match: { job_id: jobs-crud-reset-finished-time }

  - do:
      ml.open_job:
        job_id: jobs-crud-reset-finished-time

  - do:
      ml.get_jobs:
        job_id: jobs-crud-reset-finished-time
  - is_false: jobs.0.finished_time

  - do:
      ml.close_job:
        job_id: jobs-crud-reset-finished-time

  - do:
      ml.get_jobs:
        job_id: jobs-crud-reset-finished-time
  - is_true: jobs.0.finished_time

  - do:
      ml.open_job:
        job_id: jobs-crud-reset-finished-time

  - do:
      ml.get_jobs:
        job_id: jobs-crud-reset-finished-time
  - is_false: jobs.0.finished_time

---
"Test close job with body params":
  - skip:
      features:
       - "warnings"

  - do:
      catch: missing
      ml.close_job:
        job_id: job-that-doesnot-exist*
        body:  >
          {
            "allow_no_match" : false
          }

  - do:
      ml.close_job:
        job_id: job-that-doesnot-exist*
        body:  >
          {
            "allow_no_match" : true
          }

  - do:
      warnings:
        - 'Deprecated field [allow_no_jobs] used, expected [allow_no_match] instead'
      catch: missing
      ml.close_job:
        job_id: job-that-doesnot-exist*
        body:  >
          {
            "allow_no_jobs" : false
          }

  - do:
      warnings:
        - 'Deprecated field [allow_no_jobs] used, expected [allow_no_match] instead'
      ml.close_job:
        job_id: job-that-doesnot-exist*
        body:  >
          {
            "allow_no_jobs" : true
          }