lint

.gitignore

@@ -28,3 +28,4 @@ doc/_build
 doc/aws_hostname.1
 
 .coverage
+.cache

.travis.yml

@@ -9,13 +9,11 @@ python:
   - "3.6-dev"
   - "3.7-dev"
   - "nightly"
-# command to install dependencies
-install: "pip install -r tests/requirements.txt"
-# command to run tests
-script: nosetests
+install:
+  - pip install -r requirements.txt
+  - pip install -r tests/requirements.txt
+before_script: flake8
+script: pytest --cov=pytest
 sudo: required
-branches:
-  only:
-    - master
 after_success:
   coveralls

pytube/jsinterp.py

@@ -120,8 +120,10 @@ class JSInterpreter(object):
         except ValueError:
             pass
 
-        m = re.match(r'(?P<var>%s)\.(?P<member>[^(]+)'
-                     r'(?:\(+(?P<args>[^()]*)\))?$' % _NAME_RE, expr)
+        m = re.match(
+            r'(?P<var>%s)\.(?P<member>[^(]+)'
+            '(?:\(+(?P<args>[^()]*)\))?$' % _NAME_RE,
+            expr)
         if m:
             variable = m.group('var')
             member = m.group('member')
@@ -213,9 +215,8 @@ class JSInterpreter(object):
         obj = {}
         obj_m = re.search(
             (r'(?:var\s+)?%s\s*=\s*\{' % re.escape(objname)) +
-            r'\s*(?P<fields>([a-zA-Z$0-9]+\s*:\s*function\(.*?\)\s*\'' +
-            r'{.*?\}(?:,\s*)?)*)' +
-            r'\}\s*;',
+            r'\s*(?P<fields>([a-zA-Z$0-9]+\s*:\s*function\(.*?\)\s*\{.*?\}'
+            r'(?:,\s*)?)*)' + r'\}\s*;',
             self.code)
         fields = obj_m.group('fields')
         # Currently, it only supports function definitions

tests/conftest.py

@@ -0,0 +1,24 @@
+import mock
+import pytest
+
+from pytube import api
+
+
+@pytest.fixture
+def yt_video():
+    url = 'http://www.youtube.com/watch?v=9bZkp7q19f0'
+    mock_html = None
+    mock_js = None
+
+    with open('tests/mock_data/youtube_gangnam_style.html') as fh:
+        mock_html = fh.read()
+
+    with open('tests/mock_data/youtube_gangnam_style.js') as fh:
+        mock_js = fh.read()
+
+    with mock.patch('pytube.api.urlopen') as urlopen:
+        urlopen.return_value.read.return_value = mock_html
+        yt = api.YouTube()
+        yt._js_cache = mock_js
+        yt.from_url(url)
+        return yt

tests/requirements.txt

@@ -1,5 +1,6 @@
 bumpversion==0.5.3
 coveralls==1.0
 mock==1.3.0
-nose==1.3.7
 pre-commit==0.15.0
+pytest==3.1.3
+pytest-cov==2.4.0

tests/test_pytube.py

@@ -1,140 +1,130 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from __future__ import unicode_literals
-
 import warnings
 
 import mock
-from nose.tools import eq_
-from nose.tools import raises
+import pytest
 
 from pytube import api
 from pytube.exceptions import AgeRestricted
-from pytube.exceptions import DoesNotExist
 from pytube.exceptions import MultipleObjectsReturned
 from pytube.exceptions import PytubeError
 
 
