← Back to branch summary

~ubuntuone-client-engineering/ubuntuone-android-music/metadata-caching-optimisation

« back to all changes in this revision

Viewing changes to test/src/com/ubuntuone/android/music/provider/MusicProviderUtilsTest.java

  • Committer: Michał Karnicki
  • Date: 2012-11-08 14:14:54 UTC
  • Revision ID: michal.karnicki@canonical.com-20121108141454-e8yrgk6ylb00jobj
Added MusicService.
Added PlayerActivity.
Added NowPlaying view.
Added starring.
Wire UI multiple UI elements.
Added context menus, where applicable.
Minor theming.
Updated license headers.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/src/com/ubuntuone/android/music/provider/MusicProviderUtilsTest.java
 
1
package com.ubuntuone.android.music.provider;
 
2
 
 
3
import static com.ubuntuone.android.music.provider.MusicProviderUtils.QUEUE_URI;
 
4
import android.database.Cursor;
 
5
import android.net.Uri;
 
6
 
 
7
import com.ubuntuone.android.music.provider.MusicContract.Albums;
 
8
import com.ubuntuone.android.music.provider.MusicContract.Artists;
 
9
import com.ubuntuone.android.music.provider.MusicContract.PlaylistSongs;
 
10
import com.ubuntuone.android.music.provider.MusicContract.Playlists;
 
11
import com.ubuntuone.android.music.provider.MusicContract.Songs;
 
12
import com.ubuntuone.android.music.util.HashUtils;
 
