Github3 tests failing

gistfile1.txt

(github3)Matts-MacBook-Air:github3.py mattchung$ make tests >> /tmp/github3_errors.txt 
no previously-included directories found matching '*.pyc'
no previously-included directories found matching 'docs/_build'
make: *** [travis] Error 1
(github3)Matts-MacBook-Air:github3.py mattchung$ view /tmp/github3_errors.txt 

Processing /Users/mattchung/Development/github3.py
  Requirement already satisfied (use --upgrade to upgrade): github3.py==1.0.0a2 from file:///Users/mattchung/Development/github3.py in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from -r dev-requirements.txt (line 1))
Requirement already satisfied (use --upgrade to upgrade): mock==1.0.1 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from -r dev-requirements.txt (line 2))
Requirement already satisfied (use --upgrade to upgrade): pytest>=2.3.5 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from -r dev-requirements.txt (line 3))
Requirement already satisfied (use --upgrade to upgrade): wheel==0.21.0 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from -r dev-requirements.txt (line 4))
Requirement already satisfied (use --upgrade to upgrade): betamax>=0.5.0 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from -r dev-requirements.txt (line 5))
Requirement already satisfied (use --upgrade to upgrade): betamax-matchers>=0.2.0 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from -r dev-requirements.txt (line 6))
Requirement already satisfied (use --upgrade to upgrade): requests>=2.0 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from github3.py==1.0.0a2->-r dev-requirements.txt (line 1))
Requirement already satisfied (use --upgrade to upgrade): uritemplate.py>=0.2.0 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from github3.py==1.0.0a2->-r dev-requirements.txt (line 1))
Requirement already satisfied (use --upgrade to upgrade): py>=1.4.29 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from pytest>=2.3.5->-r dev-requirements.txt (line 3))
Requirement already satisfied (use --upgrade to upgrade): requests-toolbelt>=0.4.0 in /Users/mattchung/.virtualenvs/github3/lib/python2.7/site-packages (from betamax-matchers>=0.2.0->-r dev-requirements.txt (line 6))
python setup.py test
running test
Searching for unittest2==0.5.1
Best match: unittest2 0.5.1
Processing unittest2-0.5.1-py2.7.egg

Using /Users/mattchung/Development/github3.py/.eggs/unittest2-0.5.1-py2.7.egg
running egg_info
writing requirements to github3.py.egg-info/requires.txt
writing github3.py.egg-info/PKG-INFO
writing top-level names to github3.py.egg-info/top_level.txt
writing dependency_links to github3.py.egg-info/dependency_links.txt
reading manifest file 'github3.py.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
writing manifest file 'github3.py.egg-info/SOURCES.txt'
running build_ext
.............X..........................................................................................................................................x....x..................x.......................FFFFFFFFF..F.FF.FFF......F..FF..FFF..FF...F.FFF..FFFFFFFFFFF.FFFF..F.FFFxFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF..FFFF.FFFFFFFFFF.........F.FFF..FFFFF..FFFF.FFFFF.FFF.FFFFFF.FFFFFF.FFF...................................................................................................................................................................................................................................................................................................x.....................................................................................
=================================== FAILURES ===================================
_____________________________ TestAPI.test_emojis ______________________________

self = <tests.integration.test_api.TestAPI testMethod=test_emojis>

    def test_emojis(self):
        """Test the ability to use the /emojis endpoint"""
        cassette_name = self.cassette_name('emojis', cls='GitHub')
        with self.recorder.use_cassette(cassette_name):
            emojis = self.gh.emojis()
    
>       assert emojis['+1'] is not None
E       TypeError: 'NoneType' object has no attribute '__getitem__'

tests/integration/test_api.py:16: TypeError
___________________________ TestAPI.test_search_code ___________________________

self = <tests.integration.test_api.TestAPI testMethod=test_search_code>

    def test_search_code(self):
        """Test the ability to use the code search endpoint"""
        cassette_name = self.cassette_name('search_code',
                                           cls='GitHub')
        with self.recorder.use_cassette(cassette_name):
            repos = self.gh.search_code(
                'HTTPAdapter in:file language:python'
                ' repo:kennethreitz/requests'
                )
>           assert isinstance(next(repos),
                              github3.search.CodeSearchResult)

tests/integration/test_api.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/code?q=HTTPAdapter+in%3Afile+language%3Apython+repo%3Akennethreitz%2Frequests&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
__________________________ TestAPI.test_search_issues __________________________

self = <tests.integration.test_api.TestAPI testMethod=test_search_issues>

    def test_search_issues(self):
        """Test the ability to use the issues search endpoint"""
        cassette_name = self.cassette_name('search_issues',
                                           cls='GitHub')
        with self.recorder.use_cassette(cassette_name):
            issues = self.gh.search_issues('github3 labels:bugs')
>           assert isinstance(next(issues),
                              github3.search.IssueSearchResult)

tests/integration/test_api.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/issues?q=github3+labels%3Abugs&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
_______________________ TestAPI.test_search_repositories _______________________

self = <tests.integration.test_api.TestAPI testMethod=test_search_repositories>

    def test_search_repositories(self):
        """Test the ability to use the repository search endpoint"""
        cassette_name = self.cassette_name('search_repositories',
                                           cls='GitHub')
        with self.recorder.use_cassette(cassette_name):
            repos = self.gh.search_repositories('github3 language:python')
>           assert isinstance(next(repos),
                              github3.search.RepositorySearchResult)

tests/integration/test_api.py:53: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/repositories?q=github3+language%3Apython&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
__________________________ TestAPI.test_search_users ___________________________

self = <tests.integration.test_api.TestAPI testMethod=test_search_users>

    def test_search_users(self):
        """Test the ability to use the user search endpoint"""
        cassette_name = self.cassette_name('search_users', cls='GitHub')
        with self.recorder.use_cassette(cassette_name):
            users = self.gh.search_users('tom followers:>1000')
>           assert isinstance(next(users),
                              github3.search.UserSearchResult)

tests/integration/test_api.py:35: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/users?q=tom+followers%3A%3E1000&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
______________________ TestAuthorization.test_add_scopes _______________________

self = <tests.integration.test_auths.TestAuthorization testMethod=test_add_scopes>

    def test_add_scopes(self):
        """Test the ability to add scopes to an authorization."""
        self.basic_login()
        cassette_name = self.cassette_name('add_scopes')
        with self.recorder.use_cassette(cassette_name):
            auth = self.gh.authorization(10716101)
>           assert isinstance(auth, github3.auths.Authorization)
E           AssertionError: assert isinstance(<NullObject('Authorization')>, <class 'github3.auths.Authorization'>)
E            +  where <class 'github3.auths.Authorization'> = <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'>.Authorization
E            +    where <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'> = github3.auths

tests/integration/test_auths.py:17: AssertionError
________________________ TestAuthorization.test_delete _________________________

self = <tests.integration.test_auths.TestAuthorization testMethod=test_delete>

    def test_delete(self):
        """Test the ability to delete an authorization."""
        self.basic_login()
        cassette_name = self.cassette_name('delete')
        with self.recorder.use_cassette(cassette_name):
            auth = self.gh.authorization(10716101)
>           assert isinstance(auth, github3.auths.Authorization)
E           AssertionError: assert isinstance(<NullObject('Authorization')>, <class 'github3.auths.Authorization'>)
E            +  where <class 'github3.auths.Authorization'> = <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'>.Authorization
E            +    where <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'> = github3.auths

tests/integration/test_auths.py:26: AssertionError
_____________________ TestAuthorization.test_remove_scopes _____________________

self = <tests.integration.test_auths.TestAuthorization testMethod=test_remove_scopes>

    def test_remove_scopes(self):
        """Test the ability to remove scopes from an authorization."""
        self.basic_login()
        cassette_name = self.cassette_name('remove_scopes')
        with self.recorder.use_cassette(cassette_name):
            auth = self.gh.authorization(10716101)
>           assert isinstance(auth, github3.auths.Authorization)
E           AssertionError: assert isinstance(<NullObject('Authorization')>, <class 'github3.auths.Authorization'>)
E            +  where <class 'github3.auths.Authorization'> = <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'>.Authorization
E            +    where <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'> = github3.auths

tests/integration/test_auths.py:35: AssertionError
____________________ TestAuthorization.test_replace_scopes _____________________

self = <tests.integration.test_auths.TestAuthorization testMethod=test_replace_scopes>

    def test_replace_scopes(self):
        """Test the ability to replace scopes on an authorization."""
        self.basic_login()
        cassette_name = self.cassette_name('replace_scopes')
        with self.recorder.use_cassette(cassette_name):
            auth = self.gh.authorization(10716101)
>           assert isinstance(auth, github3.auths.Authorization)
E           AssertionError: assert isinstance(<NullObject('Authorization')>, <class 'github3.auths.Authorization'>)
E            +  where <class 'github3.auths.Authorization'> = <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'>.Authorization
E            +    where <module 'github3.auths' from '/Users/mattchung/Development/github3.py/github3/auths.pyc'> = github3.auths

tests/integration/test_auths.py:44: AssertionError
_________________________ TestGist.test_create_comment _________________________

