initial commit

tests/Feature/AuthenticationTest.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Tests\Feature;
+
+use App\Models\User;
+use App\Providers\RouteServiceProvider;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class AuthenticationTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_login_screen_can_be_rendered()
+    {
+        $response = $this->get(route('auth.login'));
+
+        $response->assertStatus(200);
+    }
+
+    public function test_users_can_authenticate_using_the_login_screen()
+    {
+        $user = User::factory()->create();
+
+        $response = $this->post(route('auth.login.store'), [
+            'username' => $user->username,
+            'password' => 'password',
+        ]);
+
+        $this->assertAuthenticated();
+        $response->assertRedirect('/');
+    }
+
+    public function test_users_can_not_authenticate_with_invalid_password()
+    {
+        $user = User::factory()->create();
+
+        $this->post(route('auth.login.store'), [
+            'username' => $user->username,
+            'password' => 'wrong-password',
+        ]);
+
+        $this->assertGuest();
+    }
+
+    public function test_user_can_logout()
+    {
+        $user = User::factory()->create();
+
+        $this->actingAs($user)->delete(route('auth.logout'));
+
+        $this->assertGuest();
+    }
+}

tests/Feature/CharacterCreateTest.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace Tests\Feature;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Foundation\Testing\WithFaker;
+use Tests\TestCase;
+
+use App\Models\User;
+use App\Models\Character;
+
+use App\Http\Livewire\Form\CreateCharacterForm;
+
+class CharacterCreateTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_user_can_render_character_creation_page()
+    {
+        $user = User::factory()->create();
+
+        $response = $this->actingAs($user)
+            ->get(route('character.create'));
+
+        $response->assertStatus(200); // OK
+    }
+
+    public function test_guest_can_not_render_character_creation_page()
+    {
+        $response = $this->get(route('character.create'));
+
+        $response->assertStatus(403); // Forbidden
+    }
+
+    public function test_user_can_create_characters()
+    {
+        $this->actingAs(User::factory()->create());
+
+        \Livewire::test(CreateCharacterForm::class)
+            ->set('name', 'Elise')
+            ->set('level', '70')
+            ->set('class', 'warrior')
+            ->set('race', 'human')
+            ->set('gender', 'F')
+            ->call('save')
+            ->assertRedirect(route('user.index'));
+
+        // Find character and check the data.
+        $character = Character::where('name', 'Elise')->first();
+
+        $this->assertEquals(70, $character->level);
+        $this->assertEquals('warrior', $character->class);
+        $this->assertEquals('human', $character->race);
+        $this->assertEquals('F', $character->gender);
+    }
+
+    public function test_user_can_not_create_alot_of_characters()
+    {
+        $user = User::factory()->create();
+
+        // Create "alot" of characters (8 or so is the limit in the front-end).
+        Character::factory()
+            ->for($user)
+            ->count(20)->create();
+
+        $this->actingAs($user);
+
+        // Try create one more via livewire form.
+        \Livewire::test(CreateCharacterForm::class)
+            ->set('name', 'Notonemore')
+            ->set('level', '10')
+            ->set('class', 'mage')
+            ->set('race', 'troll')
+            ->set('gender', 'M')
+            ->call('save')
+            ->assertForbidden();
+    }
+
+    public function test_guest_can_not_create_characters()
+    {
+        \Livewire::test(CreateCharacterForm::class)
+            ->set('name', 'Guestchar')
+            ->set('level', '61')
+            ->set('class', 'priest')
+            ->set('race', 'dwarf')
+            ->set('gender', 'M')
+            ->call('save')
+            ->assertForbidden();
+
+        $this->assertDatabaseMissing('characters', [ 'name' => 'Guestchar' ]);
+    }
+}

tests/Feature/CharacterDestroyTest.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace Tests\Feature;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Foundation\Testing\WithFaker;
+use Tests\TestCase;
+
+use App\Models\User;
+use App\Models\Character;
+
+class CharacterDestroyTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_user_can_delete_their_own_character()
+    {
+        $user = User::factory()->create();
+        $character = Character::factory()->for($user)->create();
+
+        $response = $this->actingAs($user)
+            ->delete(route('character.destroy', [ 'character' => $character ]));
+
+        $response->assertStatus(302); // Redirect
+
+        $this->assertDatabaseMissing('characters', [ 'id' => $character->id ]);
+    }
+
+    public function test_guest_can_not_delete_character()
+    {
+        $character = Character::factory()->create();
+
+        $response = $this->delete(route('character.destroy', [ 'character' => $character ]));
+
+        $response->assertStatus(403); // Not allowed
+
+        $this->assertDatabaseHas('characters', [ 'id' => $character->id ]);
+    }
+
+    public function test_user_can_not_delete_someone_elses_character()
+    {
+        $user = User::factory()->create();
+        $userOther = User::factory()->create();
+        $character = Character::factory()->for($userOther)->create();
+
+        $response = $this->actingAs($user)
+            ->delete(route('character.destroy', [ 'character' => $character ]));
+
+        $response->assertStatus(403); // Not allowed
+
+        $this->assertDatabaseHas('characters', [ 'id' => $character->id ]);
+    }
+}

