Skip to content

Instantly share code, notes, and snippets.

@vencejo

vencejo/Aprendiendo TDD con la Kata de Tenis

Created August 22, 2014 16:27
Show Gist options
  • Save vencejo/f39d8deadeeffbe3443f to your computer and use it in GitHub Desktop.
Save vencejo/f39d8deadeeffbe3443f to your computer and use it in GitHub Desktop.
Download ZIP
Aprendiendo TDD con la Kata de Tenis
Raw
Aprendiendo TDD con la Kata de Tenis
{
"metadata": {
"kernelspec": {
"codemirror_mode": {
"name": "python",
"singleOperators": {},
"version": 2
},
"display_name": "IPython (Python 2)",
"language": "python",
"name": "python2"
},
"name": "",
"signature": "sha256:47d2acf8e1702ef7f1b182a869d20b5c581570806c690ce372430f6c8e4c408c"
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notebook de iPython basado en la kata de [Javier Gutierrez](https://twitter.com/IWT2_Javier) sobre TDD en Python : http://www.slideshare.net/Javier_J/kata-tennis-paso-a-paso\n",
"\n",
"Con el presente notebook pretendemos seguir paso a paso el proceso de construir software con la metodolog\u00eda TDD\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Indice\n",
"\n",
"<a name=\"indice\"> Indice </a>\n",
"\n",
"<a href=\"#ronda1\">Primera ronda de test: Puntuacion inicial</a>\n",
"\n",
"<a href=\"#ronda2\">Segunda ronda de test: Primer punto</a>\n",
"\n",
"<a href=\"#ronda3\">Tercera ronda de test: Dos y tres puntos</a>\n",
"\n",
"<a href=\"#ronda4\">Cuarta ronda: A\u00f1adimos al segundo jugador</a>\n",
"\n",
"<a href=\"#ronda5\">Quinta ronda: Gestion de la ventaja</a>\n",
"\n",
"<a href=\"#ronda6\">Sexta ronda: El jugador pierde su ventaja</a>\n",
"\n",
"<a href=\"#ronda7\">Septima ronda: El jugador con ventaja gana</a>\n",
"\n",
"<a href=\"#refactorizacion\">Refactorizaci\u00f3n para ocultar detalles y acercarnos a la l\u00f3gica de negocio</a>\n",
"\n",
"<a href=\"#ronda8\">Octava ronda: El partido de tenis entre dos jugadores</a>\n",
"\n",
"<a href=\"#ronda9\">Novena ronda: Random Tenis</a>\n",
"\n",
"<a href=\"#ronda10\">Decima ronda: M\u00faltiples partidos aleatorios</a>\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda1\">ronda 1 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Primera ronda de test: Puntuaci\u00f3n inicial"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player\n",
"\n",
"class TestPlayer(unittest.TestCase):\n",
" \n",
" def test_initialScore(self):\n",
" # 1: Build\n",
" player = Player()\n",
" # 2: Execute\n",
" \n",
" # 3: Assert\n",
" self.assertEqual(\"0\", player.getScore())\n",
" \n",
" \n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 2
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"class Player:\n",
" \n",
" def getScore(self):\n",
" return \"0\"\n",
" "
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Writing tennis.py\n"
]
}
],
"prompt_number": 3
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
".\r\n",
"----------------------------------------------------------------------\r\n",
"Ran 1 test in 0.000s\r\n",
"\r\n",
"OK\r\n"
]
}
],
"prompt_number": 4
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda2\">ronda 2</a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Segunda Ronda de Test : Primer punto"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player\n",
"\n",
"class TestPlayer(unittest.TestCase):\n",
" \n",
" def test_initialScore(self):\n",
" # 1: Build\n",
" player = Player()\n",
" # 2: Execute\n",
" \n",
" # 3: Assert\n",
" self.assertEqual(\"0\", player.getScore())\n",
" \n",
" def test_firstPoint(self):\n",
" player = Player()\n",
" player.winPoint()\n",
" self.assertEqual(\"15\", player.getScore())\n",
" \n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 8
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"class Player:\n",
" \n",
" def __init__(self):\n",
" self.score = \"0\"\n",
" \n",
" def winPoint(self):\n",
" self.score = \"15\"\n",
" \n",
" def getScore(self):\n",
" return self.score"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 9
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"..\r\n",
"----------------------------------------------------------------------\r\n",
"Ran 2 tests in 0.000s\r\n",
"\r\n",
"OK\r\n"
]
}
],
"prompt_number": 10
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda3\">ronda 3</a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Tercera ronda de test : Dos y tres puntos"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player\n",
"\n",
"class TestPlayer(unittest.TestCase):\n",
" \n",
" def test_initialScore(self):\n",
" # 1: Build\n",
" player = Player()\n",
" # 2: Execute\n",
" \n",
" # 3: Assert\n",
" self.assertEqual(\"0\", player.getScore())\n",
" \n",
" def test_firstPoint(self):\n",
" player = Player()\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"15\", player.getScore())\n",
" \n",
" def test_secondPoint(self):\n",
" player = Player(1)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"30\", player.getScore())\n",
" \n",
" def test_thirdPoint(self):\n",
" player = Player(2)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"40\", player.getScore())\n",
" \n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 15
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"class Player:\n",
" \n",
" scores = [\"0\",\"15\",\"30\",\"40\"]\n",
" \n",
" def __init__(self, score = 0):\n",
" self.score = score\n",
" \n",
" def winPoint(self):\n",
" self.score += 1\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 16
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"....\n",
"----------------------------------------------------------------------\n",
"Ran 4 tests in 0.002s\n",
"\n",
"OK\n"
]
}
],
"prompt_number": 17
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda4\">ronda 4 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Cuarta ronda de test, a\u00f1adimos al segundo Jugador"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player\n",
"\n",
"class TestPlayer(unittest.TestCase):\n",
" \n",
" def test_initialScore(self):\n",
" # 1: Build\n",
" player = Player()\n",
" # 2: Execute\n",
" \n",
" # 3: Assert\n",
" self.assertEqual(\"0\", player.getScore())\n",
" \n",
" def test_firstPoint(self):\n",
" player = Player()\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"15\", player.getScore())\n",
" \n",
" def test_secondPoint(self):\n",
" player = Player(1)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"30\", player.getScore())\n",
" \n",
" def test_thirdPoint(self):\n",
" player = Player(2)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"40\", player.getScore())\n",
" \n",
" def test_playerWins(self):\n",
" player1 = Player(3)\n",
" player2 = Player()\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Winner\", player1.getScore())\n",
" \n",
" \n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 21
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"class Player:\n",
" \n",
" scores = [\"0\",\"15\",\"30\",\"40\",\"Winner\"]\n",
" \n",
" def __init__(self, score = 0):\n",
" self.score = score\n",
" \n",
" def isWinner(self):\n",
" return self.score == 4\n",
" \n",
" def winPoint(self, other = None):\n",
" self.score += 1\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 22
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
".....\n",
"----------------------------------------------------------------------\n",
"Ran 5 tests in 0.002s\n",
"\n",
"OK\n"
]
}
],
"prompt_number": 23
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda5\">ronda 5 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Quinta ronda de test: Ventaja"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player\n",
"\n",
"class TestPlayer(unittest.TestCase):\n",
" \n",
" def test_initialScore(self):\n",
" # 1: Build\n",
" player = Player()\n",
" # 2: Execute\n",
" \n",
" # 3: Assert\n",
" self.assertEqual(\"0\", player.getScore())\n",
" \n",
" def test_firstPoint(self):\n",
" player = Player()\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"15\", player.getScore())\n",
" \n",
" def test_secondPoint(self):\n",
" player = Player(1)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"30\", player.getScore())\n",
" \n",
" def test_thirdPoint(self):\n",
" player = Player(2)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"40\", player.getScore())\n",
" \n",
" def test_playerWins(self):\n",
" player1 = Player(3)\n",
" player2 = Player()\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Winner\", player1.getScore())\n",
" \n",
" def test_playerScoresOnDeuce(self):\n",
" player1 = Player(3)\n",
" player2 = Player(3)\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Advantage\", player1.getScore())\n",
" \n",
" \n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 24
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"class Player:\n",
" \n",
" scores = [\"0\",\"15\",\"30\",\"40\",\"Advantage\",\"Winner\"]\n",
" \n",
" def __init__(self, score = 0):\n",
" self.score = score\n",
" \n",
" def isWinner(self):\n",
" return self.score == 4\n",
" \n",
" def winPoint(self, other = None):\n",
" if other == None:\n",
" self.score += 1\n",
" return\n",
" \n",
" if self.getScore() == \"40\" and other.getScore() != \"40\":\n",
" self.score +=2\n",
" else:\n",
" self.score += 1\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 25
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"......\r\n",
"----------------------------------------------------------------------\r\n",
"Ran 6 tests in 0.003s\r\n",
"\r\n",
"OK\r\n"
]
}
],
"prompt_number": 26
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda6\">ronda 6 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Sexta Ronda de test : El jugador pierde su ventaja"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player\n",
"\n",
"class TestPlayer(unittest.TestCase):\n",
" \n",
" def test_initialScore(self):\n",
" # 1: Build\n",
" player = Player()\n",
" # 2: Execute\n",
" \n",
" # 3: Assert\n",
" self.assertEqual(\"0\", player.getScore())\n",
" \n",
" def test_firstPoint(self):\n",
" player = Player()\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"15\", player.getScore())\n",
" \n",
" def test_secondPoint(self):\n",
" player = Player(1)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"30\", player.getScore())\n",
" \n",
" def test_thirdPoint(self):\n",
" player = Player(2)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"40\", player.getScore())\n",
" \n",
" def test_playerWins(self):\n",
" player1 = Player(3)\n",
" player2 = Player()\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Winner\", player1.getScore())\n",
" \n",
" def test_playerScoresOnDeuce(self):\n",
" player1 = Player(3)\n",
" player2 = Player(3)\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Advantage\", player1.getScore())\n",
" \n",
" def test_playerScoresAndOtherPlayerLosesAdvantage(self):\n",
" player1 = Player(4) #Advantage\n",
" player2 = Player(3) #40\n",
" \n",
" player2.winPoint(player1)\n",
" \n",
" self.assertEqual(\"40\", player1.getScore())\n",
" self.assertEqual(\"40\", player2.getScore())\n",
" \n",
" \n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 27
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"class Player:\n",
" \n",
" scores = [\"0\",\"15\",\"30\",\"40\",\"Advantage\",\"Winner\"]\n",
" \n",
" def __init__(self, score = 0):\n",
" self.score = score\n",
" \n",
" def isWinner(self):\n",
" return self.score == 4\n",
" \n",
" def winPoint(self, other = None):\n",
" if other == None:\n",
" self.score += 1\n",
" return\n",
" \n",
" if other.getScore() == \"Advantage\":\n",
" other.score -= 1\n",
" return \n",
" \n",
" if self.getScore() == \"40\" and other.getScore() != \"40\":\n",
" self.score +=2\n",
" else:\n",
" self.score += 1\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 28
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
".......\r\n",
"----------------------------------------------------------------------\r\n",
"Ran 7 tests in 0.002s\r\n",
"\r\n",
"OK\r\n"
]
}
],
"prompt_number": 29
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda7\">ronda 7 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Septima ronda de test: El jugador con ventaja gana"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player\n",
"\n",
"class TestPlayer(unittest.TestCase):\n",
" \n",
" def test_initialScore(self):\n",
" # 1: Build\n",
" player = Player()\n",
" # 2: Execute\n",
" \n",
" # 3: Assert\n",
" self.assertEqual(\"0\", player.getScore())\n",
" \n",
" def test_firstPoint(self):\n",
" player = Player()\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"15\", player.getScore())\n",
" \n",
" def test_secondPoint(self):\n",
" player = Player(1)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"30\", player.getScore())\n",
" \n",
" def test_thirdPoint(self):\n",
" player = Player(2)\n",
" \n",
" player.winPoint()\n",
" \n",
" self.assertEqual(\"40\", player.getScore())\n",
" \n",
" def test_playerWins(self):\n",
" player1 = Player(3)\n",
" player2 = Player()\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Winner\", player1.getScore())\n",
" \n",
" def test_playerScoresOnDeuce(self):\n",
" player1 = Player(3)\n",
" player2 = Player(3)\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Advantage\", player1.getScore())\n",
" \n",
" def test_playerScoresAndOtherPlayerLosesAdvantage(self):\n",
" player1 = Player(4) #Advantage\n",
" player2 = Player(3) #40\n",
" \n",
" player2.winPoint(player1)\n",
" \n",
" self.assertEqual(\"40\", player1.getScore())\n",
" self.assertEqual(\"40\", player2.getScore())\n",
" \n",
" def test_playerWithAdvantageScoresAndWin(self):\n",
" player1 = Player(4) #Advantage\n",
" player2 = Player(3) #40\n",
" \n",
" player1.winPoint(player2)\n",
" \n",
" self.assertEqual(\"Winner\", player1.getScore())\n",
" \n",
" \n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 30
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"class Player:\n",
" \n",
" scores = [\"0\",\"15\",\"30\",\"40\",\"Advantage\",\"Winner\"]\n",
" \n",
" def __init__(self, score = 0):\n",
" self.score = score\n",
" \n",
" def isWinner(self):\n",
" return self.score == 4\n",
" \n",
" def winPoint(self, other = None):\n",
" if other == None:\n",
" self.score += 1\n",
" return\n",
" \n",
" if other.getScore() == \"Advantage\":\n",
" other.score -= 1\n",
" return \n",
" \n",
" if self.getScore() == \"40\" and other.getScore() != \"40\":\n",
" self.score +=2\n",
" else:\n",
" self.score += 1\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 31
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"........\r\n",
"----------------------------------------------------------------------\r\n",
"Ran 8 tests in 0.002s\r\n",
"\r\n",
"OK\r\n"
]
}
],
"prompt_number": 32
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"refactorizacion\">refactorizacion </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Refactorizaci\u00f3n para ocultar la l\u00f3gica de la implementacion y acercarnos a la l\u00f3gica de negocio"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"ZERO = \"0\"\n",
"FIFTEEN = \"15\"\n",
"THIRTY = \"30\"\n",
"FORTY = \"40\"\n",
"ADV = \"Adv\"\n",
"WIN = \"Win\"\n",
"\n",
"class Player:\n",
" \n",
" def __init__(self, score = ZERO):\n",
" self.scores = [ZERO,FIFTEEN,THIRTY,FORTY,ADV,WIN]\n",
" self.score = self.scores.index(score)\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]\n",
" \n",
" def winPoint(self, other):\n",
" \n",
" if other.getScore() == ADV:\n",
" other.score -= 1\n",
" return \n",
" \n",
" if self.getScore() == FORTY and other.getScore() != FORTY:\n",
" self.score +=2\n",
" else:\n",
" self.score += 1\n",
" \n",
" def isWinner(self):\n",
" return self.getScore() == WIN\n",
" \n",
" def hasNoPoints(self):\n",
" return self.getScore() == ZERO\n",
" "
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 16
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player, ZERO, FIFTEEN, THIRTY, FORTY, ADV, WIN\n",
"\n",
"class TestBase(unittest.TestCase):\n",
"\tdef createPlayers(self, scoreA = ZERO, scoreB = ZERO):\n",
"\t\tself.playerA = Player(scoreA)\n",
"\t\tself.playerB = Player(scoreB)\n",
"\n",
"class TestPlayer(TestBase):\n",
"\t\n",
"\tdef winPoint(self):\n",
"\t\tself.playerA.winPoint(self.playerB)\n",
"\n",
"\tdef test_initialScore(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.assertEqual(ZERO, self.playerA.getScore())\n",
"\n",
"\tdef test_firstPoint(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FIFTEEN, self.playerA.getScore())\n",
"\n",
"\tdef test_secondPoint(self):\n",
"\t\tself.createPlayers(scoreA=FIFTEEN)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(THIRTY, self.playerA.getScore())\n",
"\n",
"\tdef test_thirdPoint(self):\n",
"\t\tself.createPlayers(scoreA=THIRTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\n",
"\tdef test_playerOnDeuceScroresandWinAdvantage(self):\n",
"\t\tself.createPlayers(FORTY, FORTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(ADV, self.playerA.getScore())\n",
"\n",
"\tdef test_playerScoresAndOtherPlayerLosesAdvantage(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\tself.assertEqual(FORTY, self.playerB.getScore())\n",
"\n",
"\tdef test_playerWithAdvantageScoresAndWin(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.winPoint()\n",
"\n",
"\t\tself.assertEqual(WIN, self.playerA.getScore())\n",
"\n",
"\tdef test_playerIsNotAWinner(self):\n",
"\t\tself.createPlayers()\n",
"\t\n",
"\t\tself.assertFalse(self.playerA.isWinner())\n",
"\t\n",
"\tdef test_playerWins(self):\n",
"\t\tself.createPlayers(ZERO, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\t\n",
"\t\tself.assertTrue(self.playerB.isWinner())\n",
"\n",
"\n",
"# Main\n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 17
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
".........\r\n",
"----------------------------------------------------------------------\r\n",
"Ran 9 tests in 0.001s\r\n",
"\r\n",
"OK\r\n"
]
}
],
"prompt_number": 18
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda8\">ronda 8 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Octava ronda de test: El partido de tenis"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player, ZERO, FIFTEEN, THIRTY, FORTY, ADV, WIN, Match, Play\n",
"\n",
"class TestBase(unittest.TestCase):\n",
"\tdef createPlayers(self, scoreA = ZERO, scoreB = ZERO):\n",
"\t\tself.playerA = Player(scoreA)\n",
"\t\tself.playerB = Player(scoreB)\n",
"\n",
"class TestPlayer(TestBase): # Atencion a la herencia de test base\n",
"\t\n",
"\tdef winPoint(self):\n",
"\t\tself.playerA.winPoint(self.playerB)\n",
"\n",
"\tdef test_initialScore(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.assertEqual(ZERO, self.playerA.getScore())\n",
"\n",
"\tdef test_firstPoint(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FIFTEEN, self.playerA.getScore())\n",
"\n",
"\tdef test_secondPoint(self):\n",
"\t\tself.createPlayers(scoreA=FIFTEEN)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(THIRTY, self.playerA.getScore())\n",
"\n",
"\tdef test_thirdPoint(self):\n",
"\t\tself.createPlayers(scoreA=THIRTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\n",
"\tdef test_playerOnDeuceScroresandWinAdvantage(self):\n",
"\t\tself.createPlayers(FORTY, FORTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(ADV, self.playerA.getScore())\n",
"\n",
"\tdef test_playerScoresAndOtherPlayerLosesAdvantage(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\tself.assertEqual(FORTY, self.playerB.getScore())\n",
"\n",
"\tdef test_playerWithAdvantageScoresAndWin(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.winPoint()\n",
"\n",
"\t\tself.assertEqual(WIN, self.playerA.getScore())\n",
"\n",
"\tdef test_playerIsNotAWinner(self):\n",
"\t\tself.createPlayers()\n",
"\t\n",
"\t\tself.assertFalse(self.playerA.isWinner())\n",
"\t\n",
"\tdef test_playerWins(self):\n",
"\t\tself.createPlayers(ZERO, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\t\n",
"\t\tself.assertTrue(self.playerB.isWinner())\n",
" \n",
" \n",
"class TestMatch(TestBase):\n",
" \n",
"\tdef test_playMatchAndPlayerAWins(self):\n",
"\t\tself.createPlayers(FORTY, ZERO)\n",
"\t\n",
"\t\tself.match = Match()\n",
"\t\tself.match.playMatch(self.playerA, self.playerB, Play(\"A\"))\n",
"\n",
"\t\tself.assertTrue(self.playerA.isWinner())\n",
"\t\tself.assertTrue(self.playerB.hasNoPoints())\n",
"\n",
"\n",
"# Main\n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 20
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"ZERO = \"0\"\n",
"FIFTEEN = \"15\"\n",
"THIRTY = \"30\"\n",
"FORTY = \"40\"\n",
"ADV = \"Adv\"\n",
"WIN = \"Win\"\n",
"\n",
"class Player:\n",
" \n",
" def __init__(self, score = ZERO):\n",
" self.scores = [ZERO,FIFTEEN,THIRTY,FORTY,ADV,WIN]\n",
" self.score = self.scores.index(score)\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]\n",
" \n",
" def winPoint(self, other):\n",
" \n",
" if other.getScore() == ADV:\n",
" other.score -= 1\n",
" return \n",
" \n",
" if self.getScore() == FORTY and other.getScore() != FORTY:\n",
" self.score +=2\n",
" else:\n",
" self.score += 1\n",
" \n",
" def isWinner(self):\n",
" return self.getScore() == WIN\n",
" \n",
" def hasNoPoints(self):\n",
" return self.getScore() == ZERO\n",
" \n",
"class Match:\n",
"\tdef __init__(self):\n",
"\t\tpass\n",
"\tdef playMatch(self, playerA, playerB, game):\n",
"\t\twhile not(playerA.isWinner()) and not(playerB.isWinner()):\n",
"\t\t\tif game.getPlayerWhoScores() == \"A\" :\n",
"\t\t\t\tplayerA.winPoint(playerB)\n",
"\t\t\telse:\n",
"\t\t\t\tplayerB.winPoint(playerA)\n",
"\t\n",
"\n",
"class Play:\n",
"\tdef __init__(self, playerWhoScores):\n",
"\t\tself.player = playerWhoScores\n",
"\tdef getPlayerWhoScores(self):\n",
"\t\treturn self.player\n",
" "
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 21
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"..........\n",
"----------------------------------------------------------------------\n",
"Ran 10 tests in 0.001s\n",
"\n",
"OK\n"
]
}
],
"prompt_number": 22
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda9\">ronda 9 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Novena ronda de testing: Random Tenis"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player, ZERO, FIFTEEN, THIRTY, FORTY, ADV, WIN, Match, Play, RandomPlay\n",
"\n",
"class TestBase(unittest.TestCase):\n",
"\tdef createPlayers(self, scoreA = ZERO, scoreB = ZERO):\n",
"\t\tself.playerA = Player(scoreA)\n",
"\t\tself.playerB = Player(scoreB)\n",
"\n",
"class TestPlayer(TestBase): # Atencion a la herencia de test base\n",
"\t\n",
"\tdef winPoint(self):\n",
"\t\tself.playerA.winPoint(self.playerB)\n",
"\n",
"\tdef test_initialScore(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.assertEqual(ZERO, self.playerA.getScore())\n",
"\n",
"\tdef test_firstPoint(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FIFTEEN, self.playerA.getScore())\n",
"\n",
"\tdef test_secondPoint(self):\n",
"\t\tself.createPlayers(scoreA=FIFTEEN)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(THIRTY, self.playerA.getScore())\n",
"\n",
"\tdef test_thirdPoint(self):\n",
"\t\tself.createPlayers(scoreA=THIRTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\n",
"\tdef test_playerOnDeuceScroresandWinAdvantage(self):\n",
"\t\tself.createPlayers(FORTY, FORTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(ADV, self.playerA.getScore())\n",
"\n",
"\tdef test_playerScoresAndOtherPlayerLosesAdvantage(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\tself.assertEqual(FORTY, self.playerB.getScore())\n",
"\n",
"\tdef test_playerWithAdvantageScoresAndWin(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.winPoint()\n",
"\n",
"\t\tself.assertEqual(WIN, self.playerA.getScore())\n",
"\n",
"\tdef test_playerIsNotAWinner(self):\n",
"\t\tself.createPlayers()\n",
"\t\n",
"\t\tself.assertFalse(self.playerA.isWinner())\n",
"\t\n",
"\tdef test_playerWins(self):\n",
"\t\tself.createPlayers(ZERO, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\t\n",
"\t\tself.assertTrue(self.playerB.isWinner())\n",
" \n",
" \n",
"class TestMatch(TestBase):\n",
" \n",
"\tdef test_playMatchAndPlayerAWins(self):\n",
"\t\tself.createPlayers(ZERO, ZERO)\n",
"\t\n",
"\t\tself.match = Match()\n",
"\t\tself.match.playMatch(self.playerA, self.playerB, Play(\"A\"))\n",
"\n",
"\t\tself.assertTrue(self.playerA.isWinner())\n",
"\t\tself.assertTrue(self.playerB.hasNoPoints())\n",
" \n",
"\tdef test_randomTesting(self):\n",
"\t\tself.createPlayers(ZERO, ZERO)\n",
"\t\n",
"\t\tr = RandomPlay()\n",
"\t\tself.match = Match()\n",
"\t\tself.match.playMatch(self.playerA, self.playerB, r)\n",
"\n",
"\t\tif r.getMostScoredPlayer() == \"B\":\n",
"\t\t\tself.assertTrue(self.playerB.isWinner())\n",
"\t\t\tself.assertFalse(self.playerA.isWinner())\n",
"\t\telse:\n",
"\t\t\tself.assertTrue(self.playerA.isWinner())\n",
"\t\t\tself.assertFalse(self.playerB.isWinner())\n",
"\n",
"\n",
"# Main\n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 36
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file tennis.py\n",
"\n",
"import random\n",
"\n",
"ZERO = \"0\"\n",
"FIFTEEN = \"15\"\n",
"THIRTY = \"30\"\n",
"FORTY = \"40\"\n",
"ADV = \"Adv\"\n",
"WIN = \"Win\"\n",
"\n",
"class Player:\n",
" \n",
" def __init__(self, score = ZERO):\n",
" self.scores = [ZERO,FIFTEEN,THIRTY,FORTY,ADV,WIN]\n",
" self.score = self.scores.index(score)\n",
" \n",
" def getScore(self):\n",
" return self.scores[self.score]\n",
" \n",
" def winPoint(self, other):\n",
" \n",
" if other.getScore() == ADV:\n",
" other.score -= 1\n",
" return \n",
" \n",
" if self.getScore() == FORTY and other.getScore() != FORTY:\n",
" self.score +=2\n",
" else:\n",
" self.score += 1\n",
" \n",
" def isWinner(self):\n",
" return self.getScore() == WIN\n",
" \n",
" def hasNoPoints(self):\n",
" return self.getScore() == ZERO\n",
" \n",
"class Match:\n",
"\tdef __init__(self):\n",
"\t\tpass\n",
"\tdef playMatch(self, playerA, playerB, game):\n",
"\t\twhile not(playerA.isWinner()) and not(playerB.isWinner()):\n",
"\t\t\tif game.getPlayerWhoScores() == \"A\" :\n",
"\t\t\t\tplayerA.winPoint(playerB)\n",
"\t\t\telse:\n",
"\t\t\t\tplayerB.winPoint(playerA)\n",
"\t\n",
"\n",
"class Play:\n",
"\tdef __init__(self, playerWhoScores):\n",
"\t\tself.player = playerWhoScores\n",
"\tdef getPlayerWhoScores(self):\n",
"\t\treturn self.player\n",
" \n",
"class RandomPlay:\n",
" \n",
" def __init__(self):\n",
" self.players = [\"A\",\"B\"]\n",
" self.values = {\"A\":0, \"B\":0}\n",
" \n",
" def getPlayerWhoScores(self):\n",
" c = random.randint(0,1)\n",
" self.values[self.players[c]] += 1\n",
" return self.players[c]\n",
" \n",
" def getValues(self):\n",
" return self.values\n",
" \n",
" def getMostScoredPlayer(self):\n",
" key = max(self.values, key = self.values.get)\n",
" return key\n",
" "
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting tennis.py\n"
]
}
],
"prompt_number": 37
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"...........\n",
"----------------------------------------------------------------------\n",
"Ran 11 tests in 0.001s\n",
"\n",
"OK\n"
]
}
],
"prompt_number": 38
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a name=\"ronda10\">ronda 10 </a>\n",
"\n",
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "heading",
"level": 2,
"metadata": {},
"source": [
"Decima ronda de test: Multiples partidos aleatorios"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file test_Tennis.py\n",
"\n",
"import unittest\n",
"from tennis import Player, ZERO, FIFTEEN, THIRTY, FORTY, ADV, WIN, Match, Play, RandomPlay\n",
"\n",
"class TestBase(unittest.TestCase):\n",
"\tdef createPlayers(self, scoreA = ZERO, scoreB = ZERO):\n",
"\t\tself.playerA = Player(scoreA)\n",
"\t\tself.playerB = Player(scoreB)\n",
"\n",
"class TestPlayer(TestBase): # Atencion a la herencia de test base\n",
"\t\n",
"\tdef winPoint(self):\n",
"\t\tself.playerA.winPoint(self.playerB)\n",
"\n",
"\tdef test_initialScore(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.assertEqual(ZERO, self.playerA.getScore())\n",
"\n",
"\tdef test_firstPoint(self):\n",
"\t\tself.createPlayers()\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FIFTEEN, self.playerA.getScore())\n",
"\n",
"\tdef test_secondPoint(self):\n",
"\t\tself.createPlayers(scoreA=FIFTEEN)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(THIRTY, self.playerA.getScore())\n",
"\n",
"\tdef test_thirdPoint(self):\n",
"\t\tself.createPlayers(scoreA=THIRTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\n",
"\tdef test_playerOnDeuceScroresandWinAdvantage(self):\n",
"\t\tself.createPlayers(FORTY, FORTY)\n",
"\t\tself.winPoint()\n",
"\t\tself.assertEqual(ADV, self.playerA.getScore())\n",
"\n",
"\tdef test_playerScoresAndOtherPlayerLosesAdvantage(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\tself.assertEqual(FORTY, self.playerA.getScore())\n",
"\t\tself.assertEqual(FORTY, self.playerB.getScore())\n",
"\n",
"\tdef test_playerWithAdvantageScoresAndWin(self):\n",
"\t\tself.createPlayers(ADV, FORTY)\n",
"\t\tself.winPoint()\n",
"\n",
"\t\tself.assertEqual(WIN, self.playerA.getScore())\n",
"\n",
"\tdef test_playerIsNotAWinner(self):\n",
"\t\tself.createPlayers()\n",
"\t\n",
"\t\tself.assertFalse(self.playerA.isWinner())\n",
"\t\n",
"\tdef test_playerWins(self):\n",
"\t\tself.createPlayers(ZERO, FORTY)\n",
"\t\tself.playerB.winPoint(self.playerA)\n",
"\t\t\n",
"\t\tself.assertTrue(self.playerB.isWinner())\n",
" \n",
" \n",
"class TestMatch(TestBase):\n",
" \n",
"\tdef test_playMatchAndPlayerAWins(self):\n",
"\t\tself.createPlayers(ZERO, ZERO)\n",
"\t\n",
"\t\tself.match = Match()\n",
"\t\tself.match.playMatch(self.playerA, self.playerB, Play(\"A\"))\n",
"\n",
"\t\tself.assertTrue(self.playerA.isWinner())\n",
"\t\tself.assertTrue(self.playerB.hasNoPoints())\n",
" \n",
"\tdef test_randomTesting(self):\n",
"\t\tself.createPlayers(ZERO, ZERO)\n",
"\t\n",
"\t\tr = RandomPlay()\n",
"\t\tself.match = Match()\n",
"\t\tself.match.playMatch(self.playerA, self.playerB, r)\n",
"\n",
"\t\tif r.getMostScoredPlayer() == \"B\":\n",
"\t\t\tself.assertTrue(self.playerB.isWinner())\n",
"\t\t\tself.assertFalse(self.playerA.isWinner())\n",
"\t\telse:\n",
"\t\t\tself.assertTrue(self.playerA.isWinner())\n",
"\t\t\tself.assertFalse(self.playerB.isWinner())\n",
" \n",
"\n",
"\tdef test_randomTestingManyMatches(self):\n",
"\t\tself.match = Match()\n",
"\t\ttests = 100000\n",
"\n",
"\t\tfor x in range(tests):\n",
"\t\t\tr = RandomPlay()\n",
"\t\t\tself.createPlayers(ZERO, ZERO)\n",
"\t\n",
"\t\t\tself.match.playMatch(self.playerA, self.playerB, r)\n",
"\n",
"\t\t\tif r.getMostScoredPlayer() == \"B\":\n",
"\t\t\t\tself.assertTrue(self.playerB.isWinner())\n",
"\t\t\t\tself.assertFalse(self.playerA.isWinner())\n",
"\t\t\t\t#print(\"Score A:\" , self.playerA.getScore(), \" Score B:\", self.playerB.getScore())\n",
"\t\t\telse:\n",
"\t\t\t\tself.assertTrue(self.playerA.isWinner())\n",
"\t\t\t\tself.assertFalse(self.playerB.isWinner())\n",
"\t\t\t\t#print(\"Score A:\" , self.playerA.getScore(), \" Score B:\", self.playerB.getScore())\n",
"\t\tprint(tests, \" random tenis games done.\")\n",
"\n",
"\n",
"\n",
"# Main\n",
"if __name__ == '__main__':\n",
" unittest.main()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting test_Tennis.py\n"
]
}
],
"prompt_number": 41
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python test_Tennis.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"..(100000, ' random tenis games done.')\n",
"..........\n",
"----------------------------------------------------------------------\n",
"Ran 12 tests in 4.818s\n",
"\n",
"OK\n"
]
}
],
"prompt_number": 42
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<a href=\"#indice\">Volver al Indice</a>"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [],
"language": "python",
"metadata": {},
"outputs": []
}
],
"metadata": {}
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment