1 files changed, 41 insertions, 37 deletions

diff --git a/tests/test_pandora/test_models.py b/tests/test_pandora/test_models.py
index 8e0e0b5..8cfbd9d 100644
--- a/tests/test_pandora/test_models.py
+++ b/tests/test_pandora/test_models.py
@@ -5,8 +5,12 @@ from unittest.mock import Mock, patch
 from pandora.client import APIClient
 from pandora.errors import ParameterMissing
 
+import pandora.models.ad as am
 import pandora.models._base as m
-import pandora.models.pandora as pm
+import pandora.models.search as sm
+import pandora.models.station as stm
+import pandora.models.bookmark as bm
+import pandora.models.playlist as plm
 
 
 class TestField(TestCase):
@@ -59,7 +63,7 @@ class TestAdditionalUrlField(TestCase):
                 '_paramAdditionalUrls': ['foo']
                 }
 
-        field = pm.AdditionalUrlField("additionalAudioUrl")
+        field = plm.AdditionalUrlField("additionalAudioUrl")
 
         ret = field.formatter(None, dummy_data, 'test')
 
@@ -73,7 +77,7 @@ class TestAdditionalUrlField(TestCase):
                     ]
                 }
 
-        field = pm.AdditionalUrlField("additionalAudioUrl")
+        field = plm.AdditionalUrlField("additionalAudioUrl")
 
         ret = field.formatter(None, dummy_data, ['foo', 'bar'])
 
@@ -274,7 +278,7 @@ class TestPlaylistItemModel(TestCase):
     WEIRD_FORMAT = {"audioUrlMap": {"highQuality": {}}}
 
     def test_audio_url_without_map(self):
-        item = pm.PlaylistItem.from_json(Mock(), self.AUDIO_URL_NO_MAP)
+        item = plm.PlaylistItem.from_json(Mock(), self.AUDIO_URL_NO_MAP)
         self.assertEqual(item.bitrate, 64)
         self.assertEqual(item.encoding, "aacplus")
         self.assertEqual(item.audio_url, "foo")
@@ -284,7 +288,7 @@ class TestPlaylistItemModel(TestCase):
     # valid url... but I didn't add the original code so just going to test it
     # and leave it alone for now ~mcrute
     def test_empty_quality_map_url_is_map(self):
-        item = pm.PlaylistItem.from_json(Mock(), self.WEIRD_FORMAT)
+        item = plm.PlaylistItem.from_json(Mock(), self.WEIRD_FORMAT)
         self.assertIsNone(item.bitrate)
         self.assertIsNone(item.encoding)
         self.assertIsNone(item.audio_url)
@@ -293,13 +297,13 @@ class TestPlaylistItemModel(TestCase):
 class TestPlaylistModel(TestCase):
 
     def test_unplayable_get_is_playable(self):
-        playlist = pm.PlaylistModel(Mock())
+        playlist = plm.PlaylistModel(Mock())
         playlist.audio_url = ""
         self.assertFalse(playlist.get_is_playable())
 
     def test_playable_get_is_playable(self):
         client = Mock()
-        playlist = pm.PlaylistModel(client)
+        playlist = plm.PlaylistModel(client)
         playlist.audio_url = "foo"
         playlist.get_is_playable()
         client.transport.test_url.assert_called_with("foo")
@@ -339,7 +343,7 @@ class TestAdItem(TestCase):
     def setUp(self):
         api_client_mock = Mock(spec=APIClient)
         api_client_mock.default_audio_quality = APIClient.HIGH_AUDIO_QUALITY
-        self.result = pm.AdItem.from_json(api_client_mock, self.JSON_DATA)
+        self.result = am.AdItem.from_json(api_client_mock, self.JSON_DATA)
         self.result.station_id = 'station_id_mock'
         self.result.ad_token = 'token_mock'
 
@@ -355,14 +359,14 @@ class TestAdItem(TestCase):
     def test_register_ad_raises_if_no_tracking_tokens_available(self):
         with self.assertRaises(ParameterMissing):
             self.result.tracking_tokens = []
