11 Testing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Программирование на Python (SCS)](https://compscicenter.ru/courses/python/2015-autumn/classes/)\n",
    "\n",
    "### Лектор Сергей Лебедев. Дата проведения лекции - 23 ноября 2015\n",
    "\n",
    "# 11. Тестирование\n",
    "\n",
    "### Тестировать или не тестировать? \n",
    "\n",
    "`Здесь и далее под тестированием имеется в виду модульное (и иногда\n",
    "интеграционное) тестирование aka unit testing`\n",
    "\n",
    "Тестировать:\n",
    "- тесты проверяют корректность кода\n",
    "- и позволяют бесстрашно изменять код даже в больших\n",
    "проектах.\n",
    "\n",
    "Не тестировать:\n",
    "- написание тестов требует времени,\n",
    "- нередко в проекте тестов больше чем кода,\n",
    "- работающие тесты не гарантируют корректность.\n",
    "\n",
    "Тем не менее, ответ очевиден: конечно же тестировать!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('m', 1),\n",
       " ('i', 1),\n",
       " ('s', 2),\n",
       " ('i', 1),\n",
       " ('s', 2),\n",
       " ('i', 1),\n",
       " ('p', 1),\n",
       " ('i', 1)]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import itertools\n",
    "def rle(iterable):\n",
    "    \"\"\"Applies run-length encoding to an iterable\"\"\"\n",
    "    for item, g in itertools.groupby(iterable):\n",
    "        yield item, sum(1 for _ in g)\n",
    "        \n",
    "list(rle(\"mississipi\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 3. Тестирование с помощью print\n",
    "Функция **print** позволяет организовать\n",
    "полуавтоматическое тестирование вне интерактивной\n",
    "оболочки.\n",
    "- Интерпретатор печатает — вы проверяете:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('m', 1), ('i', 1), ('s', 2), ('i', 1), ('s', 2), ('i', 1), ('p', 2), ('i', 1)]\n"
     ]
    }
   ],
   "source": [
    "def test_rle():\n",
    "    print(list(rle(\"mississippi\")))\n",
    "test_rle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('inner', None)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "identity = trace(identity)\n",
    "identity.__name__, identity.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 4. Доктесты\n",
    " https://docs.python.org/3/library/doctest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "**********************************************************************\n",
      "File \"__main__\", line 7, in __main__.rle\n",
      "Failed example:\n",
      "    list(rle(\"mississippi\"))\n",
      "Expected:\n",
      "    [('m', 1), ('i', 1), ('s', 2), ('i', 1), \n",
      "    ('s', 2), ('i', 1), ('p', 2), ('i', 1)]\n",
      "Got:\n",
      "    [('m', 1), ('i', 1), ('s', 2), ('i', 1), ('s', 2), ('i', 1), ('p', 2), ('i', 1)]\n",
      "**********************************************************************\n",
      "1 items had failures:\n",
      "   1 of   2 in __main__.rle\n",
      "***Test Failed*** 1 failures.\n"
     ]
    }
   ],
   "source": [
    "import doctest\n",
    "import itertools\n",
    "def rle(iterable):\n",
    "    \"\"\"Applies run-length encoding to an iterable.\n",
    "    >>> list(rle(\"\"))\n",
    "    []\n",
    "    >>> list(rle(\"mississippi\"))\n",
    "    [('m', 1), ('i', 1), ('s', 2), ('i', 1), \n",
    "    ('s', 2), ('i', 1), ('p', 2), ('i', 1)]\n",
    "    \"\"\"\n",
    "    for item, g in itertools.groupby(iterable):\n",
    "        yield item, sum(1 for _ in g)\n",
    "        \n",
    "if __name__ == \"__main__\":\n",
    "    doctest.testmod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Директивы позволяют изменить то, как doctest сравнивает ожидаемый вывод интерпретатора с фактическим.\n",
    "\n",
    "Например, директива `NORMALIZE_WHITESPACE` нормализует пробельные символы перед сравнением:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('m', 1),\n",
       " ('i', 1),\n",
       " ('s', 2),\n",
       " ('i', 1),\n",
       " ('s', 2),\n",
       " ('i', 1),\n",
       " ('p', 2),\n",
       " ('i', 1)]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(rle(\"mississippi\"))\n",
    "... # doctest: +NORMALIZE_WHITESPACE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А директива `ELLIPSIS` позволяет использовать символ ... ,\n",
    "который совпадает с любой строкой:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('m', 1),\n",
       " ('i', 1),\n",
       " ('s', 2),\n",
       " ('i', 1),\n",
       " ('s', 2),\n",
       " ('i', 1),\n",
       " ('p', 2),\n",
       " ('i', 1)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(rle(\"mississippi\"))\n",
    "... # doctest: +ELLIPSIS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Модуль **doctest** позволяет проверить реализацию функции\n",
    "на соответствие записанному сеансу интерпретатора.\n",
    "Плюсы:\n",
    "- доступен в стандартной библиотеке,\n",
    "- решает задачу тестирования для небольших проектов,\n",
    "- доктесты их легко читать,\n",
    "- примеры кода в документации всегда актуальны.\n",
    " \n",
    " \n",
    "Минусы:\n",
    "- доктесты требуют, чтобы у результата было содержательное\n",
    "строковое представление,\n",
    "- длинные доктесты ухудшают читаемость документации,\n",
    "- нет способа запустить подмножество доктестов,\n",
    "- если в середине доктеста произошла ошибка, оставшаяся\n",
    "часть не выполнится."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cлайд 7. Assert\n",
    "Напоминание:\n",
    "- оператор assert принимает два аргумента: условие и\n",
    "произвольное значение,\n",
    "- если условие falsy, оператор поднимает исключение\n",
    "**AssertionError **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "42",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-5799a4817d38>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m42\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: 42"
     ]
    }
   ],
   "source": [
    "assert [], 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Протестируем функцию rle :\n",
    "def test_rle():\n",
    "    s = \"mississippi\"\n",
    "    tmp = set(ch for ch, _count in rle(s))\n",
    "    assert tmp == set(s[:-1] + s[1])\n",
    "    assert not list(rle(\"\"))\n",
    "\n",
    "test_rle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'i', 'm', 'p', 's'}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"mississippi\"\n",
    "set(ch for ch, _count in rle(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(rle(\"\"))\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 9. Признаки хорошего теста\n",
    "Хороший тест:\n",
    "- корректный,\n",
    "- понятный читателю,\n",
    "- конкретный, то есть проверяет что-то одно.\n",
    "\n",
    "\n",
    "Попробуем улучшить тест для функции rle \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-42-b632e7bef9fc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0mtest_rle_empty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mtest_rle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-42-b632e7bef9fc>\u001b[0m in \u001b[0;36mtest_rle\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m     assert rle(\"mississippi\") == [\n\u001b[1;32m      3\u001b[0m         \u001b[0;34m(\u001b[0m\u001b[0;34m'm'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'i'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m's'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'i'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m         \u001b[0;34m(\u001b[0m\u001b[0;34m's'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'i'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'p'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m'i'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m         ]\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "def test_rle():\n",
    "    assert rle(\"mississippi\") == [\n",
    "        ('m', 1), ('i', 1), ('s', 2), ('i', 1),\n",
    "        ('s', 2), ('i', 1), ('p', 2), ('i', 1)\n",
    "        ]\n",
    "\n",
    "def test_rle_empty():\n",
    "    assert not list(rle(\"\"))\n",
    "\n",
    "test_rle_empty()\n",
    "test_rle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "<generator object rle at 0x7f18f5a88570> != [('m', 1), ('i', 1), ('s', 2), ('i', 1), ('s', 2), ('i', 1), ('p', 2), ('i', 1)]",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-44-2a400222f121>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0;32massert\u001b[0m \u001b[0mactual\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mexpected\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mtest_rle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-44-2a400222f121>\u001b[0m in \u001b[0;36mtest_rle\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m         ]\n\u001b[1;32m      9\u001b[0m     \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"{} != {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mactual\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexpected\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0mactual\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mexpected\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmessage\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mtest_rle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: <generator object rle at 0x7f18f5a88570> != [('m', 1), ('i', 1), ('s', 2), ('i', 1), ('s', 2), ('i', 1), ('p', 2), ('i', 1)]"
     ]
    }
   ],
   "source": [
    "# Второй аргумент оператора assert используется для\n",
    "# сообщения об ошибке:\n",
    "def test_rle():\n",
    "    actual = rle(\"mississippi\")\n",
    "    expected = [\n",
    "        ('m', 1), ('i', 1), ('s', 2), ('i', 1),\n",
    "        ('s', 2), ('i', 1), ('p', 2), ('i', 1)\n",
    "        ]\n",
    "    message = \"{} != {}\".format(actual, expected)\n",
    "    assert actual == expected, message\n",
    "\n",
    "test_rle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 11. Функция assert_equal\n",
    "\n",
    "Добавим сообщение об ошибке к тесту `test_rle_empty `"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_rle_empty(): # ^C/^V\n",
    "    actual = list(rle(\"\"))\n",
    "    expected = []\n",
    "    message = \"{} != {}\".format(actual, expected)\n",
    "    assert actual == expected, message\n",
    "    \n",
    "# Самое время вынести логику сравнения в отдельную\n",
    "# функцию:\n",
    "def assert_equal(x, y):\n",
    "    assert x == y, \"{} != {}\".format(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color=blue>Вопрос</font>:<br> \n",
    "что делать, если мы также хотим проверять\n",
    "утверждения вида `(\"a\", 2) in rle(...)`? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 12. assert: резюме\n",
    "\n",
    "Оператор assert можно использовать для написания\n",
    "тестов.\n",
    "Плюсы:\n",
    "- тесты c assert легко читать,\n",
    "- они не используют ничего кроме стандартных средств\n",
    "языка,\n",
    "- в отличие от доктестов это обычные функции.\n",
    "\n",
    "Минусы:\n",
    "- запускать тесты нужно вручную,\n",
    "- их сложно отлаживать, потому что\n",
    " для каждого типа утверждения приходится самостоятельно\n",
    "конструировать сообщение об ошибке."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cлайд 13. Модуль unittest\n",
    " https://docs.python.org/3/library/unittest\n",
    " \n",
    "Модуль unittest реализует функциональность JUnit для\n",
    "тестирования кода на Python.\n",
    "- Наследие Java до сих пор в обилии присутствует в API.\n",
    "- Перепишем имеющиеся тесты с использованием unittest \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E\n",
      "======================================================================\n",
      "ERROR: /home/nenu/ (unittest.loader._FailedTest)\n",
      "----------------------------------------------------------------------\n",
      "AttributeError: module '__main__' has no attribute '/home/nenu/'\n",
      "\n",
      "----------------------------------------------------------------------\n",
      "Ran 1 test in 0.001s\n",
      "\n",
      "FAILED (errors=1)\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "True",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m True\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/nenu/.local/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3334: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class TestHomework(unittest.TestCase):\n",
    "    def test_rle(self):\n",
    "        self.assertEqual(rle(\"mississippi\"), [...])\n",
    "        \n",
    "    def test_rle_empty(self):\n",
    "        self.assertEqual(list(rle(\"\")), [])\n",
    "        \n",
    "if __name__ == \"__main__\":\n",
    "    unittest.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cлайд 15. Функция unittest.main\n",
    "\n",
    "Функция unittest.main загружает все тесты текущего\n",
    "модуля и запускает их.\n",
    "- Тест — метод экземпляра unittest.TestCase ,\n",
    "начинающийся на test .\n",
    "- При необходимости тесты можно объединять в группы с\n",
    "помощью класса unittest.TestSuite :\n",
    "```\n",
    "suite = unittest.TestSuite([\n",
    "    TestHomework(),\n",
    "    TestSomethingElse()\n",
    "])\n",
    "```\n",
    "- Указывать вручную, что нужно запустить довольно досадно.\n",
    "\n",
    "Вопрос: можно ли лучше?"
   ]
  },
  {
   "attachments": {
    "Screenshot_2.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 17. Методы unittest.TestCase\n",
    "![Screenshot_2.png](attachment:Screenshot_2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 18. Модуль unittest и контекст\n",
    "? aka fixtures — способ подготовить контекст, в котором\n",
    "будут запускаться тесты.\n",
    "- Это можно использовать, например, для работы с\n",
    "ресурсами: сокетами, файлами, временными\n",
    "директориями.\n",
    "\n",
    "Пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestHomeworkWithOracle(unittest.TestCase):\n",
    "    def setUp(self):\n",
    "        self.oracle = RleOracle(\"http://oracle.rle.com\")\n",
    "    def test_rle_against_oracle(self):\n",
    "        s = \"mississippi\"\n",
    "        self.assertEqual(list(rle(s)), self.oracle(s))\n",
    "    def tearDown(self):\n",
    "        self.oracule.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 19. Модуль unittest: резюме\n",
    "Модуль **unittest** — клон JUnit для Python.\n",
    "\n",
    "Мы обсудили\n",
    "- основные сущности unittest ,\n",
    "- как писать и запускать тесты,\n",
    "- какие полезные методы имеются в классе `unittest.TestCase` .\n",
    "\n",
    "Плюсы:\n",
    "- доступен в стандартной библиотеке,\n",
    "- выводит понятные сообщения об ошибках,\n",
    "- умеет автоматически находить тесты.\n",
    "\n",
    "Минусы:\n",
    "- API унаследован от Java,\n",
    "- заставляет писать много лишнего кода,\n",
    "- читать **unittest** тесты сложнее, чем доктесты и тесты,\n",
    "использующие assert "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 20. Пакет py.test\n",
    " https://pytest.org\n",
    " \n",
    "Пакет `py.test` — популярная альтернатива **unittest** для\n",
    "написания и запуска тестов.\n",
    "- Отличительная особенность `py.test` — практически\n",
    "полное отсутствие API: тесты можно писать, используя\n",
    "стандартные средства языка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_rle():\n",
    "    assert rle(\"mississippi\") == [\n",
    "        ('m', 1), ('i', 1), ('s', 2), ('i', 1),\n",
    "        ('s', 2), ('i', 1), ('p', 2), ('i', 1)\n",
    "    ]\n",
    "    \n",
    "def test_rle_empty():\n",
    "    assert not list(rle(\"\"))\n",
    "    \n",
    "#  python -m pytest -q test_pytest.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 22. Пакет py.test: интерфейс командной строки\n",
    "Запустить `py.test` можно 1001 способом, например:\n",
    "- найти тесты в текущей директории и во всех вложенных\n",
    "директориях и запустить их:<br>\n",
    "```$ python -m pytest```\n",
    "- найти и запустить тесты в указанном файле:<br>\n",
    "```$ python -m pytest test_pytest.py```\n",
    "- запустить один тест в файле по имени:<br>\n",
    "```$ python -m pytest test_pytest.py::test_rle```\n",
    "\n",
    "Что такое тест для `py.test`?  \n",
    "https://pytest.org/latest/goodpractises.html\n",
    "- функция test_* ,\n",
    "- метод test_* в классе Test* или в классе, наследующемся\n",
    "от unittest.TestCase ,\n",
    "- доктест, если py.test был запущен с параметром\n",
    "```--doctest-modules ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 24.Возможности py.test: raises"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def  test_undo_dict_exceptions():\n",
    "    d = UndoDict()\n",
    "    with pytest.raises(KeyError):\n",
    "        d[\"foo\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# Слайд 25. Возможности py.test: параметрические тесты\n",
    "\n",
    "Параметрические тесты позволяют писать тесты, которые работают с разными данными"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cut_suffix(s, suffix):\n",
    "    \"\"\"Принимает строку, суффикс и возвращает строку без суффикса\n",
    "    \n",
    "    - намеренно неверная реализация, чтобы тест сработал.\n",
    "    Ошибка в том, что rfind возвращает -1 если ничего не нашел, а в слайсе это\n",
    "    предпоследний элемент\n",
    "    \"\"\"\n",
    "    return s[:s.rfind(suffix)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'refrigerat'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"refrigerator\"\n",
    "cut_suffix(s, \"or\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fooba'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"foobar\"\n",
    "cut_suffix(s, \"boo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rfind(\"boo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Тестируем cut_suffix с помощью параметрического теста:\n",
    "import pytest\n",
    "@pytest.mark.parametrize(\"s,suffix,expected\", [\n",
    "    (\"foobar\", \"bar\", \"foo\"),\n",
    "    (\"foobar\", \"boo\", \"foobar\"),\n",
    "    (\"foobarbar\", \"bar\", \"foobar\")\n",
    "])\n",
    "def test_ctu_suffix(s, suffix, expected):\n",
    "    assert cut_suffix(s, suffix) == expected\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 29. -------------------\n",
    "• С помощью функции partial можно зафиксировать часть\n",
    "позиционных и ключевых аргументов в функции.\n",
    "\n",
    "• Выполнившие домашнее задание узнают в partial\n",
    "расширение функции curry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('b', 2), ('a', 4)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = functools.partial(sorted, key=lambda p: p[1])\n",
    "f([(\"a\", 4), (\"b\", 2)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = functools.partial(sorted, [2, 3, 1, 4])\n",
    "g()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Функция пребразует строки, записанные в двоичном формате в целое число\n",
    "ff = functools.partial(int, base=2)\n",
    "ff('101011')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 30. Обобщённые (мультиметоды) функции\n",
    "Функция len называется обобщённой, так как её\n",
    "реализация может быть специализирована для\n",
    "конкретного типа\n",
    "```\n",
    ">>> len([1, 2, 3, 4])\n",
    "4\n",
    ">>> len({1, 2, 3, 4})\n",
    "4\n",
    ">>> len(range(4))\n",
    "4\n",
    "• Примеры обобщённых функций в Python:\n",
    ">>> str([1, 2, 3, 4])\n",
    "'[1, 2, 3, 4]'\n",
    ">>> hash((1, 2, 3, 4))\n",
    "485696759010151909\n",
    ">>> sum([[1], [2]], [])\n",
    "[1, 2]\n",
    "• Как реализовать свою обобщённую функцию?\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 30. singledispatch \n",
    "- декоратор, который позволяет писать функции, которые по-разному работают, в зависимости от передаваемых аргументов.\n",
    "Для примера напишем функцию, которая упаковывает переданное её значение в бинарную строку (серилизует).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'LI0x1,I0x2,I0x4'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Базовая ф-ия для случаев, если остальные не подошли\n",
    "# Вызываем assert и пишем \"неподходящий тип\"\n",
    "@functools.singledispatch\n",
    "def pack(obj): \n",
    "    type_name = type(obj).__name__\n",
    "    assert False, \"Unsupported type: \" + type_name\n",
    "    \n",
    "#  Далее перечисляем особые случаи - для каждого типа своя ф-ия:\n",
    "@pack.register(int)\n",
    "def _(obj):\n",
    "    return b\"I\" + hex(obj).encode(\"ascii\")\n",
    "\n",
    "@pack.register(list)\n",
    "def _(obj):\n",
    "    return b\"L\" + b\",\".join(map(pack, obj))\n",
    "\n",
    "pack([1, 2, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "Unsupported type: float",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-6cb62133dda6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m42.\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/lib/python3.6/functools.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m    805\u001b[0m                             '1 positional argument')\n\u001b[1;32m    806\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 807\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mdispatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    808\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    809\u001b[0m     \u001b[0mfuncname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'__name__'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'singledispatch function'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-28-d4f246b11b47>\u001b[0m in \u001b[0;36mpack\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mpack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mtype_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0;32massert\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"Unsupported type: \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mtype_name\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;31m#  Далее перечисляем особые случаи - для каждого типа своя ф-ия:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: Unsupported type: float"
     ]
    }
   ],
   "source": [
    "# При передаче неподдерживаего типа - ошибка\n",
    "pack(42.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Слайд 32. Свёртка, мотивация для reduce"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Функцию суммирования\n",
    "sum([1, 2, 3, 4])\n",
    "# можно записать скобочками:\n",
    "(((0 + 1) + 2) + 3) + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Что если мы захотим использовать другую бинарную \n",
    "# операцию, например, умножение?\n",
    "(((1 * 1) * 2) * 3) * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# То, что знак + может быть легко заменён другой операцией без изменения\n",
    "# порядка вычеслений, называется `левой свёрткой` = reduce:\n",
    "functools.reduce(lambda acc, x: acc + x, [1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# примеры применения reduce:\n",
    "Функция reduce принимает три аргумента: бинарную\n",
    "функцию и последовательность.\n",
    "\n",
    "• Вычисление reduce(op, xs) можно схематично\n",
    "представить как:\n",
    "```\n",
    "op(op(op(op(xs[0]), xs[1]), xs[2]), ...)\n",
    "op(op(op(xs[0], xs[1]), xs[2]), ...)```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "functools.reduce(lambda acc, s: 10*acc + int(s), [1, 13])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1912"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Преобразование строки с числом в инт (извращенный эквивалент int(\"1912\"))\n",
    "#      acc  +  s  =  result\n",
    "# 1.    0      1       1\n",
    "# 1.  1*10     9       19\n",
    "# 1.  19*10    1       191\n",
    "# 1.  191*10   2       1912\n",
    "\n",
    "functools.reduce(lambda acc, s: 10*int(acc) + int(s), \"1912\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 5, 6, 7]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ф-я merge, которая сливает два сортиррованных списка\n",
    "def merge(list1, list2):\n",
    "    return sorted(list1 + list2)\n",
    "\n",
    "# можно обобщить на произвольное количество списков\n",
    "functools.reduce(merge, [[1, 2, 7], [5, 6], [0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# reduce: резюме\n",
    "• Несмотря на свою популярность в функциональных\n",
    "языках, в Python довольно сложно придумать полезный\n",
    "пример использования reduce.\n",
    "\n",
    "• Резюме про reduce:\n",
    "- работает с любым объектом, поддерживающим протокол\n",
    "итератора;\n",
    "- работает слева направо;\n",
    "- использует первый элемент последовательности, если\n",
    "начальное значение не указано явно.\n",
    "\n",
    "# functools: резюме\n",
    "• Модуль functools украшает будни любителя\n",
    "функционального программирования.\n",
    "\n",
    "• Мы поговорили про:\n",
    "- lru_cache\n",
    "- partial\n",
    "- singledispatch\n",
    "- reduce"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}