self = <tests.integration.test_gists.TestGist testMethod=test_create_comment>

    def test_create_comment(self):
        """Show that a user can comment on a gist."""
        self.basic_login()
        cassette_name = self.cassette_name('create_comment')
        with self.recorder.use_cassette(cassette_name):
            gist = self.gh.gist('f396190a0d0047be791b')
            assert gist is not None
            c = gist.create_comment("""```ruby
                mac.split('').map.with_index do |v, i|
                  positions.include?(i) ? ':' + v : v
                end
                ```""")
>           assert isinstance(c, github3.gists.comment.GistComment)
E           AssertionError: assert isinstance(<NullObject('Gist')>, <class 'github3.gists.comment.GistComment'>)
E            +  where <class 'github3.gists.comment.GistComment'> = <module 'github3.gists.comment' from '/Users/mattchung/Development/github3.py/github3/gists/comment.pyc'>.GistComment
E            +    where <module 'github3.gists.comment' from '/Users/mattchung/Development/github3.py/github3/gists/comment.pyc'> = <module 'github3.gists' from '/Users/mattchung/Development/github3.py/github3/gists/__init__.pyc'>.comment
E            +      where <module 'github3.gists' from '/Users/mattchung/Development/github3.py/github3/gists/__init__.pyc'> = github3.gists

tests/integration/test_gists.py:33: AssertionError
______________________________ TestGist.test_edit ______________________________

self = <tests.integration.test_gists.TestGist testMethod=test_edit>

    def test_edit(self):
        """Show that a user can edit the contents of a gist."""
        self.basic_login()
        cassette_name = self.cassette_name('edit')
        with self.recorder.use_cassette(cassette_name):
            gist = self.gh.gist(6647085)
            assert gist is not None
>           assert gist.edit('Updated description', files={
                'filename.py': {
                    'content': '# New content',
                },
                'new_file.py': {
                    'content': '# New file content',
                },
            }) is True
E           AssertionError: assert <NullObject('Gist')> is True
E            +  where <NullObject('Gist')> = <NullObject('Gist')>('Updated description', files={'filename.py': {'content': '# New content'}, 'new_file.py': {'content': '# New file content'}})
E            +    where <NullObject('Gist')> = <NullObject('Gist')>.edit

tests/integration/test_gists.py:67: AssertionError
______________________________ TestGist.test_fork ______________________________

self = <tests.integration.test_gists.TestGist testMethod=test_fork>

    def test_fork(self):
        """Show that a user can fork another user's gist."""
        self.basic_login()
        cassette_name = self.cassette_name('fork')
        with self.recorder.use_cassette(cassette_name):
            gist = self.gh.gist('8de9b9b0ae2e45383d85')
            assert gist is not None
            forked = gist.fork()
>           assert isinstance(forked, github3.gists.Gist)
E           AssertionError: assert isinstance(<NullObject('Gist')>, <class 'github3.gists.gist.Gist'>)
E            +  where <class 'github3.gists.gist.Gist'> = <module 'github3.gists' from '/Users/mattchung/Development/github3.py/github3/gists/__init__.pyc'>.Gist
E            +    where <module 'github3.gists' from '/Users/mattchung/Development/github3.py/github3/gists/__init__.pyc'> = github3.gists

tests/integration/test_gists.py:84: AssertionError
___________________________ TestGist.test_is_starred ___________________________

self = <tests.integration.test_gists.TestGist testMethod=test_is_starred>

    def test_is_starred(self):
        """Show that a user can check if they've starred a gist."""
        self.basic_login()
        cassette_name = self.cassette_name('is_starred')
        with self.recorder.use_cassette(cassette_name):
            gist = self.gh.gist(1834570)
            assert gist is not None
>           assert gist.is_starred() is True
E           AssertionError: assert <NullObject('Gist')> is True
E            +  where <NullObject('Gist')> = <NullObject('Gist')>()
E            +    where <NullObject('Gist')> = <NullObject('Gist')>.is_starred

tests/integration/test_gists.py:104: AssertionError
______________________________ TestGist.test_star ______________________________

self = <tests.integration.test_gists.TestGist testMethod=test_star>

    def test_star(self):
        """Show that a user can star a gist."""
        self.basic_login()
        cassette_name = self.cassette_name('star')
        with self.recorder.use_cassette(cassette_name):
            gist = self.gh.gist('8de9b9b0ae2e45383d85')
            assert gist is not None
>           assert gist.star() is True
E           AssertionError: assert <NullObject('Gist')> is True
E            +  where <NullObject('Gist')> = <NullObject('Gist')>()
E            +    where <NullObject('Gist')> = <NullObject('Gist')>.star

tests/integration/test_gists.py:113: AssertionError
_____________________________ TestGist.test_unstar _____________________________

self = <tests.integration.test_gists.TestGist testMethod=test_unstar>

    def test_unstar(self):
        """Show that a user can unstar a gist."""
        self.basic_login()
        cassette_name = self.cassette_name('unstar')
        with self.recorder.use_cassette(cassette_name):
            gist = self.gh.gist('8de9b9b0ae2e45383d85')
            assert gist is not None
>           assert gist.unstar() is True
E           AssertionError: assert <NullObject('Gist')> is True
E            +  where <NullObject('Gist')> = <NullObject('Gist')>()
E            +    where <NullObject('Gist')> = <NullObject('Gist')>.unstar

tests/integration/test_gists.py:122: AssertionError
_________________________ TestGitHub.test_create_issue _________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_create_issue>

    def test_create_issue(self):
        """Test the ability of a GitHub instance to create a new issue."""
        self.token_login()
        cassette_name = self.cassette_name('create_issue')
        with self.recorder.use_cassette(cassette_name):
            i = self.gh.create_issue(
                'github3py', 'fork_this', 'Test issue creation',
                "Let's see how well this works with Betamax"
                )
    
>       assert isinstance(i, github3.issues.Issue)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.issues.issue.Issue'>)
E        +  where <class 'github3.issues.issue.Issue'> = <module 'github3.issues' from '/Users/mattchung/Development/github3.py/github3/issues/__init__.pyc'>.Issue
E        +    where <module 'github3.issues' from '/Users/mattchung/Development/github3.py/github3/issues/__init__.pyc'> = github3.issues

tests/integration/test_github.py:61: AssertionError
____________________________ TestGitHub.test_emojis ____________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_emojis>

    def test_emojis(self):
        """Test the ability to retrieve from /emojis."""
        cassette_name = self.cassette_name('emojis')
        with self.recorder.use_cassette(cassette_name):
            emojis = self.gh.emojis()
    
>       assert isinstance(emojis, dict)
E       AssertionError: assert isinstance(None, dict)

tests/integration/test_github.py:94: AssertionError
____________________________ TestGitHub.test_feeds _____________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_feeds>

    def test_feeds(self):
        """Test the ability to retrieve a user's timelime URLs."""
        self.basic_login()
        cassette_name = self.cassette_name('feeds')
        with self.recorder.use_cassette(cassette_name):
>           feeds = self.gh.feeds()

