Elevator: tests and solutions

makePythonTdd Elevator

the code in makePythonTdd.sh from Elevator

 1#!/bin/bash
 2uv init atm
 3cd atm
 4mkdir src
 5mv main.py src/atm.py
 6mkdir tests
 7touch tests/__init__.py
 8
 9echo "import unittest
10
11
12class TestATM(unittest.TestCase):
13
14    def test_failure(self):
15        self.assertFalse(True)
16
17
18# Exceptions seen
19# AssertionError
20" > tests/test_atm.py
21
22echo "pytest" > requirements.txt
23echo "pytest-watcher" >> requirements.txt
24uv add --requirement requirements.txt
25uv run pytest-watcher . --now

the code in makePythonTdd.ps1 from Elevator

 1uv init atm
 2cd atm
 3mkdir src
 4Move-Item "main.py" "src/atm.py"
 5mkdir tests
 6New-Item tests/__init__.py
 7
 8"import unittest
 9
10
11class TestATM(unittest.TestCase):
12
13    def test_failure(self):
14        self.assertFalse(True)
15
16
17# Exceptions seen
18# AssertionError
19" | Out-File "tests/test_atm.py" -Encoding UTF8
20
21"pytest" | Out-File requirements.txt -Encoding UTF8
22"pytest-watcher" >> requirements.txt
23uv add --requirement requirements.txt
24uv run pytest-watcher . --now

Elevator: tests

the code in elevator/tests/test_elevator.py from Elevator

  1import src.elevator
  2import unittest
  3
  4
  5NOT_MOVE = 'NOT MOVE'
  6
  7
  8class TestElevator(unittest.TestCase):
  9
 10    def test_doors_clear_number_pushed_w_emergency(self):
 11        self.assertEqual(
 12            src.elevator.elevator(
 13                doors_clear=True,
 14                number_pushed=True,
 15                above_weight_limit=True,
 16                emergency=True,
 17            ),
 18            NOT_MOVE
 19        )
 20
 21        self.assertEqual(
 22            src.elevator.elevator(
 23                doors_clear=True,
 24                number_pushed=True,
 25                above_weight_limit=True,
 26                emergency=False,
 27            ),
 28            NOT_MOVE
 29        )
 30
 31        self.assertEqual(
 32            src.elevator.elevator(
 33                doors_clear=True,
 34                number_pushed=True,
 35                above_weight_limit=False,
 36                emergency=True,
 37            ),
 38            NOT_MOVE
 39        )
 40
 41        self.assertEqual(
 42            src.elevator.elevator(
 43                doors_clear=True,
 44                number_pushed=True,
 45                above_weight_limit=False,
 46                emergency=False,
 47            ),
 48            'MOVE'
 49        )
 50
 51    def test_doors_clear_number_not_pushed_w_emergency(self):
 52        self.assertEqual(
 53            src.elevator.elevator(
 54                doors_clear=True,
 55                number_pushed=False,
 56                above_weight_limit=True,
 57                emergency=True,
 58            ),
 59            NOT_MOVE
 60        )
 61
 62        self.assertEqual(
 63            src.elevator.elevator(
 64                doors_clear=True,
 65                number_pushed=False,
 66                above_weight_limit=True,
 67                emergency=False,
 68            ),
 69            NOT_MOVE
 70        )
 71
 72        self.assertEqual(
 73            src.elevator.elevator(
 74                doors_clear=True,
 75                number_pushed=False,
 76                above_weight_limit=False,
 77                emergency=True,
 78            ),
 79            NOT_MOVE
 80        )
 81
 82        self.assertEqual(
 83            src.elevator.elevator(
 84                doors_clear=True,
 85                number_pushed=False,
 86                above_weight_limit=False,
 87                emergency=False,
 88            ),
 89            NOT_MOVE
 90        )
 91
 92    def test_doors_not_clear_number_pushed_w_emergency(self):
 93        self.assertEqual(
 94            src.elevator.elevator(
 95                doors_clear=False,
 96                number_pushed=True,
 97                above_weight_limit=True,
 98                emergency=True,
 99            ),
100            NOT_MOVE
101        )
102
103        self.assertEqual(
104            src.elevator.elevator(
105                doors_clear=False,
106                number_pushed=True,
107                above_weight_limit=True,
108                emergency=False,
109            ),
110            NOT_MOVE
111        )
112
113        self.assertEqual(
114            src.elevator.elevator(
115                doors_clear=False,
116                number_pushed=True,
117                above_weight_limit=False,
118                emergency=True,
119            ),
120            NOT_MOVE
121        )
122
123        self.assertEqual(
124            src.elevator.elevator(
125                doors_clear=False,
126                number_pushed=True,
127                above_weight_limit=False,
128                emergency=False,
129            ),
130            NOT_MOVE
131        )
132
133    def test_doors_not_clear_number_not_pushed_w_emergency(self):
134        self.assertEqual(
135            src.elevator.elevator(
136                doors_clear=False,
137                number_pushed=False,
138                above_weight_limit=True,
139                emergency=True,
140            ),
141            NOT_MOVE
142        )
143
144        self.assertEqual(
145            src.elevator.elevator(
146                doors_clear=False,
147                number_pushed=False,
148                above_weight_limit=True,
149                emergency=False,
150            ),
151            NOT_MOVE
152        )
153
154        self.assertEqual(
155            src.elevator.elevator(
156                doors_clear=False,
157                number_pushed=False,
158                above_weight_limit=False,
159                emergency=True,
160            ),
161            NOT_MOVE
162        )
163
164        self.assertEqual(
165            src.elevator.elevator(
166                doors_clear=False,
167                above_weight_limit=False,
168                number_pushed=False,
169                emergency=False,
170            ),
171            NOT_MOVE
172        )
173
174
175# Exceptions seen
176# AssertionError
177# NameError
178# AttributeError
179# TypeError

Elevator: solution

the code in elevator/src/elevator.py from Elevator

 1def elevator(
 2        doors_clear, number_pushed,
 3        above_weight_limit=False, emergency=False,
 4    ):
 5    if (
 6        emergency
 7        or above_weight_limit
 8        or not (
 9            doors_clear
10            and
11            number_pushed
12        )
13    ):
14        return 'NOT MOVE'
15
16    return 'MOVE'
17
18    not_move = 'NOT MOVE'
19
20    if emergency:
21        return not_move
22
23    if above_weight_limit:
24        return not_move
25
26    if not doors_clear:
27        return not_move
28
29    if not number_pushed:
30        return not_move
31
32    return 'MOVE'