RatingTest::users_can_rate_a_post() - Code Metrics - canylmz/laravel-rating - Measure and Improve Code Quality continuously with Scrutinizer

RatingTest::users_can_rate_a_post() A
last analyzed 2019-10-19 22:55 UTC

↳ Parent: RatingTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	7
nc	1
nop	0
dl	0
loc	11
rs	10
c	0
b	0
f	0

<?php

namespace Canylmz\Rating\Test;

use BadMethodCallException;
use Canylmz\Rating\Test\Models\Post;
use Canylmz\Rating\Test\Models\User;
use Canylmz\Rating\Test\Models\Member;
use Canylmz\Rating\Exceptions\ModelNotRateable;
use Canylmz\Rating\Exceptions\RatingAlreadyExists;

class RatingTest extends TestCase
{
    /**
     * Information about the tests
     * - Users can rate posts, but not other users
     * - Posts can be rated
     * - Members can rate other members.
     */
    public function setUp(): void
    {
        parent::setUp();
    }

    /**
     * @test
     */
    public function user_can_rate_a_post()
    {
        $user = factory(User::class)->create();
        $post = factory(Post::class)->create();

        $this->assertTrue($user->rate($post, 10.00));
        $this->assertTrue($user->hasRated($post));
    }

    /**
     * @test
     */
    public function users_can_rate_a_post()
    {
        $user1 = factory(User::class)->create();
        $user2 = factory(User::class)->create();
        $post = factory(Post::class)->create();

        $this->assertTrue($user1->rate($post, 10.00));
        $this->assertTrue($user1->hasRated($post));

        $this->assertTrue($user2->rate($post, 10.00));
        $this->assertTrue($user2->hasRated($post));
    }

    /**
     * @test
     */
    public function users_can_rerate_a_post()
    {
        $user = factory(User::class)->create();
        $post = factory(Post::class)->create();

        $this->assertTrue($user->rate($post, 10.00));
        $this->assertTrue($user->hasRated($post));
        $this->assertEquals(10, $post->averageRating(User::class));

        $this->assertTrue($user->rate($post, 9.00));
        $this->assertTrue($user->hasRated($post));
        $this->assertEquals(9, $post->averageRating(User::class));
    }

    /**
     * @test
     */
    public function users_can_not_rerate_a_post()
    {
        $user = factory(User::class)->create();
        $post = factory(Post::class)->create();

        $this->assertTrue($user->rate($post, 10.00, false));
        $this->assertTrue($user->hasRated($post));
        $this->assertEquals(10, $post->averageRating(User::class));

        $this->expectException(RatingAlreadyExists::class);
        $user->rate($post, 9.00, false);
        $this->assertTrue($user->hasRated($post));
        $this->assertEquals(10, $post->averageRating(User::class));
    }

    /**
     * @test
     */
    public function it_can_count_ratings()
    {
        $user1 = factory(User::class)->create();
        $user2 = factory(User::class)->create();
        $user3 = factory(User::class)->create();
        $post = factory(Post::class)->create();

        $user1->rate($post, 10.00);
        $this->assertEquals(1, $post->countRatings(User::class));

        $user2->rate($post, 10.00);
        $this->assertEquals(2, $post->countRatings(User::class));

        $user3->rate($post, 10.00);
        $this->assertEquals(3, $post->countRatings(User::class));
    }

    /**
     * @test
     */
    public function no_rating_returns_count_of_zero()
    {
        $post = factory(Post::class)->create();

        $this->assertEquals(0, $post->countRatings(User::class));
    }

    /**
     * @test
     */
    public function it_can_calculate_the_average_rating()
    {
        $user1 = factory(User::class)->create();
        $user2 = factory(User::class)->create();
        $user3 = factory(User::class)->create();
        $post = factory(Post::class)->create();

        $user1->rate($post, 8.00);
        $this->assertEquals(8.00, $post->averageRating(User::class));

        $user2->rate($post, 10.00);
        $this->assertEquals(9.00, $post->averageRating(User::class));

        $user3->rate($post, 7.50);
        $this->assertEquals(8.5, $post->averageRating(User::class));
    }

    /**
     * @test
     */
    public function no_rating_returns_average_of_zero()
    {
        $post = factory(Post::class)->create();

        $this->assertEquals(0.00, $post->averageRating(User::class));
    }

    /**
     * @test
     */
    public function user_can_unrate_a_post()
    {
        $user = factory(User::class)->create();
        $post = factory(Post::class)->create();

        $user->rate($post, 10.00);
        $this->assertTrue($user->unrate($post));
    }

    /**
     * @test
     */
    public function user_can_not_rate_a_user()
    {
        $user = factory(User::class)->create();

        $this->expectException(ModelNotRateable::class);
        $user->rate($user, 10.00);
    }

    /**
     * @test
     */
    public function post_can_not_rate_a_user()
    {
        $post = factory(Post::class)->create();
        $user = factory(User::class)->create();

        $this->expectException(BadMethodCallException::class);
        $post->rate($user, 10.00);
    }

    /**
     * @test
     */
    public function member_can_rate_a_member()
    {
        $member = factory(Member::class)->create();

        $this->assertTrue($member->rate($member, 10.00));
    }
}


