[test] review related models and schema (#471)

## Why?
* Tests for product_review and review schema and model were not present.

## This change addresses the need by:
* Adding tests for product_review and review(schema).
* Refactoring the product_review and review(model tests).

[delivers #163622129]

Author: Jeshan7

apps/snitch_core/test/data/model/product_review_test.exs

@@ -55,6 +55,20 @@ defmodule Snitch.Data.Model.ProductReviewTest do
     assert result.review_count == 2
   end
 
+  @tag rating_option_count: 2
+  describe "fetch_rating_option/1" do
+    test "return a valid rating_option", context do
+      %{rating_options: rating_options} = context
+      [rating_option_1 | rating_option_2] = rating_options
+      {:ok, returned_rating_option} = ProductReview.fetch_rating_option(rating_option_1.id)
+      assert returned_rating_option.id == rating_option_1.id
+    end
+
+    test "fails for invalid id" do
+      assert {:error, :rating_option_not_found} = ProductReview.fetch_rating_option(-1)
+    end
+  end
+
   defp product_review_params(product, user, rating_option) do
     %{
       attributes: %{

apps/snitch_core/test/data/model/review_test.exs

@@ -5,58 +5,60 @@ defmodule Snitch.Data.Model.ReviewTest do
   import Snitch.Factory
   alias Snitch.Data.Model.{Review, ProductReview}
 
-  setup do
-    product = insert(:product)
-    [product: product]
+  setup :rating_options
+  setup :review_params
+
+  describe "update/2" do
+    test "updates a review successfully", %{
+      review: review,
+      rating_option_vote: rating_option_vote
+    } do
+      update_params = %{
+        description: "new description",
+        rating_option_vote: rating_option_vote
+      }
+
+      {:ok, updated_review} = Review.update(update_params, review)
+      assert updated_review.id == review.id
+      assert updated_review.description != review.description
+    end
+
+    test "fails for invalid params", %{review: review} do
+      update_params = %{description: ""}
+
+      {:error, updated_review} = Review.update(update_params, review)
+      assert %{description: ["can't be blank"]} == errors_on(updated_review)
+    end
   end
 
-  setup :rating_options
+  describe "delete/1" do
+    test "successful for valid id", %{review: review} do
+      assert {:ok, _} = Review.delete(review.id)
+      assert Review.get(review.id) == {:error, :review_not_found}
+    end
 
-  @tag rating_option_count: 2
-  test "update a review successfully", context do
-    %{product: product} = context
-    user = insert(:user)
-    %{rating_options: rating_options} = context
-    [rating_option_1 | [rating_option_2 | _]] = rating_options
-    review_params = product_review_params(product, user, rating_option_1)
-    assert {:ok, review} = ProductReview.add(review_params)
-
-    update_params = %{
-      description: "new description",
-      rating_option_vote: %{rating_option: rating_option_2}
-    }
-
-    assert {:ok, updated_review} = Review.update(update_params, review)
-    assert updated_review.id == review.id
-    assert updated_review.description != review.description
+    test "fails for invalid id" do
+      {:error, :review_not_found} = Review.get(-1)
+    end
   end
 
-  @tag rating_option_count: 1
-  test "delete a product review", context do
-    %{product: product} = context
-    user = insert(:user)
-    %{rating_options: rating_options} = context
-    rating_option = List.first(rating_options)
-    review_params = product_review_params(product, user, rating_option)
-    assert {:ok, review} = ProductReview.add(review_params)
-    product_before_delete = Repo.preload(product, :reviews)
-    assert length(product_before_delete.reviews) != 0
-    assert {:ok, _} = Review.delete(review.id)
-    product_after_delete = Repo.preload(product, :reviews)
-    assert product_after_delete.reviews == []
+  describe "get/1" do
+    test "returns a review", %{review: review} do
+      {:ok, new_review} = Review.get(review.id)
+      assert new_review.id == review.id
+    end
+
+    test "fails for invalid id" do
+      {:error, :review_not_found} = Review.get(-1)
+    end
   end
 
-  defp product_review_params(product, user, rating_option) do
-    %{
-      attributes: %{
-        description: "awesomeness redefined",
-        user_id: user.id,
-        name: "stark"
-      },
-      rating_option_vote: %{
-        rating_option: rating_option
-      },
-      product_id: product.id
-    }
+  defp review_params(context) do
+    %{rating_options: rating_options} = context
+    [rating_option_1, rating_option_2] = rating_options
+
+    review = insert(:review, rating_option_vote: %{rating_option: rating_option_1})
+    rating_option_vote = %{rating_option: rating_option_2}
+    %{review: review, rating_option_vote: rating_option_vote}
   end
 end

apps/snitch_core/test/data/schema/review/product_review_test.exs

@@ -0,0 +1,70 @@
+defmodule Snitch.Data.Schema.ProductReviewTest do
+  use ExUnit.Case
+  use Snitch.DataCase
+
+  import Snitch.Factory
+
+  alias Snitch.Data.Schema.ProductReview
+
+  setup do
+    product_review = insert(:product_review)
+    [product_review: product_review]
+  end
+
+  describe "create_changeset/2" do
+    test "returns a valid changeset", %{product_review: product_review} do
+      params = Map.from_struct(product_review)
+      changeset = ProductReview.create_changeset(%ProductReview{}, params)
+      assert changeset.valid?
+    end
+
+    test "fails for invalid params" do
+      changeset = ProductReview.create_changeset(%ProductReview{}, %{})
+
+      assert %{product_id: ["can't be blank"], review_id: ["can't be blank"]} ==
+               errors_on(changeset)
+    end
+
+    test "fails for non-existent product_id and review_id", %{product_review: product_review} do
+      product_review_1 = %{product_review | product_id: -1}
+      params = Map.from_struct(product_review_1)
+      cs = ProductReview.create_changeset(%ProductReview{}, params)
+      {:error, changeset} = Repo.insert(cs)
+      assert %{product_id: ["does not exist"]} == errors_on(changeset)
+
+      product_review = %{product_review | product_id: product_review.product_id, review_id: -1}
+      params = Map.from_struct(product_review)
+      cs = ProductReview.create_changeset(%ProductReview{}, params)
+      {:error, changeset} = Repo.insert(cs)
+      assert %{review_id: ["does not exist"]} == errors_on(changeset)
+    end
+  end
+
+  describe "update_changeset/2" do
+    test "returns a valid changeset", %{product_review: product_review} do
+      params = %{review_id: 20}
+      cs = ProductReview.update_changeset(product_review, params)
+      assert cs.valid?
+    end
+
+    test "fails for invalid params", %{product_review: product_review} do
+      params = %{review_id: nil, product_id: nil}
+      changeset = ProductReview.update_changeset(product_review, params)
+
+      assert %{product_id: ["can't be blank"], review_id: ["can't be blank"]} ==
+               errors_on(changeset)
+    end
+
+    test "fails for non existent review_id and product_id", %{product_review: product_review} do
+      params = %{product_id: -1}
+      cs = ProductReview.update_changeset(product_review, params)
+      {:error, changeset} = Repo.update(cs)
+      assert %{product_id: ["does not exist"]} == errors_on(changeset)
+
+      params = %{review_id: -1}
+      cs = ProductReview.update_changeset(product_review, params)
+      {:error, changeset} = Repo.update(cs)
+      assert %{review_id: ["does not exist"]} == errors_on(changeset)
+    end
+  end
+end

apps/snitch_core/test/data/schema/review/review_test.exs

@@ -0,0 +1,64 @@
+defmodule Snitch.Data.Schema.ReviewTest do
+  use ExUnit.Case, async: true
+  use Snitch.DataCase
+
+  import Snitch.Factory
+
+  alias Snitch.Data.Schema.Review
+
+  setup :review_params
+
+  describe "create_changeset/2" do
+    test "returns a valid changeset", %{params: params} do
+      changeset = Review.create_changeset(%Review{}, params)
+      assert changeset.valid?
+    end
+
+    test "returns invalid changeset" do
+      changeset = Review.create_changeset(%Review{}, %{})
+
+      assert %{
+               rating_option_vote: ["can't be blank"],
+               description: ["can't be blank"],
+               user_id: ["can't be blank"],
+               name: ["can't be blank"]
+             } == errors_on(changeset)
+    end
+
+    test "fails for non-existent user_id", %{params: params} do
+      params = %{params | user_id: -1}
+      cs = Review.create_changeset(%Review{}, params)
+      {:error, changeset} = Repo.insert(cs)
+      assert %{user_id: ["does not exist"]} == errors_on(changeset)
+    end
+  end
+
+  describe "update_changeset/2" do
+    test "returns a valid changeset", %{review: review} do
+      params = %{description: "hakuna matata"}
+      cs = Review.update_changeset(review, params)
+      assert cs.valid?
+    end
+
+    test "fails for invalid params", %{review: review} do
+      params = %{description: ""}
+      cs = Review.update_changeset(review, params)
+      assert %{description: ["can't be blank"]} == errors_on(cs)
+    end
+  end
+
+  defp review_params(context) do
+    review = insert(:review)
+    rating_option_vote = review.rating_option_vote
+    rating_option_vote = Map.from_struct(rating_option_vote)
+
+    params = %{
+      description: "awesomeness redefined",
+      name: "stark",
+      user_id: review.user_id,
+      rating_option_vote: rating_option_vote
+    }
+
+    [params: params, review: review]
+  end
+end

apps/snitch_core/test/support/factory/rating.ex

@@ -3,7 +3,7 @@ defmodule Snitch.Factory.Rating do
 
   defmacro __using__(_opts) do
     quote do
-      alias Snitch.Data.Schema.{Rating, RatingOption}
+      alias Snitch.Data.Schema.{Rating, RatingOption, Review, ProductReview}
 
       def rating_factory do
         %Rating{
@@ -21,10 +21,40 @@ defmodule Snitch.Factory.Rating do
         }
       end
 
+      def review_factory do
+        user = insert(:user)
+
+        %Review{
+          description: "awesomeness redefined",
+          user_id: user.id,
+          name: "stark",
+          rating_option_vote: %{
+            rating_option: build(:rating_option)
+          }
+        }
+      end
+
+      def product_review_factory do
+        %ProductReview{
+          review: build(:review),
+          product: build(:product)
+        }
+      end
+
       def rating_options(context) do
         rating = insert(:rating)
         count = Map.get(context, :rating_option_count, 2)
-        [rating_options: insert_list(3, :rating_option, rating: rating)]
+        [rating_options: insert_list(count, :rating_option, rating: rating)]
+      end
+
+      def reviews(context) do
+        rating_option = insert(:rating_option)
+        count = Map.get(context, :review_count, 1)
+
+        [
+          reviews:
+            insert_list(count, :review, rating_option_vote: %{rating_option: rating_option})
+        ]
       end
     end
   end