tests/Feature/CharacterProfessionTest.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Tests\Feature;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Foundation\Testing\WithFaker;
+use Tests\TestCase;
+
+use App\Models\User;
+use App\Models\Character;
+use App\Models\CharacterProfession;
+use App\Models\Profession;
+
+class CharacterProfessionTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_user_is_allowed_to_create_profession_for_their_own_character()
+    {
+        $user = User::factory()->create();
+        $character = Character::factory()
+            ->for($user)
+            ->create();
+
+        $response = $this->actingAs($user)
+            ->get(route('character.profession.create', [ 'character' => $character ]));
+
+        $response->assertStatus(200); // OK
+    }
+
+    public function test_user_is_not_allowed_to_create_profession_for_someone_elses_character()
+    {
+        $user = User::factory()->create();
+        $character = Character::factory()->create();
+
+        $response = $this->actingAs($user)
+            ->get(route('character.profession.create', [ 'character' => $character ]));
+
+        $response->assertStatus(403); // Not allowed
+    }
+
+    public function test_user_is_allowed_to_delete_profession_from_their_own_character()
+    {
+        $user = User::factory()->create();
+        $profession = Profession::factory()->create();
+        $character = Character::factory()
+            ->for($user)
+            ->create();
+
+        $ch_prof = CharacterProfession::factory()
+            ->for($character)
+            ->for($profession)
+            ->create();
+
+        $response = $this->actingAs($user)
+            ->delete(route('character.profession.destroy', [ 'character' => $character, 'profession' => $profession ]));
+
+        // The response should be a redirect in this case.
+        $response->assertStatus(302);
+
+        // Check that the character profession is deleted.
+        $this->assertDatabaseMissing('character_professions', [ 'id' => $ch_prof->id ]);
+    }
+
+    public function test_user_is_not_allowed_to_delete_profession_from_someone_elses_character()
+    {
+        $user = User::factory()->create();
+        $profession = Profession::factory()->create();
+        $character = Character::factory()->create();
+
+        $ch_prof = CharacterProfession::factory()
+            ->for($character)
+            ->for($profession)
+            ->create();
+
+        $response = $this->actingAs($user)
+            ->delete(route('character.profession.destroy', [ 'character' => $character, 'profession' => $profession ]));
+
+        $response->assertStatus(403);  // Not allowed
+
+        // Check that the character profession is still there.
+        $this->assertDatabaseHas('character_professions', [ 'id' => $ch_prof->id ]);
+    }
+}

tests/Feature/Models/CharacterTest.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Tests\Feature\Models;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+use App\Models\User;
+use App\Models\CharacterProfession;
+use App\Models\Character;
+
+class CharacterTest extends TestCase
+{
+    use RefreshDatabase;
+
+    /**
+     * Test user relationship.
+     *
+     * @return void
+     */
+    public function test_user_relationship()
+    {
+        $user = User::factory()->create();
+        $character = Character::factory()
+            ->for($user)
+            ->create();
+
+        $this->assertEquals($user->id, $character->user->id);
+    }
+
+    /**
+     * Test character profession relationship.
+     *
+     * @return void
+     */
+    public function test_profession_relationship()
+    {
+        $this->seed(\Database\Seeders\SettingsSeeders\ProfessionsTableSeeder::class);
+
+        $professions = CharacterProfession::factory(2)->create();
+        $character = Character::factory()->create();
+
+        $character->professions()->save($professions[0]);
+        $character->professions()->save($professions[1]);
+
+        $this->assertEquals(2, $character->professions->count());
+
+        foreach($professions as $profession) {
+            $this->assertContains($profession->id, $character->professions->pluck('id')->toArray());
+        }
+    }
+}

tests/Feature/Models/ItemTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Tests\Feature\Models;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+use App\Models\Recipe;
+use App\Models\Item;
+
+class ItemTest extends TestCase
+{
+    use RefreshDatabase;
+
+    /**
+     * Test recipe relationship.
+     *
+     * @return void
+     */
+    public function test_recipe_relationship()
+    {
+        $item = Item::factory()->create();
+        $recipe = Recipe::factory()
+            ->for($item, 'craft')
+            ->create();
+
+        $this->assertEquals($recipe->id, $item->recipe->id);
+    }
+
+    /**
+     * Test quantity attribute
+     *
+     * @return void
+     */
+    public function test_quantity_attribute()
+    {
+        $recipe = Recipe::factory()->create();
+        $item = Item::factory()->create();
+        $recipe->reagents()->attach($item, ['quantity' => 5]);
+
+        $this->assertEquals(5, $recipe->reagents[0]->quantity);
+    }
+
+    /**
+     * Test quantity attribute missing
+     *
+     * @return void
+     */
+    public function test_quantity_attribute_missing()
+    {
+        $item = Item::factory()->create();
+
+        $this->assertNull($item->quantity);
+    }
+}