-class TestPytube(object):
-    def setUp(self):
-        url = 'http://www.youtube.com/watch?v=9bZkp7q19f0'
-
-        with open('tests/mock_data/youtube_gangnam_style.html') as fh:
-            self.mock_html = fh.read()
-
-        with open('tests/mock_data/youtube_gangnam_style.js') as fh:
-            self.mock_js = fh.read()
-
-        with mock.patch('pytube.api.urlopen') as urlopen:
-            urlopen.return_value.read.return_value = self.mock_html
-            self.yt = api.YouTube()
-            self.yt._js_cache = self.mock_js
-            self.yt.from_url(url)
-
-    def test_get_video_id(self):
-        """Resolve the video id from url"""
-        eq_(self.yt.video_id, '9bZkp7q19f0')
-
-    def test_auto_filename(self):
-        """Generate safe filename based on video title"""
-        expected = 'PSY - GANGNAM STYLE(\uac15\ub0a8\uc2a4\ud0c0\uc77c) MV'
-
-        eq_(self.yt.filename, expected)
-
-    def test_manual_filename(self):
-        """Manually set a filename"""
-        expected = 'PSY - Gangnam Style'
-
-        self.yt.set_filename(expected)
-        eq_(self.yt.filename, expected)
-
-    def test_get_all_videos(self):
-        """Get all videos"""
-        eq_(len(self.yt.get_videos()), 6)
-
-    def test_filter_video_by_extension(self):
-        """Filter videos by filetype"""
-        eq_(len(self.yt.filter('mp4')), 2)
-        eq_(len(self.yt.filter('3gp')), 2)
-        eq_(len(self.yt.filter('webm')), 1)
-        eq_(len(self.yt.filter('flv')), 1)
-
-    def test_filter_video_by_extension_and_resolution(self):
-        """Filter videos by file extension and resolution"""
-        eq_(len(self.yt.filter('mp4', '720p')), 1)
-        eq_(len(self.yt.filter('mp4', '1080p')), 0)
-
-    def test_filter_video_by_extension_resolution_profile(self):
-        """Filter videos by file extension, resolution, and profile"""
-        eq_(len(self.yt.filter('mp4', '360p', 'Baseline')), 1)
-
-    def test_filter_video_by_profile(self):
-        """Filter videos by file profile"""
-        eq_(len(self.yt.filter(profile='Simple')), 2)
-
-    def test_filter_video_by_resolution(self):
-        """Filter videos by resolution"""
-        eq_(len(self.yt.filter(resolution='360p')), 2)
-
-    @raises(MultipleObjectsReturned)
-    def test_get_multiple_items(self):
-        """get(...) cannot return more than one video"""
-        self.yt.get(profile='Simple')
-        self.yt.get('mp4')
-        self.yt.get(resolution='240p')
-
-    @raises(DoesNotExist)
-    def test_get_does_not_exist(self):
-        """get(...) must return something"""
-        self.yt.get('mp4', '1080p')
-
-    @raises(AgeRestricted)
-    def test_age_restricted_video(self):
-        """Raise exception on age restricted video"""
-        url = 'http://www.youtube.com/watch?v=nzNgkc6t260'
-
-        with open('tests/mock_data/youtube_age_restricted.html') as fh:
-            mock_html = fh.read()
-
-        with mock.patch('pytube.api.urlopen') as urlopen:
-            urlopen.return_value.read.return_value = mock_html
-            yt = api.YouTube()
-            yt.from_url(url)
-
-    def test_deprecation_warnings_on_url_set(self):
-        """Deprecation warnings get triggered on url set"""
-        with warnings.catch_warnings(record=True) as w:
-            # Cause all warnings to always be triggered.
-            warnings.simplefilter('always')
-            with mock.patch('pytube.api.urlopen') as urlopen:
-                urlopen.return_value.read.return_value = self.mock_html
-                yt = api.YouTube()
-                yt._js_cache = self.mock_js
-                yt.url = 'http://www.youtube.com/watch?v=9bZkp7q19f0'
-            eq_(len(w), 1)
-
-    def test_deprecation_warnings_on_filename_set(self):
-        """Deprecation warnings get triggered on filename set"""
-        with warnings.catch_warnings(record=True) as w:
-            # Cause all warnings to always be triggered.
-            warnings.simplefilter('always')
-            self.yt.filename = 'Gangnam Style'
-            eq_(len(w), 1)
-
-    def test_deprecation_warnings_on_videos_get(self):
-        """Deprecation warnings get triggered on video getter"""
-        with warnings.catch_warnings(record=True) as w:
-            # Cause all warnings to always be triggered.
-            warnings.simplefilter('always')
-            self.yt.videos
-            eq_(len(w), 1)
-
-    def test_get_json_offset(self):
-        """Find the offset in the html for where the js starts"""
-        offset = self.yt._get_json_offset(self.mock_html)
-        eq_(offset, 312)
-
-    @raises(PytubeError)
-    def test_get_json_offset_with_bad_html(self):
-        """Raise exception if json offset cannot be found"""
-        self.yt._get_json_offset('asdfasdf')
+def test_video_id(yt_video):
+    """Resolve the video id from url"""
+    assert yt_video.video_id == '9bZkp7q19f0'
+
+
+def test_auto_filename(yt_video):
+    """Generate safe filename based on video title"""
+    expected = 'PSY - GANGNAM STYLE(\uac15\ub0a8\uc2a4\ud0c0\uc77c) MV'
+    assert yt_video.filename == expected
+
+
+def test_manual_filename(yt_video):
+    """Manually set a filename"""
+    expected = 'PSY - Gangnam Style'
+    yt_video.set_filename(expected)
+    assert yt_video.filename == expected
+
+
+def test_get_all_videos(yt_video):
+    """Get all videos"""
+    assert len(yt_video.get_videos()) == 6
+
+
+def test_filter_video_by_extension(yt_video):
+    """Filter videos by filetype"""
+    assert len(yt_video.filter('mp4')) == 2
+    assert len(yt_video.filter('3gp')) == 2
+    assert len(yt_video.filter('webm')) == 1
+    assert len(yt_video.filter('flv')) == 1
+
+
+def test_filter_video_by_extension_and_resolution(yt_video):
+    """Filter videos by file extension and resolution"""
+    assert len(yt_video.filter('mp4', '720p')) == 1
+    assert len(yt_video.filter('mp4', '1080p')) == 0
+
+
+def test_filter_video_by_extension_resolution_profile(yt_video):
+    """Filter videos by file extension, resolution, and profile"""
+    assert len(yt_video.filter('mp4', '360p', 'Baseline')) == 1
+
+
+def test_filter_video_by_profile(yt_video):
+    """Filter videos by file profile"""
+    assert len(yt_video.filter(profile='Simple')) == 2
+
+
+def test_filter_video_by_resolution(yt_video):
+    """Filter videos by resolution"""
+    assert len(yt_video.filter(resolution='360p')) == 2
+
+
+def test_get_multiple_items(yt_video):
+    """get(...) cannot return more than one video"""
+    with pytest.raises(MultipleObjectsReturned):
+        yt_video.get(profile='Simple')
+        yt_video.get('mp4')
+        yt_video.get(resolution='240p')
+
+
+def test_age_restricted_video():
+    """Raise exception on age restricted video"""
+    mock_html = None
+
+    with open('tests/mock_data/youtube_age_restricted.html') as fh:
+        mock_html = fh.read()
+
+    with mock.patch('pytube.api.urlopen') as urlopen:
+        urlopen.return_value.read.return_value = mock_html
+        yt = api.YouTube()
+
+        with pytest.raises(AgeRestricted):
+            yt.from_url('http://www.youtube.com/watch?v=nzNgkc6t260')
+
+
+def test_deprecation_warnings_on_url_set(yt_video):
+    """Deprecation warnings get triggered on url set"""
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter('always')
+        yt_video.url = 'http://www.youtube.com/watch?v=9bZkp7q19f0'
+        assert len(w) == 1
+
+
+def test_deprecation_warnings_on_filename_set(yt_video):
+    """Deprecation warnings get triggered on filename set"""
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter('always')
+        yt_video.filename = 'Gangnam Style'
+        assert len(w) == 1
+
+
+def test_deprecation_warnings_on_videos_get(yt_video):
+    """Deprecation warnings get triggered on video getter"""
+    with warnings.catch_warnings(record=True) as w:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter('always')
+        yt_video.videos
+        assert len(w) == 1
+
+
+def test_get_json_offset(yt_video):
+    """Find the offset in the html for where the js starts"""
+    mock_html = None
+
+    with open('tests/mock_data/youtube_gangnam_style.html') as fh:
+        mock_html = fh.read()
+
+    offset = yt_video._get_json_offset(mock_html)
+    assert offset == 312
+
+
+def test_get_json_offset_with_bad_html(yt_video):
+    """Raise exception if json offset cannot be found"""
+    with pytest.raises(PytubeError):
+        yt_video._get_json_offset('asdfasdf')