-            self.result._api_client.register_ad = Mock(spec=pm.AdItem)
+            self.result._api_client.register_ad = Mock(spec=am.AdItem)
 
             self.result.register_ad('id_mock')
 
             assert self.result._api_client.register_ad.called
 
     def test_prepare_playback(self):
-        with patch.object(pm.PlaylistModel, 'prepare_playback') as super_mock:
+        with patch.object(plm.PlaylistModel, 'prepare_playback') as super_mock:
 
             self.result.register_ad = Mock()
             self.result.prepare_playback()
@@ -370,7 +374,7 @@ class TestAdItem(TestCase):
             assert super_mock.called
 
     def test_prepare_playback_raises_paramater_missing(self):
-        with patch.object(pm.PlaylistModel, 'prepare_playback') as super_mock:
+        with patch.object(plm.PlaylistModel, 'prepare_playback') as super_mock:
 
             self.result.register_ad = Mock(side_effect=ParameterMissing(
                 'No ad tracking tokens provided for registration.')
@@ -380,7 +384,7 @@ class TestAdItem(TestCase):
             assert not super_mock.called
 
     def test_prepare_playback_handles_paramater_missing_if_no_tokens(self):
-        with patch.object(pm.PlaylistModel, 'prepare_playback') as super_mock:
+        with patch.object(plm.PlaylistModel, 'prepare_playback') as super_mock:
 
             self.result.tracking_tokens = []
             self.result.register_ad = Mock(side_effect=ParameterMissing(
@@ -431,7 +435,7 @@ class TestSearchResultItem(TestCase):
             APIClient.HIGH_AUDIO_QUALITY
 
     def test_is_song(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.SONG_JSON_DATA)
         assert result.is_song
         assert not result.is_artist
@@ -439,7 +443,7 @@ class TestSearchResultItem(TestCase):
         assert not result.is_genre_station
 
     def test_is_artist(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.ARTIST_JSON_DATA)
         assert not result.is_song
         assert result.is_artist
@@ -447,7 +451,7 @@ class TestSearchResultItem(TestCase):
         assert not result.is_genre_station
 
     def test_is_composer(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.COMPOSER_JSON_DATA)
         assert not result.is_song
         assert not result.is_artist
@@ -455,7 +459,7 @@ class TestSearchResultItem(TestCase):
         assert not result.is_genre_station
 
     def test_is_genre_station(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.GENRE_JSON_DATA)
         assert not result.is_song
         assert not result.is_artist
@@ -464,7 +468,7 @@ class TestSearchResultItem(TestCase):
 
     def test_fails_if_unknown(self):
         with self.assertRaises(NotImplementedError):
-            pm.SearchResultItem.from_json(
+            sm.SearchResultItem.from_json(
                 self.api_client_mock, self.UNKNOWN_JSON_DATA)
 
 
@@ -490,14 +494,14 @@ class TestArtistSearchResultItem(TestCase):
             APIClient.HIGH_AUDIO_QUALITY
 
     def test_repr(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.ARTIST_JSON_DATA)
         expected = (
             "ArtistSearchResultItem(artist='artist_name_mock', "
             "likely_match=False, score=100, token='R0000000')")
         self.assertEqual(expected, repr(result))
 
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.COMPOSER_JSON_DATA)
         expected = (
             "ArtistSearchResultItem(artist='composer_name_mock', "
@@ -505,7 +509,7 @@ class TestArtistSearchResultItem(TestCase):
         self.assertEqual(expected, repr(result))
 
     def test_create_station(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.ARTIST_JSON_DATA)
         result._api_client.create_station = Mock()
 
@@ -529,7 +533,7 @@ class TestSongSearchResultItem(TestCase):
             APIClient.HIGH_AUDIO_QUALITY
 
     def test_repr(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.SONG_JSON_DATA)
         expected = (
             "SongSearchResultItem(artist='artist_name_mock', score=100, "
@@ -537,7 +541,7 @@ class TestSongSearchResultItem(TestCase):
         self.assertEqual(expected, repr(result))
 
     def test_create_station(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.SONG_JSON_DATA)
         result._api_client.create_station = Mock()
 
@@ -560,7 +564,7 @@ class TestGenreStationSearchResultItem(TestCase):
             APIClient.HIGH_AUDIO_QUALITY
 
     def test_repr(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.GENRE_JSON_DATA)
         expected = (
             "GenreStationSearchResultItem(score=100, "
@@ -568,7 +572,7 @@ class TestGenreStationSearchResultItem(TestCase):
         self.assertEqual(expected, repr(result))
 
     def test_create_station(self):
-        result = pm.SearchResultItem.from_json(
+        result = sm.SearchResultItem.from_json(
             self.api_client_mock, self.GENRE_JSON_DATA)
         result._api_client.create_station = Mock()
 
@@ -604,7 +608,7 @@ class TestSearchResult(TestCase):
     def setUp(self):
         api_client_mock = Mock(spec=APIClient)
         api_client_mock.default_audio_quality = APIClient.HIGH_AUDIO_QUALITY
-        self.result = pm.SearchResult.from_json(
+        self.result = sm.SearchResult.from_json(
             api_client_mock, self.JSON_DATA)
 
     def test_repr(self):
@@ -634,7 +638,7 @@ class TestGenreStationList(TestCase):
         api_client = Mock()
         api_client.get_station_list_checksum.return_value = "foo"
 
-        stations = pm.GenreStationList.from_json(api_client, self.TEST_DATA)
+        stations = stm.GenreStationList.from_json(api_client, self.TEST_DATA)
         self.assertTrue(stations.has_changed())
 
 
@@ -649,7 +653,7 @@ class TestStationList(TestCase):
         api_client = Mock()
         api_client.get_station_list_checksum.return_value = "foo"
 
-        stations = pm.StationList.from_json(api_client, self.TEST_DATA)
+        stations = stm.StationList.from_json(api_client, self.TEST_DATA)
         self.assertTrue(stations.has_changed())
 
 
@@ -662,31 +666,31 @@ class TestBookmark(TestCase):
         self.client = Mock()
 
     def test_is_song_bookmark(self):
-        s = pm.Bookmark.from_json(self.client, self.SONG_BOOKMARK)
-        a = pm.Bookmark.from_json(self.client, self.ARTIST_BOOKMARK)
+        s = bm.Bookmark.from_json(self.client, self.SONG_BOOKMARK)
+        a = bm.Bookmark.from_json(self.client, self.ARTIST_BOOKMARK)
 
         self.assertTrue(s.is_song_bookmark)
         self.assertFalse(a.is_song_bookmark)
 
     def test_delete_song_bookmark(self):
-        pm.Bookmark.from_json(self.client, self.SONG_BOOKMARK).delete()
+        bm.Bookmark.from_json(self.client, self.SONG_BOOKMARK).delete()
         self.client.delete_song_bookmark.assert_called_with("token")
 
     def test_delete_artist_bookmark(self):
-        pm.Bookmark.from_json(self.client, self.ARTIST_BOOKMARK).delete()
+        bm.Bookmark.from_json(self.client, self.ARTIST_BOOKMARK).delete()
         self.client.delete_artist_bookmark.assert_called_with("token")
 
 
 class TestPandoraType(TestCase):
 
     def test_it_can_be_built_from_a_model(self):
-        pt = pm.PandoraType.from_model(None, "TR")
-        self.assertIs(pm.PandoraType.TRACK, pt)
+        pt = plm.PandoraType.from_model(None, "TR")
+        self.assertIs(plm.PandoraType.TRACK, pt)
 
     def test_it_can_be_built_from_string(self):
-        pt = pm.PandoraType.from_string("TR")
-        self.assertIs(pm.PandoraType.TRACK, pt)
+        pt = plm.PandoraType.from_string("TR")
+        self.assertIs(plm.PandoraType.TRACK, pt)
 
     def test_it_returns_genre_for_unknown_string(self):
-        pt = pm.PandoraType.from_string("FOO")
-        self.assertIs(pm.PandoraType.GENRE, pt)
+        pt = plm.PandoraType.from_string("FOO")
+        self.assertIs(plm.PandoraType.GENRE, pt)