tests/integration/test_github.py:103: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/decorators.py:54: in auth_wrapper
    return func(self, *args, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <GitHub [foo]>

    @requires_basic_auth
    def feeds(self):
        """List GitHub's timeline resources in Atom format.
    
            :returns: dictionary parsed to include URITemplates
            """
        url = self._build_url('feeds')
        json = self._json(self._get(url), 200)
>       del json['ETag']
E       TypeError: 'NoneType' object does not support item deletion

github3/github.py:368: TypeError
_____________________________ TestGitHub.test_gist _____________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_gist>

    def test_gist(self):
        """Test the ability to retrieve a single gist."""
        cassette_name = self.cassette_name('gist')
        with self.recorder.use_cassette(cassette_name):
            g = self.gh.gist(7160899)
    
>       assert isinstance(g, github3.gists.Gist)
E       AssertionError: assert isinstance(<NullObject('Gist')>, <class 'github3.gists.gist.Gist'>)
E        +  where <class 'github3.gists.gist.Gist'> = <module 'github3.gists' from '/Users/mattchung/Development/github3.py/github3/gists/__init__.pyc'>.Gist
E        +    where <module 'github3.gists' from '/Users/mattchung/Development/github3.py/github3/gists/__init__.pyc'> = github3.gists

tests/integration/test_github.py:121: AssertionError
______________________ TestGitHub.test_gitignore_template ______________________

self = <tests.integration.test_github.TestGitHub testMethod=test_gitignore_template>

    def test_gitignore_template(self):
        """Test the ability to retrieve a single gitignore template."""
        cassette_name = self.cassette_name('gitignore_template')
        with self.recorder.use_cassette(cassette_name):
            t = self.gh.gitignore_template('Python')
    
        assert t is not None
>       assert t != ''
E       AssertionError: assert '' != ''

tests/integration/test_github.py:130: AssertionError
_____________________ TestGitHub.test_gitignore_templates ______________________

self = <tests.integration.test_github.TestGitHub testMethod=test_gitignore_templates>

    def test_gitignore_templates(self):
        """Test the ability to retrieve a list of gitignore templates."""
        cassette_name = self.cassette_name('gitignore_templates')
        with self.recorder.use_cassette(cassette_name):
            l = self.gh.gitignore_templates()
    
>       assert l != []
E       AssertionError: assert [] != []

tests/integration/test_github.py:147: AssertionError
____________________________ TestGitHub.test_issue _____________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_issue>

    def test_issue(self):
        """Test the ability to retrieve a single issue."""
        cassette_name = self.cassette_name('issue')
        with self.recorder.use_cassette(cassette_name):
            i = self.gh.issue('sigmavirus24', 'github3.py', 1)
    
>       assert isinstance(i, github3.issues.Issue)
E       AssertionError: assert isinstance(<NullObject('Issue')>, <class 'github3.issues.issue.Issue'>)
E        +  where <class 'github3.issues.issue.Issue'> = <module 'github3.issues' from '/Users/mattchung/Development/github3.py/github3/issues/__init__.pyc'>.Issue
E        +    where <module 'github3.issues' from '/Users/mattchung/Development/github3.py/github3/issues/__init__.pyc'> = github3.issues

tests/integration/test_github.py:170: AssertionError
______________________________ TestGitHub.test_me ______________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_me>

    def test_me(self):
        """Test the ability to retrieve the authenticated user's info."""
        self.basic_login()
        cassette_name = self.cassette_name('me')
        with self.recorder.use_cassette(cassette_name):
            me = self.gh.me()
    
>       assert isinstance(me, github3.users.User)
E       AssertionError: assert isinstance(<NullObject('User')>, <class 'github3.users.User'>)
E        +  where <class 'github3.users.User'> = <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'>.User
E        +    where <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'> = github3.users

tests/integration/test_github.py:234: AssertionError
______________________ TestGitHub.test_notifications_all _______________________

self = <tests.integration.test_github.TestGitHub testMethod=test_notifications_all>

    def test_notifications_all(self):
        """Test the ability to retrieve read notifications as well."""
        self.basic_login()
        cassette_name = self.cassette_name('all_notifications')
        with self.recorder.use_cassette(cassette_name):
            read_notifications = []
            unread_notifications = []
            for notification in self.gh.notifications(all=True):
                assert isinstance(notification, github3.notifications.Thread)
                if notification.unread:
                    unread_notifications.append(notification)
                else:
                    read_notifications.append(notification)
    
>           assert len(read_notifications) > 0
E           AssertionError: assert 0 > 0
E            +  where 0 = len([])

tests/integration/test_github.py:266: AssertionError
_________________________ TestGitHub.test_organization _________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_organization>

    def test_organization(self):
        """Test the ability to retrieve an Organization."""
        cassette_name = self.cassette_name('organization')
        with self.recorder.use_cassette(cassette_name):
            o = self.gh.organization('github3py')
    
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_github.py:286: AssertionError
_________________________ TestGitHub.test_pull_request _________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_pull_request>

    def test_pull_request(self):
        """Test the ability to retrieve a Pull Request."""
        cassette_name = self.cassette_name('pull_request')
        with self.recorder.use_cassette(cassette_name):
            p = self.gh.pull_request('sigmavirus24', 'github3.py', 119)
    
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_github.py:294: AssertionError
__________________________ TestGitHub.test_rate_limit __________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_rate_limit>

    def test_rate_limit(self):
        """Test the ability to retrieve rate information."""
        cassette_name = self.cassette_name('rate_limit')
        with self.recorder.use_cassette(cassette_name):
            r = self.gh.rate_limit()
    
>       assert isinstance(r, dict)
E       AssertionError: assert isinstance(None, dict)

tests/integration/test_github.py:302: AssertionError
__________________________ TestGitHub.test_repository __________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_repository>

    def test_repository(self):
        """Test the ability to retrieve a Repository."""
        cassette_name = self.cassette_name('repository')
        with self.recorder.use_cassette(cassette_name):
            r = self.gh.repository('sigmavirus24', 'github3.py')
    
>       assert isinstance(r, github3.repos.repo.Repository)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.repo.Repository'>)
E        +  where <class 'github3.repos.repo.Repository'> = <module 'github3.repos.repo' from '/Users/mattchung/Development/github3.py/github3/repos/repo.pyc'>.Repository
E        +    where <module 'github3.repos.repo' from '/Users/mattchung/Development/github3.py/github3/repos/repo.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.repo
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_github.py:311: AssertionError
______________________ TestGitHub.test_repository_with_id ______________________

self = <tests.integration.test_github.TestGitHub testMethod=test_repository_with_id>

    def test_repository_with_id(self):
        """Test the ability to retrieve a repository by its id."""
        cassette_name = self.cassette_name('repository_with_id')
        with self.recorder.use_cassette(cassette_name):
            r = self.gh.repository_with_id(11439734)
    
>       assert isinstance(r, github3.repos.repo.Repository)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.repo.Repository'>)
E        +  where <class 'github3.repos.repo.Repository'> = <module 'github3.repos.repo' from '/Users/mattchung/Development/github3.py/github3/repos/repo.pyc'>.Repository
E        +    where <module 'github3.repos.repo' from '/Users/mattchung/Development/github3.py/github3/repos/repo.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.repo
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_github.py:319: AssertionError
_________________________ TestGitHub.test_search_code __________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_search_code>

    def test_search_code(self):
        """Test the ability to use the code search endpoint."""
        cassette_name = self.cassette_name('search_code')
        with self.recorder.use_cassette(cassette_name):
            result_iterator = self.gh.search_code(
                'HTTPAdapter in:file language:python'
                ' repo:kennethreitz/requests'
                )
>           code_result = next(result_iterator)

tests/integration/test_github.py:344: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/code?q=HTTPAdapter+in%3Afile+language%3Apython+repo%3Akennethreitz%2Frequests&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
_________________ TestGitHub.test_search_code_with_text_match __________________

self = <tests.integration.test_github.TestGitHub testMethod=test_search_code_with_text_match>

    def test_search_code_with_text_match(self):
        """Test the ability to use the code search endpoint."""
        cassette_name = self.cassette_name('search_code_with_text_match')
        with self.recorder.use_cassette(cassette_name,
                                        match_requests_on=self.match_on):
            result_iterator = self.gh.search_code(
                ('HTTPAdapter in:file language:python'
                 ' repo:kennethreitz/requests'),
                text_match=True
                )
>           code_result = next(result_iterator)

tests/integration/test_github.py:358: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/code?q=HTTPAdapter+in%3Afile+language%3Apython+repo%3Akennethreitz%2Frequests&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
________________________ TestGitHub.test_search_issues _________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_search_issues>

    def test_search_issues(self):
        """Test the ability to use the issues search endpoint."""
        cassette_name = self.cassette_name('search_issues')
        with self.recorder.use_cassette(cassette_name):
            issues = self.gh.search_issues('github3 labels:bugs')
>           assert isinstance(next(issues), github3.search.IssueSearchResult)

tests/integration/test_github.py:392: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/issues?q=github3+labels%3Abugs&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
_____________________ TestGitHub.test_search_repositories ______________________

self = <tests.integration.test_github.TestGitHub testMethod=test_search_repositories>

    def test_search_repositories(self):
        """Test the ability to use the repository search endpoint."""
        cassette_name = self.cassette_name('search_repositories')
        with self.recorder.use_cassette(cassette_name):
            repos = self.gh.search_repositories('github3 language:python')
>           assert isinstance(next(repos),
                              github3.search.RepositorySearchResult)

tests/integration/test_github.py:401: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/repositories?q=github3+language%3Apython&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
_____________ TestGitHub.test_search_repositories_with_text_match ______________

self = <tests.integration.test_github.TestGitHub testMethod=test_search_repositories_with_text_match>

    def test_search_repositories_with_text_match(self):
        """Test the ability to use the repository search endpoint."""
        self.token_login()
        cassette_name = self.cassette_name('search_repositories_text_match')
        with self.recorder.use_cassette(cassette_name,
                                        match_requests_on=self.match_on):
            repos = self.gh.search_repositories('github3 language:python',
                                                text_match=True)
>           repo_result = next(repos)

tests/integration/test_github.py:414: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/repositories?q=github3+language%3Apython&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
_________________________ TestGitHub.test_search_users _________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_search_users>

    def test_search_users(self):
        """Test the ability to use the user search endpoint."""
        cassette_name = self.cassette_name('search_users')
        with self.recorder.use_cassette(cassette_name):
            users = self.gh.search_users('tom followers:>1000')
>           assert isinstance(next(users),
                              github3.search.UserSearchResult)

tests/integration/test_github.py:368: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/users?q=tom+followers%3A%3E1000&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
_________________ TestGitHub.test_search_users_with_text_match _________________

self = <tests.integration.test_github.TestGitHub testMethod=test_search_users_with_text_match>

    def test_search_users_with_text_match(self):
        """Test the ability to use the user search endpoint."""
        cassette_name = self.cassette_name('search_users_with_text_match')
        with self.recorder.use_cassette(cassette_name,
                                        match_requests_on=self.match_on):
            users = self.gh.search_users('tom followers:>1000',
                                         text_match=True)
>           user_result = next(users)

tests/integration/test_github.py:380: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
github3/structs.py:106: in __next__
    return next(self.__i__)
github3/structs.py:76: in __iter__
    json = self._get_json(response)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <SearchIterator [-1, /search/users?q=tom+followers%3A%3E1000&per_page=100]>
response = <Response [200]>

    def _get_json(self, response):
        json = self._json(response, 200)
        # I'm not sure if another page will retain the total_count attribute,
        # so if it's not in the response, just set it back to what it used to
        # be
>       self.total_count = json.get('total_count', self.total_count)
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/structs.py:151: AttributeError
__________________________ TestGitHub.test_update_me ___________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_update_me>

    def test_update_me(self):
        """Test the ability to update the current authenticated User."""
        cassette_name = self.cassette_name('update_me')
        self.basic_login()
        with self.recorder.use_cassette(cassette_name):
>           assert self.gh.update_me(name='Ian "RFC" Cordasco') is True
E           AssertionError: assert <bound method GitHub.update_me of <GitHub [foo]>>(name='Ian "RFC" Cordasco') is True
E            +  where <bound method GitHub.update_me of <GitHub [foo]>> = <GitHub [foo]>.update_me
E            +    where <GitHub [foo]> = <tests.integration.test_github.TestGitHub testMethod=test_update_me>.gh

tests/integration/test_github.py:426: AssertionError
_____________________________ TestGitHub.test_user _____________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_user>

    def test_user(self):
        """Test the ability to retrieve a User."""
        cassette_name = self.cassette_name('user')
        with self.recorder.use_cassette(cassette_name):
            sigmavirus24 = self.gh.user('sigmavirus24')
    
>       assert isinstance(sigmavirus24, github3.users.User)
E       AssertionError: assert isinstance(<NullObject('User')>, <class 'github3.users.User'>)
E        +  where <class 'github3.users.User'> = <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'>.User
E        +    where <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'> = github3.users

tests/integration/test_github.py:435: AssertionError
_________________________ TestGitHub.test_user_with_id _________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_user_with_id>

    def test_user_with_id(self):
        """Test the ability to retrieve a user by their id."""
        cassette_name = self.cassette_name('user_with_id')
        with self.recorder.use_cassette(cassette_name):
            sigmavirus24 = self.gh.user_with_id(240830)
    
>       assert isinstance(sigmavirus24, github3.users.User)
E       AssertionError: assert isinstance(<NullObject('User')>, <class 'github3.users.User'>)
E        +  where <class 'github3.users.User'> = <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'>.User
E        +    where <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'> = github3.users

tests/integration/test_github.py:443: AssertionError
_____________________________ TestGitHub.test_zen ______________________________

self = <tests.integration.test_github.TestGitHub testMethod=test_zen>

    def test_zen(self):
        """Test the ability to retrieve tidbits of Zen."""
        cassette_name = self.cassette_name('zen')
        with self.recorder.use_cassette(cassette_name):
            z = self.gh.zen()
    
        assert z is not None
>       assert z != ''
E       AssertionError: assert '' != ''

tests/integration/test_github.py:452: AssertionError
___________________ TestGitHubCore.test_ratelimit_remaining ____________________

self = <tests.integration.test_github_core.TestGitHubCore testMethod=test_ratelimit_remaining>

    def test_ratelimit_remaining(self):
        cassette_name = self.cassette_name('ratelimit_remaining')
        with self.recorder.use_cassette(cassette_name):
>           assert self.gh.ratelimit_remaining > 0

tests/integration/test_github_core.py:8: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <GitHub at 0x10330bb90>

    @property
    def ratelimit_remaining(self):
        """Number of requests before GitHub imposes a ratelimit.
    
            :returns: int
            """
        json = self._json(self._get(self._github_url + '/rate_limit'), 200)
>       core = json.get('resources', {}).get('core', {})
E       AttributeError: 'NoneType' object has no attribute 'get'

github3/models.py:243: AttributeError
___________________________ TestIssue.test_comments ____________________________

self = <tests.integration.test_issue.TestIssue testMethod=test_comments>

    def test_comments(self):
        """Test the ability to retrieve comments on an issue."""
        cassette_name = self.cassette_name('comments')
        with self.recorder.use_cassette(cassette_name):
            issue = self.gh.issue('sigmavirus24', 'github3.py', 187)
            assert issue is not None
            comments = list(issue.comments())
    
>       assert len(comments) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_issue.py:19: AssertionError
_________________________ TestIssue.test_pull_request __________________________

self = <tests.integration.test_issue.TestIssue testMethod=test_pull_request>

    def test_pull_request(self):
        """Test the ability to retrieve the PR associated with an issue."""
        cassette_name = self.cassette_name('pull_request')
        with self.recorder.use_cassette(cassette_name):
            issue = self.gh.issue('sigmavirus24', 'github3.py', 301)
            assert issue is not None
            pull_request = issue.pull_request()
    
>       assert isinstance(pull_request, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('Issue')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_issue.py:52: AssertionError
_______________________ TestOrganization.test_add_member _______________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_add_member>

    def test_add_member(self):
        """Test the ability to add a member to an organization."""
        self.basic_login()
        cassette_name = self.cassette_name('add_member')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:37: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_add_member>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_____________________ TestOrganization.test_add_repository _____________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_add_repository>

    def test_add_repository(self):
        """Test the ability to add a repository to an organization."""
        self.basic_login()
        cassette_name = self.cassette_name('add_repository')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:46: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_add_repository>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_______________ TestOrganization.test_can_filter_members_by_role _______________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_can_filter_members_by_role>

    def test_can_filter_members_by_role(self):
        """Test the ability to filter an organization's members by role."""
        self.basic_login()
        cassette_name = self.cassette_name('members_roles')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:151: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_can_filter_members_by_role>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_____________________ TestOrganization.test_conceal_member _____________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_conceal_member>

    def test_conceal_member(self):
        """Test the ability to conceal a User's membership."""
        self.basic_login()
        cassette_name = self.cassette_name('conceal_member')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:65: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_conceal_member>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
___________________ TestOrganization.test_create_repository ____________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_create_repository>

    def test_create_repository(self):
        """Test the ability to create a repository in an organization."""
        self.basic_login()
        cassette_name = self.cassette_name('create_repository')
        with self.recorder.use_cassette(cassette_name, **self.betamax_kwargs):
>           o = self.get_organization()

tests/integration/test_orgs.py:55: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_create_repository>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
______________________ TestOrganization.test_create_team _______________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_create_team>

    def test_create_team(self):
        """Test the ability to create a new team."""
        self.basic_login()
        cassette_name = self.cassette_name('create_team')
        with self.recorder.use_cassette(cassette_name, **self.betamax_kwargs):
>           o = self.get_organization()

tests/integration/test_orgs.py:81: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_create_team>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
__________________________ TestOrganization.test_edit __________________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_edit>

    def test_edit(self):
        """Test the ability to edit an organization."""
        self.basic_login()
        cassette_name = self.cassette_name('edit')
        with self.recorder.use_cassette(cassette_name, **self.betamax_kwargs):
>           o = self.get_organization()

tests/integration/test_orgs.py:92: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_edit>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_________________________ TestOrganization.test_events _________________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_events>

    def test_events(self):
        """Test the ability to retrieve an organization's event stream."""
        cassette_name = self.cassette_name('events')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:116: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_events>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_______________________ TestOrganization.test_is_member ________________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_is_member>

    def test_is_member(self):
        """Test the ability to check if a User is a member of the org."""
        cassette_name = self.cassette_name('is_member')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:100: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_is_member>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
____________________ TestOrganization.test_is_public_member ____________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_is_public_member>

    def test_is_public_member(self):
        """Test the ability to check if a User is a public member."""
        cassette_name = self.cassette_name('is_public_member')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:108: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_is_public_member>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
________________________ TestOrganization.test_members _________________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_members>

    def test_members(self):
        """Test the ability to retrieve an organization's members."""
        self.basic_login()
        cassette_name = self.cassette_name('members')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:126: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_members>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_____________________ TestOrganization.test_public_members _____________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_public_members>

    def test_public_members(self):
        """Test the ability to retrieve an organization's public members."""
        self.basic_login()
        cassette_name = self.cassette_name('public_members')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:161: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_public_members>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
____________________ TestOrganization.test_publicize_member ____________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_publicize_member>

    def test_publicize_member(self):
        """Test the ability to publicize a member of the organization."""
        self.basic_login()
        cassette_name = self.cassette_name('publicize_member')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:190: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_publicize_member>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_____________________ TestOrganization.test_remove_member ______________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_remove_member>

    def test_remove_member(self):
        """Test the ability to remove a member of the organization."""
        self.basic_login()
        cassette_name = self.cassette_name('remove_member')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:204: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_remove_member>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
___________________ TestOrganization.test_remove_repository ____________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_remove_repository>

    def test_remove_repository(self):
        """Test the ability to remove a repository from a team."""
        self.basic_login()
        cassette_name = self.cassette_name('remove_repository')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:217: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_remove_repository>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
______________________ TestOrganization.test_repositories ______________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_repositories>

    def test_repositories(self):
        """Test the ability to retrieve an organization's repositories."""
        cassette_name = self.cassette_name('repositories')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:170: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_repositories>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
__________________________ TestOrganization.test_team __________________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_team>

    def test_team(self):
        """Test the ability retrieve an individual team by id."""
        self.basic_login()
        cassette_name = self.cassette_name('team')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:226: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_team>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
_________________________ TestOrganization.test_teams __________________________

self = <tests.integration.test_orgs.TestOrganization testMethod=test_teams>

    def test_teams(self):
        """Test the ability to retrieve an organization's teams."""
        self.basic_login()
        cassette_name = self.cassette_name('teams')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs.py:180: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs.TestOrganization testMethod=test_teams>
name = 'github3py'

    def get_organization(self, name='github3py'):
        """Get the organization for each test."""
        o = self.gh.organization(name)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs.py:19: AssertionError
___________________________ TestTeam.test_add_member ___________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_add_member>

    def test_add_member(self):
        """Show a user can add a member to a team."""
        cassette_name = self.cassette_name('add_member')
        with self.recorder.use_cassette(cassette_name):
>           team = self.get_team()

tests/integration/test_orgs_team.py:37: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_add_member>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
_________________________ TestTeam.test_add_repository _________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_add_repository>

    def test_add_repository(self):
        """Show that a user can add a repository to a team."""
        cassette_name = self.cassette_name('add_repository')
        with self.recorder.use_cassette(cassette_name):
>           team = self.get_team()

tests/integration/test_orgs_team.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_add_repository>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
___________________ TestTeam.test_can_filter_members_by_role ___________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_can_filter_members_by_role>

    def test_can_filter_members_by_role(self):
        """Test the ability to filter an team's members by role."""
        self.basic_login()
        cassette_name = self.cassette_name('members_roles')
        with self.recorder.use_cassette(cassette_name):
>           t = self.get_team()

tests/integration/test_orgs_team.py:98: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_can_filter_members_by_role>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
_____________________________ TestTeam.test_delete _____________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_delete>

    def test_delete(self):
        """Show that a user can delete a team."""
        cassette_name = self.cassette_name('delete')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs_team.py:51: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_delete>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
______________________________ TestTeam.test_edit ______________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_edit>

    def test_edit(self):
        """Show that a user can edit a team."""
        cassette_name = self.cassette_name('edit')
        with self.recorder.use_cassette(cassette_name):
>           o = self.get_organization()

tests/integration/test_orgs_team.py:60: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_edit>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
_________________________ TestTeam.test_has_repository _________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_has_repository>

    def test_has_repository(self):
        """Show that a user can check of a team has access to a repository."""
        cassette_name = self.cassette_name('has_repository')
        with self.recorder.use_cassette(cassette_name):
>           t = self.get_team()

tests/integration/test_orgs_team.py:75: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_has_repository>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
___________________________ TestTeam.test_is_member ____________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_is_member>

    def test_is_member(self):
        """Show that a user can check if another user is a team member."""
        cassette_name = self.cassette_name('is_member')
        with self.recorder.use_cassette(cassette_name):
>           t = self.get_team()

tests/integration/test_orgs_team.py:82: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_is_member>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
____________________________ TestTeam.test_members _____________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_members>

    def test_members(self):
        """Show that a user can retrieve a team's members."""
        cassette_name = self.cassette_name('members')
        with self.recorder.use_cassette(cassette_name):
>           t = self.get_team()

tests/integration/test_orgs_team.py:89: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_members>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
_________________________ TestTeam.test_remove_member __________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_remove_member>

    def test_remove_member(self):
        """Show a user can remove a member from a team."""
        cassette_name = self.cassette_name('remove_member')
        with self.recorder.use_cassette(cassette_name):
>           team = self.get_team()

tests/integration/test_orgs_team.py:114: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_remove_member>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
_______________________ TestTeam.test_remove_repository ________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_remove_repository>

    def test_remove_repository(self):
        """Show a user can remove a repository from a team."""
        cassette_name = self.cassette_name('remove_repository')
        with self.recorder.use_cassette(cassette_name):
>           team = self.get_team(id=923595)

tests/integration/test_orgs_team.py:121: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_remove_repository>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
__________________________ TestTeam.test_repositories __________________________

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_repositories>

    def test_repositories(self):
        """Show that a user can retrieve a team's repositories."""
        cassette_name = self.cassette_name('repositories')
        with self.recorder.use_cassette(cassette_name):
>           t = self.get_team()

tests/integration/test_orgs_team.py:106: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
tests/integration/test_orgs_team.py:28: in get_team
    o = self.get_organization(organization)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_orgs_team.TestTeam testMethod=test_repositories>
organization = 'github3py'

    def get_organization(self, organization='github3py'):
        """Get the desired organization."""
        o = self.gh.organization(organization)
>       assert isinstance(o, github3.orgs.Organization)
E       AssertionError: assert isinstance(<NullObject('Organization')>, <class 'github3.orgs.Organization'>)
E        +  where <class 'github3.orgs.Organization'> = <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'>.Organization
E        +    where <module 'github3.orgs' from '/Users/mattchung/Development/github3.py/github3/orgs.pyc'> = github3.orgs

tests/integration/test_orgs_team.py:23: AssertionError
__________________________ TestPullRequest.test_close __________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_close>

    def test_close(self):
        """Show that one can close an open Pull Request."""
        self.basic_login()
        cassette_name = self.cassette_name('close')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request(num=241)

tests/integration/test_pulls.py:27: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_close>
repository = 'sigmavirus24/github3.py', num = 241

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
_________________________ TestPullRequest.test_commits _________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_commits>

    def test_commits(self):
        """Show that one can iterate over a PR's commits."""
        cassette_name = self.cassette_name('commits')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:43: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_commits>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
_____________________ TestPullRequest.test_create_comment ______________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_create_comment>

    def test_create_comment(self):
        """Show that a user can create a comment on a PR."""
        self.basic_login()
        cassette_name = self.cassette_name('create_comment')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request(num=423)

tests/integration/test_pulls.py:35: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_create_comment>
repository = 'sigmavirus24/github3.py', num = 423

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
__________________ TestPullRequest.test_create_review_comment __________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_create_review_comment>

    def test_create_review_comment(self):
        """Show that a user can create an in-line reveiw comment on a PR."""
        self.basic_login()
        cassette_name = self.cassette_name('create_review_comment')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request(num=286)

tests/integration/test_pulls.py:52: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_create_review_comment>
repository = 'sigmavirus24/github3.py', num = 286

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
__________________________ TestPullRequest.test_diff ___________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_diff>

    def test_diff(self):
        """Show that one can retrieve a bytestring diff of a PR."""
        cassette_name = self.cassette_name('diff')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:65: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_diff>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
__________________________ TestPullRequest.test_files __________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_files>

    def test_files(self):
        """Show that one can iterate over a PR's files."""
        cassette_name = self.cassette_name('files')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:74: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_files>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
________________________ TestPullRequest.test_is_merged ________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_is_merged>

    def test_is_merged(self):
        """Show that one can check if a PR was merged."""
        cassette_name = self.cassette_name('is_merged')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:82: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_is_merged>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
__________________________ TestPullRequest.test_issue __________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_issue>

    def test_issue(self):
        """Show that one can retrieve the associated issue of a PR."""
        cassette_name = self.cassette_name('issue')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:89: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_issue>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
_____________________ TestPullRequest.test_issue_comments ______________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_issue_comments>

    def test_issue_comments(self):
        """Show that one can iterate over a PR's issue comments."""
        cassette_name = self.cassette_name('issue_comments')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:97: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_issue_comments>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
__________________________ TestPullRequest.test_patch __________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_patch>

    def test_patch(self):
        """Show that a user can get the patch from a PR."""
        cassette_name = self.cassette_name('patch')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:106: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_patch>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
_________________________ TestPullRequest.test_reopen __________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_reopen>

    def test_reopen(self):
        """Show that one can reopen an open Pull Request."""
        self.basic_login()
        cassette_name = self.cassette_name('reopen')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request(num=241)

tests/integration/test_pulls.py:116: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_reopen>
repository = 'sigmavirus24/github3.py', num = 241

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
_____________________ TestPullRequest.test_review_comments _____________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_review_comments>

    def test_review_comments(self):
        """Show that one can iterate over a PR's review comments."""
        cassette_name = self.cassette_name('review_comments')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request()

tests/integration/test_pulls.py:123: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_review_comments>
repository = 'sigmavirus24/github3.py', num = 235

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
_________________________ TestPullRequest.test_update __________________________

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_update>

    def test_update(self):
        """Show that one can update an open Pull Request."""
        self.basic_login()
        cassette_name = self.cassette_name('update')
        with self.recorder.use_cassette(cassette_name):
>           p = self.get_pull_request(num=241)

tests/integration/test_pulls.py:132: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullRequest testMethod=test_update>
repository = 'sigmavirus24/github3.py', num = 241

    def get_pull_request(self, repository='sigmavirus24/github3.py', num=235):
        """Get the pull request we wish to use in this test."""
        owner, repo = repository.split('/')
        p = self.gh.pull_request(owner, repo, num)
>       assert isinstance(p, github3.pulls.PullRequest)
E       AssertionError: assert isinstance(<NullObject('PullRequest')>, <class 'github3.pulls.PullRequest'>)
E        +  where <class 'github3.pulls.PullRequest'> = <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'>.PullRequest
E        +    where <module 'github3.pulls' from '/Users/mattchung/Development/github3.py/github3/pulls.pyc'> = github3.pulls

tests/integration/test_pulls.py:19: AssertionError
_________________________ TestReviewComment.test_reply _________________________

self = <tests.integration.test_pulls.TestReviewComment testMethod=test_reply>

    def test_reply(self):
        """Show that a user can reply to an existing ReviewComment."""
        self.basic_login()
        cassette_name = self.cassette_name('reply')
        with self.recorder.use_cassette(cassette_name):
            p = self.gh.pull_request('sigmavirus24', 'github3.py', 286)
>           c = next(p.review_comments())

tests/integration/test_pulls.py:146: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <NullObject('PullRequest')>

    def __next__(self):
>       raise StopIteration
E       StopIteration

github3/null.py:50: StopIteration
__________________________ TestPullFile.test_contents __________________________

self = <tests.integration.test_pulls.TestPullFile testMethod=test_contents>

    def test_contents(self):
        """Show that a user can retrieve the contents of a PR file."""
        cassette_name = self.cassette_name('contents')
        with self.recorder.use_cassette(cassette_name):
            pull_file = self.get_pull_request_file(
                owner='sigmavirus24', repo='github3.py', pull_number=286,
>               filename='github3/pulls.py'
            )

tests/integration/test_pulls.py:170: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <tests.integration.test_pulls.TestPullFile testMethod=test_contents>
owner = 'sigmavirus24', repo = 'github3.py', pull_number = 286
filename = 'github3/pulls.py'

    def get_pull_request_file(self, owner, repo, pull_number, filename):
        p = self.gh.pull_request(owner, repo, pull_number)
    
        for pull_file in p.files():
            if pull_file.filename == filename:
                break
        else:
>           assert False, "Could not find '{0}'".format(filename)
E           AssertionError: Could not find 'github3/pulls.py'
E           assert False

tests/integration/test_pulls.py:160: AssertionError
______________________ TestDeployment.test_create_status _______________________

self = <tests.integration.test_repos_deployment.TestDeployment testMethod=test_create_status>

    def test_create_status(self):
        """Show that a user can create a deployment status."""
        self.basic_login()
        cassette_name = self.cassette_name('create_status')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            deployment = find(lambda d: d.id == 801,
>                             repository.deployments())

tests/integration/test_repos_deployment.py:24: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

func = <function <lambda> at 0x103edc1b8>, iterable = <NullObject('Repository')>

    def find(func, iterable):
        """Helper function to find the first item in an interable."""
>       return next(iter(filter(func, iterable)))
E       StopIteration

tests/integration/test_repos_deployment.py:9: StopIteration
_________________________ TestDeployment.test_statuses _________________________

self = <tests.integration.test_repos_deployment.TestDeployment testMethod=test_statuses>

    def test_statuses(self):
        """Show that a user can retrieve deployment statuses."""
        cassette_name = self.cassette_name('statuses')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            deployment = find(lambda d: d.id == 801,
>                             repository.deployments())

tests/integration/test_repos_deployment.py:37: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

func = <function <lambda> at 0x103edc398>, iterable = <NullObject('Repository')>

    def find(func, iterable):
        """Helper function to find the first item in an interable."""
>       return next(iter(filter(func, iterable)))
E       StopIteration

tests/integration/test_repos_deployment.py:9: StopIteration
_________________ TestRepositoryPages.test_latest_pages_build __________________

self = <tests.integration.test_repos_pages.TestRepositoryPages testMethod=test_latest_pages_build>

    def test_latest_pages_build(self):
        """Test the ability to retrieve the latest pages build for a repo."""
        self.basic_login()
        cassette_name = self.cassette_name('latest_pages_build')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            latest_build = repository.latest_pages_build()
    
>       assert isinstance(latest_build, github3.repos.pages.PagesBuild)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.pages.PagesBuild'>)
E        +  where <class 'github3.repos.pages.PagesBuild'> = <module 'github3.repos.pages' from '/Users/mattchung/Development/github3.py/github3/repos/pages.pyc'>.PagesBuild
E        +    where <module 'github3.repos.pages' from '/Users/mattchung/Development/github3.py/github3/repos/pages.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.pages
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_pages.py:16: AssertionError
________________________ TestRepositoryPages.test_pages ________________________

self = <tests.integration.test_repos_pages.TestRepositoryPages testMethod=test_pages>

    def test_pages(self):
        """
            Test the ability to retrieve information about a repository's pages.
            """
        self.basic_login()
        cassette_name = self.cassette_name('pages')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            pages_info = repository.pages()
    
>       assert isinstance(pages_info, github3.repos.pages.PagesInfo)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.pages.PagesInfo'>)
E        +  where <class 'github3.repos.pages.PagesInfo'> = <module 'github3.repos.pages' from '/Users/mattchung/Development/github3.py/github3/repos/pages.pyc'>.PagesInfo
E        +    where <module 'github3.repos.pages' from '/Users/mattchung/Development/github3.py/github3/repos/pages.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.pages
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_pages.py:29: AssertionError
____________________________ TestRelease.test_asset ____________________________

self = <tests.integration.test_repos_release.TestRelease testMethod=test_asset>

    def test_asset(self):
        """Test the ability to retrieve a single asset from a release."""
        cassette_name = self.cassette_name('asset')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            release = repository.release(76677)
            asset = release.asset(37944)
    
        assert asset is not None
>       assert isinstance(asset, github3.repos.release.Asset)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.release.Asset'>)
E        +  where <class 'github3.repos.release.Asset'> = <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'>.Asset
E        +    where <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.release
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_release.py:18: AssertionError
___________________________ TestRelease.test_assets ____________________________

self = <tests.integration.test_repos_release.TestRelease testMethod=test_assets>

    def test_assets(self):
        """Test the ability to iterate over the assets of a release."""
        cassette_name = self.cassette_name('assets')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            release = repository.release(76677)
            for asset in release.assets():
                assert isinstance(asset, github3.repos.release.Asset)
>           assert asset is not None
E           UnboundLocalError: local variable 'asset' referenced before assignment

tests/integration/test_repos_release.py:28: UnboundLocalError
___________________________ TestRelease.test_delete ____________________________

self = <tests.integration.test_repos_release.TestRelease testMethod=test_delete>

    def test_delete(self):
        """Test the ability to delete a release."""
        self.token_login()
        cassette_name = self.cassette_name('delete')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('github3py', 'github3.py')
            release = repository.create_release(
                '0.8.0.pre', 'develop', '0.8.0 fake release',
                'To be deleted'
                )
            assert release is not None
>           assert release.delete() is True
E           AssertionError: assert <NullObject('Repository')> is True
E            +  where <NullObject('Repository')> = <NullObject('Repository')>()
E            +    where <NullObject('Repository')> = <NullObject('Repository')>.delete

tests/integration/test_repos_release.py:41: AssertionError
____________________________ TestRelease.test_edit _____________________________

self = <tests.integration.test_repos_release.TestRelease testMethod=test_edit>

    def test_edit(self):
        """Test the ability to edit a release on a repository."""
        self.token_login()
        cassette_name = self.cassette_name('edit')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'charade')
            release = repository.release(85783)
>           assert release.edit(body='Test editing a release') is True
E           AssertionError: assert <NullObject('Repository')> is True
E            +  where <NullObject('Repository')> = <NullObject('Repository')>(body='Test editing a release')
E            +    where <NullObject('Repository')> = <NullObject('Repository')>.edit

tests/integration/test_repos_release.py:50: AssertionError
________________________ TestRelease.test_upload_asset _________________________

self = <tests.integration.test_repos_release.TestRelease testMethod=test_upload_asset>

    def test_upload_asset(self):
        """Test the ability to upload an asset to a release."""
        self.token_login()
        cassette_name = self.cassette_name('upload_asset')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('github3py', 'github3.py')
            release = repository.create_release(
                '0.8.0.pre', 'develop', '0.8.0 fake release with upload',
                'To be deleted'
                )
            with open(__file__) as fd:
                asset = release.upload_asset(
                    'text/plain', 'test_repos_release.py', fd.read()
                    )
>           assert isinstance(asset, github3.repos.release.Asset)
E           AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.release.Asset'>)
E            +  where <class 'github3.repos.release.Asset'> = <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'>.Asset
E            +    where <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.release
E            +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_release.py:67: AssertionError
____________________________ TestAsset.test_delete _____________________________

self = <tests.integration.test_repos_release.TestAsset testMethod=test_delete>

    def test_delete(self):
        """Test the ability to delete an asset."""
        self.basic_login()
        cassette_name = self.cassette_name('delete')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('github3py', 'github3.py')
            release = repository.release(833407)
            asset = release.asset(370020)
>           assert asset.delete() is True
E           AssertionError: assert <NullObject('Repository')> is True
E            +  where <NullObject('Repository')> = <NullObject('Repository')>()
E            +    where <NullObject('Repository')> = <NullObject('Repository')>.delete

tests/integration/test_repos_release.py:80: AssertionError
___________________________ TestAsset.test_download ____________________________

self = <tests.integration.test_repos_release.TestAsset testMethod=test_download>

    def test_download(self):
        """Test the ability to download an asset."""
        cassette_name = self.cassette_name('download')
        with self.recorder.use_cassette(cassette_name,
                                        preserve_exact_body_bytes=True):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            release = repository.release(76677)
>           asset = next(release.assets())

tests/integration/test_repos_release.py:89: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <NullObject('Repository')>

    def __next__(self):
>       raise StopIteration
E       StopIteration

github3/null.py:50: StopIteration
__________________ TestAsset.test_download_when_authenticated __________________

self = <tests.integration.test_repos_release.TestAsset testMethod=test_download_when_authenticated>

    def test_download_when_authenticated(self):
        """Test the ability to download an asset when authenticated."""
        self.basic_login()
        cassette_name = self.cassette_name('download_when_authenticated')
        with self.recorder.use_cassette(cassette_name,
                                        preserve_exact_body_bytes=True):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            release = repository.release(76677)
>           asset = next(release.assets())

tests/integration/test_repos_release.py:106: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <NullObject('Repository')>

    def __next__(self):
>       raise StopIteration
E       StopIteration

github3/null.py:50: StopIteration
_____________________________ TestAsset.test_edit ______________________________

self = <tests.integration.test_repos_release.TestAsset testMethod=test_edit>

    def test_edit(self):
        """Test the ability to edit an existing asset."""
        self.basic_login()
        cassette_name = self.cassette_name('edit')
        with self.recorder.use_cassette(cassette_name,
                                        preserve_exact_body_bytes=True):
            repository = self.gh.repository('github3py', 'github3.py')
            release = repository.create_release(
                '0.8.0.pre', 'develop', '0.8.0 fake release with upload',
                'To be deleted'
                )
            with open(__file__) as fd:
                asset = release.upload_asset(
                    'text/plain', 'test_repos_release.py', fd.read()
                    )
>           assert isinstance(asset, github3.repos.release.Asset)
E           AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.release.Asset'>)
E            +  where <class 'github3.repos.release.Asset'> = <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'>.Asset
E            +    where <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.release
E            +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_release.py:132: AssertionError
_____________________ TestRepository.test_add_collaborator _____________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_add_collaborator>

    def test_add_collaborator(self):
        """Test the ability to add a collaborator to a repository."""
        self.basic_login()
        cassette_name = self.cassette_name('add_collaborator')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('testgh3', 'collaborators')
>           assert repository
E           AssertionError: assert <NullObject('Repository')>

tests/integration/test_repos_repo.py:20: AssertionError
____________________ TestRepository.test_create_deployment _____________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_create_deployment>

    def test_create_deployment(self):
        """Test the ability to create a deployment for a repository."""
        self.basic_login()
        cassette_name = self.cassette_name('create_deployment')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            deployment = repository.create_deployment('0.8.2')
    
>       assert isinstance(deployment, github3.repos.deployment.Deployment)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.deployment.Deployment'>)
E        +  where <class 'github3.repos.deployment.Deployment'> = <module 'github3.repos.deployment' from '/Users/mattchung/Development/github3.py/github3/repos/deployment.pyc'>.Deployment
E        +    where <module 'github3.repos.deployment' from '/Users/mattchung/Development/github3.py/github3/repos/deployment.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.deployment
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_repo.py:127: AssertionError
______________________ TestRepository.test_create_release ______________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_create_release>

    def test_create_release(self):
        """Test the ability to create a release on a repository."""
        self.token_login()
        cassette_name = self.cassette_name('create_release')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'charade')
            assert repository is not None
            release = repository.create_release(
                '1.0.3.test', 'f1d4e150be7070adfbbdca164328d69723e096ec',
                'Test release'
                )
    
