コード例 #1
0
    def test_podcast_dump(self):
        podcast = Podcast(name="Test",
                          duration=33,
                          host="Tester",
                          participants=["A", "B"])
        podcast.save_to_db()

        # Retrieve DB record for the podcast created
        podcast = Podcast.find_by_name(podcast.name)
        expected = OrderedDict({
            "id":
            1,
            "name":
            "Test",
            "duration":
            33,
            "host":
            "Tester",
            "participants": ["A", "B"],
            "uploaded_time":
            "T".join(str(podcast.uploaded_time).split())
        })

        # Get the serialized data
        json_data = self.schema().dump(podcast)

        # Separate out participant lists from json_data and expected data to compare separately
        participantList = json_data.pop("participants")
        expectedParticipantList = expected.pop("participants")

        self.assertDictEqual(json_data, expected)
        self.assertCountEqual(participantList, expectedParticipantList)
コード例 #2
0
    def setUp(self):
        BaseTest.setUp(self)

        self.post_data = {
            "audioFileType": "podcast",
            "audioFileMetadata": {
                "name": "Test API Podcast",
                "duration": 360,
                "host": "Robert",
                "participants": [
                    "Rambo"
                ]
            }
        }

        self.update_data = {
            "name": "Updated Test API Podcast",
            "duration": 34223,
            "host": "Sukanta",
            "participants": [
                "Norman"
            ]
        }

        # Create some dummy data
        Podcast("Test 1", 13, "Host 1", ["Participant 1"]).save_to_db()
        Podcast("Test 2", 23, "Host 2", ["Participant 2"]).save_to_db()
コード例 #3
0
    def test_podcast_repr(self):
        test = Podcast("name", 12, "ss", ["ab", "cd", "ef"])

        self.assertEqual(
            "name: name, Audio type: podcast, Host:ss, participants: [ab, cd, ef]",
            test.__repr__()
        )
コード例 #4
0
    def test_podcast_participants_list_optional(self):
        test = Podcast("Test", 12, "ss")

        self.assertEqual(
            "name: Test, Audio type: podcast, Host:ss, participants: []",
            test.__repr__()
        )
        self.assertCountEqual([], test.participants)
コード例 #5
0
    def test_delete_podcast(self):
        with self.app() as client:
            with self.app_context():
                test_id = 1

                # Check record exists before deleting
                self.assertIsNotNone(Podcast.find_by_id(test_id))

                request = client.delete(f"/podcast/{test_id}")

                # Check record doesn't exist after deleting
                self.assertIsNone(Podcast.find_by_id(test_id))
コード例 #6
0
    def test_post_podcast(self):
        with self.app() as client:
            with self.app_context():
                # Check record named "Test API Podcast" does not exist
                self.assertIsNone(Podcast.find_by_name(self.post_data["audioFileMetadata"]["name"]))
                request = client.post("/", data=json.dumps(self.post_data))

                self.assertEqual(request.status_code, 200)
                self.assertIsNotNone(Podcast.find_by_name(self.post_data["audioFileMetadata"]["name"]))
                self.assertDictEqual(
                    PodcastSchema().dump(Podcast.find_by_name(self.post_data["audioFileMetadata"]["name"])),
                    json.loads(request.data)
                )
コード例 #7
0
    def test_update_podcast(self):
        podcast = Podcast(**self.data)
        podcast.save_to_db()

        # Get the record and check field values
        record = Podcast.find_by_name(self.data["name"])
        self.assertIsNotNone(record)
        self.assertEqual(record.name, self.data["name"])
        self.assertEqual(record.duration, self.data["duration"])

        # Update field values
        update_data = {
            "name": "Updated Test Podcast",
            "duration": 120,
            "host": Host("Updated host"),
            "participants": [
                Participant("Rohan")
            ]
        }
        Podcast.update(update_data, record)

        # Check updated field values
        updated_record = Podcast.find_by_id(record.id)
        self.assertIsNotNone(updated_record)
        self.assertEqual(updated_record.name, update_data["name"])
        self.assertEqual(updated_record.duration, update_data["duration"])
        self.assertIsInstance(updated_record.host, Host)
        self.assertEqual(str(updated_record.host.name), update_data["host"].name)
        self.assertEqual(len(updated_record.participants), 1)
        self.assertEqual(updated_record.participants[0].name, update_data["participants"][0].name)
コード例 #8
0
    def test_podcast_load_with_existing_record(self):
        podcast = self.schema().load(self.data, session=db.session)

        self.assertIsNone(Podcast.find_by_name(podcast.name))
        podcast.save_to_db()
        db_podcast = Podcast.find_by_name(podcast.name)
        self.assertIsNotNone(db_podcast)

        # load another podcast with same data and check id is same
        self.data["id"] = db_podcast.id
        podcast2 = self.schema().load(self.data, session=db.session,\
             instance=Podcast.find_by_name(self.data["name"]), unknown=EXCLUDE)

        self.assertIsNotNone(podcast2)
        self.assertEqual(podcast2.id, db_podcast.id)