13
 
 
14
public class MusicProviderUtilsTest extends MusicProviderMockDataTestBase {
 
15
        
 
16
        public MusicProviderUtilsTest() {
 
17
                super(MusicProvider.class, MusicContract.CONTENT_AUTHORITY);
 
18
        }
 
19
        
 
20
        public void testGetArtistSongCount() {
 
21
                String artistId = HashUtils.md5("artist1-artist_name");
 
22
                Uri artistUri = Artists.buildArtistUri(artistId);
 
23
                int songCount = MusicProviderUtils.getArtistSongCount(mContext, artistUri);
 
24
                assertEquals("Wrong artist song count.", 2, songCount);
 
25
        }
 
26
        
 
27
        public void testGetAlbumSongCount() {
 
28
                String albumId = HashUtils.md5("album1-album_titleartist1-artist_name");
 
29
                Uri albumUri = Albums.buildAlbumUri(albumId);
 
30
                int songCount = MusicProviderUtils.getAlbumSongCount(mContext, albumUri);
 
31
                assertEquals("Wrong album song count.", 2, songCount);
 
32
        }
 
33
        
 
34
        public void testGetSelectedSongCount() {
 
35
                int songCount = MusicProviderUtils.getSongCount(mContext, null);
 
36
                assertEquals("Wrong total song count.", MockData.SONGS_COUNT, songCount);
 
37
        }
 
38
        
 
39
        public void testGetSongCount() {
 
40
                int songCount = MusicProviderUtils.getSongCount(mContext);
 
41
                assertEquals("Wrong total song count.", MockData.SONGS_COUNT, songCount);
 
42
        }
 
43
        
 
44
        public void testGetStarredSongCount() {
 
45
                int songCount = MusicProviderUtils.getStarredSongCount(mContext);
 
46
                assertEquals("Wrong starred song count.", MockData.STARRED_SONGS_COUNT, songCount);
 
47
        }
 
48
        
 
49
        public void testGetSongStarred() {
 
50
                Uri songUri = Songs.buildSongUri("song2-song_id");
 
51
                
 
52
                int starred = MusicProviderUtils.getSongStarred(mContext, songUri);
 
53
                assertEquals("Wrong song starred state.", 0, starred);
 
54
        }
 
55
        
 
56
        public void testSetSongStarred() {
 
57
                Uri songUri = Songs.buildSongUri("song2-song_id");
 
58
                String[] projection = new String[] { Songs.STARRED };
 
59
                
 
60
                Cursor cursor = mResolver.query(songUri, projection, null, null, null);
 
61
                cursor.moveToFirst();
 
62
                assertEquals("Wrong song starred state.",
 
63
                                0, cursor.getInt(cursor.getColumnIndex(Songs.STARRED)));
 
64
                cursor.close();
 
65
                
 
66
                MusicProviderUtils.setSongStarred(mContext, songUri, true);
 
67
                
 
68
                cursor = mResolver.query(songUri, projection, null, null, null);
 
69
                cursor.moveToFirst();
 
70
                assertEquals("Wrong song starred state.",
 
71
                                1, cursor.getInt(cursor.getColumnIndex(Songs.STARRED)));
 
72
                cursor.close();
 
73
                
 
74
                MusicProviderUtils.setSongStarred(mContext, songUri, false);
 
75
                
 
76
                cursor = mResolver.query(songUri, projection, null, null, null);
 
77
                cursor.moveToFirst();
 
78
                assertEquals("Wrong song starred state.",
 
79
                                0, cursor.getInt(cursor.getColumnIndex(Songs.STARRED)));
 
80
                cursor.close();
 
81
        }
 
82
        
 
83
        public void testToggleSongStarred() {
 
84
                Uri songUri = Songs.buildSongUri("song2-song_id");
 
85
                String[] projection = new String[] { Songs.STARRED };
 
86
                
 
87
                Cursor cursor = mResolver.query(songUri, projection, null, null, null);
 
88
                cursor.moveToFirst();
 
89
                assertEquals("Wrong song starred state.",
 
90
                                0, cursor.getInt(cursor.getColumnIndex(Songs.STARRED)));
 
91
                cursor.close();
 
92
                
 
93
                MusicProviderUtils.toggleSongStarred(mContext, songUri);
 
94
                
 
95
                cursor = mResolver.query(songUri, projection, null, null, null);
 
96
                cursor.moveToFirst();
 
97
                assertEquals("Wrong song starred state.",
 
98
                                1, cursor.getInt(cursor.getColumnIndex(Songs.STARRED)));
 
99
                cursor.close();
 
100
                
 
101
                MusicProviderUtils.toggleSongStarred(mContext, songUri);
 
102
                
 
103
                cursor = mResolver.query(songUri, projection, null, null, null);
 
104
                cursor.moveToFirst();
 
105
                assertEquals("Wrong song starred state.",
 
106
                                0, cursor.getInt(cursor.getColumnIndex(Songs.STARRED)));
 
107
                cursor.close();
 
108
        }
 
109
        
 
110
        public void testGetCachedSongCount() {
 
111
                int songCount = MusicProviderUtils.getCachedSongCount(mContext);
 
112
                assertEquals("Wrong starred song count.", MockData.CACHED_SONGS_COUNT, songCount);
 
113
        }
 
114
        
 
115
        public void testGetPlaylistSongCount() {
 
116
                Uri playlistUri = Playlists.buildPlaylistSongsUri("playlist1-playlist_id");
 
117
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
118
                assertEquals("Wrong playlist song count.", 2, songCount);
 
119
        }
 
120
        
 
121
        public void testGetPlayQueueSongCount() {
 
122
                Uri playlistUri = MusicProviderUtils.QUEUE_URI;
 
123
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
124
                assertEquals("Wrong play queue song count.", 1, songCount);
 
125
        }
 
126
        
 
127
        public void testClearPlaylist() {
 
128
                Uri playlistUri = Playlists.buildPlaylistSongsUri("playlist1-playlist_id");
 
129
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
130
                assertTrue("Playlist should not be empty.", songCount != 0);
 
131
                
 
132
                MusicProviderUtils.clearPlaylist(mContext, playlistUri);
 
133
                
 
134
                songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
135
                assertEquals("Playlist not empty.", 0, songCount);
 
136
        }
 
137
        
 
138
        public void testClearPlayQueue() {
 
139
                Uri playlistUri = MusicProviderUtils.QUEUE_URI;
 
140
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
141
                assertTrue("Play queue should not be empty.", songCount != 0);
 
142
                
 
143
                MusicProviderUtils.clearPlayQueue(getMockContext());
 
144
                
 
145
                songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
146
                assertTrue("Play queue not empty.", songCount == 0);
 
147
        }
 
148
        
 
149
        public void testDeletePlaylist() {
 
150
                Uri playlistUri = Playlists.buildPlaylistSongsUri("playlist2-playlist_id");
 
151
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
152
                assertTrue("Playlist should not be empty.", songCount > 0);
 
153
                
 
154
                MusicProviderUtils.deletePlaylist(mContext, playlistUri);
 
155
                
 
156
                songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
157
                assertEquals("No songs should have been returned.", 0, songCount);
 
158
                
 
159
                Cursor cursor = mResolver.query(playlistUri, new String[] { Playlists._ID },
 
160
                                null, null, null);
 
161
                int rowsReturned = cursor.getCount();
 
162
                cursor.close();
 
163
                assertEquals("Playlist should not exists.", 0, rowsReturned);
 
164
        }
 
165
        
 
166
        public void testDeletePlaylistDoesNotDeletePlayQueue() {
 
167
                Uri playlistUri = MusicProviderUtils.QUEUE_URI;
 
168
                int songCount = MusicProviderUtils.getPlayQueueSongCount(mContext);
 
169
                assertTrue("Play queue should not be empty.", songCount > 0);
 
170
                
 
171
                MusicProviderUtils.deletePlaylist(mContext, playlistUri);
 
172
                
 
173
                int newSongCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
174
                assertEquals("No songs should have been deleted.", songCount, newSongCount);
 
175
                
 
176
                Cursor cursor = mResolver.query(playlistUri, new String[] { Playlists._ID },
 
177
                                null, null, null);
 
178
                int rowsReturned = cursor.getCount();
 
179
                cursor.close();
 
180
                assertEquals("Play queue should still exists.", 1, rowsReturned);
 
181
        }
 
182
        
 
183
        public void testEnqueueSongInPlaylist() {
 
184
                Uri playlistUri = Playlists.buildPlaylistSongsUri("playlist2-playlist_id");
 
185
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
186
                assertEquals("Wrong song count of playlist.", 1, songCount);
 
187
                
 
188
                final String newSongId = "song1-song_id";
 
189
                Uri songUri = Songs.buildSongUri("song1-song_id");
 
190
                MusicProviderUtils.enqueueSong(mContext, songUri, playlistUri);
 
191
                
 
192
                int newSongCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
193
                assertEquals("Wrong new song count of playlist.", songCount + 1, newSongCount);
 
194
                
 
195
                Cursor cursor = null;
 
196
                try {
 
197
                        String[] projection = new String[] { Songs.SONG_ID };
 
198
                        cursor = mResolver.query(playlistUri, projection,
 
199
                                        null, null, PlaylistSongs.DEFAULT_SORT);
 
200
                        if (cursor != null && cursor.isBeforeFirst()) {
 
201
                                cursor.moveToLast();
 
202
                                String songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
203
                                assertEquals("Wrong queued song id.", newSongId, songId);
 
204
                        }
 
205
                } finally {
 
206
                        if (cursor != null) cursor.close();
 
207
                }
 
208
        }
 
209
        
 
210
        public void testClearAndEnqueueSong() {
 
211
                final String newSongId = "song1-song_id";
 
212
                Uri songUri = Songs.buildSongUri("song1-song_id");
 
213
                
 
214
                MusicProviderUtils.clearAndEnqueueSong(mContext, songUri);
 
215
                
 
216
                int songCount = MusicProviderUtils.getPlayQueueSongCount(mContext);
 
217
                assertEquals("Wrong new song count of play queue.", 1, songCount);
 
218
                
 
219
                Cursor cursor = null;
 
220
                try {
 
221
                        String[] projection = new String[] { Songs.SONG_ID };
 
222
                        cursor = mResolver.query(QUEUE_URI, projection,
 
223
                                        null, null, PlaylistSongs.DEFAULT_SORT);
 
224
                        if (cursor != null && cursor.isBeforeFirst()) {
 
225
                                cursor.moveToFirst();
 
226
                                String songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
227
                                assertEquals("Wrong queued song id.", newSongId, songId);
 
228
                        }
 
229
                } finally {
 
230
                        if (cursor != null) cursor.close();
 
231
                }
 
232
        }
 
233
 
 
234
        public void testEnqueueAlbumInPlaylist() {
 
235
                Uri playlistUri = Playlists.buildPlaylistSongsUri("playlist2-playlist_id");
 
236
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
237
                assertEquals("Wrong song count of playlist.", 1, songCount);
 
238
                
 
239
                final String newAlbumId = HashUtils.md5("album1-album_titleartist1-artist_name");
 
240
                Uri albumUri = Albums.buildAlbumUri(newAlbumId);
 
241
                int albumSongCount = MusicProviderUtils.getAlbumSongCount(mContext, albumUri);
 
242
                MusicProviderUtils.enqueueAlbum(mContext, albumUri, playlistUri);
 
243
                
 
244
                int newSongCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
245
                assertEquals("Wrong new song count of playlist.", songCount + albumSongCount, newSongCount);
 
246
                
 
247
                Cursor cursor = null;
 
248
                try {
 
249
                        String[] projection = new String[] { Songs.SONG_ID };
 
250
                        cursor = mResolver.query(playlistUri, projection,
 
251
                                        null, null, PlaylistSongs.DEFAULT_SORT);
 
252
                        if (cursor != null && cursor.isBeforeFirst()) {
 
253
                                cursor.moveToFirst();
 
254
                                
 
255
                                cursor.moveToNext();
 
256
                                String songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
257
                                assertEquals("Wrong queued album song id.", "song1-song_id", songId);
 
258
                                
 
259
                                cursor.moveToNext();
 
260
                                songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
261
                                assertEquals("Wrong queued album song id.", "song2-song_id", songId);
 
262
                        }
 
263
                } finally {
 
264
                        if (cursor != null) cursor.close();
 
265
                }
 
266
        }
 
267
 
 
268
        public void testClearAndEnqueueAlbum() {
 
269
                Uri playlistUri = MusicProviderUtils.QUEUE_URI;
 
270
                int songCount = MusicProviderUtils.getPlayQueueSongCount(mContext);
 
271
                assertEquals("Wrong song count of play queue.", 1, songCount);
 
272
                
 
273
                final String newAlbumId = HashUtils.md5("album1-album_titleartist1-artist_name");
 
274
                Uri albumUri = Albums.buildAlbumUri(newAlbumId);
 
275
                int albumSongCount = MusicProviderUtils.getAlbumSongCount(mContext, albumUri);
 
276
                MusicProviderUtils.clearAndEnqueueAlbum(mContext, albumUri);
 
277
                
 
278
                int newSongCount = MusicProviderUtils.getPlayQueueSongCount(mContext);
 
279
                assertEquals("Wrong new song count of play queue.", albumSongCount, newSongCount);
 
280
                
 
281
                Cursor cursor = null;
 
282
                try {
 
283
                        String[] projection = new String[] { Songs.SONG_ID };
 
284
                        cursor = mResolver.query(playlistUri, projection,
 
285
                                        null, null, PlaylistSongs.DEFAULT_SORT);
 
286
                        if (cursor != null && cursor.isBeforeFirst()) {
 
287
                                cursor.moveToNext();
 
288
                                String songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
289
                                assertEquals("Wrong queued album song id.", "song1-song_id", songId);
 
290
                                
 
291
                                cursor.moveToNext();
 
292
                                songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
293
                                assertEquals("Wrong queued album song id.", "song2-song_id", songId);
 
294
                        }
 
295
                } finally {
 
296
                        if (cursor != null) cursor.close();
 
297
                }
 
298
        }
 
299
        
 
300
        public void testEnqueueArtistInPlaylist() {
 
301
                Uri playlistUri = Playlists.buildPlaylistSongsUri("playlist2-playlist_id");
 
302
                int songCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
303
                assertEquals("Wrong song count of playlist.", 1, songCount);
 
304
                
 
305
                String newArtistId = HashUtils.md5("artist1-artist_name");
 
306
                Uri artistUri = Artists.buildArtistUri(newArtistId);
 
307
                int artistSongCount = MusicProviderUtils.getArtistSongCount(mContext, artistUri);
 
308
                assertTrue("Artist song count should be non zero.", artistSongCount > 0);
 
309
                MusicProviderUtils.enqueueArtist(mContext, artistUri, playlistUri);
 
310
                        
 
311
                int newSongCount = MusicProviderUtils.getPlaylistSongCount(mContext, playlistUri);
 
312
                assertEquals("Wrong new song count of playlist.", songCount + artistSongCount, newSongCount);
 
313
                
 
314
                Cursor cursor = null;
 
315
                try {
 
316
                        String[] projection = new String[] { Songs.SONG_ID };
 
317
                        cursor = mResolver.query(playlistUri, projection,
 
318
                                        null, null, PlaylistSongs.DEFAULT_SORT);
 
319
                        if (cursor != null && cursor.isBeforeFirst()) {
 
320
                                cursor.moveToFirst();
 
321
                                
 
322
                                cursor.moveToNext();
 
323
                                String songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
324
                                assertEquals("Wrong queued album song id.", "song1-song_id", songId);
 
325
                                
 
326
                                cursor.moveToNext();
 
327
                                songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
328
                                assertEquals("Wrong queued album song id.", "song2-song_id", songId);
 
329
                        }
 
330
                } finally {
 
331
                        if (cursor != null) cursor.close();
 
332
                }
 
333
        }
 
334
        
 
335
        public void testClearAndEnqueueArtist() {
 
336
                Uri playlistUri = MusicProviderUtils.QUEUE_URI;
 
337
                int songCount = MusicProviderUtils.getPlayQueueSongCount(mContext);
 
338
                assertEquals("Wrong song count of play queue.", 1, songCount);
 
339
                
 
340
                String newArtistId = HashUtils.md5("artist1-artist_name");
 
341
                Uri artistUri = Artists.buildArtistUri(newArtistId);
 
342
                int artistSongCount = MusicProviderUtils.getArtistSongCount(mContext, artistUri);
 
343
                assertTrue("Artist song count should be non zero.", artistSongCount > 0);
 
344
                MusicProviderUtils.enqueueArtist(mContext, artistUri);
 
345
                        
 
346
                int newSongCount = MusicProviderUtils.getPlayQueueSongCount(mContext);
 
347
                assertEquals("Wrong new song count of play queue.", artistSongCount, newSongCount);
 
348
                
 
349
                Cursor cursor = null;
 
350
                try {
 
351
                        String[] projection = new String[] { Songs.SONG_ID };
 
352
                        cursor = mResolver.query(playlistUri, projection,
 
353
                                        null, null, PlaylistSongs.DEFAULT_SORT);
 
354
                        if (cursor != null && cursor.isBeforeFirst()) {
 
355
                                cursor.moveToNext();
 
356
                                String songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
357
                                assertEquals("Wrong queued album song id.", "song1-song_id", songId);
 
358
                                
 
359
                                cursor.moveToNext();
 
360
                                songId = cursor.getString(cursor.getColumnIndex(Songs.SONG_ID));
 
361
                                assertEquals("Wrong queued album song id.", "song2-song_id", songId);
 
362
                        }
 
363
                } finally {
 
364
                        if (cursor != null) cursor.close();
 
365
                }
 
366
        }
 
367
}