>       assert isinstance(release, github3.repos.release.Release)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.release.Release'>)
E        +  where <class 'github3.repos.release.Release'> = <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'>.Release
E        +    where <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.release
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_repo.py:141: AssertionError
__________________________ TestRepository.test_delete __________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_delete>

    def test_delete(self):
        """Test that a repository can be deleted."""
        self.basic_login()
        cassette_name = self.cassette_name('delete')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'my-new-repo')
            assert repository is not None
>           assert repository.delete() is True
E           AssertionError: assert <NullObject('Repository')> is True
E            +  where <NullObject('Repository')> = <NullObject('Repository')>()
E            +    where <NullObject('Repository')> = <NullObject('Repository')>.delete

tests/integration/test_repos_repo.py:150: AssertionError
________________________ TestRepository.test_deployment ________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_deployment>

    def test_deployment(self):
        """Test that a deployment can be retrieved by its id."""
        cassette_name = self.cassette_name('deployment')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            deployment = repository.deployment(797)
    
>       assert isinstance(deployment, github3.repos.deployment.Deployment)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.deployment.Deployment'>)
E        +  where <class 'github3.repos.deployment.Deployment'> = <module 'github3.repos.deployment' from '/Users/mattchung/Development/github3.py/github3/repos/deployment.pyc'>.Deployment
E        +    where <module 'github3.repos.deployment' from '/Users/mattchung/Development/github3.py/github3/repos/deployment.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.deployment
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_repo.py:160: AssertionError
__________________________ TestRepository.test_events __________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_events>

    def test_events(self):
        """Test that a user can iterate over the events from a repository."""
        cassette_name = self.cassette_name('events')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            events = list(repository.events(number=100))
    