tests/test_utils.py

@@ -2,32 +2,32 @@
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
-from nose.tools import eq_
-
 from pytube import utils
 
 
-class TestUtils(object):
-    blob = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit'
-
-    def test_truncate(self):
-        """Truncate string works as expected"""
-        truncated = utils.truncate(self.blob, 11)
-        eq_(truncated, 'Lorem ipsum')
-
-    def test_safe_filename(self):
-        """Unsafe characters get stripped from generated filename"""
-        eq_(utils.safe_filename('abc1245$$'), 'abc1245')
-        eq_(utils.safe_filename('abc##'), 'abc')
-        eq_(utils.safe_filename('abc:foo'), 'abc -foo')
-        eq_(utils.safe_filename('abc_foo'), 'abc foo')
-
-    def test_sizeof(self):
-        """Accurately converts the bytes to its humanized equivalent"""
-        eq_(utils.sizeof(1), '1 byte')
-        eq_(utils.sizeof(2), '2 bytes')
-        eq_(utils.sizeof(2400), '2 KB')
-        eq_(utils.sizeof(2400000), '2 MB')
-        eq_(utils.sizeof(2400000000), '2 GB')
-        eq_(utils.sizeof(2400000000000), '2 TB')
-        eq_(utils.sizeof(2400000000000000), '2 PB')
+blob = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit'
+
+
+def test_truncate():
+    """Truncate string works as expected"""
+    truncated = utils.truncate(blob, 11)
+    assert truncated == 'Lorem ipsum'
+
+
+def test_safe_filename():
+    """Unsafe characters get stripped from generated filename"""
+    assert utils.safe_filename('abc1245$$') == 'abc1245'
+    assert utils.safe_filename('abc##') == 'abc'
+    assert utils.safe_filename('abc:foo') == 'abc -foo'
+    assert utils.safe_filename('abc_foo') == 'abc foo'
+
+
+def test_sizeof():
+    """Accurately converts the bytes to its humanized equivalent"""
+    assert utils.sizeof(1) == '1 byte'
+    assert utils.sizeof(2) == '2 bytes'
+    assert utils.sizeof(2400) == '2 KB'
+    assert utils.sizeof(2400000) == '2 MB'
+    assert utils.sizeof(2400000000) == '2 GB'
+    assert utils.sizeof(2400000000000) == '2 TB'
+    assert utils.sizeof(2400000000000000) == '2 PB'