feat: merge branch 'feature/scenario' into 'main'

# Test scenario

The goal of this scenario is to showcase the usage of Movie Recommender Application.

# Usage

* show_movie_ratings 

* rate_random_movie  

* recommend_movie 

# Setup

First, you need to have Python 3 installed. (It is advised to have a virtual environment set up)

**Step 1:** Clone the repository

run ```pip install -r requirements.txt```

After this setup is done, you can run locust using

locust --headless --users 10 --spawn-rate 1

 No newline at end of file

from locust import HttpUser, task, between

import json

import random

from movie_service import MovieService

from rating_service import RatingService

from movie_recommender_service import MovieRecommenderService

class MovieRecommenderShowcase(HttpUser):

    tasks = []

    host = "http://localhost:8080"

    wait_time = between(1, 3)

    def __init__(self, *args, **kwargs):

        self.movie_service = MovieService(*args, **kwargs)

        self.rating_service = RatingService(*args, **kwargs)

        self.movie_recommender_service = MovieRecommenderService(*args, **kwargs)

        self.movie_service.seed_database()

        super().__init__(*args, **kwargs)

    def __del__(self):

        self.movie_service.clean_database()

        self.movie_service.client.close()

        self.rating_service.client.close()

        self.movie_recommender_service.client.close()

    @task

    def pick_movie_show_details(self):

        # Get all movies

        movies_response = self.movie_service.get_all_movies()

        if movies_response.status_code != 200:

            print(movies_response.text)

            return

        all_movies = json.loads(movies_response.content)

        # Get a random movie

        random_movie = random.choice(all_movies)

        # Show movie details

        movie_response = self.movie_service.get_movie_details(random_movie["id"])

        if movie_response.status_code != 200:

            print(movie_response.text)

            return

    @task

    def rate_random_movie(self):

        # Get all movies

        movies_response = self.movie_service.get_all_movies()

        if movies_response.status_code != 200:

            print(movies_response.text)

            return

        all_movies = json.loads(movies_response.content)

        # Get a random movie

        random_movie = random.choice(all_movies)

        # Rate the movie

        rating = {

            "movieId": random_movie["id"],

            "score": random.randint(1, 10),

            "review": "Great movie!",

            "userId": random_movie["id"],

        }

        self.rating_service.rate_movie(random_movie["id"], rating)

    @task

    def recommend_movie(self):

        # Get all movies

        movies_response = self.movie_service.get_all_movies()

        if movies_response.status_code != 200:

            print(movies_response.text)

            return

        all_movies = json.loads(movies_response.content)

        # Get a random movie

        random_movie = random.choice(all_movies)

        # Recommend a movie

        self.movie_recommender_service.recommend_movie(random_movie["id"])

from locust import HttpUser

class MovieRecommenderService(HttpUser):

    host = "http://localhost:8000/api/v1"

    abstract = True

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

    def recommend_movie(self, movie_id):

        response = self.client.get(f"{self.host}/recommend/{movie_id}")

        if response.status_code == 200:

            return response

        print(response.text)

from locust import HttpUser

class MovieService(HttpUser):

    host = "http://localhost:8001/api/v1"

    abstract = True

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

    def get_all_movies(self):

        response = self.client.get(f"{self.host}/movies")

        return response

    def get_movie_details(self, movie_id):

        response = self.client.get(f"{self.host}/movies/{movie_id}")

        return response

    def create_movie(self, movie):

        response = self.client.post(f"{self.host}/movies", json=movie)

        return response

    def update_movie(self, movie_id, movie):

        response = self.client.put(f"{self.host}/{movie_id}", json=movie)

        return response

    def delete_movie(self, movie_id):

        response = self.client.delete(f"{self.host}/{movie_id}")

        return response

    def seed_database(self):

        response = self.client.post(f"{self.host}/movies/production/seed")

        return response

    def clean_database(self):

        response = self.client.post(f"{self.host}/movies/production/clean")

        return response

from locust import HttpUser

class RatingService(HttpUser):

    host = "http://localhost:8002/api/v1"

    abstract = True

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

    def get_ratings_for_movie(self, movie_id):

        response = self.client.get(f"{self.host}/ratings/{movie_id}")

        if response.status_code == 200:

            return response

        print(response.text)

    def rate_movie(self, movie_id, rating):

        response = self.client.post(f"{self.host}/ratings", json=rating)

        if response.status_code == 200:

            return response

        print(response.text)