Open_Music_API_V3_Test.postman_collection.json

{
	"info": {
		"_postman_id": "01e0b592-6700-4047-abb8-40d54196efad",
		"name": "Open Music API V3 Test",
		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
		"_exporter_id": "12297972"
	},
	"item": [
		{
			"name": "Albums",
			"item": [
				{
					"name": "Add Album with Invalid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let badAlbumPayloads = pm.environment.get('badAlbumPayloads');\r",
									"\r",
									"if (!badAlbumPayloads | badAlbumPayloads.length === 0) {\r",
									"    badAlbumPayloads = [\r",
									"        {},\r",
									"        { name: 1 },\r",
									"        { name: 'Bad song' },\r",
									"        { name: 'Bad song', year: 'dummy' },\r",
									"    ]\r",
									"}\r",
									"\r",
									"const currentBadAlbumPayload = badAlbumPayloads.shift();\r",
									"pm.environment.set('currentBadAlbumPayload', JSON.stringify(currentBadAlbumPayload));\r",
									"pm.environment.set('badAlbumPayloads', badAlbumPayloads);\r",
									"\r",
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})\r",
									"\r",
									"const repeatRequestUntilDatasetEmpty = () => {\r",
									"    const badAlbumPayloads = pm.environment.get('badAlbumPayloads');\r",
									" \r",
									"    if(badAlbumPayloads && badAlbumPayloads.length > 0) {\r",
									"        postman.setNextRequest('Add Album with Invalid Payload');\r",
									"    }\r",
									"}\r",
									" \r",
									"repeatRequestUntilDatasetEmpty();"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{{currentBadAlbumPayload}}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add Album with Valid Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.albumId).to.be.a('string');\r",
									"\r",
									"    pm.environment.set('albumId', responseJson.data.albumId);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"name\": \"Viva la vida\",\r\n    \"year\": 2008\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Detail Album with Invalid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/xxx",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"xxx"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Detail Album with Valid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    const albumId = pm.environment.get('albumId');\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album.id).to.equal(albumId);\r",
									"    pm.expect(responseJson.data.album.name).to.equal('Viva la vida');\r",
									"    pm.expect(responseJson.data.album.year).to.equal(2008)\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Edit Album with Invalid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let badAlbumPayloads = pm.environment.get('badAlbumPayloads');\r",
									"\r",
									"if (!badAlbumPayloads | badAlbumPayloads.length === 0) {\r",
									"    badAlbumPayloads = [\r",
									"        {},\r",
									"        { name: 1 },\r",
									"        { name: 'Bad song' },\r",
									"        { name: 'Bad song', year: 'dummy' },\r",
									"    ]\r",
									"}\r",
									"\r",
									"const currentBadAlbumPayload = badAlbumPayloads.shift();\r",
									"pm.environment.set('currentBadAlbumPayload', JSON.stringify(currentBadAlbumPayload));\r",
									"pm.environment.set('badAlbumPayloads', badAlbumPayloads);\r",
									"\r",
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})\r",
									"\r",
									"const repeatRequestUntilDatasetEmpty = () => {\r",
									"    const badAlbumPayloads = pm.environment.get('badAlbumPayloads');\r",
									" \r",
									"    if(badAlbumPayloads && badAlbumPayloads.length > 0) {\r",
									"        postman.setNextRequest('Edit Album with Invalid Payload');\r",
									"    }\r",
									"}\r",
									" \r",
									"repeatRequestUntilDatasetEmpty();"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{{currentBadAlbumPayload}}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Edit Album with Invalid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"name\": \"Viva la vida Revision\",\r\n    \"year\": 2010\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums/xxx",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"xxx"
							]
						}
					},
					"response": []
				},
				{
					"name": "Edit Album with Valid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									"\r",
									"pm.test('when GET detail albums', () => {\r",
									"    const albumId = pm.environment.get('albumId');\r",
									"    const port = pm.environment.get('port');\r",
									"    pm.sendRequest(`http://localhost:${port}/albums/${albumId}`, (error, response) => {\r",
									"        if (!error) {\r",
									"            pm.test('it should response with revised content', () => {\r",
									"                pm.expect(response.code).to.equal(200);\r",
									"\r",
									"                const responseJson = response.json();\r",
									"\r",
									"                pm.expect(responseJson.status).to.equal('success');\r",
									"                pm.expect(responseJson.data.album).to.be.an('object');\r",
									"                pm.expect(responseJson.data.album.id).to.equal(albumId);\r",
									"                pm.expect(responseJson.data.album.name).to.equal('Viva la vida Revision');\r",
									"                pm.expect(responseJson.data.album.year).to.equal(2010);\r",
									"            });\r",
									"        }\r",
									"    });\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"name\": \"Viva la vida Revision\",\r\n    \"year\": 2010\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Album with Invalid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/xxx",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"xxx"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Album with Valid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									"\r",
									"pm.test('when GET detail albums', () => {\r",
									"    const albumId = pm.environment.get('albumId');\r",
									"    const port = pm.environment.get('port');\r",
									"    pm.sendRequest(`http://localhost:${port}/albums/${albumId}`, (error, response) => {\r",
									"        if (!error) {\r",
									"            pm.test('it should response with not found', () => {\r",
									"                pm.expect(response.code).to.equal(404);\r",
									"            });\r",
									"        }\r",
									"    });\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Songs",
			"item": [
				{
					"name": "Add Song with Invalid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let badSongPayloads = pm.environment.get('badSongPayloads');\r",
									"\r",
									"if (!badSongPayloads | badSongPayloads.length === 0) {\r",
									"    badSongPayloads = [\r",
									"        {},\r",
									"        { title: 1 },\r",
									"        { title: 'Life in Technicolor' },\r",
									"        { title: 'Life in Technicolor', year: 'dummy' },\r",
									"        { title: 'Life in Technicolor', year: 2008 },\r",
									"        { title: 'Life in Technicolor', year: 2008, performer: true },\r",
									"        { title: 'Life in Technicolor', year: 2008, performer: 'Coldplay' },\r",
									"        { title: 'Life in Technicolor', year: 2008, performer: 'Coldplay', genre: 123 },\r",
									"    ]\r",
									"}\r",
									"\r",
									"const currentBadSongPayload = badSongPayloads.shift();\r",
									"pm.environment.set('currentBadSongPayload', JSON.stringify(currentBadSongPayload));\r",
									"pm.environment.set('badSongPayloads', badSongPayloads);"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})\r",
									"\r",
									"const repeatRequestUntilDatasetEmpty = () => {\r",
									"    const badSongPayloads = pm.environment.get('badSongPayloads');\r",
									" \r",
									"    if(badSongPayloads && badSongPayloads.length > 0) {\r",
									"        postman.setNextRequest('Add Song with Invalid Payload');\r",
									"    }\r",
									"}\r",
									" \r",
									"repeatRequestUntilDatasetEmpty();"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{{currentBadSongPayload}}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add Song with Valid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.songId).to.be.a('string');\r",
									"\r",
									"    pm.environment.set('songId', responseJson.data.songId);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"title\": \"Life in Technicolor\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "[No Test] Add Song with Valid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"title\": \"Fix You\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get All Songs",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.songs).to.length.least(2);\r",
									"\r",
									"    const songs = responseJson.data.songs;\r",
									"    songs.forEach((song) => {\r",
									"        pm.expect(Object.keys(song)).to.length(3);\r",
									"        pm.expect(song.id).to.be.ok;\r",
									"        pm.expect(song.title).to.be.ok;\r",
									"        pm.expect(song.performer).to.be.ok;\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Detail Songs with Invalid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/songs/xxx",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"xxx"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Detail Songs with Valid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const songId = pm.environment.get('songId');\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.a('object');\r",
									"    pm.expect(responseJson.data.song).to.be.an('object');\r",
									"    pm.expect(responseJson.data.song.id).to.equal(songId);\r",
									"    pm.expect(responseJson.data.song.title).to.equal('Life in Technicolor');\r",
									"    pm.expect(responseJson.data.song.year).to.equal(2008);\r",
									"    pm.expect(responseJson.data.song.performer).to.equal('Coldplay');\r",
									"    pm.expect(responseJson.data.song.genre).to.equal('Pop');\r",
									"    pm.expect(responseJson.data.song.duration).to.equal(120);\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Edit Song with Invalid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let badSongPayloads = pm.environment.get('badSongPayloads');\r",
									"\r",
									"if (!badSongPayloads | badSongPayloads.length === 0) {\r",
									"    badSongPayloads = [\r",
									"        {},\r",
									"        { title: 1 },\r",
									"        { title: 'Life in Technicolor' },\r",
									"        { title: 'Life in Technicolor', year: 'dummy' },\r",
									"        { title: 'Life in Technicolor', year: 2008 },\r",
									"        { title: 'Life in Technicolor', year: 2008, performer: true },\r",
									"        { title: 'Life in Technicolor', year: 2008, performer: 'Coldplay' },\r",
									"        { title: 'Life in Technicolor', year: 2008, performer: 'Coldplay', genre: 123 },\r",
									"    ]\r",
									"}\r",
									"\r",
									"const currentBadSongPayload = badSongPayloads.shift();\r",
									"pm.environment.set('currentBadSongPayload', JSON.stringify(currentBadSongPayload));\r",
									"pm.environment.set('badSongPayloads', badSongPayloads);"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})\r",
									"\r",
									"const repeatRequestUntilDatasetEmpty = () => {\r",
									"    const badSongPayloads = pm.environment.get('badSongPayloads');\r",
									" \r",
									"    if(badSongPayloads && badSongPayloads.length > 0) {\r",
									"        postman.setNextRequest('Edit Song with Invalid Payload');\r",
									"    }\r",
									"}\r",
									" \r",
									"repeatRequestUntilDatasetEmpty();"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{{currentBadSongPayload}}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Edit Song with Invalid Id",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"title\": \"Life in Technicolor revision\",\r\n    \"year\": 2010,\r\n    \"performer\": \"Coldplay 2\",\r\n    \"genre\": \"Hip Hop\",\r\n    \"duration\": 125\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/xxx",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"xxx"
							]
						}
					},
					"response": []
				},
				{
					"name": "Edit Song with Valid Id",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									"\r",
									"pm.test('when GET detail song', () => {\r",
									"    const songId = pm.environment.get('songId');\r",
									"    const port = pm.environment.get('port');\r",
									"    pm.sendRequest(`http://localhost:${port}/songs/${songId}`, (error, response) => {\r",
									"        if (!error) {\r",
									"            pm.test('it should response with revised content', () => {\r",
									"                pm.expect(response.code).to.equal(200);\r",
									"\r",
									"                const responseJson = response.json();\r",
									"\r",
									"                pm.expect(responseJson.status).to.equal('success');\r",
									"                pm.expect(responseJson.data.song).to.be.an('object');\r",
									"                pm.expect(responseJson.data.song.id).to.equal(songId);\r",
									"                pm.expect(responseJson.data.song.title).to.equal('Life in Technicolor revision');\r",
									"                pm.expect(responseJson.data.song.year).to.equal(2010);\r",
									"                pm.expect(responseJson.data.song.performer).to.equal('Coldplay 2');\r",
									"                pm.expect(responseJson.data.song.genre).to.equal('Hip Hop');\r",
									"                pm.expect(responseJson.data.song.duration).to.equal(125)\r",
									"            });\r",
									"        }\r",
									"    });\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"title\": \"Life in Technicolor revision\",\r\n    \"year\": 2010,\r\n    \"performer\": \"Coldplay 2\",\r\n    \"genre\": \"Hip Hop\",\r\n    \"duration\": 125\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Song with Invalid Id",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/songs/xxx",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"xxx"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Song with Valid Id",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});\r",
									"\r",
									"pm.test('when GET detail song', () => {\r",
									"    const songId = pm.environment.get('songId');\r",
									"    const port = pm.environment.get('port');\r",
									"    pm.sendRequest(`http://localhost:${port}/songs/${songId}`, (error, response) => {\r",
									"        if (!error) {\r",
									"            pm.test('it should response with not found', () => {\r",
									"                pm.expect(response.code).to.equal(404);\r",
									"            });\r",
									"        }\r",
									"    });\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songId}}"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "[Optional] Song in Album",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add Album",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseJson = pm.response.json();\r",
											"pm.environment.set('albumId', responseJson.data.albumId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"name\": \"Viva la vida\",\r\n    \"year\": 2008\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/albums",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"albums"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Album With No Songs",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseJson = pm.response.json();\r",
											"pm.environment.set('albumIdWithNoSongs', responseJson.data.albumId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"name\": \"Viva la vida\",\r\n    \"year\": 2008\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/albums",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"albums"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Add Song A with Album Id",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.songId).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"title\": \"Life in Technicolor\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120,\r\n    \"albumId\": \"{{albumId}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add Song B with Album Id",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.songId).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"title\": \"Fix you\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120,\r\n    \"albumId\": \"{{albumId}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Detail Album which Contains Songs",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    const albumId = pm.environment.get('albumId');\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album.id).to.equal(albumId);\r",
									"    pm.expect(responseJson.data.album.name).to.equal('Viva la vida');\r",
									"    pm.expect(responseJson.data.album.year).to.equal(2008);\r",
									"    pm.expect(responseJson.data.album.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.album.songs).to.length(2);\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Detail Album which Not Contains Songs",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    const albumId = pm.environment.get('albumIdWithNoSongs');\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album.id).to.equal(albumId);\r",
									"    pm.expect(responseJson.data.album.name).to.equal('Viva la vida');\r",
									"    pm.expect(responseJson.data.album.year).to.equal(2008);\r",
									"    pm.expect(responseJson.data.album.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.album.songs).to.length(0);\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumIdWithNoSongs}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumIdWithNoSongs}}"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "[Optional] Query Parameter",
			"item": [
				{
					"name": "[No Test] Prerequisite",
					"item": [
						{
							"name": "Add Song A",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdA', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Kupu-kupu Malam\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Chrisye\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Song B",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdB', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Cinta\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Chrisye\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Song C",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdC', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Cinta Mati\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Dewa 98\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Song D",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdD', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Kupu-kupu Malam\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Peterpan\",\r\n    \"genre\": \"Rock\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Seach Song using Title",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.songs).to.length(2);\r",
									"\r",
									"    const songs = responseJson.data.songs;\r",
									"    songs.forEach((song) => {\r",
									"        pm.expect(Object.keys(song)).to.length(3);\r",
									"        pm.expect(song.id).to.be.ok;\r",
									"        pm.expect(song.title).to.be.ok;\r",
									"        pm.expect(song.title.toLowerCase()).includes('cint');\r",
									"        pm.expect(song.performer).to.be.ok;\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/songs?title=cint",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							],
							"query": [
								{
									"key": "title",
									"value": "cint"
								}
							]
						}
					},
					"response": []
				},
				{
					"name": "Seach Song using Performer",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.songs).to.length(2);\r",
									"\r",
									"    const songs = responseJson.data.songs;\r",
									"    songs.forEach((song) => {\r",
									"        pm.expect(Object.keys(song)).to.length(3);\r",
									"        pm.expect(song.id).to.be.ok;\r",
									"        pm.expect(song.title).to.be.ok;\r",
									"        pm.expect(song.performer).to.be.ok;\r",
									"        pm.expect(song.performer.toLowerCase()).to.includes('chris');\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/songs?performer=chris",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							],
							"query": [
								{
									"key": "performer",
									"value": "chris"
								}
							]
						}
					},
					"response": []
				},
				{
					"name": "Seach Song using Title and Performer",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.songs).to.length(1);\r",
									"\r",
									"    const songs = responseJson.data.songs;\r",
									"    songs.forEach((song) => {\r",
									"        pm.expect(Object.keys(song)).to.length(3);\r",
									"        pm.expect(song.id).to.be.ok;\r",
									"        pm.expect(song.title).to.be.ok;\r",
									"        pm.expect(song.title.toLowerCase()).to.includes('kupu');\r",
									"        pm.expect(song.performer).to.be.ok;\r",
									"        pm.expect(song.performer.toLowerCase()).to.includes('peter');\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/songs?title=kupu&performer=peter",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs"
							],
							"query": [
								{
									"key": "title",
									"value": "kupu"
								},
								{
									"key": "performer",
									"value": "peter"
								}
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Song A",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songIdA}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songIdA}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Song B",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songIdB}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songIdB}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Song C",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songIdC}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songIdC}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Song D",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/songs/{{songIdD}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"songs",
								"{{songIdD}}"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Users",
			"item": [
				{
					"name": "Add User with Invalid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let badUserPayloads = pm.environment.get('badUserPayloads');\r",
									"\r",
									"if (!badUserPayloads | badUserPayloads.length === 0) {\r",
									"    badUserPayloads = [\r",
									"        {},\r",
									"        { username: 1 },\r",
									"        { username: 'dicoding' },\r",
									"        { username: 'dicoding', password: true },\r",
									"        { username: 'dicoding', passowrd: 'secret' },\r",
									"        { username: 'dicoding', password: 'secret', fullname: 0 }\r",
									"    ];\r",
									"}\r",
									"\r",
									"const currentBadUserPayload = badUserPayloads.shift();\r",
									"pm.environment.set('currentBadUserPayload', JSON.stringify(currentBadUserPayload));\r",
									"pm.environment.set('badUserPayloads', badUserPayloads);"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})\r",
									"\r",
									"const repeatRequestUntilDatasetEmpty = () => {\r",
									"    const badUserPayloads = pm.environment.get('badUserPayloads');\r",
									" \r",
									"    if(badUserPayloads && badUserPayloads.length > 0) {\r",
									"        postman.setNextRequest('Add User with Invalid Payload');\r",
									"    }\r",
									"}\r",
									" \r",
									"repeatRequestUntilDatasetEmpty();"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{{currentBadUserPayload}}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/users",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"users"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add User with Valid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.userId).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"username\": \"dicoding_{{$timestamp}}\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"Dicoding Indonesia\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/users",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"users"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add User with Already Taken Username",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"const port = pm.environment.get('port');\r",
									"\r",
									"const requestParams = {\r",
									"  url: `http://localhost:${port}/users`,\r",
									"  method: 'POST',\r",
									"  header: {\r",
									"    'Content-Type': 'application/json',\r",
									"  },\r",
									"  body: {\r",
									"    mode: 'raw',\r",
									"    raw: JSON.stringify({ username: 'dicoding', password: 'secret', fullname: 'Dicoding Indonesia' })\r",
									"  }\r",
									"};\r",
									"pm.sendRequest(requestParams, (_, error) => {\r",
									"    if (error) {\r",
									"        console.error(error);\r",
									"    }\r",
									"});"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"username\": \"dicoding\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"Dicoding Indonesia\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/users",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"users"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Authentications",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add User John",
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User Jane",
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Login with Invalid Payload",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									"let badLoginPayloads = pm.environment.get('badLoginPayloads');\r",
									"\r",
									"if (!badLoginPayloads | badLoginPayloads.length === 0) {\r",
									"    badLoginPayloads = [\r",
									"        {},\r",
									"        { username: true },\r",
									"        { username: 'dicoding' },\r",
									"        { username: 'dicoding', password: true }\r",
									"    ];\r",
									"}\r",
									"\r",
									"const currentBadLoginPayload = badLoginPayloads.shift();\r",
									"pm.environment.set('currentBadLoginPayload', JSON.stringify(currentBadLoginPayload));\r",
									"pm.environment.set('badLoginPayloads', badLoginPayloads);"
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})\r",
									"\r",
									"const repeatRequestUntilDatasetEmpty = () => {\r",
									"    const badLoginPayloads = pm.environment.get('badLoginPayloads');\r",
									" \r",
									"    if(badLoginPayloads && badLoginPayloads.length > 0) {\r",
									"        postman.setNextRequest('Login with Invalid Payload');\r",
									"    }\r",
									"}\r",
									" \r",
									"repeatRequestUntilDatasetEmpty();"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{{currentBadLoginPayload}}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Login with Not Found User",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 401 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(401);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"username\": \"xxx\",\r\n    \"password\": \"xxx\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Login with Invalid Password",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 401 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(401);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"xxx\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Login with User John",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.accessToken).to.be.a('string');\r",
									"    pm.expect(responseJson.data.refreshToken).to.be.a('string');\r",
									"    \r",
									"    pm.environment.set('accessTokenJohn', responseJson.data.accessToken);\r",
									"    pm.environment.set('refreshTokenJohn', responseJson.data.refreshToken);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Login with User Jane",
					"event": [
						{
							"listen": "prerequest",
							"script": {
								"exec": [
									""
								],
								"type": "text/javascript"
							}
						},
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.accessToken).to.be.a('string');\r",
									"    pm.expect(responseJson.data.refreshToken).to.be.a('string');\r",
									"    \r",
									"    pm.environment.set('accessTokenJane', responseJson.data.accessToken);\r",
									"    pm.environment.set('refreshTokenJane', responseJson.data.refreshToken);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Refresh Authentication with Invalid Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Refresh Authentication with Invalid Token",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"refreshToken\": \"xxxx\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Refresh Authentication with John Access Token",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"refreshToken\": \"{{accessTokenJohn}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Refresh Authentication John Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.accessToken).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"refreshToken\": \"{{refreshTokenJohn}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Authentication with Invalid Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Authentication with Invalid Token",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"refreshToken\": \"xxx\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Authentication John Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"refreshToken\": \"{{refreshTokenJohn}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Delete Authentication Jane Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"refreshToken\": \"{{refreshTokenJane}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				},
				{
					"name": "Refresh Authentication with Deleted Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"})"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "PUT",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"refreshToken\": \"{{refreshTokenJohn}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/authentications",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"authentications"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Playlists",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add Song A",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdA', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Life in Technicolor\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Song B",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdB', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Fix You\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User John",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User Jane",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User John",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJohn', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User Jane",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJane', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Add Playlist without Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 401 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(401);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add Playlist with Invalid Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"name\": true\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Add Playlist with Valid Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.a('object');\r",
									"    pm.expect(responseJson.data.playlistId).to.be.a('string');\r",
									"\r",
									"    pm.environment.set('playlistIdJohnFirst', responseJson.data.playlistId);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"name\": \"Lagu Indie Hits Indonesia\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Add Another Playlist with Valid Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.a('object');\r",
									"    pm.expect(responseJson.data.playlistId).to.be.a('string');\r",
									"\r",
									"    pm.environment.set('playlistIdJohn', responseJson.data.playlistId);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"name\": \"Lagu Untuk Membaca\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Get All Playlists",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlists).to.be.an('array');\r",
									"    pm.expect(responseJson.data.playlists).to.length(2);\r",
									"\r",
									"    const { playlists } = responseJson.data;\r",
									"    playlists.forEach((playlist) => {\r",
									"        pm.expect(Object.keys(playlist)).to.length(3);\r",
									"        pm.expect(playlist.id).to.be.ok;\r",
									"        pm.expect(playlist.name).to.be.ok;\r",
									"        pm.expect(playlist.username).to.be.ok;\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Add Song to Playlist with Bad Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": 123\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Add Song to Playlist with Not Found Song",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"xxx\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Add Song A to Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Add Song B to Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdB}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Add Song to John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Get Songs in Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlist).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlist.id).to.be.a('string');\r",
									"    pm.expect(responseJson.data.playlist.name).to.equal('Lagu Untuk Membaca');\r",
									"    pm.expect(responseJson.data.playlist.username).to.equal('john');\r",
									"    \r",
									"    pm.expect(responseJson.data.playlist.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.playlist.songs).to.length(2);\r",
									"    const { songs } = responseJson.data.playlist;\r",
									"    songs.forEach((song) => {\r",
									"        pm.expect(Object.keys(song)).to.length(3);\r",
									"        pm.expect(song.id).to.be.ok;\r",
									"        pm.expect(song.title).to.be.ok;\r",
									"        pm.expect(song.performer).to.be.ok;\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Get Songs in John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete Song from Playlist with Invalid Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": 123\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete Song A from Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Delete Song B from John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdB}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Get Songs in Playlist After Deletion Song",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlist).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlist.id).to.be.a('string');\r",
									"    pm.expect(responseJson.data.playlist.name).to.equal('Lagu Untuk Membaca');\r",
									"    pm.expect(responseJson.data.playlist.username).to.equal('john');\r",
									"    \r",
									"    pm.expect(responseJson.data.playlist.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.playlist.songs).to.length(1);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Delete John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string')\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete First Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string')\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohnFirst}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohnFirst}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string')\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Get Songs in Playlist After Deletion",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "[Optional] Activities Playlist",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add Song A",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdA', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Life in Technicolor\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Song B",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdB', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Fix You\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User John",
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User Jane",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User John",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJohn', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User Jane",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJane', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Create Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseJson = pm.response.json();\r",
											"pm.environment.set('playlistIdJohn', responseJson.data.playlistId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"name\": \"Lagu Indie Hits Indonesia\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Add Song A to Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists",
										"{{playlistIdJohn}}",
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Add Song B to Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"songId\": \"{{songIdB}}\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists",
										"{{playlistIdJohn}}",
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Delete Song A from Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists",
										"{{playlistIdJohn}}",
										"songs"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Get Activities in Playlist without Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 401 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(401);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/activities",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"activities"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Get Activities in Not Found Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/playlists/xxx/activities",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"xxx",
								"activities"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Get Activities in John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/activities",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"activities"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Get Activities in Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('it should response with valid body', () => {\r",
									"    const expectedPlaylistId = pm.environment.get('playlistIdJohn');\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    const { playlistId, activities } = responseJson.data;\r",
									"    pm.expect(playlistId).to.equal(expectedPlaylistId);\r",
									"    pm.expect(activities).to.be.an('array');\r",
									"    pm.expect(activities).to.length(3);\r",
									"\r",
									"    const [ activity1, activity2, activity3 ] = activities;\r",
									"\r",
									"    pm.expect(activity1.username).to.equal('john');\r",
									"    pm.expect(activity1.title).to.equal('Life in Technicolor');\r",
									"    pm.expect(activity1.action).to.equal('add');\r",
									"    pm.expect(activity1.time).to.be.a('string');\r",
									"\r",
									"    pm.expect(activity2.username).to.equal('john');\r",
									"    pm.expect(activity2.title).to.equal('Fix You');\r",
									"    pm.expect(activity2.action).to.equal('add');\r",
									"    pm.expect(activity2.time).to.be.a('string');\r",
									"\r",
									"    pm.expect(activity3.username).to.equal('john');\r",
									"    pm.expect(activity3.title).to.equal('Life in Technicolor');\r",
									"    pm.expect(activity3.action).to.equal('delete');\r",
									"    pm.expect(activity3.time).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/activities",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"activities"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string')\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Get Activities in Playlist After Deletion",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/activities",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"activities"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "[Optional] Collaborations Playlist",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add Song A",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdA', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Life in Technicolor\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Song B",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdB', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Fix You\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User John",
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User Tom",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { userId } } = pm.response.json();\r",
											"pm.environment.set('userIdTom', userId);"
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											"const usernameTom = `tom${+ new Date()}`;\r",
											"pm.environment.set('usernameTom', usernameTom);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"{{usernameTom}}\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"Tom Riddle\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User John",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJohn', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User Tom",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenTom', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"{{usernameTom}}\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Create Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseJson = pm.response.json();\r",
											"pm.environment.set('playlistIdJohn', responseJson.data.playlistId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"name\": \"Lagu Indie Hits Indonesia\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Make Collaborator without Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 401 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(401);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"playlistId\": \"{{playlistIdJohn}}\",\r\n    \"userId\": \"{{userIdTom}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/collaborations",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"collaborations"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Make Collaboration in Playlist with Not Found User",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"playlistId\": \"{{playlistIdJohn}}\",\r\n    \"userId\": \"xxx\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/collaborations",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"collaborations"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Make Collaboration in Not Found Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"playlistId\": \"xxx\",\r\n    \"userId\": \"{{userIdTom}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/collaborations",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"collaborations"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Make Collaboration in John Playlist by His Own",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"playlistId\": \"{{playlistIdJohn}}\",\r\n    \"userId\": \"{{userIdTom}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/collaborations",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"collaborations"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Make Collaboration in Playlist with Tom",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.collaborationId).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"playlistId\": \"{{playlistIdJohn}}\",\r\n    \"userId\": \"{{userIdTom}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/collaborations",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"collaborations"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Get All Playlists",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlists).to.be.an('array');\r",
									"    pm.expect(responseJson.data.playlists).to.length(1);\r",
									"\r",
									"    const { playlists } = responseJson.data;\r",
									"    playlists.forEach((playlist) => {\r",
									"        pm.expect(Object.keys(playlist)).to.length(3);\r",
									"        pm.expect(playlist.id).to.be.ok;\r",
									"        pm.expect(playlist.name).to.be.ok;\r",
									"        pm.expect(playlist.username).to.equal('john');\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Add Song A to John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Add Song B to John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdB}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Get John Playlist Songs",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlist).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlist.id).to.be.a('string');\r",
									"    pm.expect(responseJson.data.playlist.name).to.equal('Lagu Indie Hits Indonesia');\r",
									"    pm.expect(responseJson.data.playlist.username).to.equal('john');\r",
									"    \r",
									"    pm.expect(responseJson.data.playlist.songs).to.be.an('array');\r",
									"    pm.expect(responseJson.data.playlist.songs).to.length(2);\r",
									"    const { songs } = responseJson.data.playlist;\r",
									"    songs.forEach((song) => {\r",
									"        pm.expect(Object.keys(song)).to.length(3);\r",
									"        pm.expect(song.id).to.be.ok;\r",
									"        pm.expect(song.title).to.be.ok;\r",
									"        pm.expect(song.performer).to.be.ok;\r",
									"    });\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Delete Song A from John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Delete John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Delete Collaboration in Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"playlistId\": \"{{playlistIdJohn}}\",\r\n    \"userId\": \"{{userIdTom}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/collaborations",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"collaborations"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete Collaboration in Playlist with Tom",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.an('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"playlistId\": \"{{playlistIdJohn}}\",\r\n    \"userId\": \"{{userIdTom}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/collaborations",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"collaborations"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Get All Playlists after Collaboration Deletion",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.playlists).to.be.an('array');\r",
									"    pm.expect(responseJson.data.playlists).to.length(0);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"protocolProfileBehavior": {
						"disableBodyPruning": true
					},
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "GET",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Tom) Add Song to John Playlist after Collaboration Deletion",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenTom}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}",
								"songs"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string')\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Exports",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add Song A",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdA', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Life in Technicolor\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add Song B",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { songId } } = pm.response.json();\r",
											"pm.environment.set('songIdB', songId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"title\": \"Fix You\",\r\n    \"year\": 2008,\r\n    \"performer\": \"Coldplay\",\r\n    \"genre\": \"Pop\",\r\n    \"duration\": 120\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User John",
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User Jane",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User John",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJohn', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User Jane",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJane', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Create Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseJson = pm.response.json();\r",
											"pm.environment.set('playlistIdJohn', responseJson.data.playlistId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"name\": \"Lagu Indie Hits Indonesia\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Add Song A to Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists",
										"{{playlistIdJohn}}",
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Add Song B to Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"songId\": \"{{songIdB}}\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists",
										"{{playlistIdJohn}}",
										"songs"
									]
								}
							},
							"response": []
						},
						{
							"name": "(John) Delete Song A from Playlist",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"auth": {
									"type": "bearer",
									"bearer": [
										{
											"key": "token",
											"value": "{{accessTokenJohn}}",
											"type": "string"
										}
									]
								},
								"method": "DELETE",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"songId\": \"{{songIdA}}\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}/songs",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"playlists",
										"{{playlistIdJohn}}",
										"songs"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Export Playlist without Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 401 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(401);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/export/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"export",
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Export Playlist with Bad Payload",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/export/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"export",
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Export Playlist with Not Found Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"targetEmail\": \"example@dicoding.com\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/export/playlists/xxx",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"export",
								"playlists",
								"xxx"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Export John Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 403 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(403);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"targetEmail\": \"{{exportEmail}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/export/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"export",
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Export Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"\r",
									"    // wait for consumer to export data\r",
									"    setTimeout(() => {}, 5000);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "{\r\n    \"targetEmail\": \"{{exportEmail}}\"\r\n}",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/export/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"export",
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Delete Playlist",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string')\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"body": {
							"mode": "raw",
							"raw": "",
							"options": {
								"raw": {
									"language": "json"
								}
							}
						},
						"url": {
							"raw": "http://localhost:{{port}}/playlists/{{playlistIdJohn}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"playlists",
								"{{playlistIdJohn}}"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Uploads",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add Album",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseJson = pm.response.json();\r",
											"pm.environment.set('albumId', responseJson.data.albumId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"name\": \"Viva la vida\",\r\n    \"year\": 2008\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/albums",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"albums"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Get Detail Albums without Cover URL",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    const albumId = pm.environment.get('albumId');\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album.id).to.equal(albumId);\r",
									"    pm.expect(responseJson.data.album.name).to.equal('Viva la vida');\r",
									"    pm.expect(responseJson.data.album.year).to.equal(2008);\r",
									"    pm.expect(responseJson.data.album.coverUrl).to.equal(null);\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add Cover Album with Non Image File",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.an('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "formdata",
							"formdata": [
								{
									"key": "cover",
									"type": "file",
									"src": "/home/dimas/Downloads/small-text.txt"
								}
							]
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/covers",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"covers"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add Cover Album with Big Image File",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 413 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(413);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "formdata",
							"formdata": [
								{
									"key": "cover",
									"type": "file",
									"src": "/home/dimas/Downloads/picture-large.jpg"
								}
							]
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/covers",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"covers"
							]
						}
					},
					"response": []
				},
				{
					"name": "Add Cover Album with Valid File",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.an('string');\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "POST",
						"header": [],
						"body": {
							"mode": "formdata",
							"formdata": [
								{
									"key": "cover",
									"type": "file",
									"src": "/home/dimas/Downloads/picture-small.jpg"
								}
							]
						},
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/covers",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"covers"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Detail Albums with Cover URL",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body should have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    const albumId = pm.environment.get('albumId');\r",
									"    \r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album).to.be.an('object');\r",
									"    pm.expect(responseJson.data.album.id).to.equal(albumId);\r",
									"    pm.expect(responseJson.data.album.name).to.equal('Viva la vida');\r",
									"    pm.expect(responseJson.data.album.year).to.equal(2008);\r",
									"    pm.expect(responseJson.data.album.coverUrl).to.be.a('string');\r",
									"\r",
									"    const { coverUrl } = responseJson.data.album;\r",
									"\r",
									"    pm.sendRequest(coverUrl, (_, response) => {\r",
									"        pm.expect(response.code).to.equal(200);\r",
									"    });\r",
									"});\r",
									""
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}"
							]
						}
					},
					"response": []
				}
			]
		},
		{
			"name": "Album Likes",
			"item": [
				{
					"name": "[No test] Prerequisite",
					"item": [
						{
							"name": "Add Album",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											"const responseJson = pm.response.json();\r",
											"pm.environment.set('albumId', responseJson.data.albumId);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"name\": \"Viva la vida\",\r\n    \"year\": 2008\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/albums",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"albums"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User John",
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Add User Jane",
							"event": [
								{
									"listen": "test",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\",\r\n    \"fullname\": \"John Doe\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/users",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"users"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User John",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJohn', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"john\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						},
						{
							"name": "Login with User Jane",
							"event": [
								{
									"listen": "prerequest",
									"script": {
										"exec": [
											""
										],
										"type": "text/javascript"
									}
								},
								{
									"listen": "test",
									"script": {
										"exec": [
											"const { data: { accessToken } } = pm.response.json();\r",
											"pm.environment.set('accessTokenJane', accessToken);"
										],
										"type": "text/javascript"
									}
								}
							],
							"request": {
								"method": "POST",
								"header": [],
								"body": {
									"mode": "raw",
									"raw": "{\r\n    \"username\": \"jane\",\r\n    \"password\": \"secret\"\r\n}",
									"options": {
										"raw": {
											"language": "json"
										}
									}
								},
								"url": {
									"raw": "http://localhost:{{port}}/authentications",
									"protocol": "http",
									"host": [
										"localhost"
									],
									"port": "{{port}}",
									"path": [
										"authentications"
									]
								}
							},
							"response": []
						}
					]
				},
				{
					"name": "Like Album with No Authentication",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 401 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(401);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "POST",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Like Not Found Album",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 404 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(404);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/xxx/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"xxx",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Like Album",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "(John) Like Album Again",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 400 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(400);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('fail');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJohn}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Like Album",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 201 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(201);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "POST",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Album Like Count",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"});\r",
									"\r",
									"pm.test('respose should not have X-Data-Source header with value not \"cache\"', () => {\r",
									"    pm.expect(pm.response.headers.get('X-Data-Source')).to.not.equal(\"cache\");\r",
									"});\r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.likes).to.equal(2);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "(Jane) Unlike Album",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.message).to.be.a('string');\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "bearer",
							"bearer": [
								{
									"key": "token",
									"value": "{{accessTokenJane}}",
									"type": "string"
								}
							]
						},
						"method": "DELETE",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "Get Album Like Count After Jane Unlike",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('respose should not have X-Data-Source header with value not \"cache\"', () => {\r",
									"    pm.expect(pm.response.headers.get('X-Data-Source')).to.not.equal(\"cache\");\r",
									"});\r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.likes).to.equal(1);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				},
				{
					"name": "[Cache Test] Get Album Like Count (Again)",
					"event": [
						{
							"listen": "test",
							"script": {
								"exec": [
									"pm.test('it should response 200 status code', () => {\r",
									"    pm.expect(pm.response).to.have.status(200);\r",
									"});\r",
									"\r",
									"pm.test('response Content-Type header should have application/json value', () => {\r",
									"    pm.expect(pm.response.headers.get('Content-Type')).to.includes('application/json');\r",
									"}); \r",
									"\r",
									"pm.test('respose should have X-Data-Source header with value \"cache\"', () => {\r",
									"    pm.expect(pm.response.headers.get('X-Data-Source')).to.equal(\"cache\");\r",
									"});\r",
									"\r",
									"pm.test('response body should an object', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"    pm.expect(responseJson).to.be.an('object');\r",
									"});\r",
									"\r",
									"pm.test('response body have correct property and value', () => {\r",
									"    const responseJson = pm.response.json();\r",
									"\r",
									"    pm.expect(responseJson.status).to.equal('success');\r",
									"    pm.expect(responseJson.data).to.be.an('object');\r",
									"    pm.expect(responseJson.data.likes).to.equal(1);\r",
									"});"
								],
								"type": "text/javascript"
							}
						}
					],
					"request": {
						"auth": {
							"type": "noauth"
						},
						"method": "GET",
						"header": [],
						"url": {
							"raw": "http://localhost:{{port}}/albums/{{albumId}}/likes",
							"protocol": "http",
							"host": [
								"localhost"
							],
							"port": "{{port}}",
							"path": [
								"albums",
								"{{albumId}}",
								"likes"
							]
						}
					},
					"response": []
				}
			]
		}
	]
}