Mirrors/python-plexapi
2
0
Fork 0
mirror of https://github.com/pkkid/python-plexapi synced 2024-09-20 05:41:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

UPdating tests to work on second install

Browse source
This commit is contained in:
Michael Shepanski 2017-04-14 20:47:59 -04:00
parent ae91ba14b7
commit 7bb39aa05c
8 changed files with 464 additions and 492 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
plexapi/server.py
View file

@ -265,11 +265,8 @@ class PlexServer(PlexObject):
by encoding the response to utf-8 and parsing the returned XML into and
ElementTree object. Returns None if no data exists in the response.
"""
if not key.startswith('http'):
url = self.url(key)
else:
url = key
#url = key if key.startswith('http') else self.url(key)
url = self.url(key)
method = method or self._session.get
log.debug('%s %s', method.__name__.upper(), url)
headers = self._headers(**headers or {})

175
tests/conftest.py
View file

@ -1,144 +1,105 @@
# -*- coding: utf-8 -*-
import betamax, os, plexapi
import pytest, requests
from betamax_serializers import pretty_json
import plexapi, pytest, requests
from datetime import datetime
from plexapi.myplex import MyPlexAccount
from plexapi.server import PlexServer
from functools import partial
test_baseurl = plexapi.CONFIG.get('auth.server_baseurl')
test_token = plexapi.CONFIG.get('auth.server_token')
test_username = plexapi.CONFIG.get('auth.myplex_username')
test_password = plexapi.CONFIG.get('auth.myplex_password')
@pytest.fixture(scope='session')
def pms(request):
from plexapi.server import PlexServer
sess = requests.Session()
# CASSETTE_LIBRARY_DIR = 'response/'
# betamax.Betamax.register_serializer(pretty_json.PrettyJSONSerializer)
# config = betamax.Betamax.configure()
# config.define_cassette_placeholder('MASKED', token)
# config.define_cassette_placeholder('MASKED', test_token)
# recorder = betamax.Betamax(sess, cassette_library_dir=CASSETTE_LIBRARY_DIR)
# recorder.use_cassette('http_responses', serialize_with='prettyjson') # record='new_episodes'
# recorder.start()
assert test_baseurl
assert test_token
pms = PlexServer(test_baseurl, test_token, session=sess)
#request.addfinalizer(recorder.stop)
return pms
@pytest.fixture()
def freshpms():
from plexapi.server import PlexServer
sess = requests.Session()
assert test_baseurl
assert test_token
pms = PlexServer(test_baseurl, test_token, session=sess)
return pms
MIN_DATETIME = datetime(2017, 1, 1)
SERVER_BASEURL = plexapi.CONFIG.get('auth.server_baseurl')
SERVER_TOKEN = plexapi.CONFIG.get('auth.server_token')
MYPLEX_USERNAME = plexapi.CONFIG.get('auth.myplex_username')
MYPLEX_PASSWORD = plexapi.CONFIG.get('auth.myplex_password')
def pytest_addoption(parser):
parser.addoption("--req_client", action="store_true",
help="Run tests that interact with a client")
parser.addoption('--req_client', action='store_true', help='Run tests that interact with a client')
def pytest_runtest_setup(item):
if 'req_client' in item.keywords and not item.config.getvalue("req_client"):
pytest.skip("need --req_client option to run")
if 'req_client' in item.keywords and not item.config.getvalue('req_client'):
pytest.skip('need --req_client option to run')
else:
item.config.getvalue("req_client")
item.config.getvalue('req_client')
#---------------------------------
# Fixtures
#---------------------------------
@pytest.fixture()
def account():
assert MYPLEX_USERNAME, 'Required MYPLEX_USERNAME not specified.'
assert MYPLEX_PASSWORD, 'Required MYPLEX_PASSWORD not specified.'
return MyPlexAccount(MYPLEX_USERNAME, MYPLEX_PASSWORD)
@pytest.fixture(scope='session')
def plex():
assert SERVER_BASEURL, 'Required SERVER_BASEURL not specified.'
assert SERVER_TOKEN, 'Requred SERVER_TOKEN not specified.'
session = requests.Session()
return PlexServer(SERVER_BASEURL, SERVER_TOKEN, session=session)
@pytest.fixture()
def plex_account():
from plexapi.myplex import MyPlexAccount
username = test_username
password = test_password
assert username and password
account = MyPlexAccount(username, password)
assert account
return account
def plex2():
return plex()
@pytest.fixture()
def a_movie(pms):
m = pms.library.search('16 blocks')
assert m
return m[0]
def tvshows(plex):
return plex.library.section('TV Shows')
@pytest.fixture()
def a_tv_section(pms):
sec = pms.library.section('TV Shows')
assert sec
return sec
def movies(plex):
return plex.library.section('Movies')
@pytest.fixture()
def a_movie_section(pms):
sec = pms.library.section('Movies')
assert sec
return sec
def music(plex):
return plex.library.section('Music')
@pytest.fixture()
def a_music_section(pms):
sec = pms.library.section('Music')
assert sec
return sec
def photos(plex):
return plex.library.section('Photos')
@pytest.fixture()
def a_photo_section(pms):
sec = pms.library.section('Photos')
assert sec
return sec
def movie(movies):
return movies.get('16 blocks')
@pytest.fixture()
def a_artist(a_music_section):
sec = a_music_section.get('Infinite State')
assert sec
return sec
def artist(music):
return music.get('Infinite State')
@pytest.fixture()
def a_music_album(a_music_section):
sec = a_music_section.get('Infinite State').album('Unmastered Impulses')
assert sec
return sec
def album(artist):
return artist.album('Unmastered Impulses')
@pytest.fixture()
def a_track(a_music_album):
track = a_music_album.track('Holy Moment')
assert track
return track
def track(album):
return album.track('Holy Moment')
@pytest.fixture()
def a_show(a_tv_section):
sec = a_tv_section.get('The 100')
assert sec
return sec
def show(tvshows):
return tvshows.get('The 100')
@pytest.fixture()
def a_episode(a_show):
ep = a_show.get('Pilot')
assert ep
return ep
def episode(show):
return show.get('Pilot')
@pytest.fixture()
def a_photo_album(pms):
sec = pms.library.section('Photos')
assert sec
album = sec.get('photo_album1')
assert album
return album
def photoalbum(photos):
return photos.get('photo_album1')
@pytest.fixture()
@ -146,3 +107,27 @@ def monkeydownload(request, monkeypatch):
monkeypatch.setattr('plexapi.utils.download', partial(plexapi.utils.download, mocked=True))
yield
monkeypatch.undo()
#---------------------------------
# Utility Functions
#---------------------------------
def is_datetime(value):
return value > MIN_DATETIME
def is_int(value):
return int(value) >= 1
def is_metadata(key):
return key.startswith('/library/metadata/')
def is_part(key):
return key.startswith('/library/parts/')
def is_thumb(key):
return key.startswith('/library/metadata/') and '/thumb/' in key

31
tests/test_actions.py
View file

@ -1,22 +1,21 @@
# -*- coding: utf-8 -*-
def test_mark_movie_watched(a_movie):
a_movie.markUnwatched()
print('Marking movie watched: %s' % a_movie)
print('View count: %s' % a_movie.viewCount)
a_movie.markWatched()
print('View count: %s' % a_movie.viewCount)
assert a_movie.viewCount == 1, 'View count 0 after watched.'
a_movie.markUnwatched()
print('View count: %s' % a_movie.viewCount)
assert a_movie.viewCount == 0, 'View count 1 after unwatched.'
def test_mark_movie_watched(movie):
movie.markUnwatched()
print('Marking movie watched: %s' % movie)
print('View count: %s' % movie.viewCount)
movie.markWatched()
print('View count: %s' % movie.viewCount)
assert movie.viewCount == 1, 'View count 0 after watched.'
movie.markUnwatched()
print('View count: %s' % movie.viewCount)
assert movie.viewCount == 0, 'View count 1 after unwatched.'
def test_refresh_section(pms):
shows = pms.library.section('TV Shows')
#shows.refresh()
def test_refresh_section(tvshows):
tvshows.refresh()
def test_refresh_video(pms):
result = pms.search('16 blocks')
#result[0].refresh()
def test_refresh_video(movie):
movie.refresh()

460
tests/test_audio.py
View file

@ -1,310 +1,314 @@
# -*- coding: utf-8 -*-
def test_audio_Artist_attr(a_artist):
m = a_artist
m.reload()
assert str(m.addedAt.date()) == '2017-01-17'
assert m.countries == []
assert [i.tag for i in m.genres] == ['Electronic']
assert m.guid == 'com.plexapp.agents.lastfm://Infinite%20State?lang=en'
assert m.index == '1'
assert m._initpath == '/library/metadata/20'
assert m.key == '/library/metadata/20'
assert m.librarySectionID == '3'
assert m.listType == 'audio'
assert m.locations == ['/media/music/unmastered_impulses']
assert m.ratingKey == 20
assert m._server._baseurl == 'http://138.68.157.5:32400'
assert m.similar == []
assert m.summary == ""
assert m.title == 'Infinite State'
assert m.titleSort == 'Infinite State'
assert m.type == 'artist'
# keeps breaking because of timezone differences between us
# assert str(m.updatedAt.date()) == '2017-02-01'
assert m.viewCount == 0
from datetime import datetime
from .conftest import is_int, is_datetime
from .conftest import is_metadata, is_part, is_thumb
from .conftest import SERVER_BASEURL
def test_audio_Artist_get(a_artist, a_music_section):
a_artist == a_music_section.searchArtists(**{'title': 'Infinite State'})[0]
a_artist.title == 'Infinite State'
def test_audio_Artist_attr(artist):
artist.reload()
assert is_datetime(artist.addedAt)
assert artist.countries == []
assert [i.tag for i in artist.genres] == ['Electronic']
assert 'lastfm' in artist.guid
assert artist.index == '1'
assert is_metadata(artist._initpath)
assert is_metadata(artist.key)
assert is_int(artist.librarySectionID)
assert artist.listType == 'audio'
assert len(artist.locations) == 1
assert len(artist.locations[0]) >= 10
assert artist.ratingKey >= 1
assert artist._server._baseurl == SERVER_BASEURL
assert artist.similar == []
assert artist.summary == ''
assert artist.title == 'Infinite State'
assert artist.titleSort == 'Infinite State'
assert artist.type == 'artist'
assert is_datetime(artist.updatedAt)
assert artist.viewCount == 0
def test_audio_Artist_track(a_artist):
track = a_artist.track('Holy Moment')
def test_audio_Artist_get(artist, music):
artist == music.searchArtists(**{'title': 'Infinite State'})[0]
artist.title == 'Infinite State'
def test_audio_Artist_track(artist):
track = artist.track('Holy Moment')
assert track.title == 'Holy Moment'
def test_audio_Artist_tracks(a_artist):
tracks = a_artist.tracks()
def test_audio_Artist_tracks(artist):
tracks = artist.tracks()
assert len(tracks) == 14
def test_audio_Artist_album(a_artist):
album = a_artist.album('Unmastered Impulses')
def test_audio_Artist_album(artist):
album = artist.album('Unmastered Impulses')
assert album.title == 'Unmastered Impulses'
def test_audio_Artist_albums(a_artist):
albums = a_artist.albums()
def test_audio_Artist_albums(artist):
albums = artist.albums()
assert len(albums) == 1 and albums[0].title == 'Unmastered Impulses'
def test_audio_Album_attrs(a_music_album):
m = a_music_album
assert str(m.addedAt.date()) == '2017-01-17'
assert [i.tag for i in m.genres] == ['Electronic']
assert m.index == '1'
assert m._initpath == '/library/metadata/20/children'
assert m.key == '/library/metadata/21'
assert m.librarySectionID == '3'
assert m.listType == 'audio'
assert str(m.originallyAvailableAt.date()) == '2016-01-01'
assert m.parentKey == '/library/metadata/20'
assert m.parentRatingKey == '20'
assert m.parentThumb is None
assert m.parentTitle == 'Infinite State'
assert m.ratingKey == 21
assert m._server._baseurl == 'http://138.68.157.5:32400'
assert m.studio is None
assert m.summary == ''
assert m.thumb == '/library/metadata/21/thumb/1484693407'
assert m.title == 'Unmastered Impulses'
assert m.titleSort == 'Unmastered Impulses'
assert m.type == 'album'
assert str(m.updatedAt.date()) == '2017-01-17'
assert m.viewCount == 0
assert m.year == 2016
def test_audio_Album_attrs(album):
assert is_datetime(album.addedAt)
assert [i.tag for i in album.genres] == ['Electronic']
assert album.index == '1'
assert is_metadata(album._initpath)
assert is_metadata(album.key)
assert is_int(album.librarySectionID)
assert album.listType == 'audio'
assert album.originallyAvailableAt == datetime(2016, 1, 1)
assert is_metadata(album.parentKey)
assert is_int(album.parentRatingKey)
assert is_thumb(album.parentThumb)
assert album.parentTitle == 'Infinite State'
assert album.ratingKey >= 1
assert album._server._baseurl == SERVER_BASEURL
assert album.studio is None
assert album.summary == ''
assert is_thumb(album.thumb)
assert album.title == 'Unmastered Impulses'
assert album.titleSort == 'Unmastered Impulses'
assert album.type == 'album'
assert is_datetime(album.updatedAt)
assert album.viewCount == 0
assert album.year == 2016
def test_audio_Album_tracks(a_music_album):
tracks = a_music_album.tracks()
def test_audio_Album_tracks(album):
tracks = album.tracks()
track = tracks[0]
assert len(tracks) == 14
assert tracks[0].grandparentKey == '/library/metadata/20'
assert tracks[0].grandparentRatingKey == '20'
assert tracks[0].grandparentTitle == 'Infinite State'
assert tracks[0].index == '1'
assert tracks[0]._initpath == '/library/metadata/21/children'
assert tracks[0].key == '/library/metadata/22'
assert tracks[0].listType == 'audio'
assert tracks[0].originalTitle == 'Kenneth Reitz'
assert tracks[0].parentIndex == '1'
assert tracks[0].parentKey == '/library/metadata/21'
assert tracks[0].parentRatingKey == '21'
assert tracks[0].parentThumb == '/library/metadata/21/thumb/1484693407'
assert tracks[0].parentTitle == 'Unmastered Impulses'
assert tracks[0].player is None
assert tracks[0].ratingCount == 9
assert tracks[0].ratingKey == 22
assert tracks[0]._server._baseurl == 'http://138.68.157.5:32400'
assert tracks[0].summary == ""
assert tracks[0].thumb == '/library/metadata/21/thumb/1484693407'
assert tracks[0].title == 'Holy Moment'
assert tracks[0].titleSort == 'Holy Moment'
assert tracks[0].transcodeSession is None
assert tracks[0].type == 'track'
assert str(tracks[0].updatedAt.date()) == '2017-01-17'
assert tracks[0].username is None
assert tracks[0].viewCount == 0
assert tracks[0].viewOffset == 0
def test_audio_Album_track(a_music_album):
# this is not reloaded. its not that much info missing.
track = a_music_album.track('Holy Moment')
assert str(track.addedAt.date()) == '2017-01-17'
assert track.duration == 298606
assert track.grandparentKey == '/library/metadata/20'
assert track.grandparentRatingKey == '20'
assert is_metadata(track.grandparentKey)
assert is_int(track.grandparentRatingKey)
assert track.grandparentTitle == 'Infinite State'
assert track.index == '1'
assert track._initpath == '/library/metadata/21/children'
assert track.key == '/library/metadata/22'
assert is_metadata(track._initpath)
assert is_metadata(track.key)
assert track.listType == 'audio'
# Assign 0 track.media
med0 = track.media[0]
assert track.originalTitle == 'Kenneth Reitz'
assert track.parentIndex == '1'
assert track.parentKey == '/library/metadata/21'
assert track.parentRatingKey == '21'
assert track.parentThumb == '/library/metadata/21/thumb/1484693407'
assert is_int(track.parentIndex)
assert is_metadata(track.parentKey)
assert is_int(track.parentRatingKey)
assert is_thumb(track.parentThumb)
assert track.parentTitle == 'Unmastered Impulses'
assert track.player is None
assert track.ratingCount == 9
assert track.ratingKey == 22
assert track._server._baseurl == 'http://138.68.157.5:32400'
assert track.summary == ''
assert track.thumb == '/library/metadata/21/thumb/1484693407'
assert is_int(track.ratingKey)
assert track._server._baseurl == SERVER_BASEURL
assert track.summary == ""
assert is_thumb(track.thumb)
assert track.title == 'Holy Moment'
assert track.titleSort == 'Holy Moment'
assert track.transcodeSession is None
assert track.type == 'track'
assert str(track.updatedAt.date()) == '2017-01-17'
assert is_datetime(track.updatedAt)
assert track.username is None
assert track.viewCount == 0
assert track.viewOffset == 0
assert med0.aspectRatio is None
assert med0.audioChannels == 2
assert med0.audioCodec == 'mp3'
assert med0.bitrate == 385
assert med0.container == 'mp3'
assert med0.duration == 298606
assert med0.height is None
assert med0.id == 22
assert med0._initpath == '/library/metadata/21/children'
assert med0.optimizedForStreaming is None
# Assign 0 med0.parts
par0 = med0.parts[0]
assert med0._server._baseurl == 'http://138.68.157.5:32400'
assert med0.videoCodec is None
assert med0.videoFrameRate is None
assert med0.videoResolution is None
assert med0.width is None
assert par0.container == 'mp3'
assert par0.duration == 298606
assert par0.file == '/media/music/unmastered_impulses/01-Holy_Moment.mp3'
assert par0.id == 22
assert par0._initpath == '/library/metadata/21/children'
assert par0.key == '/library/parts/22/1484693136/file.mp3'
assert par0._server._baseurl == 'http://138.68.157.5:32400'
assert par0.size == 14360402
def test_audio_Album_get():
""" Just a alias for track(); skip it. """
pass
def test_audio_Album_track(album, track=None):
# this is not reloaded. its not that much info missing.
track = track or album.track('Holy Moment')
assert is_datetime(track.addedAt)
assert track.duration == 298606
assert is_metadata(track.grandparentKey)
assert is_int(track.grandparentRatingKey)
assert track.grandparentTitle == 'Infinite State'
assert int(track.index) == 1
assert is_metadata(track._initpath)
assert is_metadata(track.key)
assert track.listType == 'audio'
# Assign 0 track.media
media = track.media[0]
assert track.originalTitle == 'Kenneth Reitz'
assert is_int(track.parentIndex)
assert is_metadata(track.parentKey)
assert is_int(track.parentRatingKey)
assert is_thumb(track.parentThumb)
assert track.parentTitle == 'Unmastered Impulses'
assert track.player is None
assert track.ratingCount == 9
assert is_int(track.ratingKey)
assert track._server._baseurl == SERVER_BASEURL
assert track.summary == ''
assert is_thumb(track.thumb)
assert track.title == 'Holy Moment'
assert track.titleSort == 'Holy Moment'
assert track.transcodeSession is None
assert track.type == 'track'
assert is_datetime(track.updatedAt)
assert track.username is None
assert track.viewCount == 0
assert track.viewOffset == 0
assert media.aspectRatio is None
assert media.audioChannels == 2
assert media.audioCodec == 'mp3'
assert media.bitrate == 385
assert media.container == 'mp3'
assert media.duration == 298606
assert media.height is None
assert media.id == 22
assert is_metadata(media._initpath)
assert media.optimizedForStreaming is None
# Assign 0 media.parts
part = media.parts[0]
assert media._server._baseurl == SERVER_BASEURL
assert media.videoCodec is None
assert media.videoFrameRate is None
assert media.videoResolution is None
assert media.width is None
assert part.container == 'mp3'
assert part.duration == 298606
assert part.file.endswith('.mp3')
assert is_int(part.id)
assert is_metadata(part._initpath)
assert is_part(part.key)
assert part._server._baseurl == SERVER_BASEURL
assert part.size == 14360402
def test_audio_Album_artist(a_music_album):
artist = a_music_album.artist()
def test_audio_Album_get(album):
# alias for album.track()
track = album.get('Holy Moment')
test_audio_Album_track(album, track=track)
def test_audio_Album_artist(album):
artist = album.artist()
artist.title == 'Infinite State'
def test_audio_Track_attrs(a_music_album):
track = a_music_album.get('Holy Moment')
track.reload()
assert str(track.addedAt.date()) == '2017-01-17'
def test_audio_Track_attrs(album):
track = album.get('Holy Moment').reload()
assert is_datetime(track.addedAt)
assert track.art is None
assert track.chapterSource is None
assert track.duration == 298606
assert track.grandparentArt is None
assert track.grandparentKey == '/library/metadata/20'
assert track.grandparentRatingKey == '20'
assert track.grandparentThumb is None
assert is_metadata(track.grandparentKey)
assert is_int(track.grandparentRatingKey)
assert is_thumb(track.grandparentThumb)
assert track.grandparentTitle == 'Infinite State'
assert track.guid == 'local://22'
assert track.index == '1'
assert track._initpath == '/library/metadata/22'
assert track.key == '/library/metadata/22'
assert track.guid.startswith('local://')
assert int(track.index) == 1
assert is_metadata(track._initpath)
assert is_metadata(track.key)
assert track.lastViewedAt is None
assert track.librarySectionID == '3'
assert is_int(track.librarySectionID)
assert track.listType == 'audio'
# Assign 0 track.media
med0 = track.media[0]
media = track.media[0]
assert track.moods == []
assert track.originalTitle == 'Kenneth Reitz'
assert track.parentIndex == '1'
assert track.parentKey == '/library/metadata/21'
assert track.parentRatingKey == '21'
assert track.parentThumb == '/library/metadata/21/thumb/1484693407'
assert int(track.parentIndex) == 1
assert is_metadata(track.parentKey)
assert is_int(track.parentRatingKey)
assert is_thumb(track.parentThumb)
assert track.parentTitle == 'Unmastered Impulses'
assert track.player is None
assert track.playlistItemID is None
assert track.primaryExtraKey is None
assert track.ratingCount == 9
assert track.ratingKey == 22
assert track._server._baseurl == 'http://138.68.157.5:32400'
assert is_int(track.ratingKey)
assert track._server._baseurl == SERVER_BASEURL
assert track.sessionKey is None
assert track.summary == ''
assert track.thumb == '/library/metadata/21/thumb/1484693407'
assert is_thumb(track.thumb)
assert track.title == 'Holy Moment'
assert track.titleSort == 'Holy Moment'
assert track.transcodeSession is None
assert track.type == 'track'
assert str(track.updatedAt.date()) == '2017-01-17'
assert is_datetime(track.updatedAt)
assert track.username is None
assert track.viewCount == 0
assert track.viewOffset == 0
assert track.viewedAt is None
assert track.year is None
assert med0.aspectRatio is None
assert med0.audioChannels == 2
assert med0.audioCodec == 'mp3'
assert med0.bitrate == 385
assert med0.container == 'mp3'
assert med0.duration == 298606
assert med0.height is None
assert med0.id == 22
assert med0._initpath == '/library/metadata/22'
assert med0.optimizedForStreaming is None
# Assign 0 med0.parts
par0 = med0.parts[0]
assert med0._server._baseurl == 'http://138.68.157.5:32400'
assert med0.videoCodec is None
assert med0.videoFrameRate is None
assert med0.videoResolution is None
assert med0.width is None
assert par0.container == 'mp3'
assert par0.duration == 298606
assert par0.file == '/media/music/unmastered_impulses/01-Holy_Moment.mp3'
assert par0.id == 22
assert par0._initpath == '/library/metadata/22'
assert par0.key == '/library/parts/22/1484693136/file.mp3'
#assert par0.media == <Media:Holy.Moment>
assert par0._server._baseurl == 'http://138.68.157.5:32400'
assert par0.size == 14360402
# Assign 0 par0.streams
str0 = par0.streams[0]
assert str0.audioChannelLayout == 'stereo'
assert str0.bitDepth is None
assert str0.bitrate == 320
assert str0.bitrateMode is None
assert str0.channels == 2
assert str0.codec == 'mp3'
assert str0.codecID is None
assert str0.dialogNorm is None
assert str0.duration is None
assert str0.id == 44
assert str0.index == 0
assert str0._initpath == '/library/metadata/22'
assert str0.language is None
assert str0.languageCode is None
#assert str0.part == <MediaPart:22>
assert str0.samplingRate == 44100
assert str0.selected is True
assert str0._server._baseurl == 'http://138.68.157.5:32400'
assert str0.streamType == 2
assert str0.title is None
assert str0.type == 2
assert media.aspectRatio is None
assert media.audioChannels == 2
assert media.audioCodec == 'mp3'
assert media.bitrate == 385
assert media.container == 'mp3'
assert media.duration == 298606
assert media.height is None
assert media.id == 22
assert is_metadata(media._initpath)
assert media.optimizedForStreaming is None
# Assign 0 media.parts
part = media.parts[0]
assert media._server._baseurl == SERVER_BASEURL
assert media.videoCodec is None
assert media.videoFrameRate is None
assert media.videoResolution is None
assert media.width is None
assert part.container == 'mp3'
assert part.duration == 298606
assert part.file.endswith('.mp3')
assert is_int(part.id)
assert is_metadata(part._initpath)
assert is_part(part.key)
#assert part.media == <Media:Holy.Moment>
assert part._server._baseurl == SERVER_BASEURL
assert part.size == 14360402
# Assign 0 part.streams
stream = part.streams[0]
assert stream.audioChannelLayout == 'stereo'
assert stream.bitDepth is None
assert stream.bitrate == 320
assert stream.bitrateMode is None
assert stream.channels == 2
assert stream.codec == 'mp3'
assert stream.codecID is None
assert stream.dialogNorm is None
assert stream.duration is None
assert is_int(stream.id)
assert stream.index == 0
assert is_metadata(stream._initpath)
assert stream.language is None
assert stream.languageCode is None
#assert stream.part == <MediaPart:22>
assert stream.samplingRate == 44100
assert stream.selected is True
assert stream._server._baseurl == SERVER_BASEURL
assert stream.streamType == 2
assert stream.title is None
assert stream.type == 2
def test_audio_Track_album(a_music_album):
tracks = a_music_album.tracks()
assert tracks[0].album() == a_music_album
def test_audio_Track_album(album):
tracks = album.tracks()
assert tracks[0].album() == album
def test_audio_Track_artist(a_music_album, a_artist):
tracks = a_music_album.tracks()
assert tracks[0].artist() == a_artist
def test_audio_Track_artist(album, artist):
tracks = album.tracks()
assert tracks[0].artist() == artist
def test_audio_Audio_section(a_artist, a_music_album, a_track):
assert a_artist.section()
assert a_music_album.section()
assert a_track.section()
assert a_track.section().key == a_music_album.section().key == a_artist.section().key
def test_audio_Audio_section(artist, album, track):
assert artist.section()
assert album.section()
assert track.section()
assert track.section().key == album.section().key == artist.section().key
def test_audio_Track_download(monkeydownload, tmpdir, a_track):
f = a_track.download(savepath=str(tmpdir))
def test_audio_Track_download(monkeydownload, tmpdir, track):
f = track.download(savepath=str(tmpdir))
assert f
def test_audio_album_download(monkeydownload, a_music_album, tmpdir):
f = a_music_album.download(savepath=str(tmpdir))
def test_audio_album_download(monkeydownload, album, tmpdir):
f = album.download(savepath=str(tmpdir))
assert len(f) == 14
def test_audio_Artist_download(monkeydownload, a_artist, tmpdir):
f = a_artist.download(savepath=str(tmpdir))
def test_audio_Artist_download(monkeydownload, artist, tmpdir):
f = artist.download(savepath=str(tmpdir))
assert len(f) == 14

239
tests/test_library.py
View file

@ -1,212 +1,203 @@
# -*- coding: utf-8 -*-
import pytest
from datetime import datetime
from plexapi.exceptions import NotFound
from .conftest import is_datetime
from .conftest import SERVER_BASEURL
def test_library_Library_section(pms):
sections = pms.library.sections()
def test_library_Library_section(plex):
sections = plex.library.sections()
assert len(sections) == 4
lfs = 'TV Shows'
section_name = pms.library.section(lfs)
assert section_name.title == lfs
section_name = plex.library.section('TV Shows')
assert section_name.title == 'TV Shows'
with pytest.raises(NotFound):
assert pms.library.section('gfdsas')
assert plex.library.section('cant-find-me')
def test_library_Library_sectionByID_is_equal_section(pms, freshpms):
def test_library_Library_sectionByID_is_equal_section(plex, plex2):
# test that sctionmyID refreshes the section if the key is missing
# this is needed if there isnt any cached sections
assert freshpms.library.sectionByID('1')
assert pms.library.sectionByID('1').uuid == pms.library.section('Movies').uuid
assert plex2.library.sectionByID('1')
assert plex.library.sectionByID('1').uuid == plex.library.section('Movies').uuid
def test_library_sectionByID_with_attrs(pms):
m = pms.library.sectionByID('1')
assert m.agent == 'com.plexapp.agents.imdb'
assert m.allowSync is False
assert m.art == '/:/resources/movie-fanart.jpg'
assert '/library/sections/1/composite/' in m.composite
assert m.createdAt > datetime(2017, 1, 16)
assert m.filters == '1'
assert m._initpath == '/library/sections'
assert m.key == '1'
assert m.language == 'en'
assert m.locations == ['/media/movies']
assert m.refreshing is False
assert m.scanner == 'Plex Movie Scanner'
assert m._server._baseurl == 'http://138.68.157.5:32400'
assert m.thumb == '/:/resources/movie.png'
assert m.title == 'Movies'
assert m.type == 'movie'
assert m.updatedAt > datetime(2017, 1, 16)
assert m.uuid == '2b72d593-3881-43f4-a8b8-db541bd3535a'
def test_library_sectionByID_with_attrs(plex):
section = plex.library.sectionByID('1')
assert section.agent == 'com.plexapp.agents.imdb'
assert section.allowSync is False
assert section.art == '/:/resources/movie-fanart.jpg'
assert '/library/sections/1/composite/' in section.composite
assert is_datetime(section.createdAt)
assert section.filters == '1'
assert section._initpath == '/library/sections'
assert section.key == '1'
assert section.language == 'en'
assert len(section.locations) == 1
assert len(section.locations[0]) >= 10
assert section.refreshing is False
assert section.scanner == 'Plex Movie Scanner'
assert section._server._baseurl == SERVER_BASEURL
assert section.thumb == '/:/resources/movie.png'
assert section.title == 'Movies'
assert section.type == 'movie'
assert is_datetime(section.updatedAt)
assert len(section.uuid) == 36
def test_library_section_get_movie(pms): # fix me
m = pms.library.section('Movies').get('16 blocks')
assert m
def test_library_section_get_movie(plex):
assert plex.library.section('Movies').get('16 blocks')
def test_library_section_delete(monkeypatch, pms):
m = pms.library.section('Movies')
def test_library_section_delete(monkeypatch, movies):
monkeypatch.delattr("requests.sessions.Session.request")
try:
m.delete()
movies.delete()
except AttributeError:
pass # this will always raise because there is no request anymore.
# will always raise because there is no request
pass
def test_library_fetchItem(pms):
m = pms.library.fetchItem('/library/metadata/1')
f = pms.library.fetchItem(1)
assert m.title == '16 Blocks'
assert f == m
def test_library_fetchItem(plex, movie):
item1 = plex.library.fetchItem('/library/metadata/%s' % movie.ratingKey)
item2 = plex.library.fetchItem(movie.ratingKey)
assert item1.title == '16 Blocks'
assert item1 == item2 == movie
def test_library_onDeck(pms):
assert len(list(pms.library.onDeck()))
def test_library_onDeck(plex):
assert len(list(plex.library.onDeck()))
def test_library_recentlyAdded(pms):
assert len(list(pms.library.recentlyAdded()))
def test_library_recentlyAdded(plex):
assert len(list(plex.library.recentlyAdded()))
def test_library_search(pms):
m = pms.library.search('16 blocks')[0]
assert m.title == '16 Blocks'
def test_library_search(plex):
item = plex.library.search('16 blocks')[0]
assert item.title == '16 Blocks'
def test_library_add_edit_delete(pms):
d = dict(name='zomg strange11', type='movie', agent='com.plexapp.agents.imdb',
scanner='Plex Movie Scanner', language='en')
rn = dict(name='a renamed lib', type='movie', agent='com.plexapp.agents.imdb')
# We dont want to add a location because we dont want to start scanning.
pms.library.add(**d)
assert pms.library.section('zomg strange11')
edited_library = pms.library.section('zomg strange11').edit(**rn)
def test_library_add_edit_delete(plex):
# Dont add a location to prevent scanning scanning
plex.library.add(name='zomg strange11', type='movie', agent='com.plexapp.agents.imdb',
scanner='Plex Movie Scanner', language='en')
assert plex.library.section('zomg strange11')
edited_library = plex.library.section('zomg strange11').edit(name='a renamed lib',
type='movie', agent='com.plexapp.agents.imdb')
assert edited_library.title == 'a renamed lib'
pms.library.section('a renamed lib').delete()
plex.library.section('a renamed lib').delete()
def test_library_Library_cleanBundle(pms):
pms.library.cleanBundles()
def test_library_Library_cleanBundle(plex):
plex.library.cleanBundles()
def test_library_Library_optimize(pms):
pms.library.optimize()
def test_library_Library_optimize(plex):
plex.library.optimize()
def test_library_Library_emptyTrash(pms):
pms.library.emptyTrash()
def test_library_Library_emptyTrash(plex):
plex.library.emptyTrash()
def _test_library_Library_refresh(pms):
pms.library.refresh() # fix mangle and proof the sections attrs
def test_library_Library_update(pms):
pms.library.update()
def test_library_Library_cancelUpdate(pms):
pms.library.cancelUpdate()
def _test_library_Library_refresh(plex):
# TODO: fix mangle and proof the sections attrs
plex.library.refresh()
def test_library_Library_deleteMediaPreviews(pms):
pms.library.deleteMediaPreviews()
def test_library_Library_update(plex):
plex.library.update()
def _test_library_MovieSection_refresh(a_movie_section):
a_movie_section.refresh()
def test_library_Library_cancelUpdate(plex):
plex.library.cancelUpdate()
def test_library_MovieSection_update(a_movie_section):
a_movie_section.update()
def test_library_Library_deleteMediaPreviews(plex):
plex.library.deleteMediaPreviews()
def test_library_MovieSection_cancelUpdate(a_movie_section):
a_movie_section.cancelUpdate()
def test_librarty_deleteMediaPreviews(a_movie_section):
a_movie_section.deleteMediaPreviews()
def _test_library_MovieSection_refresh(movies):
movies.refresh()
def _test_library_MovieSection_refresh(a_movie_section):
a_movie_section.refresh() # check how much this breaks test before enabling it.
def test_library_MovieSection_update(movies):
movies.update()
def test_library_MovieSection_onDeck(a_movie_section):
assert len(a_movie_section.onDeck())
def test_library_MovieSection_cancelUpdate(movies):
movies.cancelUpdate()
def test_library_MovieSection_recentlyAdded(a_movie_section):
assert len(a_movie_section.recentlyAdded())
def test_librarty_deleteMediaPreviews(movies):
movies.deleteMediaPreviews()
def test_library_MovieSection_analyze(a_movie_section):
a_movie_section.analyze()
def test_library_MovieSection_onDeck(movies):
assert len(movies.onDeck())
def test_library_ShowSection_searchShows(a_tv_section):
s = a_tv_section.searchShows(**{'title': 'The 100'})
assert s
def test_library_MovieSection_recentlyAdded(movies):
assert len(movies.recentlyAdded())
def test_library_ShowSection_searchEpisodes(a_tv_section):
s = a_tv_section.searchEpisodes(**{'title': 'Pilot'})
assert s
def test_library_MovieSection_analyze(movies):
movies.analyze()
def test_library_ShowSection_recentlyAdded(a_tv_section):
assert len(a_tv_section.recentlyAdded())
def test_library_ShowSection_searchShows(tvshows):
assert tvshows.searchShows(title='The 100')
def test_library_MusicSection_albums(a_music_section):
assert len(a_music_section.albums())
def test_library_ShowSection_searchEpisodes(tvshows):
assert tvshows.searchEpisodes(title='Pilot')
def test_library_MusicSection_searchTracks(a_music_section):
assert len(a_music_section.searchTracks(**{'title': 'Holy Moment'}))
def test_library_ShowSection_recentlyAdded(tvshows):
assert len(tvshows.recentlyAdded())
def test_library_MusicSection_searchAlbums(a_music_section):
assert len(a_music_section.searchAlbums(**{'title': 'Unmastered Impulses'}))
def test_library_MusicSection_albums(music):
assert len(music.albums())
def test_library_PhotoSection_searchAlbums(a_photo_section):
albums = a_photo_section.searchAlbums('photo_album1')
def test_library_MusicSection_searchTracks(music):
assert len(music.searchTracks(title='Holy Moment'))
def test_library_MusicSection_searchAlbums(music):
assert len(music.searchAlbums(title='Unmastered Impulses'))
def test_library_PhotoSection_searchAlbums(photos):
albums = photos.searchAlbums('Cats')
assert len(albums)
print([i.TYPE for i in albums])
def test_library_PhotoSection_searchPhotos(a_photo_section):
assert len(a_photo_section.searchPhotos('lolcat2'))
def test_library_PhotoSection_searchPhotos(photos):
assert len(photos.searchPhotos('CatBed'))
# Start on library search
def test_library_and_section_search_for_movie(pms):
def test_library_and_section_search_for_movie(plex):
find = '16 blocks'
l_search = pms.library.search(find)
s_search = pms.library.section('Movies').search(find)
l_search = plex.library.search(find)
s_search = plex.library.section('Movies').search(find)
assert l_search == s_search
def test_search_with_apostrophe(pms):
show_title = "Marvel's Daredevil" # Test ' in show title
result_root = pms.search(show_title)
result_shows = pms.library.section('TV Shows').search(show_title)
def test_search_with_apostrophe(plex):
show_title = "Marvel's Daredevil"
result_root = plex.search(show_title)
result_shows = plex.library.section('TV Shows').search(show_title)
assert result_root
assert result_shows
assert result_root == result_shows
def test_crazy_search(pms, a_movie):
movie = a_movie
movies = pms.library.section('Movies')
assert movie in pms.library.search(genre=29, libtype='movie')
def test_crazy_search(plex, movie):
movies = plex.library.section('Movies')
assert movie in movies.search(actor=movie.actors[0], sort='titleSort'), 'Unable to search movie by actor.'
assert movie in movies.search(director=movie.directors[0]), 'Unable to search movie by director.'
assert movie in movies.search(year=['2006', '2007']), 'Unable to search movie by year.'

8
tests/test_misc.py
View file

@ -23,9 +23,9 @@ def test_build_documentation():
assert 'traceback' not in line
def test_readme_examples(pms):
def test_readme_examples(plex):
failed = 0
examples = _fetch_examples(pms)
examples = _fetch_examples()
assert len(examples), 'No examples found in README'
for title, example in examples:
if _check_run_example(title):
@ -38,7 +38,7 @@ def test_readme_examples(pms):
assert not failed, '%s examples raised an exception.' % failed
def _fetch_examples(pms):
def _fetch_examples():
parsing = False
examples = []
filepath = join(dirname(dirname(abspath(__file__))), 'README.rst')
@ -48,7 +48,7 @@ def _fetch_examples(pms):
if line.startswith('# Example '):
parsing = True
title = line.lstrip('# ')
examples.append([title, ['plex = pms']])
examples.append([title, []])
elif parsing and line == '':
parsing = False
elif parsing:

27
tests/test_myplex.py
View file

@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
def test_myplex_accounts(plex_account, pms):
account = plex_account
def test_myplex_accounts(account, plex):
assert account, 'Must specify username, password & resource to run this test.'
print('MyPlexAccount:')
print('username: %s' % account.username)
@ -13,7 +13,7 @@ def test_myplex_accounts(plex_account, pms):
assert account.email, 'Account has no email'
assert account.home is not None, 'Account has no home'
assert account.queueEmail, 'Account has no queueEmail'
account = pms.account()
account = plex.account()
print('Local PlexServer.account():')
print('username: %s' % account.username)
print('authToken: %s' % account.authToken)
@ -23,8 +23,7 @@ def test_myplex_accounts(plex_account, pms):
assert account.signInState, 'Account has no signInState'
def test_myplex_resources(plex_account):
account = plex_account
def test_myplex_resources(account):
assert account, 'Must specify username, password & resource to run this test.'
resources = account.resources()
for resource in resources:
@ -35,8 +34,8 @@ def test_myplex_resources(plex_account):
assert resources, 'No resources found for account: %s' % account.name
def test_myplex_connect_to_resource(plex_account):
for resource in plex_account.resources():
def test_myplex_connect_to_resource(account):
for resource in account.resources():
if resource.name == 'PMS_API_TEST_SERVER':
break
server = resource.connect()
@ -44,8 +43,7 @@ def test_myplex_connect_to_resource(plex_account):
assert server
def test_myplex_devices(plex_account):
account = plex_account
def test_myplex_devices(account):
devices = account.devices()
for device in devices:
name = device.name or 'Unknown'
@ -54,9 +52,7 @@ def test_myplex_devices(plex_account):
assert devices, 'No devices found for account: %s' % account.name
#@pytest.mark.req_client # this need to be recorded?
def _test_myplex_connect_to_device(plex_account):
account = plex_account
def _test_myplex_connect_to_device(account):
devices = account.devices()
for device in devices:
if device.name == 'some client name' and len(device.connections):
@ -65,11 +61,10 @@ def _test_myplex_connect_to_device(plex_account):
assert client, 'Unable to connect to device'
def test_myplex_users(plex_account):
account = plex_account
def test_myplex_users(account):
users = account.users()
assert users, 'Found no users on account: %s' % account.name
print('Found %s users.' % len(users))
user = account.user('Hellowlol')
user = account.user(users[0].title)
print('Found user: %s' % user)
assert user, 'Could not find user Hellowlol'
assert user, 'Could not find user %s' % users[0].title

9
tests/test_navigation.py
View file

@ -1,7 +1,8 @@
# -*- coding: utf-8 -*-
def test_navigate_around_show(plex_account, pms):
show = pms.library.section('TV Shows').get('The 100')
def test_navigate_around_show(account, plex):
show = plex.library.section('TV Shows').get('The 100')
seasons = show.seasons()
season = show.season('Season 1')
episodes = show.episodes()
@ -16,8 +17,8 @@ def test_navigate_around_show(plex_account, pms):
assert episode.season() == season, 'episode.season() doesnt match expected season.'
def test_navigate_around_artist(plex_account, pms):
artist = pms.library.section('Music').get('Infinite State')
def test_navigate_around_artist(account, plex):
artist = plex.library.section('Music').get('Infinite State')
albums = artist.albums()
album = artist.album('Unmastered Impulses')
tracks = artist.tracks()