>       assert len(events) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:190: AssertionError
______________________ TestRepository.test_file_contents _______________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_file_contents>

    def test_file_contents(self):
        """Test that a file's contents can be retrieved."""
        cassette_name = self.cassette_name('file_contents')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            contents = repository.file_contents('github3/repos/repo.py')
    
>       assert isinstance(contents, github3.repos.contents.Contents)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.contents.Contents'>)
E        +  where <class 'github3.repos.contents.Contents'> = <module 'github3.repos.contents' from '/Users/mattchung/Development/github3.py/github3/repos/contents.pyc'>.Contents
E        +    where <module 'github3.repos.contents' from '/Users/mattchung/Development/github3.py/github3/repos/contents.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.contents
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_repo.py:201: AssertionError
__________________________ TestRepository.test_forks ___________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_forks>

    def test_forks(self):
        """Test that a user can iterate over the forks of a repository."""
        cassette_name = self.cassette_name('forks')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            forks = list(repository.forks())
    
>       assert len(forks) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:211: AssertionError
__________________________ TestRepository.test_hooks ___________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_hooks>

    def test_hooks(self):
        """Test that a user can iterate over the hooks of a repository."""
        self.basic_login()
        cassette_name = self.cassette_name('hooks')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            hooks = list(repository.hooks())
    
