def test_shouldParseOptionValuesAndRemoveNameBeforePassingThemOn(fixture): schedOptInfo, syncerOptInfo = object(), object() sched = fakeConfigurable("sched", availableOptions=[schedOptInfo]) syncer = fakeConfigurable("syncer", availableOptions=[syncerOptInfo]) oldRuleOpts = {"Opt": "abc"} oldSchedOpts, oldSyncerOpts = {"Name": "sched", "N": "2"}, \ {"Name": "syncer", "A": "yes"} newSchedOpts, newSyncerOpts = {"N": 2}, {"A": True} fixture.parser.expectCallsInAnyOrder( mock.callMatching("parseOptions", lambda infos, opts: opts == dict(N="2") and infos[0] is schedOptInfo, ret=newSchedOpts), mock.callMatching("parseOptions", lambda infos, opts: opts == dict(A="yes") and infos[ 0] is syncerOptInfo, ret=newSyncerOpts), mock.callMatching("parseOptions", lambda infos, opts: opts == oldRuleOpts and infos is syncrule.AvailableOptions, ret=oldRuleOpts)) fixture.ruleFactory.expectCalls( mock.callMatchingTuple( "build", lambda args: args[3] == oldRuleOpts and args[4] == newSchedOpts and args[5] == mkSyncerOpts(**newSyncerOpts))) fixture.makeReader([sched], [syncer]).readRule("name", oldRuleOpts, oldSchedOpts, oldSyncerOpts, True)
def test_shouldTreatLocsCorrespondingToPortsAsMinimumOptions(fixture): def locOptInfo(number): return optInfo("Loc" + str(number), types.Location) sched = fakeConfigurable("scheduler") syncer = fakeConfigurable("synchronizer", ports=[port(), port(), port(), port()], availableOptions=[ locOptInfo(1), locOptInfo(2), locOptInfo(3), locOptInfo(4) ]) loc1Through3 = { "Loc1": loc("/some-place"), "Loc2": loc("/place"), "Loc3": loc("/bar") } with pytest.raises(ConfigConsistencyException) as ex: fixture.factory.build("rulename", sched, syncer, {}, {}, mkSyncerOpts(**loc1Through3), True) strToTest(str(ex.value)).shouldIncludeInOrder("not", "minimum opt").andAlso.\ shouldInclude("Loc4") with noException(): fixture.factory.build( "rule", sched, syncer, {}, {}, mkSyncerOpts(Loc4=loc("/fourth"), **loc1Through3), True)
def test_shouldFindSyncersAndSchedsByTheirNameOptions(fixture): sched = fakeConfigurable("sched-b") syncer = fakeConfigurable("syncer") fixture.parser.parseOptions = lambda _, opts: opts fixture.ruleFactory.expectCalls( mock.callMatching( "build", lambda name, receivedSched, receivedSyncer, *_: name == "sys" and receivedSched is sched and receivedSyncer is syncer)) reader = fixture.makeReader([fakeConfigurable("sched-a"), sched], [syncer]) reader.readRule("sys", {}, {"Name": "sched-b"}, {"Name": "syncer"}, False)
def test_shouldAddLocOptInfosToAvailableOptionsBasedOnPorts(): wrapped = fakeConfigurable("syncer", ports=[port(), port(), port()], availableOptions=[]) syncer = DefaultValueSynchronizer(wrapped) iterToTest(syncer.availableOptions).shouldContainMatching( lambda opt: opt.name == "Loc1" and opt.optionType == types.Location, lambda opt: opt.name == "Loc2", lambda opt: opt.name == "Loc3")
def test_shouldFailIfSyncersOrSchedsWithNamesOrNameOptionsThemselvesAreNotThere( fixture): scheduler = fakeConfigurable("the-sched") synchronizer = fakeConfigurable("the-syncer") reader = fixture.makeReader([scheduler], [synchronizer]) with pytest.raises(ConfigurableNotFoundException) as ex: reader.readRule("rule", {}, {}, {"Name": "synchronizer"}, True) assert strToTest(ex.value.message).shouldIncludeInOrder("option", "not") with pytest.raises(ConfigurableNotFoundException): reader.readRule("name", {}, {"Name": "no"}, {"Name": "the-syncer"}, False) with pytest.raises(ConfigurableNotFoundException) as ex: reader.readRule("name", {}, {"Name": "the-sched"}, {"Name": "no"}, False) assert ex.value.unitName == "no" assert ex.value.unitType == "synchronizer"
def test_shouldThrowExceptionIfAnOptionIsNotSupported(fixture): scheduler = fakeConfigurable("sched", availableOptions=[optInfo("sched-supported")]) synchronizer = fakeConfigurable( "syncer", ports=[], availableOptions=[optInfo("syncer-supported")]) def callBuild(ruleOptions, schedulerOptions, synchronizerOptions): fixture.factory.build("rule", scheduler, synchronizer, ruleOptions, schedulerOptions, mkSyncerOpts(**synchronizerOptions), True) with pytest.raises(ConfigConsistencyException): callBuild({}, {"sched-supported": 1}, {"not": 1}) with pytest.raises(ConfigConsistencyException): callBuild({}, {"not": 1}, {"syncer-supported": 1}) with noException(): callBuild({}, {"sched-supported": 1}, {"syncer-supported": 1}) with pytest.raises(ConfigConsistencyException): callBuild({"Blah": 2}, {"sched-supported": 1}, {"syncer-supported": 1})
def test_shouldWrapAllParseExceptionsItGetsInAConsistencyEx(fixture): def fail(_, opts): if "A" not in opts or opts["A"] == "3": raise OptionParseException( ["rule-foo" if "A" not in opts else "sched-bar"]) return True sched, syncer = fakeConfigurable("sched"), fakeConfigurable("syncer") fixture.parser.expectCalls( mock.callMatching("parseOptions", fail, anyNumber=True, ret={})) with pytest.raises(ConfigConsistencyException) as ex: fixture.makeReader([sched], [syncer]).readRule("rule", {}, { "Name": "sched", "A": "3" }, { "Name": "syncer", "A": "0" }, False) strToTest(ex.value.message).shouldIncludeInOrder("[Scheduler]", "sched-bar").\ andAlso.shouldIncludeInOrder("[Rule]", "rule-foo").andAlso.\ shouldNotInclude("[Synchronizer]")
def test_shouldThrowExceptionIfRuleNameContainsInvalidCharacters(fixture): with pytest.raises(RuleNameInvalidException) as ex: fixture.factory.build("foo@with space", fakeConfigurable("sched"), fakeConfigurable("syncer", ports=[]), {}, {}, mkSyncerOpts(), False) assert ex.value.invalidCharacter == " "
def buildRuleWithNoOpts(self): return self.factory.build("name", fakeConfigurable(), fakeConfigurable(ports=[]), {}, {}, mkSyncerOpts(), False)
def ruleWith(**kwargs): ret = mockRule(**kwargs) ret.scheduler, ret.synchronizer = fakeConfigurable(), fakeConfigurable() return ret