exploration.tests.test_core

   1"""
   2Authors: Peter Mawhorter
   3Consulted:
   4Date: 2022-3-12
   5Purpose: Tests for the core functionality and types.
   6"""
   7
   8from typing import Optional, Union, Iterable, Tuple, Literal
   9
  10import json
  11import copy
  12
  13import pytest
  14
  15from .. import base
  16from .. import core
  17from .. import parsing
  18
  19
  20@pytest.fixture
  21def pf() -> parsing.ParseFormat:
  22    """
  23    A fixture that provides the default `parsing.ParseFormat`.
  24    """
  25    return parsing.ParseFormat()
  26
  27
  28@pytest.fixture
  29def trc() -> base.RequirementContext:
  30    """
  31    A fixture providing an empty requirement context.
  32    """
  33    baseGraph = core.DecisionGraph.example('simple')
  34    # Has nodes A/B/C in a triangle with "next"/"prev" transitions
  35    baseState = base.emptyState()
  36    # Set up node A as the current position
  37    baseState['common']['focalization']['main'] = 'singular'
  38    baseState['common']['activeDomains'] = { 'main' }
  39    baseState['common']['activeDecisions']['main'] = 0
  40    baseState['primaryDecision'] = 0  # A
  41    return base.RequirementContext(
  42        state=baseState,
  43        graph=baseGraph,
  44        searchFrom=set()
  45    )
  46
  47
  48def rcWith(
  49    original: base.RequirementContext,
  50    where: Optional[Iterable[base.AnyDecisionSpecifier]] = None,
  51    eq: Optional[
  52        Iterable[
  53            Tuple[
  54                base.Requirement,
  55                Union[
  56                    base.Capability,
  57                    Tuple[base.MechanismID, base.MechanismState]
  58                ]
  59            ]
  60        ]
  61    ] = None,
  62    **kwargs: Union[
  63        bool,
  64        base.TokenCount,
  65        base.MechanismState,
  66        Tuple[Literal['skill'], int],
  67        Tuple[Literal['tag'], base.TagValue]
  68    ]
  69):
  70    """
  71    Clones the given `base.RequirementContext` and returns a clone with
  72    additional powers, tokens, and/or mechanism states set according to
  73    keyword arguments provided, where the type of each value determines
  74    what is being changed: True/False sets a `base.Capability`, an
  75    integer sets a `base.Token`'s count, and a string sets the state of
  76    the named mechanism. Tuples starting with 'skill' (followed by an
  77    integer) or "tag" (followed by any kind of tag value) set up skill
  78    levels or tags.
  79
  80    Capabilities, tokens, and skills are set up in the common focal
  81    context.
  82
  83    Tags values are added to the current primary decision, and mechanism
  84    states  are set for the mechanism found via mechanism search for
  85    that name (default is global search).
  86
  87    In addition to changing token, capability, and/or mechanism states,
  88    a new search from location set can be provided via the `where`, and
  89    a list of new equivalences can be provided via the `eq` argument.
  90    """
  91    if where is not None:
  92        searchFrom = set(
  93            original.graph.resolveDecision(x) for x in where
  94        )
  95    else:
  96        searchFrom = copy.deepcopy(original.searchFrom)
  97
  98    newState = copy.deepcopy(original.state)
  99    newGraph = copy.deepcopy(original.graph)
 100
 101    if eq is not None:
 102        for (req, equivalentTo) in eq:
 103            newGraph.addEquivalence(req, equivalentTo)
 104
 105    commonFC = newState['common']
 106
 107    for kw in kwargs:
 108        val = kwargs[kw]
 109        if isinstance(val, bool):
 110            if val:
 111                commonFC['capabilities']['capabilities'].add(kw)
 112            else:
 113                try:
 114                    commonFC['capabilities']['capabilities'].remove(kw)
 115                except KeyError:
 116                    pass
 117
 118        elif isinstance(val, base.TokenCount):
 119            commonFC['capabilities']['tokens'][kw] = val
 120
 121        elif isinstance(val, base.MechanismState):
 122            mID = original.graph.resolveMechanism(kw, original.searchFrom)
 123            newState['mechanisms'][mID] = val
 124
 125        elif (
 126            isinstance(val, tuple)
 127        and len(val) == 2
 128        and val[0] == 'skill'
 129        and isinstance(val[1], int)
 130        ):
 131            commonFC['capabilities']['skills'][kw] = val[1]
 132
 133        elif (
 134            isinstance(val, tuple)
 135        and len(val) == 2
 136        and val[0] == 'tag'
 137        ):
 138            pr = original.state['primaryDecision']
 139            if pr is None:
 140                raise ValueError(
 141                    "Base context has no primary decision so we can't"
 142                    " tag anything."
 143                )
 144            newGraph.tagDecision(pr, kw, val[1])
 145
 146        else:
 147            raise ValueError(f"Invalid context addition value: {val!r}")
 148
 149    return base.RequirementContext(
 150        state=newState,
 151        graph=newGraph,
 152        searchFrom=searchFrom
 153    )
 154
 155
 156def test_Requirements(pf, trc) -> None:
 157    """
 158    Multi-method test for `exploration.core.Requirement` and sub-classes.
 159    """
 160    # Tests of comparison
 161    r: base.Requirement = base.ReqAll([
 162        base.ReqAny([base.ReqCapability('p1'), base.ReqCapability('p2')]),
 163        base.ReqTokens('key', 1)
 164    ])
 165    r2: base.Requirement = base.ReqAll([
 166        base.ReqAny([base.ReqCapability('p1'), base.ReqCapability('p2')]),
 167        base.ReqTokens('key', 1)
 168    ])
 169    assert r == r2
 170    assert base.ReqNothing() == base.ReqNothing()
 171    assert base.ReqImpossible() == base.ReqImpossible()
 172
 173    # Tests of satisfied
 174    assert not r.satisfied(trc)
 175    assert r.satisfied(rcWith(trc, p1=True, key=1))
 176    assert not r.satisfied(rcWith(trc, key=1))
 177    assert not r.satisfied(rcWith(trc, p1=True, key=0))
 178    assert not r.satisfied(rcWith(trc, p1=True))
 179    assert r.satisfied(
 180        rcWith(trc, p1=True, p2=True, key=2)
 181    )
 182
 183    r = base.ReqAny([
 184        base.ReqAll([base.ReqCapability('p1'), base.ReqCapability('p2')]),
 185        base.ReqTokens('key', 3)
 186    ])
 187    assert r.satisfied(rcWith(trc, p1=True, key=3))
 188    assert not r.satisfied(rcWith(trc, key=1))
 189    assert not r.satisfied(rcWith(trc, p2=True, key=0))
 190    assert not r.satisfied(rcWith(trc, p1=True))
 191    assert r.satisfied(rcWith(trc, p1=True, p2=True))
 192    assert r.satisfied(rcWith(trc, p1=True, p2=True, key=2))
 193    assert r.satisfied(rcWith(trc, p1=True, p2=True, key=5))
 194    assert r.satisfied(rcWith(trc, key=5))
 195
 196    assert not base.hasCapabilityOrEquivalent('p3', trc)
 197    assert base.hasCapabilityOrEquivalent('p3', rcWith(trc, p3=True))
 198    p2IsP3 = rcWith(trc, eq=[(base.ReqCapability('p2'), 'p3')])
 199    assert not base.hasCapabilityOrEquivalent('p3', p2IsP3)
 200    assert base.hasCapabilityOrEquivalent('p3', rcWith(p2IsP3, p2=True))
 201    assert base.hasCapabilityOrEquivalent('p3', rcWith(p2IsP3, p3=True))
 202    assert not base.hasCapabilityOrEquivalent('p2', rcWith(p2IsP3, p3=True))
 203
 204    assert base.ReqCapability('p3').satisfied(rcWith(p2IsP3, p2=True))
 205    r = base.ReqAll(
 206        [base.ReqCapability('p1'), base.ReqCapability('p3')]
 207    )
 208    assert r.satisfied(rcWith(p2IsP3, p1=True, p2=True))
 209    assert not r.satisfied(rcWith(p2IsP3, p2=True))
 210    assert not r.satisfied(rcWith(p2IsP3, p1=True))
 211    assert not r.satisfied(rcWith(p2IsP3, p3=True))
 212    assert r.satisfied(rcWith(p2IsP3, p1=True, p3=True))
 213
 214    r = base.ReqImpossible()
 215    assert not r.satisfied(trc)
 216
 217    r = base.ReqNothing()
 218    assert r.satisfied(trc)
 219
 220    r = base.ReqNot(
 221        base.ReqAll([base.ReqCapability('p1'), base.ReqCapability('p2')])
 222    )
 223    assert r.satisfied(trc)
 224    assert r.satisfied(rcWith(trc, p1=True))
 225    assert r.satisfied(rcWith(trc, p2=True))
 226    assert not r.satisfied(rcWith(trc, p1=True, p2=True))
 227    assert not r.satisfied(rcWith(p2IsP3, p1=True, p2=True))
 228    r = base.ReqNot(
 229        base.ReqAll([base.ReqCapability('p1'), base.ReqCapability('p3')])
 230    )
 231    assert r.satisfied(p2IsP3)
 232    assert not r.satisfied(rcWith(p2IsP3, p1=True, p2=True))
 233    assert not r.satisfied(rcWith(p2IsP3, p1=True, p3=True))
 234    assert r.satisfied(rcWith(p2IsP3, p1=True))
 235    assert r.satisfied(rcWith(p2IsP3, p2=True))
 236    assert r.satisfied(rcWith(p2IsP3, p3=True))
 237
 238    # Mechanism requirements
 239    withSwitch = copy.deepcopy(trc)
 240    withSwitch.graph.addMechanism('switch', 0)  # at A
 241    r = base.ReqMechanism('switch', 'on')
 242    assert not r.satisfied(withSwitch)
 243    assert not r.satisfied(rcWith(withSwitch, switch="off"))
 244    assert r.satisfied(rcWith(withSwitch, switch="on"))
 245
 246    leverNearby = copy.deepcopy(trc)
 247    leverNearby.graph.addMechanism('lever', 1)  # at B
 248    r = base.ReqMechanism('lever', 'pulled')
 249    assert not r.satisfied(leverNearby)
 250    assert not r.satisfied(rcWith(leverNearby, lever="default"))
 251    assert r.satisfied(rcWith(leverNearby, lever="pulled"))
 252
 253    # Mechanism requirement w/ decision ID
 254    switchAt0 = base.MechanismSpecifier(None, None, 0, 'switch')
 255    switchAt1 = base.MechanismSpecifier(None, None, 1, 'switch')
 256    r = base.ReqMechanism(switchAt0, 'on')
 257    assert not r.satisfied(withSwitch)
 258    assert r.satisfied(rcWith(withSwitch, switch="on"))
 259
 260    # 'switch' at different specific decision won't search
 261    r2 = base.ReqMechanism(switchAt1, 'on')
 262    assert not r.satisfied(withSwitch)
 263    assert r.satisfied(rcWith(withSwitch, switch="on"))
 264
 265    # Skill level requirements
 266    r = base.ReqLevel('skill', 1)
 267    r2 = base.ReqNot(base.ReqLevel('skill', 2))
 268    assert not r.satisfied(trc)
 269    assert not r.satisfied(rcWith(trc, skill=("skill", 0)))
 270    assert r.satisfied(rcWith(trc, skill=("skill", 1)))
 271    assert r.satisfied(rcWith(trc, skill=("skill", 2)))
 272    assert r.satisfied(rcWith(trc, skill=("skill", 10)))
 273    assert r2.satisfied(rcWith(trc, skill=("skill", 1)))
 274    assert not r2.satisfied(rcWith(trc, skill=("skill", 2)))
 275    assert not r2.satisfied(rcWith(trc, skill=("skill", 10)))
 276
 277    # Tag requirements
 278    r = base.ReqTag('tag', 1)
 279    r2 = base.ReqTag('tag2', 'value')
 280    assert not r.satisfied(trc)
 281    assert not r2.satisfied(trc)
 282    tagged = rcWith(trc, tag=("tag", 1))
 283    assert tagged.graph.decisionTags(0) == {'tag': 1}
 284    assert r.satisfied(tagged)
 285    assert not r.satisfied(rcWith(trc, tag=("tag", 2)))
 286    assert not r.satisfied(rcWith(trc, tag=("tag", 0)))
 287    assert r2.satisfied(rcWith(trc, tag2=("tag", 'value')))
 288    taggedAside = copy.deepcopy(trc)
 289    taggedAside.graph.tagDecision(1, 'tag', 1)
 290    taggedAside.graph.tagDecision(2, 'tag2', 'value')
 291    assert not r.satisfied(taggedAside)
 292    assert not r2.satisfied(taggedAside)
 293    taggedAside.state['common']['activeDecisions']['main'] = 1
 294    assert r.satisfied(taggedAside)
 295    assert not r2.satisfied(taggedAside)
 296    taggedAside.state['common']['activeDecisions']['main'] = 2
 297    assert not r.satisfied(taggedAside)
 298    assert r2.satisfied(taggedAside)
 299    zoneTagged = copy.deepcopy(trc)
 300    zoneTagged.graph.createZone('zone')
 301    zoneTagged.graph.addDecisionToZone(0, 'zone')
 302    zoneTagged.graph.tagZone('zone', 'tag', 1)
 303    assert r.satisfied(zoneTagged)
 304    assert not r2.satisfied(zoneTagged)
 305    zoneTagged.graph.removeDecisionFromZone(0, 'zone')
 306    assert not r.satisfied(zoneTagged)
 307
 308    # Tests of parsing:
 309    assert pf.parseRequirement('a') == base.ReqCapability('a')
 310
 311    assert pf.parseRequirement('(a)') == base.ReqCapability('a')
 312
 313    assert pf.parseRequirement('a*5') == base.ReqTokens('a', 5)
 314
 315    assert pf.parseRequirement('((a*5))') == base.ReqTokens('a', 5)
 316
 317    assert pf.parseRequirement('(a|b)&c*3') == base.ReqAll([
 318        base.ReqAny([base.ReqCapability('a'), base.ReqCapability('b')]),
 319        base.ReqTokens('c', 3)
 320    ])
 321
 322    assert pf.parseRequirement(' ( a | b )\t& c * 3 ') == base.ReqAll([
 323        base.ReqAny([base.ReqCapability('a'), base.ReqCapability('b')]),
 324        base.ReqTokens('c', 3)
 325    ])
 326
 327    assert pf.parseRequirement('a|(b&c*3)') == base.ReqAny([
 328        base.ReqCapability('a'),
 329        base.ReqAll([base.ReqCapability('b'), base.ReqTokens('c', 3)]),
 330    ])
 331
 332    assert pf.parseRequirement('a|b&c*3') == base.ReqAny([
 333        base.ReqCapability('a'),
 334        base.ReqAll([base.ReqCapability('b'), base.ReqTokens('c', 3)]),
 335    ])
 336
 337    assert pf.parseRequirement('a&b|c*3') == base.ReqAny([
 338        base.ReqAll([base.ReqCapability('a'), base.ReqCapability('b')]),
 339        base.ReqTokens('c', 3)
 340    ])
 341
 342    assert pf.parseRequirement('a|b|c') == base.ReqAny([
 343        base.ReqCapability('a'),
 344        base.ReqCapability('b'),
 345        base.ReqCapability('c'),
 346    ])
 347
 348    assert pf.parseRequirement('a&b&c&d') == base.ReqAll([
 349        base.ReqCapability('a'),
 350        base.ReqCapability('b'),
 351        base.ReqCapability('c'),
 352        base.ReqCapability('d'),
 353    ])
 354
 355    assert pf.parseRequirement('a&b|c&d') == base.ReqAny([
 356        base.ReqAll([
 357            base.ReqCapability('a'),
 358            base.ReqCapability('b')
 359        ]),
 360        base.ReqAll([
 361            base.ReqCapability('c'),
 362            base.ReqCapability('d')
 363        ])
 364    ])
 365
 366    assert pf.parseRequirement('a&!b|!c&d') == base.ReqAny([
 367        base.ReqAll([
 368            base.ReqCapability('a'),
 369            base.ReqNot(base.ReqCapability('b'))
 370        ]),
 371        base.ReqAll([
 372            base.ReqNot(base.ReqCapability('c')),
 373            base.ReqCapability('d')
 374        ])
 375    ])
 376
 377    assert pf.parseRequirement('!(a|b)&c') == base.ReqAll([
 378        base.ReqNot(
 379            base.ReqAny([base.ReqCapability('a'), base.ReqCapability('b')])
 380        ),
 381        base.ReqCapability('c')
 382    ])
 383
 384    assert pf.parseRequirement('!a&b&c') == base.ReqAll([
 385        base.ReqNot(base.ReqCapability('a')),
 386        base.ReqCapability('b'),
 387        base.ReqCapability('c')
 388    ])
 389
 390    assert pf.parseRequirement('!(a&b)&c') == base.ReqAll([
 391        base.ReqNot(
 392            base.ReqAll([base.ReqCapability('a'), base.ReqCapability('b')])
 393        ),
 394        base.ReqCapability('c')
 395    ])
 396
 397    assert pf.parseRequirement('!c*3') == base.ReqNot(base.ReqTokens('c', 3))
 398
 399    assert pf.parseRequirement('X') == base.ReqImpossible()
 400
 401    assert pf.parseRequirement('O') == base.ReqNothing()
 402
 403    assert pf.parseRequirement('X|a') == base.ReqAny([
 404        base.ReqImpossible(),
 405        base.ReqCapability('a')
 406    ])
 407
 408    assert pf.parseRequirement('door:open') == base.ReqMechanism('door', 'open')
 409
 410    assert pf.parseRequirement('z::d::door:open') == base.ReqMechanism(
 411        base.MechanismSpecifier(None, 'z', 'd', 'door'),
 412        'open'
 413    )
 414
 415    assert pf.parseRequirement('3::door:open') == base.ReqMechanism(
 416        base.MechanismSpecifier(None, None, 3, 'door'),
 417        'open'
 418    )
 419
 420    with pytest.raises(parsing.ParseError):
 421        pf.parseRequirement('a*3*2')
 422
 423    with pytest.raises(parsing.ParseError):
 424        pf.parseRequirement('(a):2')
 425
 426    with pytest.raises(parsing.ParseError):
 427        pf.parseRequirement('(a|b&c):3')
 428
 429    with pytest.raises(parsing.ParseError):
 430        pf.parseRequirement('a|&b')
 431
 432    with pytest.raises(parsing.ParseError):
 433        pf.parseRequirement('(a|b')
 434
 435    with pytest.raises(parsing.ParseError):
 436        pf.parseRequirement('a|b)')
 437
 438    assert (pf.parseRequirement('a*-3') == base.ReqTokens('a', -3))
 439
 440    with pytest.raises(parsing.ParseError):
 441        pf.parseRequirement('a*!3')
 442
 443    with pytest.raises(parsing.ParseError):
 444        pf.parseRequirement('a!b')
 445
 446    with pytest.raises(parsing.ParseError):
 447        pf.parseRequirement('a*-b')
 448
 449
 450def test_DecisionGraph() -> None:
 451    "Multi-method test for `exploration.core.DecisionGraph`."
 452    m = core.DecisionGraph()
 453    m.addDecision('a')
 454    m.addDecision('b')
 455    m.addDecision('c')
 456    assert len(m) == 3
 457    assert set(m) == {0, 1, 2}
 458
 459    m.addTransition('a', 'East', 'b', 'West')
 460    m.addTransition('a', 'Northeast', 'c')
 461    m.addTransition('c', 'Southeast', 'b')
 462
 463    assert m.destinationsFrom('a') == {'East': 1, 'Northeast': 2}
 464    assert m.destinationsFrom('b') == {'West': 0}
 465    assert m.destinationsFrom('c') == {'Southeast': 1}
 466
 467    assert m.getReciprocal('a', 'East') == 'West'
 468    assert m.getReciprocal('a', 'Northeast') is None
 469    assert m.getReciprocal('b', 'Southwest') is None
 470    assert m.getReciprocal('c', 'Southeast') is None
 471
 472    m.addUnexploredEdge('a', 'South')
 473    m.addUnexploredEdge('b', 'East')
 474    m.addUnexploredEdge('c', 'North')
 475
 476    assert len(m) == 6
 477    assert set(m) == set(range(6))
 478    assert m.namesListing(m) == """\
 479  0 (a)
 480  1 (b)
 481  2 (c)
 482  3 (_u.0)
 483  4 (_u.1)
 484  5 (_u.2)
 485"""
 486    assert (
 487        m.destinationsFrom('a')
 488     == {'East': 1, 'Northeast': 2, 'South': 3}
 489    )
 490    assert (m.destinationsFrom('b') == {'West': 0, 'East': 4})
 491    assert (m.destinationsFrom('c') == {'Southeast': 1, 'North': 5})
 492
 493    m.replaceUnconfirmed('c', 'North', 'd', 'South')
 494    assert m.destinationsFrom('c') == {'Southeast': 1, 'North': 5}
 495    assert m.nameFor(5) == 'd'
 496    assert len(m) == 6
 497    assert set(m) == set(range(6))
 498    assert m.namesListing(m) == """\
 499  0 (a)
 500  1 (b)
 501  2 (c)
 502  3 (_u.0)
 503  4 (_u.1)
 504  5 (d)
 505"""
 506
 507    m.addTransition('d', 'West', 'a', 'North')
 508    assert (
 509        m.destinationsFrom('a')
 510     == {'East': 1, 'Northeast': 2, 'South': 3, 'North': 5}
 511    )
 512    assert (
 513        m.destinationsFrom('d')
 514     == {'West': 0, 'South': 2}
 515    )
 516
 517    with pytest.raises(core.MissingDecisionError):
 518        _ = m.destinationsFrom('z')
 519
 520    with pytest.raises(core.TransitionCollisionError):
 521        m.addTransition('a', 'East', 'b', 'West')
 522
 523    with pytest.raises(core.TransitionCollisionError):
 524        m.addTransition('c', 'East', 'b', 'West')
 525
 526    with pytest.raises(core.TransitionCollisionError):
 527        m.addUnexploredEdge('a', 'East')
 528
 529    with pytest.raises(core.TransitionCollisionError):
 530        m.addUnexploredEdge('c', 'North')
 531
 532    with pytest.raises(core.MissingTransitionError):
 533        m.replaceUnconfirmed('a', 'Up', 'z')
 534
 535    with pytest.raises(core.ExplorationStatusError):
 536        m.replaceUnconfirmed('a', 'East', 'z')
 537
 538    assert m.destinationsFrom('c') == {'Southeast': 1, 'North': 5}
 539
 540    m.addTransition('a', 'EastBelow', 'b', 'WestBelow')
 541    assert (m.destinationsFrom('a') == {
 542        'East': 1,
 543        'EastBelow': 1,
 544        'Northeast': 2,
 545        'South': 3,
 546        'North': 5
 547    })
 548    assert (
 549        m.destinationsFrom('b')
 550     == {'West': 0, 'WestBelow': 0, 'East': 4}
 551    )
 552
 553    # Two edges that could be but are not reciprocals
 554    m.addTransition('d', 'East', 'b')
 555    m.addTransition('b', 'North', 'd')
 556    assert (
 557        m.destinationsFrom('b')
 558     == {'West': 0, 'WestBelow': 0, 'East': 4, 'North': 5}
 559    )
 560    assert (
 561        m.destinationsFrom('d')
 562     == {'West': 0, 'South': 2, 'East': 1}
 563    )
 564    assert m.getReciprocal('b', 'North') is None
 565    assert m.getReciprocal('d', 'East') is None
 566
 567    # Establish a reciprocal relationship
 568    m.setReciprocal('b', 'North', 'East')
 569    assert m.getReciprocal('b', 'North') == 'East'
 570    assert m.getReciprocal('d', 'East') == 'North'
 571
 572    with pytest.raises(core.MissingDecisionError):
 573        m.setReciprocal('z', 'Nope', 'None')
 574
 575    with pytest.raises(core.MissingTransitionError):
 576        m.setReciprocal('b', 'Nope', 'None')
 577
 578    # Remove the reciprocal relationship again (from the other side)
 579    m.setReciprocal('d', 'East', None)
 580    assert m.getReciprocal('b', 'North') is None
 581    assert m.getReciprocal('d', 'East') is None
 582
 583    with pytest.raises(core.InvalidDestinationError):
 584        m.setReciprocal('b', 'North', 'West')
 585
 586    with pytest.raises(core.MissingTransitionError):
 587        m.setReciprocal('b', 'North', 'None')
 588
 589    assert (m.isConfirmed("_u.0") is False)
 590    assert (m.isConfirmed("_u.1") is False)
 591    assert (m.isConfirmed("a") is True)
 592    assert (m.isConfirmed("d") is True)
 593
 594    assert (
 595        json.dumps(m.textMapObj(), indent=4)
 596     == """\
 597{
 598    "0::East": {
 599        "1::West": "0",
 600        "1::East": {},
 601        "1::WestBelow": "0",
 602        "1::North": {
 603            "5::South": {
 604                "2::Southeast": "1",
 605                "2::North": "5"
 606            },
 607            "5::West": "0",
 608            "5::East": "1"
 609        }
 610    },
 611    "0::Northeast": "2",
 612    "0::South": {},
 613    "0::North": "5",
 614    "0::EastBelow": "1"
 615}"""
 616    )
 617
 618    assert (
 619        json.dumps(
 620            m.textMapObj(
 621                explorationOrder=(
 622                    0,
 623                    [
 624                        'East',
 625                        'West',
 626                        'Northeast',
 627                        'Southeast',
 628                        'North',
 629                        'West',
 630                        'South',
 631                    ]
 632                )
 633            ),
 634            indent=4
 635        )
 636     == """\
 637{
 638    "0::East": {
 639        "1::West": "0",
 640        "1::North": {
 641            "5::West": "0",
 642            "5::South": {
 643                "2::Southeast": "1",
 644                "2::North": "5"
 645            },
 646            "5::East": "1"
 647        },
 648        "1::East": {},
 649        "1::WestBelow": "0"
 650    },
 651    "0::Northeast": "2",
 652    "0::South": {},
 653    "0::North": "5",
 654    "0::EastBelow": "1"
 655}"""
 656    )
 657
 658    m.addTransition(
 659        'd',
 660        'failure',
 661        m.endingID('failure')
 662    )
 663    assert set(m) == set(range(7))
 664    assert m.namesListing(m) == """\
 665  0 (a)
 666  1 (b)
 667  2 (c)
 668  3 (_u.0)
 669  4 (_u.1)
 670  5 (d)
 671  6 (endings//failure)
 672"""
 673    assert (
 674        m.destinationsFrom('d')
 675     == {'West': 0, 'South': 2, 'East': 1, 'failure': 6}
 676    )
 677    assert m.destinationsFrom('failure') == {}
 678
 679
 680def test_DGTagsAndAnnotations() -> None:
 681    """
 682    Test for tagging decisions and transitions in an
 683    `exploration.core.DecisionGraph`.
 684    """
 685    m = core.DecisionGraph()
 686    m.addDecision('a')
 687    m.addDecision('b', tags={'grass': 1})
 688    m.addDecision('c')
 689    m.tagDecision('c', {'water': 1, 'big': 1})
 690    m.annotateDecision('c', "This is a note.")
 691    m.addTransition('a', 'East', 'b', 'West')
 692    m.addTransition(
 693        'a', 'South', 'c', 'North',
 694        {'green': 1}, ["Requires green key"],
 695        {'blue': 1}, ["Requires blue key"]
 696    )
 697    m.tagTransition('a', 'South', 'green')
 698    m.annotateTransition('a', 'South', "a2")
 699    m.tagTransition('c', 'North', 'blue', 1)
 700    m.annotateTransition('c', 'North', ["Requires", "blue key"])
 701
 702    assert m.decisionTags('a') == {}
 703    assert m.decisionTags('b') == {'grass': 1}
 704    assert m.decisionTags('c') == {'water': 1, 'big': 1}
 705    assert m.transitionTags('a', 'East') == {}
 706    assert m.transitionTags('a', 'South') == {'green': 1}
 707    assert m.transitionTags('b', 'West') == {}
 708    assert m.transitionTags('c', 'North') == {'blue': 1}
 709
 710    assert m.decisionAnnotations('a') == []
 711    assert m.decisionAnnotations('b') == []
 712    assert m.decisionAnnotations('c') == ["This is a note."]
 713    assert m.transitionAnnotations('a', 'East') == []
 714    assert m.transitionAnnotations('a', 'South') == [
 715        "Requires green key",
 716        "a2"
 717    ]
 718    assert m.transitionAnnotations('b', 'West') == []
 719    assert m.transitionAnnotations('c', 'North') == [
 720        "Requires blue key",
 721        "Requires",
 722        "blue key"
 723    ]
 724
 725    m.tagDecision('a', 'grass')
 726    assert m.decisionTags('a') == {'grass': 1}
 727
 728    m.untagDecision('b', 'grass')
 729    assert m.decisionTags('b') == {}
 730
 731    m.annotateDecision('a', "Starting location.")
 732    assert m.decisionAnnotations('a') == ["Starting location."]
 733
 734    m.annotateDecision('c', "Blue key here.")
 735    assert m.decisionAnnotations('c') == ["This is a note.", "Blue key here."]
 736
 737    assert m.decisionAnnotations('b') == []
 738
 739    m.tagTransition('a', 'East', 'open')
 740    assert m.transitionTags('a', 'East') == {'open': 1}
 741    m.tagTransition('a', 'South', 'open')
 742    assert m.transitionTags('a', 'South') == {'green': 1, 'open': 1}
 743    m.untagTransition('a', 'South', 'green')
 744    assert m.transitionTags('a', 'South') == {'open': 1}
 745    m.tagTransition('a', 'South', 'open', [1, 2, 3])
 746    assert m.transitionTags('a', 'South') == {'open': [1, 2, 3]}
 747
 748    m.annotateTransition('c', 'North', "This was difficult.")
 749    assert (
 750        m.transitionAnnotations('c', 'North')
 751     == ['Requires blue key', 'Requires', 'blue key', 'This was difficult.']
 752    )
 753    cna = m.transitionAnnotations('c', 'North')
 754    cna.clear()
 755    cna.append('hi')
 756    assert m.transitionAnnotations('c', 'North') == ['hi']
 757
 758    with pytest.raises(core.MissingTransitionError):
 759        _ = m.transitionAnnotations('a', 'West')
 760
 761
 762def test_DiscreteExploration() -> None:
 763    "Multi-method test for `exploration.core.DiscreteExploration`."
 764    e = core.DiscreteExploration()
 765
 766    s0 = e.getSituation(0)
 767    assert e.getSituation() is s0
 768
 769    assert len(s0.graph) == 0
 770    assert e.getActiveDecisions(0) == set()
 771    assert s0.state == base.emptyState()
 772    assert s0.type == "pending"
 773    assert s0.action is None
 774
 775    assert len(e) == 1
 776
 777    e.start('a')
 778    e.observeAll('a', 'North', 'East', 'South')
 779
 780    assert len(e) == 2
 781
 782    s0 = e.getSituation(0)
 783    s1 = e.getSituation(1)
 784    assert s1 is e.getSituation()
 785    assert len(s1.graph) == 4
 786    assert set(s1.graph) == set(range(4))
 787    assert s1.graph.namesListing(s1.graph) == """\
 788  0 (a)
 789  1 (_u.0)
 790  2 (_u.1)
 791  3 (_u.2)
 792"""
 793    assert e.getActiveDecisions() == e.getActiveDecisions(1)
 794    assert e.getActiveDecisions() == {0}
 795    assert s0.type == "imposed"
 796    assert s0.action == (
 797        'start',
 798        0,
 799        0,
 800        'main',
 801        None,
 802        None,
 803        None
 804    )
 805
 806    e.explore('East', 'b', 'West')
 807    e.observeAll('b', 'North', 'South')
 808
 809    assert len(e) == 3
 810    assert set(s1.graph) == set(range(4))
 811    assert s1.graph.namesListing(s1.graph) == """\
 812  0 (a)
 813  1 (_u.0)
 814  2 (_u.1)
 815  3 (_u.2)
 816"""
 817    assert e.getActiveDecisions(1) == {0}
 818    s1 = e.getSituation(1)
 819    assert s1.type == 'active'
 820    dz = base.DefaultZone
 821    assert s1.action == (
 822        'explore',
 823        'active',
 824        0,
 825        ('East', []),
 826        'b',
 827        'West',
 828        dz
 829    )
 830
 831    s2 = e.getSituation(2)
 832    assert s2 is e.getSituation()
 833    assert set(s2.graph) == set(range(6))
 834    assert s2.graph.namesListing(s2.graph) == """\
 835  0 (a)
 836  1 (_u.0)
 837  2 (b)
 838  3 (_u.2)
 839  4 (_u.3)
 840  5 (_u.4)
 841"""
 842    assert e.getActiveDecisions() == {2}
 843    assert s2.type == "pending"
 844    assert s2.action is None
 845    assert (s2.graph.destinationsFrom('a') == {
 846        'North': 1,
 847        'East': 2,
 848        'South': 3
 849    })
 850    assert (s2.graph.destinationsFrom('b') == {
 851        'North': 4,
 852        'West': 0,
 853        'South': 5
 854    })
 855    assert (s2.graph.destinationsFrom('_u.3') == {})
 856    assert (s2.graph.destinationsFrom('_u.4') == {})
 857
 858    with pytest.raises(core.ExplorationStatusError):
 859        e.returnTo('West', 'a', 'North')
 860
 861    with pytest.raises(core.ExplorationStatusError):
 862        e.returnTo('West', 'a', 'East')
 863        # (would need to use retrace instead)
 864
 865    e.explore('North', 'c', None)
 866    e.observe('c', 'West')
 867
 868    assert len(e) == 4
 869    assert e.getSituation(0) == s0
 870    assert e.getSituation(1) == s1
 871    assert set(s1.graph) == set(range(4))
 872    assert s1.graph.namesListing(s1.graph) == """\
 873  0 (a)
 874  1 (_u.0)
 875  2 (_u.1)
 876  3 (_u.2)
 877"""
 878    assert e.getActiveDecisions(1) == {0}
 879    assert s1.type == "active"
 880    assert s1.action == ('explore', 'active', 0, ('East', []), 'b', 'West', dz)
 881    ns2 = e.getSituation(2)
 882    assert ns2 != s2
 883    assert ns2.graph == s2.graph
 884    assert ns2.state == s2.state
 885    assert s2.type, ns2.type == ('pending', 'active')
 886    assert s2.action is None
 887    assert ns2.tags == s2.tags
 888    assert ns2.annotations == s2.annotations
 889    s2 = ns2
 890    assert set(s2.graph) == set(range(6))
 891    assert s2.graph.namesListing(s2.graph) == """\
 892  0 (a)
 893  1 (_u.0)
 894  2 (b)
 895  3 (_u.2)
 896  4 (_u.3)
 897  5 (_u.4)
 898"""
 899    assert e.getActiveDecisions(2) == {2}
 900    assert s2.type == "active"
 901    assert s2.action == ('explore', 'active', 2, ('North', []), 'c', None, dz)
 902    assert (s2.graph.destinationsFrom('a') == {
 903        'North': 1,
 904        'East': 2,
 905        'South': 3
 906    })
 907    assert (s2.graph.destinationsFrom('b') == {
 908        'North': 4,
 909        'West': 0,
 910        'South': 5
 911    })
 912    s3 = e.getSituation(3)
 913    assert set(s3.graph) == set(range(7))
 914    assert s3.graph.namesListing(s3.graph) == """\
 915  0 (a)
 916  1 (_u.0)
 917  2 (b)
 918  3 (_u.2)
 919  4 (c)
 920  5 (_u.4)
 921  6 (_u.5)
 922"""
 923    assert e.getActiveDecisions(3) == {4}
 924    assert s3.type == "pending"
 925    assert s3.action is None
 926    assert (s3.graph.destinationsFrom('a') == {
 927        'North': 1,
 928        'East': 2,
 929        'South': 3
 930    })
 931    assert (s3.graph.destinationsFrom('b') == {
 932        'North': 4,
 933        'West': 0,
 934        'South': 5
 935    })
 936    assert s3.graph.destinationsFrom('c') == {'West': 6}
 937    assert s3.graph.destinationsFrom('_u.0') == {}
 938    assert s3.graph.destinationsFrom('_u.2') == {}
 939    assert s3.graph.destinationsFrom('_u.4') == {}
 940    assert s3.graph.destinationsFrom('_u.5') == {}
 941    assert s3.graph.degree(0) == 4
 942    assert s3.graph.degree(2) == 4
 943    assert s3.graph.degree(4) == 2
 944    assert s3.graph.degree(6) == 1
 945
 946    e.explore('West', 'd', 'East')
 947
 948    assert len(e) == 5
 949    s3 = e.getSituation(3)
 950    s4 = e.getSituation(4)
 951    assert set(s4.graph) == set(range(7))
 952    assert s4.graph.namesListing(s4.graph) == """\
 953  0 (a)
 954  1 (_u.0)
 955  2 (b)
 956  3 (_u.2)
 957  4 (c)
 958  5 (_u.4)
 959  6 (d)
 960"""
 961    assert e.getActiveDecisions(4) == {6}
 962    assert s4.type == "pending"
 963    assert s4.action is None
 964    assert s4.graph.destinationsFrom('c') == {'West': 6}
 965    assert s4.graph.destinationsFrom('d') == {'East': 4}
 966    assert s4.graph.degree(4) == 3
 967    assert s4.graph.degree(6) == 2
 968
 969    # Can't return if there's no outgoing edge yet
 970    with pytest.raises(core.MissingTransitionError):
 971        e.returnTo('South', 'a', 'North')
 972
 973    with pytest.raises(core.ExplorationStatusError):
 974        e.returnTo('East', 'a', 'North')
 975
 976    # Add the edge and then we can use it to return
 977    g = s4.graph
 978    g.addUnexploredEdge('d', 'South')
 979    assert set(g) == set(range(8))
 980    assert g.namesListing(g) == """\
 981  0 (a)
 982  1 (_u.0)
 983  2 (b)
 984  3 (_u.2)
 985  4 (c)
 986  5 (_u.4)
 987  6 (d)
 988  7 (_u.6)
 989"""
 990    e.returnTo('South', 'a', 'North')
 991
 992    assert len(e) == 6
 993    s4 = e.getSituation(4)
 994    s5 = e.getSituation(5)
 995    assert s5 == e.getSituation()
 996    assert set(s5.graph) == set([0, 2, 3, 4, 5, 6])
 997    assert s5.graph.namesListing(s5.graph) == """\
 998  0 (a)
 999  2 (b)
1000  3 (_u.2)
1001  4 (c)
1002  5 (_u.4)
1003  6 (d)
1004"""
1005    assert e.getActiveDecisions(5) == {0}
1006    assert s5.type == "pending"
1007    assert s5.action is None
1008    assert s5.graph.destinationsFrom('a') == {
1009        'East': 2,
1010        'North': 6,
1011        'South': 3
1012    }
1013    assert s5.graph.destinationsFrom('d') == {'East': 4, 'South': 0}
1014    assert s5.graph.degree(4) == 3
1015    assert s5.graph.degree(6) == 4
1016    assert s5.graph.degree(0) == 5
1017
1018    e.wait()
1019
1020    assert len(e) == 7
1021    s5 = e.getSituation(5)
1022    s6 = e.getSituation(6)
1023    assert set(s6.graph) == set([0, 2, 3, 4, 5, 6])
1024    assert s6.graph.namesListing(s6.graph) == """\
1025  0 (a)
1026  2 (b)
1027  3 (_u.2)
1028  4 (c)
1029  5 (_u.4)
1030  6 (d)
1031"""
1032    assert e.getActiveDecisions(6) == {0}
1033    assert s6.type == "pending"
1034    assert s6.action is None
1035
1036    assert s5.action == ('noAction',)
1037
1038    e.takeAction(
1039        'powerUp',
1040        consequence=[
1041            base.effect(gain='power'),
1042            base.effect(gain=('token', 2)),
1043        ],
1044        fromDecision=0
1045    )
1046
1047    assert len(e) == 8
1048    s6 = e.getSituation(6)
1049    s7 = e.getSituation(7)
1050    assert set(s7.graph) == set([0, 2, 3, 4, 5, 6])
1051    assert s7.graph.namesListing(s7.graph) == """\
1052  0 (a)
1053  2 (b)
1054  3 (_u.2)
1055  4 (c)
1056  5 (_u.4)
1057  6 (d)
1058"""
1059    assert e.getActiveDecisions(7) == {0}
1060    assert base.hasCapabilityOrEquivalent(
1061        'power',
1062        base.genericContextForSituation(s7)
1063    )
1064    assert base.combinedTokenCount(s7.state, 'token') == 2
1065    assert base.effectiveCapabilitySet(s7.state) == {
1066        "capabilities": {"power"},
1067        "tokens": {"token": 2},
1068        "skills": {}
1069    }
1070    assert s7.type == "pending"
1071    assert s7.action is None
1072    assert (s7.graph.destinationsFrom('a') == {
1073        'North': 6,
1074        'East': 2,
1075        'South': 3,
1076        'powerUp': 0
1077    })
1078    assert s6.action == ('take', 'active', 0, ('powerUp', []))
1079
1080    e.retrace('East')
1081
1082    assert len(e) == 9
1083    s7 = e.getSituation(7)
1084    s8 = e.getSituation(8)
1085    assert set(s8.graph) == set([0, 2, 3, 4, 5, 6])
1086    assert s8.graph.namesListing(s8.graph) == """\
1087  0 (a)
1088  2 (b)
1089  3 (_u.2)
1090  4 (c)
1091  5 (_u.4)
1092  6 (d)
1093"""
1094    assert e.getActiveDecisions(8) == {2}
1095    assert s8.type == "pending"
1096    assert s8.action is None
1097    assert base.effectiveCapabilitySet(s8.state) == {
1098        "capabilities": {"power"},
1099        "tokens": {"token": 2},
1100        "skills": {}
1101    }
1102    assert s7.action == ('take', 'active', 0, ('East', []))
1103
1104    e.observeMechanisms('d', ('gate', 'closed'))
1105    gateD = base.mechanismAt('gate', decision='d')
1106    gateA = base.mechanismAt('gate', decision='a')
1107    assert gateD == (None, None, 'd', 'gate')
1108    assert gateA == (None, None, 'a', 'gate')
1109    assert base.mechanismInStateOrEquivalent(
1110        'gate',
1111        'closed',
1112        base.genericContextForSituation(s8)
1113    )
1114    assert e.mechanismState('gate') == "closed"
1115    assert e.mechanismState(gateD) == "closed"
1116
1117    # Can't get mechanism state in step before it's been observed
1118    with pytest.raises(core.MissingMechanismError):
1119        e.mechanismState('gate', step=6)
1120
1121    # Can't get mechanism state for mechanism at a different decision
1122    assert e.mechanismState(gateA) == "closed"
1123
1124    e.observeMechanisms('a', 'gate')  # without starting state
1125    with pytest.raises(core.AmbiguousMechanismError):
1126        e.mechanismState('gate')
1127
1128    with pytest.raises(core.AmbiguousMechanismError):
1129        e.mechanismState(base.mechanismAt('gate', decision='c'))
1130
1131    # Default state
1132    assert e.mechanismState(gateA) == 'off'
1133    assert e.mechanismState(gateD) == 'closed'
1134
1135    e.warp(
1136        'd',
1137        consequence=[
1138            base.effect(lose=('token', 1)),
1139            base.effect(set=('gate', 'open'))  # knows to open gate at 'd'
1140        ]
1141    )
1142
1143    assert len(e) == 10
1144    s8 = e.getSituation(8)
1145    s9 = e.getSituation(9)
1146    assert s8.action == ("warp", "active", 6)
1147    assert set(s9.graph) == set([0, 2, 3, 4, 5, 6])
1148    assert s9.graph.namesListing(s9.graph) == """\
1149  0 (a)
1150  2 (b)
1151  3 (_u.2)
1152  4 (c)
1153  5 (_u.4)
1154  6 (d)
1155"""
1156    assert e.getActiveDecisions(9) == {6}
1157    assert base.effectiveCapabilitySet(s9.state) == {
1158        "capabilities": {"power"},
1159        "tokens": {"token": 1},
1160        "skills": {}
1161    }
1162    assert s9.type == "pending"
1163    assert s9.action is None
1164    assert (s9.graph.destinationsFrom('a') == {
1165        'North': 6,
1166        'East': 2,
1167        'South': 3,
1168        'powerUp': 0
1169    })
1170    assert (s9.graph.destinationsFrom('b') == {
1171        'North': 4,
1172        'West': 0,
1173        'South': 5
1174    })
1175    assert (s9.graph.destinationsFrom('c') == {'West': 6})
1176    assert (s9.graph.destinationsFrom('d') == {'East': 4, 'South': 0})
1177
1178    ctx1 = base.genericContextForSituation(s1)
1179    ctx8 = base.genericContextForSituation(s8)
1180    ctx9 = base.genericContextForSituation(s9)
1181    with pytest.raises(core.MissingMechanismError):
1182        base.mechanismInStateOrEquivalent(gateD, 'open', ctx1)
1183        # 'gate mechanism doesn't exist back then (neither does decision 'd')
1184    assert not base.mechanismInStateOrEquivalent(gateD, 'open', ctx8)
1185    assert base.mechanismInStateOrEquivalent(gateD, 'open', ctx9)
1186
1187    with pytest.raises(core.MissingMechanismError):
1188        e.mechanismState(gateA, step=1)
1189
1190    assert e.mechanismState(gateA) == 'off'
1191    assert e.mechanismState(gateD) == 'open'
1192    assert e.mechanismState(gateD, step=8) == 'closed'
1193
1194
1195def test_exploring_with_zones() -> None:
1196    """
1197    A test for exploring with zones being applied.
1198    """
1199    e = core.DiscreteExploration()
1200
1201    assert e.start('start') == 0
1202    graph = e.getSituation().graph
1203    graph.createZone('zone', 0)
1204    graph.addDecisionToZone('start', 'zone')
1205    e.observe(0, 'transition')
1206    assert e.explore('transition', 'room') == 1
1207
1208    s = e.getSituation()
1209    g = s.graph
1210    assert g.zoneParents(0) == {'zone'}
1211    assert g.zoneParents(1) == {'zone'}
1212
1213    e.observeAll(1, 'out', 'down')
1214    unknown = g.destination('room', 'down')
1215    g.renameDecision(unknown, 'fourth_room')
1216    assert g.nameFor(3) == 'fourth_room'
1217    assert g.zoneParents(3) == set()
1218    assert not g.isConfirmed('fourth_room')
1219    assert not e.hasBeenVisited('fourth_room')
1220    assert e.explore('out', 'another_room', 'back', 'zone2') == 2
1221    e.retrace('back')
1222    e.explore('down', None, 'up')  # already named 'fourth_room'
1223
1224    g = e.getSituation().graph
1225    assert g.nameFor(3) == 'fourth_room'
1226    assert g.zoneParents(0) == {'zone'}
1227    assert g.zoneParents(1) == {'zone'}
1228    assert g.zoneParents(2) == {'zone2'}
1229    assert g.zoneParents(3) == {'zone'}
1230
1231
1232def test_triggers() -> None:
1233    e = core.DiscreteExploration()
1234    e.start('start')
1235    assert e.primaryDecision() == 0
1236    e.takeAction(
1237        'shiver',
1238        requires=base.ReqNot(base.ReqCapability('jacket')),
1239        consequence=[base.effect(gain=('cold', 1))],
1240        fromDecision='start'
1241    )
1242    e.getSituation().graph.tagTransition('start', 'shiver', 'trigger')
1243    assert e.tokenCountNow('cold') == 1
1244    e.observe('start', 'right')
1245    e.explore('right', 'room', 'left')
1246    assert e.primaryDecision() == 1
1247    assert e.tokenCountNow('cold') == 1
1248    e.takeAction(
1249        'warmUp',
1250        requires=base.ReqTokens('cold', 1),
1251        consequence=[base.effect(lose=('cold', 1))],
1252        fromDecision='room'
1253    )
1254    assert e.tokenCountNow('cold') == 0
1255    e.getSituation().graph.tagTransition('room', 'warmUp', 'trigger')
1256    e.wait()
1257    assert e.tokenCountNow('cold') == 0
1258    e.retrace('left')
1259    assert e.primaryDecision() == 0
1260    assert e.tokenCountNow('cold') == 1
1261    e.wait()
1262    assert e.tokenCountNow('cold') == 2
1263    e.wait()
1264    assert e.tokenCountNow('cold') == 3
1265    e.retrace('right')
1266    assert e.tokenCountNow('cold') == 2
1267    e.wait()
1268    assert e.tokenCountNow('cold') == 1
1269    e.wait()
1270    # No issue with trigger when out of tokens because of its requirement
1271    assert e.tokenCountNow('cold') == 0
1272    e.wait()
1273    assert e.tokenCountNow('cold') == 0
1274    # Get a jacket
1275    e.applyExtraneousEffect(base.effect(gain='jacket'))
1276    e.retrace('left')
1277    # Jacket prevents trigger
1278    assert e.primaryDecision() == 0
1279    assert e.tokenCountNow('cold') == 0
1280    e.wait()
1281    assert e.tokenCountNow('cold') == 0
1282    # TODO: Add a trigger group...