Constraint validation is handled at the RAML layer. AppDefinition defined a redundant set
of constraint validation rules that added no value and grew out of sync w/ the RAML layer.
This change set removes the constraint validation from AppDefinition and refactors some of
the related unit tests. As part of the test refactoring the constraint violation messages
were tweaked and turned into constants for easier testing.
sbt test
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
Thanks - Looks good to me.
I see the test cases are working. I wonder where we use the constraints validator for the raml app?
| src/main/scala/mesosphere/marathon/state/AppDefinition.scala | ||
|---|---|---|
| 563 | I only see a reference to mesosphere/marathon/api/v2/validation/SchedulingValidation.scala:112 ?? | |
Build is green https://jenkins.mesosphere.com/service/jenkins/job/public-test-marathon-phabricator/2013/ for more details.
Nice change. I'd feel a bit better if there was some manual testing on this to see if there's any coverage missing.
| Commit | Tree | Parents | Author | Summary | Date |
|---|---|---|---|---|---|
| 800f8ce6b952 | d21f0b8e510b | a23133456a67 | James DeFelice | remove redundant (and incorrect) constraint validation in app model (Show More…) | Apr 3 2017, 4:08 PM |
| Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Line(s) | |||
| 48 | 48 | lazy val validForSingleInstanceApps: Validator[UpgradeStrategy] = validator[UpgradeStrategy] { strategy => | |
|---|---|---|---|
| 49 | 49 | strategy.minimumHealthCapacity should valid(be == 0.0) | |
| 50 | 50 | strategy.maximumOverCapacity should valid(be == 0.0) | |
| 51 | 51 | } | |
| 52 | 52 | ||
| 53 | 53 | val complyWithConstraintRules: Validator[Constraint] = new Validator[Constraint] { | |
| 54 | 54 | import mesosphere.marathon.raml.ConstraintOperator._ | |
| 55 | 55 | override def apply(c: Constraint): Result = { | |
| 56 | def failure(constraintViolation: String, description: Option[String] = None) = | ||
| 57 | Failure(Set(RuleViolation(c, constraintViolation, description))) | ||
| 56 | 58 | if (c.fieldName.isEmpty) { | |
| 57 | Failure(Set(RuleViolation(c, "Missing field", None))) | ||
| 59 | failure(ConstraintRequiresField) | ||
| 58 | 60 | } else { | |
| 59 | 61 | c.operator match { | |
| 60 | 62 | case Unique => | |
| 61 | c.value.fold[Result](Success) { _ => Failure(Set(RuleViolation(c, "Value specified but not used", None))) } | ||
| 63 | c.value.fold[Result](Success) { _ => failure(ConstraintUniqueDoesNotAcceptValue) } | ||
| 62 | 64 | case Cluster => | |
| 63 | 65 | // value is completely optional for CLUSTER | |
| 64 | 66 | Success | |
| 65 | 67 | case GroupBy => | |
| 66 | 68 | if (c.value.fold(true)(i => Try(i.toInt).isSuccess)) { | |
| 67 | 69 | Success | |
| 68 | 70 | } else { | |
| 69 | Failure(Set(RuleViolation( | ||
| 70 | c, | ||
| 71 | "Value was specified but is not a number", | ||
| 72 | Some("GROUP_BY may either have no value or an integer value")))) | ||
| 71 | failure(ConstraintGroupByMustBeEmptyOrInt) | ||
| 73 | 72 | } | |
| 74 | 73 | case MaxPer => | |
| 75 | 74 | if (c.value.fold(false)(i => Try(i.toInt).isSuccess)) { | |
| 76 | 75 | Success | |
| 77 | 76 | } else { | |
| 78 | Failure(Set(RuleViolation( | ||
| 79 | c, | ||
| 80 | "Value was not specified or is not a number", | ||
| 81 | Some("MAX_PER must have an integer value")))) | ||
| 77 | failure(ConstraintMaxPerRequiresInt) | ||
| 82 | 78 | } | |
| 83 | 79 | case Like | Unlike => | |
| 84 | 80 | c.value.fold[Result] { | |
| 85 | Failure(Set(RuleViolation(c, "A regular expression value must be provided", None))) | ||
| 81 | failure(ConstraintLikeAnUnlikeRequireRegexp) | ||
| 86 | 82 | } { p => | |
| 87 | 83 | Try(Pattern.compile(p)) match { | |
| 88 | 84 | case util.Success(_) => Success | |
| 89 | case util.Failure(e) => | ||
| 90 | Failure(Set(RuleViolation( | ||
| 91 | c, | ||
| 92 | s"'$p' is not a valid regular expression", | ||
| 93 | Some(s"$p\n${e.getMessage}")))) | ||
| 85 | case util.Failure(e) => failure(InvalidRegularExpression, Option(e.getMessage)) | ||
| 94 | 86 | } | |
| 95 | 87 | } | |
| 96 | 88 | } | |
| 97 | 89 | } | |
| 98 | 90 | } | |
| 99 | 91 | } | |
| 100 | 92 | ||
| 101 | 93 | val placementStrategyValidator = validator[PodPlacementPolicy] { ppp => | |
| Show All 30 Lines | |||
| 132 | 124 | } | |
| 133 | 125 | } | |
| 134 | 126 | } | |
| 135 | 127 | } | |
| 136 | 128 | ||
| 137 | 129 | object SchedulingValidation extends SchedulingValidation | |
| 138 | 130 | ||
| 139 | 131 | object SchedulingValidationMessages { | |
| 140 | val ConstraintMissingValue = "Missing value" | ||
| 141 | val IllegalConstraintSpecification = "Illegal constraint specification" | ||
| 142 | val ConstraintOperatorInvalid = "Constraint operator must be one of the following UNIQUE, CLUSTER, GROUP_BY, LIKE, MAX_PER or UNLIKE" | ||
| 132 | val ConstraintRequiresField = "missing field for constraint declaration" | ||
| 133 | val InvalidRegularExpression = "is not a valid regular expression" | ||
| 134 | val ConstraintLikeAnUnlikeRequireRegexp = "LIKE and UNLIKE require a non-empty, regular expression value" | ||
| 135 | val ConstraintMaxPerRequiresInt = "MAX_PER requires an integer value" | ||
| 136 | val ConstraintGroupByMustBeEmptyOrInt = "GROUP BY must define an integer value or else no value at all" | ||
| 137 | val ConstraintUniqueDoesNotAcceptValue = "UNIQUE does not accept a value" | ||
| 138 | val IllegalConstraintSpecification = "illegal constraint specification" | ||
| 139 | val ConstraintOperatorInvalid = "operator must be one of the following UNIQUE, CLUSTER, GROUP_BY, LIKE, MAX_PER or UNLIKE" | ||
| 143 | 140 | } | |
| 1 | 1 | package mesosphere.marathon | ||
|---|---|---|---|---|
| 2 | 2 | package state | ||
| 3 | 3 | |||
| 4 | import java.util.regex.Pattern | |||
| 5 | ||||
| 6 | 4 | import com.wix.accord._ | ||
| 7 | 5 | import com.wix.accord.combinators.GeneralPurposeCombinators | ||
| 8 | 6 | import com.wix.accord.dsl._ | ||
| 9 | 7 | import mesosphere.marathon.Protos.Constraint | ||
| 10 | 8 | import mesosphere.marathon.api.serialization._ | ||
| 11 | 9 | import mesosphere.marathon.api.v2.Validation._ | ||
| 12 | 10 | import mesosphere.marathon.api.v2.validation.NetworkValidation | ||
| 13 | 11 | import mesosphere.marathon.core.externalvolume.ExternalVolumes | ||
| 14 | 12 | import mesosphere.marathon.core.health._ | ||
| 15 | 13 | import mesosphere.marathon.core.plugin.PluginManager | ||
| 16 | 14 | import mesosphere.marathon.core.pod.{ HostNetwork, Network } | ||
| 17 | 15 | import mesosphere.marathon.core.readiness.ReadinessCheck | ||
| 18 | 16 | import mesosphere.marathon.plugin.validation.RunSpecValidator | ||
| 19 | 17 | import mesosphere.marathon.raml.{ App, Apps, Resources } | ||
| 20 | 18 | import mesosphere.marathon.state.Container.{ Docker, MesosAppC, MesosDocker } | ||
| 21 | 19 | import mesosphere.marathon.state.VersionInfo._ | ||
| 22 | 20 | import mesosphere.marathon.stream.Implicits._ | ||
| 23 | 21 | import mesosphere.mesos.TaskBuilder | ||
| 24 | 22 | import mesosphere.mesos.protos.{ Resource, ScalarResource } | ||
| 25 | 23 | import org.apache.mesos.{ Protos => mesos } | ||
| 26 | 24 | |||
| 27 | 25 | import scala.concurrent.duration._ | ||
| 28 | import scala.util.Try | |||
| 29 | 26 | |||
| 30 | 27 | case class AppDefinition( | ||
| 31 | 28 | |||
| 32 | 29 | id: PathId, | ||
| 33 | 30 | |||
| 34 | 31 | override val cmd: Option[String] = App.DefaultCmd, | ||
| 35 | 32 | |||
| 36 | 33 | override val args: Seq[String] = App.DefaultArgs, | ||
| ▲ Show 20 Lines • Show All 478 Lines • ▼ Show 20 Line(s) | ||||
| 515 | 512 | isTrue[AppDefinition]("GPU resources only work with the Mesos containerizer") { app => | ||
| 516 | 513 | app.container match { | ||
| 517 | 514 | case Some(_: Docker) => false | ||
| 518 | 515 | case _ => true | ||
| 519 | 516 | } | ||
| 520 | 517 | } and featureEnabled(enabledFeatures, Features.GPU_RESOURCES) | ||
| 521 | 518 | } | ||
| 522 | 519 | |||
| 523 | val complyWithConstraintRules: Validator[Constraint] = new Validator[Constraint] { | |||
| 524 | import Constraint.Operator._ | |||
| 525 | override def apply(c: Constraint): Result = { | |||
| 526 | if (!c.hasField || !c.hasOperator) { | |||
| 527 | Failure(Set(RuleViolation(c, "Missing field and operator", None))) | |||
| 528 | } else { | |||
| 529 | c.getOperator match { | |||
| 530 | case UNIQUE => | |||
| 531 | if (c.hasValue && c.getValue.nonEmpty) { | |||
| 532 | Failure(Set(RuleViolation(c, "Value specified but not used", None))) | |||
| 533 | } else { | |||
| 534 | Success | |||
| 535 | } | |||
| 536 | case CLUSTER => | |||
| 537 | if (c.hasValue && c.getValue.nonEmpty) { | |||
| 538 | Success | |||
| 539 | } else { | |||
| 540 | Failure(Set(RuleViolation(c, "Missing value", None))) | |||
| 541 | } | |||
| 542 | case GROUP_BY => | |||
| 543 | if (!c.hasValue || (c.hasValue && c.getValue.nonEmpty && Try(c.getValue.toInt).isSuccess)) { | |||
| 544 | Success | |||
| 545 | } else { | |||
| 546 | Failure(Set(RuleViolation( | |||
| 547 | c, | |||
| 548 | "Value was specified but is not a number", | |||
| 549 | Some("GROUP_BY may either have no value or an integer value")))) | |||
| 550 | } | |||
| 551 | case LIKE | UNLIKE => | |||
| 552 | if (c.hasValue) { | |||
| 553 | Try(Pattern.compile(c.getValue)) match { | |||
| 554 | case scala.util.Success(_) => | |||
| 555 | Success | |||
| 556 | case scala.util.Failure(e) => | |||
| 557 | Failure(Set(RuleViolation( | |||
| 558 | c, | |||
| 559 | s"'${c.getValue}' is not a valid regular expression", | |||
| 560 | Some(s"${c.getValue}\n${e.getMessage}")))) | |||
| 561 | } | |||
| 562 | } else { | |||
| 563 | Failure(Set(RuleViolation(c, "A regular expression value must be provided", None))) | |||
| 564 | } | |||
| 565 | case MAX_PER => | |||
| 566 | if (c.hasValue && c.getValue.nonEmpty && Try(c.getValue.toInt).isSuccess) { | |||
| 567 | Success | |||
| 568 | } else { | |||
| 569 | Failure(Set(RuleViolation( | |||
| 570 | c, | |||
| 571 | "Value was not specified or is not a number", | |||
| 572 | Some("MAX_PER must have an integer value")))) | |||
| 573 | } | |||
| 574 | case _ => | |||
| 575 | Failure(Set( | |||
| 576 | RuleViolation(c, "Operator must be one of UNIQUE, CLUSTER, GROUP_BY, LIKE, MAX_PER or UNLIKE", None))) | |||
| 577 | } | |||
| 578 | } | |||
| 579 | } | |||
| 580 | } | |||
| 581 | ||||
| 582 | 520 | private val haveAtMostOneMesosHealthCheck: Validator[AppDefinition] = | ||
| 583 | 521 | isTrue[AppDefinition]("AppDefinition can contain at most one Mesos health check") { appDef => | ||
| 584 | 522 | // Previous versions of Marathon allowed saving an app definition with more than one command health check, and | ||
| 585 | 523 | // we don't want to make them invalid | ||
| 586 | 524 | (appDef.healthChecks.count(_.isInstanceOf[MesosHealthCheck]) - | ||
| 587 | 525 | appDef.healthChecks.count(_.isInstanceOf[MesosCommandHealthCheck])) <= 1 | ||
| 588 | 526 | } | ||
| 589 | 527 | |||
| Show All 27 Lines | ||||
| 617 | 555 | appDef.acceptedResourceRoles is empty or valid(ResourceRole.validAcceptedResourceRoles(appDef.isResident)) | ||
| 618 | 556 | appDef must complyWithGpuRules(enabledFeatures) | ||
| 619 | 557 | appDef must complyWithMigrationAPI | ||
| 620 | 558 | appDef must complyWithReadinessCheckRules | ||
| 621 | 559 | appDef must complyWithResidencyRules | ||
| 622 | 560 | appDef must complyWithSingleInstanceLabelRules | ||
| 623 | 561 | appDef must complyWithUpgradeStrategyRules | ||
| 624 | 562 | appDef should requireUnreachableDisabledForResidentTasks | ||
| 625 | appDef.constraints.each must complyWithConstraintRules | |||
| 563 | // constraints are only validated in RAML layer | |||
| 626 | 564 | appDef.unreachableStrategy is valid | ||
| 627 | 565 | appDef.networks is valid(NetworkValidation.modelNetworksValidator) | ||
| 628 | 566 | appDef.networks is every(NetworkValidation.modelNetworkValidator) | ||
| 629 | 567 | } and ExternalVolumes.validApp and EnvVarValue.validApp | ||
| 630 | 568 | |||
| 631 | 569 | @SuppressWarnings(Array("TraversableHead")) | ||
| 632 | 570 | private def portIndexIsValid(hostPortsIndices: Range): Validator[HealthCheck] = | ||
| 633 | 571 | isTrue("Health check port indices must address an element of the ports array or container port mappings.") { | ||
| ▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines | ||||
| Show All 12 Lines | |||
| 13 | 13 | "SchedulingValidation" when { | |
|---|---|---|---|
| 14 | 14 | "validating bogus operator" should { | |
| 15 | 15 | "fail with human readable error message" in { | |
| 16 | 16 | validate(Seq("a", "b", "c"))(complyWithAppConstraintRules) should failWith(RuleViolationMatcher( | |
| 17 | 17 | constraint = ConstraintOperatorInvalid | |
| 18 | 18 | )) | |
| 19 | 19 | } | |
| 20 | 20 | } | |
| 21 | "validating CLUSTER constraint" should { | ||
| 22 | 21 | def validAppConstraint(subtitle: String, c: Seq[String]): Unit = { | |
| 23 | 22 | subtitle in { | |
| 24 | 23 | validate(c)(complyWithAppConstraintRules) should be(aSuccess) | |
| 25 | 24 | } | |
| 26 | 25 | } | |
| 27 | 26 | def failsAsExpected(subtitle: String, c: Seq[String], violatedConstraint: String): Unit = { | |
| 28 | 27 | subtitle in { | |
| 29 | 28 | validate(c)(complyWithAppConstraintRules) should failWith(RuleViolationMatcher( | |
| 30 | 29 | constraint = violatedConstraint | |
| 31 | 30 | )) | |
| 32 | 31 | } | |
| 33 | 32 | } | |
| 33 | "validating CLUSTER constraint" should { | ||
| 34 | |||
| 34 | 35 | behave like validAppConstraint("lowercase cluster operator", Seq("foo", "cluster", "bar")) | |
| 35 | 36 | behave like validAppConstraint("CLUSTER hostname field and no value", Seq("hostname", "CLUSTER")) | |
| 36 | 37 | behave like validAppConstraint("CLUSTER hostname field and empty value", Seq("hostname", "CLUSTER", "")) | |
| 37 | 38 | behave like validAppConstraint("CLUSTER hostname field and value", Seq("hostname", "CLUSTER", "somehost")) | |
| 38 | 39 | ||
| 39 | 40 | behave like validAppConstraint("CLUSTER non-hostname field with a value", Seq("attr", "CLUSTER", "foo")) | |
| 40 | 41 | behave like validAppConstraint("CLUSTER non-hostname field w/o value", Seq("a", "CLUSTER")) | |
| 41 | 42 | behave like validAppConstraint("CLUSTER non-hostname field w/ empty value", Seq("a", "CLUSTER")) | |
| 42 | 43 | ||
| 43 | 44 | behave like failsAsExpected("CLUSTER w/ empty field w/ value", Seq("", "CLUSTER", "b"), IllegalConstraintSpecification) | |
| 44 | 45 | behave like failsAsExpected("CLUSTER w/ empty field w/ empty value", Seq("", "CLUSTER", ""), IllegalConstraintSpecification) | |
| 45 | 46 | behave like failsAsExpected("CLUSTER w/ empty field w/o value", Seq("", "CLUSTER"), IllegalConstraintSpecification) | |
| 47 | } | ||
| 48 | |||
| 49 | "validation of other constraints" should { | ||
| 50 | |||
| 51 | val unique = Seq("hostname", "UNIQUE") | ||
| 52 | val groupBy = Seq("rack-id", "GROUP_BY") | ||
| 53 | val like = Seq("rack-id", "LIKE") | ||
| 54 | val unlike = Seq("rack-id", "UNLIKE") | ||
| 55 | val max_per = Seq("rack-id", "MAX_PER") | ||
| 56 | |||
| 57 | behave like validAppConstraint("A UNIQUE constraint without a value", unique) | ||
| 58 | behave like failsAsExpected("A UNIQUE constraint with a value", unique :+ "a", ConstraintUniqueDoesNotAcceptValue) | ||
| 59 | |||
| 60 | behave like validAppConstraint("A GROUP_BY without a value", groupBy) | ||
| 61 | behave like validAppConstraint("A GROUP_BY with a numeric value", groupBy :+ "123") | ||
| 62 | behave like failsAsExpected("A GROUP_BY with a non-numeric value", groupBy :+ "AbcDZ", ConstraintGroupByMustBeEmptyOrInt) | ||
| 63 | |||
| 64 | behave like failsAsExpected("A MAX_PER without a value", max_per, ConstraintMaxPerRequiresInt) | ||
| 65 | behave like validAppConstraint("A MAX_PER with a numeric value", max_per :+ "123") | ||
| 66 | behave like failsAsExpected("A MAX_PER with a non-numeric value", max_per :+ "AbcDZ", ConstraintMaxPerRequiresInt) | ||
| 67 | |||
| 68 | Seq(like, unlike).foreach { op => | ||
| 69 | behave like failsAsExpected(s"A ${op(1)} without a value", op, ConstraintLikeAnUnlikeRequireRegexp) | ||
| 70 | behave like validAppConstraint(s"A ${op(1)} with a valid regex", op :+ ".*") | ||
| 71 | behave like failsAsExpected(s"A ${op(1)} with an invalid regex", op :+ "*", InvalidRegularExpression) | ||
| 72 | } | ||
| 46 | 73 | } | |
| 47 | 74 | } | |
| 48 | 75 | } | |
| 1 | 1 | package mesosphere.marathon | |
|---|---|---|---|
| 2 | 2 | package api.validation | |
| 3 | 3 | ||
| 4 | 4 | import com.wix.accord.validate | |
| 5 | 5 | import mesosphere.UnitTest | |
| 6 | import mesosphere.marathon.Protos.Constraint | ||
| 7 | 6 | import mesosphere.marathon.api.v2.AppNormalization | |
| 8 | 7 | import mesosphere.marathon.api.v2.Validation._ | |
| 9 | 8 | import mesosphere.marathon.api.v2.validation.AppValidation | |
| 10 | 9 | import mesosphere.marathon.core.health.{ MarathonHttpHealthCheck, MesosCommandHealthCheck } | |
| 11 | 10 | import mesosphere.marathon.core.plugin.{ PluginDefinitions, PluginManager } | |
| 12 | 11 | import mesosphere.marathon.core.pod.{ HostNetwork, Network } | |
| 13 | 12 | import mesosphere.marathon.core.readiness.ReadinessCheck | |
| 14 | 13 | import mesosphere.marathon.raml.{ App, Apps, Raml, Resources } | |
| ▲ Show 20 Lines • Show All 533 Lines • ▼ Show 20 Line(s) | |||
| 548 | 547 | Given("a normal app with a defined readinessCheck") | |
| 549 | 548 | val app = AppDefinition( | |
| 550 | 549 | id = PathId("/test"), | |
| 551 | 550 | cmd = Some("true"), | |
| 552 | 551 | readinessChecks = Seq(ReadinessCheck())) | |
| 553 | 552 | ||
| 554 | 553 | Then("validation fails") | |
| 555 | 554 | validAppDefinition(app).isFailure shouldBe true | |
| 556 | } | ||
| 557 | |||
| 558 | "validation of constraints" in { | ||
| 559 | import Constraint.Operator._ | ||
| 560 | |||
| 561 | val unique = Constraint.newBuilder.setField("hostname").setOperator(UNIQUE) | ||
| 562 | val cluster = Constraint.newBuilder.setField("rack-id").setOperator(CLUSTER) | ||
| 563 | val groupBy = Constraint.newBuilder.setField("rack-id").setOperator(GROUP_BY) | ||
| 564 | val like = Constraint.newBuilder.setField("rack-id").setOperator(LIKE) | ||
| 565 | val unlike = Constraint.newBuilder.setField("rack-id").setOperator(UNLIKE) | ||
| 566 | val max_per = Constraint.newBuilder.setField("rack-id").setOperator(MAX_PER) | ||
| 567 | |||
| 568 | Given("no constraints") | ||
| 569 | val app = AppDefinition( | ||
| 570 | id = PathId("/test"), | ||
| 571 | cmd = Some("true"), | ||
| 572 | constraints = Set()) | ||
| 573 | Then("validation succeeds") | ||
| 574 | validAppDefinition(app).isSuccess shouldBe true | ||
| 575 | |||
| 576 | Given("A UNIQUE constraint without a value") | ||
| 577 | val appUnique = app.copy(constraints = Set(unique.build())) | ||
| 578 | Then("validation succeeds") | ||
| 579 | validAppDefinition(appUnique).isSuccess shouldBe true | ||
| 580 | |||
| 581 | Given("A UNIQUE constraint with a value") | ||
| 582 | val appUniqueValue = app.copy(constraints = Set(unique.setValue("a").build())) | ||
| 583 | Then("validation fails") | ||
| 584 | validAppDefinition(appUniqueValue).isFailure shouldBe true | ||
| 585 | |||
| 586 | Given("A CLUSTER constraint without a value") | ||
| 587 | val appClusterNoValue = app.copy(constraints = Set(cluster.build())) | ||
| 588 | Then("validation fails") | ||
| 589 | validAppDefinition(appClusterNoValue).isFailure shouldBe true | ||
| 590 | |||
| 591 | Given("A CLUSTER constraint with a value") | ||
| 592 | val appCluster = app.copy(constraints = Set(cluster.setValue("abc").build())) | ||
| 593 | Then("validation succeeds") | ||
| 594 | validAppDefinition(appCluster).isSuccess shouldBe true | ||
| 595 | |||
| 596 | Given("A GROUP_BY without a value") | ||
| 597 | val appGroupByNoValue = app.copy(constraints = Set(groupBy.build())) | ||
| 598 | Then("validation succeeds") | ||
| 599 | validAppDefinition(appGroupByNoValue).isSuccess shouldBe true | ||
| 600 | |||
| 601 | Given("A GROUP_BY with a numeric value") | ||
| 602 | val appGroupByNumericValue = app.copy(constraints = Set(groupBy.setValue("123").build())) | ||
| 603 | Then("validation succeeds") | ||
| 604 | validAppDefinition(appGroupByNumericValue).isSuccess shouldBe true | ||
| 605 | |||
| 606 | Given("A GROUP_BY with a non-numeric value") | ||
| 607 | val appGroupByNonNumericValue = app.copy(constraints = Set(groupBy.setValue("AbcDZ").build())) | ||
| 608 | Then("validation fails") | ||
| 609 | validAppDefinition(appGroupByNonNumericValue).isFailure shouldBe true | ||
| 610 | |||
| 611 | Given("A MAX_PER with a numeric value") | ||
| 612 | val appMaxPerNumericValue = app.copy(constraints = Set(max_per.setValue("123").build())) | ||
| 613 | Then("validation succeeds") | ||
| 614 | validAppDefinition(appMaxPerNumericValue).isSuccess shouldBe true | ||
| 615 | |||
| 616 | Given("A MAX_PER with a non-numeric value") | ||
| 617 | val appMaxPerNonNumericValue = app.copy(constraints = Set(max_per.setValue("AbcDZ").build())) | ||
| 618 | Then("validation fails") | ||
| 619 | validAppDefinition(appMaxPerNonNumericValue).isFailure shouldBe true | ||
| 620 | |||
| 621 | Seq(like, unlike).foreach { op => | ||
| 622 | Given(s"A ${op.getOperator} without a value") | ||
| 623 | val appOpNoValue = app.copy(constraints = Set(op.build())) | ||
| 624 | Then("validation fails") | ||
| 625 | validAppDefinition(appOpNoValue).isFailure shouldBe true | ||
| 626 | |||
| 627 | Given(s"A ${op.getOperator} with a valid regex") | ||
| 628 | val appOpRegex = app.copy(constraints = Set(op.setValue(".*").build())) | ||
| 629 | Then("validation succeeds") | ||
| 630 | validAppDefinition(appOpRegex).isSuccess shouldBe true | ||
| 631 | |||
| 632 | Given(s"A ${op.getOperator} with an invalid regex") | ||
| 633 | val appOpBadRegex = app.copy(constraints = Set(op.setValue("*").build())) | ||
| 634 | Then("validation fails") | ||
| 635 | validAppDefinition(appOpBadRegex).isFailure shouldBe true | ||
| 636 | } | ||
| 637 | 555 | } | |
| 638 | 556 | ||
| 639 | 557 | "Resident app may only define unreserved acceptedResourceRoles or None" in { | |
| 640 | 558 | Given("A resident app definition") | |
| 641 | 559 | val f = new Fixture | |
| 642 | 560 | val from = f.validResident | |
| 643 | 561 | ||
| 644 | 562 | When("validating with role for static reservation") | |
| ▲ Show 20 Lines • Show All 211 Lines • Show Last 20 Lines | |||
I only see a reference to mesosphere/marathon/api/v2/validation/SchedulingValidation.scala:112 ??
Where do we use the constraints validator?