diff --git a/tests/test_wave_01.py b/tests/test_wave_01.py
index 6be6994a5..e0a537115 100644
--- a/tests/test_wave_01.py
+++ b/tests/test_wave_01.py
@@ -4,7 +4,7 @@
 from viewing_party.party import *
 from tests.test_constants import *
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_create_successful_movie():
     # Arrange
     movie_title = MOVIE_TITLE_1
@@ -18,8 +18,8 @@ def test_create_successful_movie():
     assert new_movie["title"] == MOVIE_TITLE_1
     assert new_movie["genre"] == GENRE_1
     assert new_movie["rating"] == pytest.approx(RATING_1)
-
-@pytest.mark.skip()
+#this test to see if our create movie function will return true if 
+# @pytest.mark.skip()
 def test_create_no_title_movie():
     # Arrange
     movie_title = None
@@ -32,7 +32,7 @@ def test_create_no_title_movie():
     # Assert
     assert new_movie is None
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_create_no_genre_movie():
     # Arrange
     movie_title = "Title A"
@@ -45,7 +45,7 @@ def test_create_no_genre_movie():
     # Assert
     assert new_movie is None
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_create_no_rating_movie():
     # Arrange
     movie_title = "Title A"
@@ -58,7 +58,7 @@ def test_create_no_rating_movie():
     # Assert
     assert new_movie is None
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_adds_movie_to_user_watched():
     # Arrange
     movie = {
@@ -79,7 +79,7 @@ def test_adds_movie_to_user_watched():
     assert updated_data["watched"][0]["genre"] == GENRE_1
     assert updated_data["watched"][0]["rating"] == RATING_1
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_adds_movie_to_user_watchlist():
     # Arrange
     movie = {
@@ -100,7 +100,7 @@ def test_adds_movie_to_user_watchlist():
     assert updated_data["watchlist"][0]["genre"] == GENRE_1
     assert updated_data["watchlist"][0]["rating"] == RATING_1
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_moves_movie_from_watchlist_to_empty_watched():
     # Arrange
     janes_data = {
@@ -119,12 +119,19 @@ def test_moves_movie_from_watchlist_to_empty_watched():
     assert len(updated_data["watchlist"]) == 0
     assert len(updated_data["watched"]) == 1
     
-    raise Exception("Test needs to be completed.")
+    # raise Exception("Test needs to be completed.")
     # *******************************************************************************************
     # ****** Add assertions here to test that the correct movie was added to "watched" **********
     # *******************************************************************************************
+    assert updated_data["watched"][0]["title"] == MOVIE_TITLE_1
+    assert updated_data["watched"][0] == {
+            "title": MOVIE_TITLE_1,
+            "genre": GENRE_1,
+            "rating": RATING_1 }
+    
 
-@pytest.mark.skip()
+    
+# @pytest.mark.skip()
 def test_moves_movie_from_watchlist_to_watched():
     # Arrange
     movie_to_watch = HORROR_1
@@ -143,12 +150,15 @@ def test_moves_movie_from_watchlist_to_watched():
     assert len(updated_data["watchlist"]) == 1
     assert len(updated_data["watched"]) == 2
     
-    raise Exception("Test needs to be completed.")
+    # raise Exception("Test needs to be completed.")
     # *******************************************************************************************
     # ****** Add assertions here to test that the correct movie was added to "watched" **********
     # *******************************************************************************************
-
-@pytest.mark.skip()
+   
+    
+    assert updated_data["watched"][0]["title"] == "The Lord of the Functions: The Two Parameters"
+    assert updated_data["watched"][1]["title"] == "It Came from the Stack Trace"
+# @pytest.mark.skip()
 def test_does_nothing_if_movie_not_in_watchlist():
     # Arrange
     movie_to_watch = HORROR_1
diff --git a/tests/test_wave_02.py b/tests/test_wave_02.py
index 3a588299e..9610db07a 100644
--- a/tests/test_wave_02.py
+++ b/tests/test_wave_02.py
@@ -2,19 +2,20 @@
 from viewing_party.party import *
 from tests.test_constants import *
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_calculates_watched_average_rating():
     # Arrange
     janes_data = clean_wave_2_data()
 
     # Act
     average = get_watched_avg_rating(janes_data)
+    print(average)
 
     # Assert
     assert average == pytest.approx(3.58333)
     assert janes_data == clean_wave_2_data()
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_empty_watched_average_rating_is_zero():
     # Arrange
     janes_data = {
@@ -27,7 +28,7 @@ def test_empty_watched_average_rating_is_zero():
     # Assert
     assert average == pytest.approx(0.0)
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_most_watched_genre():
     # Arrange
     janes_data = clean_wave_2_data()
@@ -39,7 +40,7 @@ def test_most_watched_genre():
     assert popular_genre == "Fantasy"
     assert janes_data == clean_wave_2_data()
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_genre_is_None_if_empty_watched():
     # Arrange
     janes_data = {
@@ -51,3 +52,5 @@ def test_genre_is_None_if_empty_watched():
 
     # Assert
     assert popular_genre == None
+
+
diff --git a/tests/test_wave_03.py b/tests/test_wave_03.py
index 046429360..538ecf24e 100644
--- a/tests/test_wave_03.py
+++ b/tests/test_wave_03.py
@@ -2,21 +2,26 @@
 from viewing_party.party import *
 from tests.test_constants import *
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_my_unique_movies():
     # Arrange
     amandas_data = clean_wave_3_data()
+    print(amandas_data)
 
     # Act
     amandas_unique_movies = get_unique_watched(amandas_data)
+    
 
     # Assert
     assert len(amandas_unique_movies) == 2
     assert FANTASY_2 in amandas_unique_movies
     assert INTRIGUE_2 in amandas_unique_movies
     assert amandas_data == clean_wave_3_data()
-
-@pytest.mark.skip()
+    
+    
+    
+    
+# @pytest.mark.skip()
 def test_my_not_unique_movies():
     # Arrange
     amandas_data = clean_wave_3_data()
@@ -28,22 +33,24 @@ def test_my_not_unique_movies():
     # Assert
     assert len(amandas_unique_movies) == 0
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_friends_unique_movies():
     # Arrange
     amandas_data = clean_wave_3_data()
 
     # Act
     friends_unique_movies = get_friends_unique_watched(amandas_data)
-
+    
     # Assert
     assert len(friends_unique_movies) == 3
     assert INTRIGUE_3 in friends_unique_movies
     assert HORROR_1 in friends_unique_movies
     assert FANTASY_4 in friends_unique_movies
+    # print(friends_unique_movies)
     assert amandas_data == clean_wave_3_data()
+    
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_friends_unique_movies_not_duplicated():
     # Arrange
     amandas_data = clean_wave_3_data()
@@ -51,16 +58,17 @@ def test_friends_unique_movies_not_duplicated():
 
     # Act
     friends_unique_movies = get_friends_unique_watched(amandas_data)
-
+    print(amandas_data)
     # Assert
     assert len(friends_unique_movies) == 3
 
-    raise Exception("Test needs to be completed.")
+    # raise Exception("Test needs to be completed.")
     # *************************************************************************************************
     # ****** Add assertions here to test that the correct movies are in friends_unique_movies **********
     # **************************************************************************************************
-
-@pytest.mark.skip()
+    assert INTRIGUE_3 in friends_unique_movies
+    
+# @pytest.mark.skip()
 def test_friends_not_unique_movies():
     # Arrange
     amandas_data = {
diff --git a/tests/test_wave_04.py b/tests/test_wave_04.py
index 499669077..1252f3665 100644
--- a/tests/test_wave_04.py
+++ b/tests/test_wave_04.py
@@ -2,10 +2,11 @@
 from viewing_party.party import *
 from tests.test_constants import *
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_get_available_friend_rec():
     # Arrange
     amandas_data = clean_wave_4_data()
+    print(amandas_data)
 
     # Act
     recommendations = get_available_recs(amandas_data)
@@ -16,7 +17,7 @@ def test_get_available_friend_rec():
     assert FANTASY_4b in recommendations
     assert amandas_data == clean_wave_4_data()
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_no_available_friend_recs():
     # Arrange
     amandas_data = {
@@ -38,7 +39,7 @@ def test_no_available_friend_recs():
     # Assert
     assert len(recommendations) == 0
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_no_available_friend_recs_watched_all():
     # Arrange
     amandas_data = {
diff --git a/tests/test_wave_05.py b/tests/test_wave_05.py
index 85ebb8b18..10bbde827 100644
--- a/tests/test_wave_05.py
+++ b/tests/test_wave_05.py
@@ -2,7 +2,7 @@
 from viewing_party.party import *
 from tests.test_constants import *
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_new_genre_rec():
     # Arrange
     sonyas_data = clean_wave_5_data()
@@ -17,7 +17,7 @@ def test_new_genre_rec():
     assert FANTASY_4b in recommendations
     assert sonyas_data == clean_wave_5_data()
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_new_genre_rec_from_empty_watched():
     # Arrange
     sonyas_data = {
@@ -38,7 +38,8 @@ def test_new_genre_rec_from_empty_watched():
     # Assert
     assert len(recommendations) == 0
 
-@pytest.mark.skip()
+
+# @pytest.mark.skip()
 def test_new_genre_rec_from_empty_friends():
     # Arrange
     sonyas_data = {
@@ -53,12 +54,18 @@ def test_new_genre_rec_from_empty_friends():
         ]
     }
 
-    raise Exception("Test needs to be completed.")
+    # raise Exception("Test needs to be completed.")
     # *********************************************************************
     # ****** Complete the Act and Assert Portions of theis tests **********
     # *********************************************************************
+    recommendations = get_new_rec_by_genre(sonyas_data)
+
+    assert len(recommendations) == 0
+
+
+
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_unique_rec_from_favorites():
     # Arrange
     sonyas_data = clean_wave_5_data()
@@ -72,7 +79,7 @@ def test_unique_rec_from_favorites():
     assert INTRIGUE_2b in recommendations
     assert sonyas_data == clean_wave_5_data()
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_unique_from_empty_favorites():
     # Arrange
     sonyas_data = {
@@ -94,7 +101,7 @@ def test_unique_from_empty_favorites():
     # Assert
     assert len(recommendations) == 0
 
-@pytest.mark.skip()
+# @pytest.mark.skip()
 def test_new_rec_from_empty_friends():
     # Arrange
     sonyas_data = {
diff --git a/viewing_party/party.py b/viewing_party/party.py
index 6d34a6b5f..e85dc54cf 100644
--- a/viewing_party/party.py
+++ b/viewing_party/party.py
@@ -1,23 +1,206 @@
 # ------------- WAVE 1 --------------------
 
+
 def create_movie(title, genre, rating):
-    pass
+
+   
+    movie = {
+        "title":title,
+        "genre":genre,
+        "rating":rating
+    }
+    #returns none if title or movie or rating is falsy
+    if title == None or genre == None or rating == None:
+        return None 
+    
+    else: 
+        return movie
+
+
+
+
+
+
+def add_to_watched(user_data, movie):
+    #user data is dictionary w/ key "watched"
+    
+    user_data = {
+        "watched": [movie]
+    }
+
+    
+    return user_data
+
+def add_to_watchlist(user_data, movie):
+    #user_data {"watchlist": list of dictionaries representing the movies the user wants to watch}
+ 
+    user_data = {"watchlist":[movie]}
+
+    return user_data
+
+
+
+
+def watch_movie(user_data, title):
+               
+   
+    for movie_title in user_data["watchlist"]:
+        if title == movie_title["title"]:
+            user_data["watchlist"].remove(movie_title)
+            user_data["watched"].append(movie_title)
+    return user_data
+    
+
 
 # -----------------------------------------
 # ------------- WAVE 2 --------------------
 # -----------------------------------------
+def get_watched_avg_rating(user_data):
+#   
+#     #find average rating by accessing the "ratings" key from "watched" list from user_data dictionary
+#user_data = {'watched': [{'genre': 'Fantasy', 'rating': 4.8, 'title': 'The Lord of the Functions: The Fellowship of the Function'}... 'rating': 2.0, 'title': 'Recursion'}, {'genre': 'Intrigue', 'rating': 4.5, 'title': 'Instructor Student TA Manager'}]}
 
+    rating_list = []
+   
 
-# -----------------------------------------
-# ------------- WAVE 3 --------------------
-# -----------------------------------------
+    for movie in user_data["watched"]:
+    
+        rating_list.append(movie["rating"])
+    if len(user_data["watched"]) == 0:
+        return 0.0
+        
+    else:
+        return sum(rating_list)/len(rating_list)
+    
+   
+
+    
+def get_most_watched_genre(user_data):
+    #determine the most frequently occuring genre in user's watched list
+   
+
+    genre_list = []
+
+    if len(user_data["watched"]) == 0:
+        return None
 
+    else:
+        for watch_list  in user_data["watched"]:
+            genre_list.append(watch_list["genre"])
+
+    return max(set(genre_list), key =genre_list.count)
+
+
+
+# # -----------------------------------------
+# # ------------- WAVE 3 --------------------
+# # -----------------------------------------
+def get_unique_watched(user_data):
+    
+# initiated two emtpy list: user and friends
+#we have an outer dictionary, one with "watched" key and one with "friends " key
+# {'watched': [{'title': 'The Lord of the Functions: The Fellowship of the Function', 'genre': 'Fantasy', 'rating': 4.8}, {'title': 'The Lord of the Functions: The Two Parameters', 'genre': 'Fantasy', 'rating': 4.0}, {'title': 'The Lord of the Functions: The Return of the Value', 'genre': 'Fantasy', 'rating': 4.0}, {'title': 'The JavaScript and the React', 'genre': 'Action', 'rating': 2.2}, {'title': 'Recursion', 'genre': 'Intrigue', 'rating': 2.0}, {'title': 'Instructor Student TA Manager', 'genre': 'Intrigue', 'rating': 4.5}],
+# 'friends': [{'watched': [{'title': 'The Lord of the Functions: The Fellowship of the Function', 'genre': 'Fantasy', 'rating': 4.8}, {'title': 'The Lord of the Functions: The Return of the Value', 'genre': 'Fantasy', 'rating': 4.0}, {'title': 'The Programmer: An Unexpected Stack Trace', 'genre': 'Fantasy', 'rating': 4.0}, {'title': 'It Came from the Stack Trace', 'genre': 'Horror', 'rating': 3.5}]}, {'watched': [{'title': 'The Lord of the Functions: The Fellowship of the Function', 'genre': 'Fantasy', 'rating': 4.8}, {'title': 'The JavaScript and the React', 'genre': 'Action', 'rating': 2.2}, {'title': 'Recursion', 'genre': 'Intrigue', 'rating': 2.0}, {'title': 'Zero Dark Python', 'genre': 'Intrigue', 'rating': 3.0}]}]
+#They want to see the what the user saw that none of their friends saw, and return list of movies 
+ 
+    friends_watched_titles = []
+    for friend in user_data["friends"]:
+        for movie in friend["watched"]:
+            if movie["title"] not in friends_watched_titles:
+                friends_watched_titles.append(movie["title"])
+                
+    
         
-# -----------------------------------------
-# ------------- WAVE 4 --------------------
-# -----------------------------------------
+    unique_movies = []
+    for user_watched_movie in user_data["watched"]:
+        if user_watched_movie["title"] not in friends_watched_titles:
+            unique_movies.append(user_watched_movie)
+    return unique_movies
+    
+    
+def get_friends_unique_watched(user_data):
+#get only one of the friend's movie watched list, compare it to the users to see what the friend has saw the user hasn't
+
+
+    user_list =[]
+    friend_unique_movies = []
+    friend_unique_no_duplicate = []
+
+    for movie in user_data["watched"]:
+        user_list.append(movie)
+    for friend in user_data["friends"]:
+        for movie in friend["watched"]:
+            if movie not in user_list:
+                friend_unique_movies.append(movie)
+    #removing duplicates
+    friend_unique_no_duplicate = [i for n, i in enumerate(friend_unique_movies)
+            if i not in friend_unique_movies[n + 1:]]
+    return friend_unique_no_duplicate
+
+    
+
+
+        
+# # -----------------------------------------
+# # ------------- WAVE 4 --------------------
+# # -----------------------------------------
+def get_available_recs(user_data):
+# # # {'watched': [{'title': 'The Lord of the Functions: The Fellowship of the Function', 'genre': 'Fantasy', 'rating': 4.8, 'host': 'netflix'}
+# # # 'subscriptions': ['netflix', 'hulu']}
+# # #return a list with what the user has not wached that would be in the friends list, that the user has a subscription for
+
+
+    recommended_movies = []
+    
+    for friend in user_data["friends"]:
+        for movie in friend["watched"]:
+            if movie["host"] in user_data["subscriptions"] and movie not in user_data["watched"]:
+                recommended_movies.append(movie)
+    return recommended_movies
+
+
+   
+
+
+
+
+
+# # # -----------------------------------------
+# # # ------------- WAVE 5 --------------------
+# # # -----------------------------------------
+def get_new_rec_by_genre(user_data):
+# we have to make a list of recommended movies from the friend's unique watched list IF it is in the most frequently watched genre
+
+    recommended_movies = []
+    most_watched_genre = get_most_watched_genre(user_data)
+    
+    
+    for friend in user_data["friends"]:
+        for movie in friend["watched"]:
+            if movie["genre"] == most_watched_genre and movie not in user_data["watched"]:
+                recommended_movies.append(movie)
+    return recommended_movies
+
+
+               
+
+
+
+def get_rec_from_favorites(user_data):
+# make a list of recommendations from user's favorite 
+
+    recommendations =[]
+    user_watched_movies = get_unique_watched(user_data)
+    
+    for movie in user_data["favorites"]:
+        if movie in user_watched_movies:
+            recommendations.append(movie)
+    return recommendations
+    
+
+
+
+
 
-# -----------------------------------------
-# ------------- WAVE 5 --------------------
-# -----------------------------------------
 
+