tests/Feature/Models/RecipeTest.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace Tests\Feature\Models;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+use App\Models\Recipe;
+use App\Models\RecipeCategory;
+use App\Models\Profession;
+use App\Models\CharacterProfession;
+use App\Models\Character;
+use App\Models\Item;
+
+class RecipeTest extends TestCase
+{
+    use RefreshDatabase;
+
+    /**
+     * Test profession relationship.
+     *
+     * @return void
+     */
+    public function test_profession_relationship()
+    {
+        $profession = Profession::factory()->create();
+
+        $recipe = Recipe::factory()
+            ->for($profession)
+            ->create();
+
+        $this->assertEquals($profession->id, $recipe->profession->id);
+    }
+
+    /**
+     * Test category relationship.
+     *
+     * @return void
+     */
+    public function test_category_relationship()
+    {
+        $category = RecipeCategory::factory()->create();
+
+        $recipe = Recipe::factory()
+            ->for($category, 'category')
+            ->create();
+
+        $this->assertEquals($category->id, $recipe->category->id);
+    }
+
+    /**
+     * Test craft relationship.
+     *
+     * @return void
+     */
+    public function test_craft_relationship()
+    {
+        $item = Item::factory()->create();
+
+        $recipe = Recipe::factory()
+            ->for($item, 'craft')
+            ->create();
+
+        $this->assertEquals($item->id, $recipe->craft->id);
+    }
+
+    /**
+     * Test character profession relationship.
+     *
+     * @return void
+     */
+    public function test_character_profession_relationship()
+    {
+        $profession = Profession::factory()->create();
+        $ch_profs = CharacterProfession::factory(2)->create([ 'profession_id' => $profession->id ]);
+        $characters = Character::factory(2)->create();
+
+        $characters[0]->professions()->save($ch_profs[0]);
+        $characters[1]->professions()->save($ch_profs[1]);
+
+        $recipe = Recipe::factory()
+            ->for($profession)
+            ->create();
+
+        $characters[0]->professions[0]->recipes()->save($recipe);
+        $characters[1]->professions[0]->recipes()->save($recipe);
+
+        $professions = $recipe->character_profession;
+
+        $this->assertEquals($ch_profs[0]->id, $professions[0]->id);
+        $this->assertEquals($ch_profs[1]->id, $professions[1]->id);
+    }
+
+    /**
+     * Test crafters relationship.
+     *
+     * @return void
+     */
+    public function test_crafters_relationship()
+    {
+        $profession = Profession::factory()->create();
+        $ch_profs = CharacterProfession::factory(2)->create([ 'profession_id' => $profession->id ]);
+        $characters = Character::factory(2)->create();
+
+        $characters[0]->professions()->save($ch_profs[0]);
+        $characters[1]->professions()->save($ch_profs[1]);
+
+        $recipe = Recipe::factory()
+            ->for($profession)
+            ->create();
+
+        // Make both character learn the recipe.
+        $characters[0]->professions[0]->learn($recipe);
+        $characters[1]->professions[0]->learn($recipe);
+
+        $crafters = $recipe->crafters;
+
+        $this->assertEquals($crafters[0]->id, $characters[0]->id);
+        $this->assertEquals($crafters[1]->id, $characters[1]->id);
+    }
+
+    /**
+     * Test reagants relationship.
+     *
+     * @return void
+     */
+    public function test_reagents_relationship()
+    {
+        $profession = Profession::factory()->create();
+        $items = Item::factory(3)->create();
+
+        $recipe = Recipe::factory()
+            ->for($profession)
+            ->create();
+
+        $recipe->reagents()->attach($items[0], ['quantity' => 1]);
+        $recipe->reagents()->attach($items[1], ['quantity' => 4]);
+        $recipe->reagents()->attach($items[2], ['quantity' => 10]);
+
+        $this->assertEquals($items[0]->id, $recipe->reagents[0]->id);
+        $this->assertEquals($items[1]->id, $recipe->reagents[1]->id);
+        $this->assertEquals($items[2]->id, $recipe->reagents[2]->id);
+    }
+}

tests/Feature/UserTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Tests\Feature;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Foundation\Testing\WithFaker;
+use Tests\TestCase;
+
+use App\Models\User;
+
+class UserTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_user_can_view_profile()
+    {
+        $user = User::factory()->create();
+
+        $response = $this->actingAs($user)->get(route('user.index'));
+
+        $response->assertStatus(200);
+    }
+
+    public function test_guest_can_not_view_profile()
+    {
+        $response = $this->get(route('user.index'));
+
+        $response->assertRedirect(route('auth.login'));
+    }
+
+    public function test_user_can_update()
+    {
+        $user = User::factory()->create();
+
+        $response = $this->actingAs($user)
+            ->post(route('user.update'), [
+                'current_password' => 'password',
+                'password' => 'newpassword',
+                'password_confirmation' => 'newpassword'
+            ]);
+
+        $response->assertRedirect(route('user.index'));
+    }
+
+    public function test_guest_can_not_update()
+    {
+        $response = $this->post(route('user.update'), [
+            'current_password' => 'password',
+            'password' => 'newpassword',
+            'password_confirmation' => 'newpassword'
+        ]);
+
+        $response->assertRedirect(route('auth.login'));
+    }
+}