>       assert len(hooks) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:224: AssertionError
__________________________ TestRepository.test_ignore __________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_ignore>

    def test_ignore(self):
        """Test that a user can ignore the notifications on a repository."""
        self.basic_login()
        cassette_name = self.cassette_name('ignore')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('jnewland',
                                            'gmond_python_modules')
            assert repository is not None
            subscription = repository.ignore()
>           assert subscription.ignored is True
E           AssertionError: assert <NullObject('Repository')> is True
E            +  where <NullObject('Repository')> = <NullObject('Repository')>.ignored

tests/integration/test_repos_repo.py:237: AssertionError
_________________ TestRepository.test_issues_sorts_ascendingly _________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_issues_sorts_ascendingly>

    def test_issues_sorts_ascendingly(self):
        """Test that issues will be returned in ascending order."""
        cassette_name = self.cassette_name('issues_ascending')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'betamax')
            assert repository is not None
            issues = list(repository.issues(direction='asc'))
    
>       assert len(issues) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:258: AssertionError
___________________________ TestRepository.test_key ____________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_key>

    def test_key(self):
        """Test the retrieval of a single key."""
        self.basic_login()
        cassette_name = self.cassette_name('key')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            key = repository.key(8820641)
    
>       assert isinstance(key, github3.users.Key)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.users.Key'>)
E        +  where <class 'github3.users.Key'> = <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'>.Key
E        +    where <module 'github3.users' from '/Users/mattchung/Development/github3.py/github3/users.pyc'> = github3.users

