1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
from unittest import TestCase
from pandora import errors
from pandora.models.pandora import AdItem
from pandora.client import APIClient, BaseAPIClient
from pandora.py2compat import Mock, call, patch
from tests.test_pandora.test_models import TestAdItem
class TestAPIClientLogin(TestCase):
class StubTransport(object):
API_VERSION = None
partner = None
user = None
FAKE_PARTNER = object()
FAKE_USER = object()
def __call__(self, method, **params):
if method == "auth.partnerLogin":
return self.FAKE_PARTNER
elif method == "auth.userLogin":
return self.FAKE_USER
else:
raise AssertionError("Invalid call")
def set_partner(self, partner):
self.partner = partner
def set_user(self, user):
self.user = user
def test_login(self):
transport = self.StubTransport()
client = BaseAPIClient(transport, None, None, None)
client.login("foobear", "secret")
self.assertEqual("foobear", client.username)
self.assertEqual("secret", client.password)
self.assertIs(self.StubTransport.FAKE_USER, transport.user)
self.assertIs(self.StubTransport.FAKE_PARTNER, transport.partner)
def test_login_user_error(self):
with self.assertRaises(errors.InvalidUserLogin):
transport = Mock(side_effect=[None, errors.InvalidPartnerLogin])
client = BaseAPIClient(transport, None, None, None)
client.login("foobear", "secret")
class TestCallingAPIClient(TestCase):
def test_call_should_retry_on_token_error(self):
transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
client = BaseAPIClient(transport, None, None, None)
client._authenticate = Mock()
client.login("foo", "bar")
client("method")
client._authenticate.assert_called_with()
transport.assert_has_calls([call("method"), call("method")])
def test_playlist_fetches_ads(self):
fake_playlist = {"items": [
{"songName": "test"},
{"adToken": "foo"},
{"songName": "test"},
]}
with patch.object(APIClient, '__call__', return_value=fake_playlist):
client = APIClient(Mock(), None, None, None, None)
client._authenticate = Mock()
items = client.get_playlist('token_mock')
self.assertIsInstance(items[1], AdItem)
def test_ad_support_enabled_parameters(self):
with patch.object(APIClient, '__call__') as playlist_mock:
transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
client = APIClient(transport, None, None, None, None)
client._authenticate = Mock()
client.get_playlist('token_mock')
playlist_mock.assert_has_calls([call("station.getPlaylist",
audioAdPodCapable=True,
includeTrackLength=True,
stationToken='token_mock',
xplatformAdCapable=True)])
class TestGettingQualities(TestCase):
def test_with_invalid_quality_returning_all(self):
result = BaseAPIClient.get_qualities("foo", True)
self.assertEqual(BaseAPIClient.ALL_QUALITIES, result)
def test_with_invalid_quality_returning_none(self):
result = BaseAPIClient.get_qualities("foo", False)
self.assertEqual([], result)
def test_with_valid_quality(self):
result = BaseAPIClient.get_qualities(
BaseAPIClient.MED_AUDIO_QUALITY, False)
expected = [
BaseAPIClient.LOW_AUDIO_QUALITY,
BaseAPIClient.MED_AUDIO_QUALITY]
self.assertEqual(expected, result)
class TestGettingAds(TestCase):
def test_get_ad_item_(self):
metamock = patch.object(
APIClient, '__call__', return_value=TestAdItem.JSON_DATA)
with metamock as ad_metadata_mock:
transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
client = APIClient(transport, None, None, None, None)
client._authenticate = Mock()
ad_item = client.get_ad_item('id_mock', 'token_mock')
assert ad_item.station_id == 'id_mock'
assert ad_item.ad_token == 'token_mock'
ad_metadata_mock.assert_has_calls([
call("ad.getAdMetadata", adToken='token_mock',
returnAdTrackingTokens=True, supportAudioAds=True)])
def test_get_ad_item_with_no_station_id_specified_raises_exception(self):
transport = Mock(side_effect=[errors.InvalidAuthToken(), None])
client = APIClient(transport, None, None, None, None)
client.get_ad_metadata = Mock()
self.assertRaises(
errors.ParameterMissing, client.get_ad_item, '', 'token_mock')
class TestCreatingStation(TestCase):
def test_using_search_token(self):
client = APIClient(Mock(), None, None, None, None)
client.create_station(search_token="foo")
client.transport.assert_called_with(
"station.createStation", musicToken="foo")
def test_using_artist_token(self):
client = APIClient(Mock(), None, None, None, None)
client.create_station(artist_token="foo")
client.transport.assert_called_with(
"station.createStation", trackToken="foo", musicType="artist")
def test_using_track_token(self):
client = APIClient(Mock(), None, None, None, None)
client.create_station(track_token="foo")
client.transport.assert_called_with(
"station.createStation", trackToken="foo", musicType="song")
def test_with_no_token(self):
with self.assertRaises(KeyError):
client = APIClient(Mock(), None, None, None, None)
client.create_station()
class TestCreatingGenreStation(TestCase):
def test_has_initial_checksum(self):
fake_data = {
"categories": [
{"categoryName": "foo", "stations": []},
],
# Not actually part of the genre station response but is needed to
# fake out the mock for get_genre_stations_checksum
"checksum": "foo"
}
with patch.object(APIClient, '__call__', return_value=fake_data):
client = APIClient(Mock(), None, None, None, None)
station = client.get_genre_stations()
self.assertEqual(station.checksum, "foo")
|