1			<?php
2
3			namespace Canylmz\Rating\Test;
4
5			use BadMethodCallException;
6			use Canylmz\Rating\Test\Models\Post;
7			use Canylmz\Rating\Test\Models\User;
8			use Canylmz\Rating\Test\Models\Member;
9			use Canylmz\Rating\Exceptions\ModelNotRateable;
10			use Canylmz\Rating\Exceptions\RatingAlreadyExists;
11
12			class RatingTest extends TestCase
13			{
14			/**
15			* Information about the tests
16			* - Users can rate posts, but not other users
17			* - Posts can be rated
18			* - Members can rate other members.
19			*/
20			public function setUp(): void
21			{
22			parent::setUp();
23			}
24
25			/**
26			* @test
27			*/
28			public function user_can_rate_a_post()
29			{
30			$user = factory(User::class)->create();
31			$post = factory(Post::class)->create();
32
33			$this->assertTrue($user->rate($post, 10.00));
34			$this->assertTrue($user->hasRated($post));
35			}
36
37			/**
38			* @test
39			*/
40			public function users_can_rate_a_post()
41			{
42			$user1 = factory(User::class)->create();
43			$user2 = factory(User::class)->create();
44			$post = factory(Post::class)->create();
45
46			$this->assertTrue($user1->rate($post, 10.00));
47			$this->assertTrue($user1->hasRated($post));
48
49			$this->assertTrue($user2->rate($post, 10.00));
50			$this->assertTrue($user2->hasRated($post));
51			}
52
53			/**
54			* @test
55			*/
56			public function users_can_rerate_a_post()
57			{
58			$user = factory(User::class)->create();
59			$post = factory(Post::class)->create();
60
61			$this->assertTrue($user->rate($post, 10.00));
62			$this->assertTrue($user->hasRated($post));
63			$this->assertEquals(10, $post->averageRating(User::class));
64
65			$this->assertTrue($user->rate($post, 9.00));
66			$this->assertTrue($user->hasRated($post));
67			$this->assertEquals(9, $post->averageRating(User::class));
68			}
69
70			/**
71			* @test
72			*/
73			public function users_can_not_rerate_a_post()
74			{
75			$user = factory(User::class)->create();
76			$post = factory(Post::class)->create();
77
78			$this->assertTrue($user->rate($post, 10.00, false));
79			$this->assertTrue($user->hasRated($post));
80			$this->assertEquals(10, $post->averageRating(User::class));
81
82			$this->expectException(RatingAlreadyExists::class);
83			$user->rate($post, 9.00, false);
84			$this->assertTrue($user->hasRated($post));
85			$this->assertEquals(10, $post->averageRating(User::class));
86			}
87
88			/**
89			* @test
90			*/
91			public function it_can_count_ratings()
92			{
93			$user1 = factory(User::class)->create();
94			$user2 = factory(User::class)->create();
95			$user3 = factory(User::class)->create();
96			$post = factory(Post::class)->create();
97
98			$user1->rate($post, 10.00);
99			$this->assertEquals(1, $post->countRatings(User::class));
100
101			$user2->rate($post, 10.00);
102			$this->assertEquals(2, $post->countRatings(User::class));
103
104			$user3->rate($post, 10.00);
105			$this->assertEquals(3, $post->countRatings(User::class));
106			}
107
108			/**
109			* @test
110			*/
111			public function no_rating_returns_count_of_zero()
112			{
113			$post = factory(Post::class)->create();
114
115			$this->assertEquals(0, $post->countRatings(User::class));
116			}
117
118			/**
119			* @test
120			*/
121			public function it_can_calculate_the_average_rating()
122			{
123			$user1 = factory(User::class)->create();
124			$user2 = factory(User::class)->create();
125			$user3 = factory(User::class)->create();
126			$post = factory(Post::class)->create();
127
128			$user1->rate($post, 8.00);
129			$this->assertEquals(8.00, $post->averageRating(User::class));
130
131			$user2->rate($post, 10.00);
132			$this->assertEquals(9.00, $post->averageRating(User::class));
133
134			$user3->rate($post, 7.50);
135			$this->assertEquals(8.5, $post->averageRating(User::class));
136			}
137
138			/**
139			* @test
140			*/
141			public function no_rating_returns_average_of_zero()
142			{
143			$post = factory(Post::class)->create();
144
145			$this->assertEquals(0.00, $post->averageRating(User::class));
146			}
147
148			/**
149			* @test
150			*/
151			public function user_can_unrate_a_post()
152			{
153			$user = factory(User::class)->create();
154			$post = factory(Post::class)->create();
155
156			$user->rate($post, 10.00);
157			$this->assertTrue($user->unrate($post));
158			}
159
160			/**
161			* @test
162			*/
163			public function user_can_not_rate_a_user()
164			{
165			$user = factory(User::class)->create();
166
167			$this->expectException(ModelNotRateable::class);
168			$user->rate($user, 10.00);
169			}
170
171			/**
172			* @test
173			*/
174			public function post_can_not_rate_a_user()
175			{
176			$post = factory(Post::class)->create();
177			$user = factory(User::class)->create();
178
179			$this->expectException(BadMethodCallException::class);
180			$post->rate($user, 10.00);
181			}
182
183			/**
184			* @test
185			*/
186			public function member_can_rate_a_member()
187			{
188			$member = factory(Member::class)->create();
189
190			$this->assertTrue($member->rate($member, 10.00));
191			}
192			}
193

canylmz / laravel-rating

RatingTest::users_can_rate_a_post() A last analyzed 2019-10-19 22:55 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

RatingTest::users_can_rate_a_post() A
last analyzed 2019-10-19 22:55 UTC