tests/integration/test_repos_repo.py:284: AssertionError
___________________________ TestRepository.test_keys ___________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_keys>

    def test_keys(self):
        """Test that the user can retrieve all deploy keys."""
        self.basic_login()
        cassette_name = self.cassette_name('keys')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            keys = list(repository.keys())
    
>       assert len(keys) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:295: AssertionError
__________________________ TestRepository.test_labels __________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_labels>

    def test_labels(self):
        """Test that a user can retrieve a repository's labels."""
        cassette_name = self.cassette_name('labels')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            labels = list(repository.labels())
    
>       assert len(labels) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:307: AssertionError
________________________ TestRepository.test_milestone _________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_milestone>

    def test_milestone(self):
        """Test the ability to retrieve a milestone on a repository."""
        cassette_name = self.cassette_name('milestone')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            milestone = repository.milestone(7)
>       assert isinstance(milestone, github3.issues.milestone.Milestone)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.issues.milestone.Milestone'>)
E        +  where <class 'github3.issues.milestone.Milestone'> = <module 'github3.issues.milestone' from '/Users/mattchung/Development/github3.py/github3/issues/milestone.pyc'>.Milestone
E        +    where <module 'github3.issues.milestone' from '/Users/mattchung/Development/github3.py/github3/issues/milestone.pyc'> = <module 'github3.issues' from '/Users/mattchung/Development/github3.py/github3/issues/__init__.pyc'>.milestone
E        +      where <module 'github3.issues' from '/Users/mattchung/Development/github3.py/github3/issues/__init__.pyc'> = github3.issues