コード例 #9
0
    def get(self, audioFileType, audioFileID):
        if self.isValidInput(audioFileType, audioFileID):
            responseData = None
            audioFileID = int(audioFileID)
            
            if audioFileType == 'song':
                schema = SongSchema()
                song = Song.find_by_id(audioFileID)

                if song:
                    responseData = schema.dump(song)

            elif audioFileType == 'podcast':
                schema = PodcastSchema()
                podcast = Podcast.find_by_id(audioFileID)

                if podcast:
                    responseData = schema.dump(podcast)

            elif audioFileType == 'audiobook':
                schema = AudioBookSchema()
                audiobook = AudioBook.find_by_id(audioFileID)

                if audiobook:
                    responseData = schema.dump(audiobook)
            
            if responseData:
                return responseData, 200
            
            logging.warn(f"File with ID: {audioFileID} not found")
            return {'Message': 'File not found'}, 400

        logging.warn(f"AudioFileType or AudioFileID is not validd")
        return {'Message': 'AudioFileType or AudioFileID is not valid'}, 400 
コード例 #10
0
    def test_delete_podcast(self):
        # Check a record exists in the db
        podcast = Podcast(**self.data)
        podcast.save_to_db()
        self.assertIsNotNone(Podcast.find_by_name(self.data["name"]))

        # Delete podcast
        podcast.delete_from_db()

        # Check record doesn't exist anymore
        self.assertIsNone(Podcast.find_by_name(self.data["name"]))
コード例 #11
0
    def test_get_podcast(self):
        with self.app() as client:
            with self.app_context():
                test_id = 1
                request = client.get(f"/podcast/{test_id}")

                self.assertEqual(request.status_code, 200)
                self.assertDictEqual(
                    PodcastSchema().dump(Podcast.find_by_id(1)),
                    json.loads(request.data)
                )
コード例 #12
0
    def test_update_podcast(self):
        with self.app() as client:
            with self.app_context():
                test_id = 1
                # Check record exists
                self.assertIsNotNone(Podcast.find_by_id(test_id))

                request = client.put(f"/podcast/{test_id}", \
                    data=json.dumps(self.update_data),\
                    headers={'content-type': 'application/json'})

                self.assertEqual(request.status_code, 200)

                record = Podcast.find_by_id(test_id)

                self.assertIsNotNone(record)
                self.assertDictEqual(
                    PodcastSchema().dump(Podcast.find_by_id(test_id)),
                    json.loads(request.data)
                )
                self.assertEqual(record.name, self.update_data["name"])
                self.assertEqual(record.duration, self.update_data["duration"])
                self.assertEqual(record.host.name, self.update_data["host"])
                self.assertEqual(record.participants[0].name, self.update_data["participants"][0])
コード例 #13
0
    def test_podcast_create_object(self):
        test = Podcast(
            name="Test",
            duration=3600,
            host="Tester",
            participants=["One", "Two"]
        )

        self.assertEqual("Test", test.name)
        self.assertEqual(3600, test.duration)
        self.assertIsInstance(test.host, Host)
        self.assertEqual("Tester", test.host.name)
        self.assertIsInstance(test.participants, list)
        self.assertEqual(2, len(test.participants))
        self.assertIsInstance(test.participants[0], Participant)
        self.assertEqual("One", test.participants[0].name)
コード例 #14
0
    def test_get_podcast_by_id_or_name(self):
        # Check a record exists in the db
        podcast = Podcast(**self.data)
        podcast.save_to_db()

        podcast_byname = Podcast.find_by_name(self.data["name"])
        self.assertIsNotNone(podcast_byname)

        id = podcast_byname.id
        
        # Check find_by_id method
        podcast_byid = Podcast.find_by_id(id)
        self.assertIsNotNone(podcast_byid)
        self.assertEqual(podcast_byid.name, podcast_byname.name)
        self.assertEqual(podcast_byid.uploaded_time, podcast_byname.uploaded_time)
コード例 #15
0
    def test_create_podcast(self):

        podcast = Podcast(**self.data)

        # Check there is no exisiting podcast named "Test Podcast"
        self.assertIsNone(Podcast.find_by_name(podcast.name))

        # Save podcast to database
        podcast.save_to_db()

        # Check podcast exists
        record = Podcast.find_by_name(podcast.name)
        self.assertIsNotNone(record)
        self.assertIsNotNone(record.id)
        self.assertIsNotNone(record.uploaded_time)
        self.assertEqual(record.name, podcast.name)
        self.assertEqual(record.duration, podcast.duration)

        # check host name and type
        self.assertIsInstance(record.host, Host)
        self.assertEqual(record.host.name, "Robert")
        self.assertEqual(len(record.participants), 3)
        self.assertIsInstance(record.participants[0], Participant)
コード例 #16
0
 def test_podcast_create_object_with_str_duration_error(self):
     with self.assertRaises(TypeError) as e:
         test = Podcast("name", "12", host="tester", participants=["ab"])
         self.assertIn(b"A required field does not have the correct type", str(e))
コード例 #17
0
 def test_podcast_create_object_without_host_error(self):
     with self.assertRaises(TypeError) as e:
         test = Podcast("name", 12, participants=["ab"])
         self.assertIn(b"__init__() missing 1 required positional argument: 'host'", str(e))
コード例 #18
0
 def test_podcast_create_object_with_11_participants_error(self):
     with self.assertRaises(ValidationError) as e:
         test = Podcast("name", 12, host="ss", \
             participants=["ab", "cd", "ef", "a", "c", "b", "w", "wx", "xxx", "xcv", "xc"])
         self.assertIn(b"Podcast cannot have more than 10 participants", str(e))