tests/integration/test_repos_repo.py:329: AssertionError
________________________ TestRepository.test_milestones ________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_milestones>

    def test_milestones(self):
        """Test the ability to retrieve the milestones in a repository."""
        cassette_name = self.cassette_name('milestones')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            milestones = list(repository.milestones())
    
>       assert len(milestones) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:339: AssertionError
______________________ TestRepository.test_network_events ______________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_network_events>

    def test_network_events(self):
        """Test that a user can retrieve the events of a repo's network."""
        cassette_name = self.cassette_name('network_events')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            events = list(repository.network_events())
    
>       assert len(events) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:351: AssertionError
______________________ TestRepository.test_notifications _______________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_notifications>

    def test_notifications(self):
        """Test that a user can retrieve their repo notifications."""
        self.basic_login()
        cassette_name = self.cassette_name('notifications')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            notifications = list(repository.notifications())
    
>       assert len(notifications) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:364: AssertionError
______________________ TestRepository.test_pull_requests _______________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_pull_requests>

    def test_pull_requests(self):
        """Test that a user can retrieve the pull requests from a repo."""
        cassette_name = self.cassette_name('pull_requests')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            pulls = list(repository.pull_requests())
    
>       assert len(pulls) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:376: AssertionError
___________________________ TestRepository.test_refs ___________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_refs>

    def test_refs(self):
        """Test the ability to retrieve the references from a repository."""
        cassette_name = self.cassette_name('refs')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            references = list(repository.refs())
    
>       assert len(references) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:421: AssertionError
___________ TestRepository.test_refs_raises_unprocessable_exception ____________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_refs_raises_unprocessable_exception>

    def test_refs_raises_unprocessable_exception(self):
        """Verify github3.exceptions.UnprocessableResponseBody is raised."""
        cassette_name = self.cassette_name('invalid_refs')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            with pytest.raises(exc.UnprocessableResponseBody):
>               list(repository.refs('heads/develop'))
E               Failed: DID NOT RAISE

tests/integration/test_repos_repo.py:432: Failed
_________________________ TestRepository.test_release __________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_release>

    def test_release(self):
        """Test the ability to retrieve a single release."""
        cassette_name = self.cassette_name('release')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            release = repository.release(76677)
    
>       assert isinstance(release, github3.repos.release.Release)
E       AssertionError: assert isinstance(<NullObject('Repository')>, <class 'github3.repos.release.Release'>)
E        +  where <class 'github3.repos.release.Release'> = <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'>.Release
E        +    where <module 'github3.repos.release' from '/Users/mattchung/Development/github3.py/github3/repos/release.pyc'> = <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'>.release
E        +      where <module 'github3.repos' from '/Users/mattchung/Development/github3.py/github3/repos/__init__.pyc'> = github3.repos

tests/integration/test_repos_repo.py:402: AssertionError
________________________ TestRepository.test_stargazers ________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_stargazers>

    def test_stargazers(self):
        """Test the ability to retrieve the stargazers on a repository."""
        cassette_name = self.cassette_name('stargazers')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'betamax')
            assert repository is not None
            stargazers = list(repository.stargazers())
    
>       assert len(stargazers) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:442: AssertionError
_________________________ TestRepository.test_statuses _________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_statuses>

    def test_statuses(self):
        """Test the ability to retrieve a commit's statuses."""
        cassette_name = self.cassette_name('statuses')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'github3.py')
            assert repository is not None
            statuses = list(repository.statuses(
                '0cea3860f91717272a5edb3961e9723b70769084'
            ))
    
>       assert len(statuses) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:456: AssertionError
_______________________ TestRepository.test_subscribers ________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_subscribers>

    def test_subscribers(self):
        """Test the ability to retrieve a repository's subscribers."""
        cassette_name = self.cassette_name('subscribers')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'betamax')
            assert repository is not None
            subscribers = list(repository.subscribers())
    
>       assert len(subscribers) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:468: AssertionError
_______________________ TestRepository.test_subscription _______________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_subscription>

    def test_subscription(self):
        """Test the ability to subscribe to a repository's notifications."""
        self.basic_login()
        cassette_name = self.cassette_name('subscription')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('vcr', 'vcr')
            assert repository is not None
            subscription = repository.subscribe()
>           assert subscription.subscribed is True
E           AssertionError: assert <NullObject('Repository')> is True
E            +  where <NullObject('Repository')> = <NullObject('Repository')>.subscribed

tests/integration/test_repos_repo.py:480: AssertionError
___________________________ TestRepository.test_tags ___________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_tags>

    def test_tags(self):
        """Test the ability to retrieve a repository's tags."""
        cassette_name = self.cassette_name('tags')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('sigmavirus24', 'betamax')
            assert repository is not None
            tags = list(repository.tags())
    
>       assert len(tags) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:490: AssertionError
__________________________ TestRepository.test_teams ___________________________

self = <tests.integration.test_repos_repo.TestRepository testMethod=test_teams>

    def test_teams(self):
        """Test the ability to retrieve teams assigned to a repo."""
        self.basic_login()
        cassette_name = self.cassette_name('teams')
        with self.recorder.use_cassette(cassette_name):
            repository = self.gh.repository('github3py', 'github3.py')
            assert repository is not None
            teams = list(repository.teams())
    
>       assert len(teams) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_repos_repo.py:503: AssertionError
_____________________ TestGitHubIterator.test_resets_etag ______________________

self = <tests.integration.test_structs.TestGitHubIterator testMethod=test_resets_etag>

    def test_resets_etag(self):
        cassette_name = self.cassette_name('resets_etag')
        with self.recorder.use_cassette(cassette_name):
            users_iter = self.gh.all_users(number=10)
            assert users_iter.etag is None
>           next(users_iter)  # Make the request

tests/integration/test_structs.py:10: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
github3/structs.py:120: in next
    return self.__next__()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <GitHubIterator [10, /users]>

    def __next__(self):
        if not hasattr(self, '__i__'):
            self.__i__ = self.__iter__()
>       return next(self.__i__)
E       StopIteration

github3/structs.py:106: StopIteration
_____________________________ TestUser.test_events _____________________________

self = <tests.integration.test_users.TestUser testMethod=test_events>

    def test_events(self):
        """Show that a user can retrieve a events performed by a user."""
        cassette_name = self.cassette_name('events')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            events = list(user.events(25))
    
>       assert len(events) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:18: AssertionError
___________________________ TestUser.test_followers ____________________________

self = <tests.integration.test_users.TestUser testMethod=test_followers>

    def test_followers(self):
        """Show that a user can retrieve any user's followers."""
        cassette_name = self.cassette_name('followers')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            followers = list(user.followers(50))
    
>       assert len(followers) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:29: AssertionError
___________________________ TestUser.test_following ____________________________

self = <tests.integration.test_users.TestUser testMethod=test_following>

    def test_following(self):
        """Show that a user can retrieve users that a user is following."""
        cassette_name = self.cassette_name('following')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            following = list(user.following(50))
    
>       assert len(following) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:40: AssertionError
______________________________ TestUser.test_keys ______________________________

self = <tests.integration.test_users.TestUser testMethod=test_keys>

    def test_keys(self):
        """Show that a user can retrieve any user's public keys."""
        cassette_name = self.cassette_name('keys')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            keys = list(user.keys())
    
>       assert len(keys) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:51: AssertionError
______________________ TestUser.test_organization_events _______________________

self = <tests.integration.test_users.TestUser testMethod=test_organization_events>

    def test_organization_events(self):
        """Show that a user can retrieve their events on an organization."""
        self.basic_login()
        cassette_name = self.cassette_name('organization_events')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            events = list(user.organization_events('pdfkit', 25))
    
>       assert len(events) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:63: AssertionError
________________________ TestUser.test_received_events _________________________

self = <tests.integration.test_users.TestUser testMethod=test_received_events>

    def test_received_events(self):
        """Show that a user can retrieve any user's received events."""
        cassette_name = self.cassette_name('received_events')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            events = list(user.received_events(number=25))
    
>       assert len(events) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:82: AssertionError
______________________ TestUser.test_starred_repositories ______________________

self = <tests.integration.test_users.TestUser testMethod=test_starred_repositories>

    def test_starred_repositories(self):
        """Show that a user can retrieve the repositories starred by a user."""
        cassette_name = self.cassette_name('starred_repositories')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            repos = list(user.starred_repositories(50))
    
>       assert len(repos) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:93: AssertionError
_________________________ TestUser.test_subscriptions __________________________

self = <tests.integration.test_users.TestUser testMethod=test_subscriptions>

    def test_subscriptions(self):
        """Show that a user can retrieve the repos subscribed to by a user."""
        cassette_name = self.cassette_name('subscriptions')
        with self.recorder.use_cassette(cassette_name):
            user = self.gh.user('sigmavirus24')
            repos = list(user.subscriptions())
    
>       assert len(repos) > 0
E       AssertionError: assert 0 > 0
E        +  where 0 = len([])

tests/integration/test_users.py:104: AssertionError
137 failed, 620 passed, 5 xfailed, 1 xpassed in 13.83 seconds