faveo/tests/Unit/ArticleControllerTest.php

<?php

namespace Tests\Unit;

use App\Http\Requests\kb\ArticleRequest;
use App\Http\Requests\kb\ArticleUpdate;
use App\Http\Requests\kb\CategoryRequest;
use App\Model\kb\Article;
use App\Model\kb\Category;
use App\Model\kb\Relationship;
use App\User;
use Faker\Factory as FakerFactory;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Lang;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;
use Tests\TestCase;

class ArticleControllerTest extends TestCase
{

    protected $user; // Declare a user property

    // Set up the authenticated user before each test
    public function setUp(): void
    {
        parent::setUp();

        $faker = FakerFactory::create();

        //Create User -> Agent

        //$str = Str::random(10);
        $str = 'demopass';
        $password = Hash::make($str);
        $email = $faker->unique()->email();
        $user = new User([
            'first_name' => $faker->firstName(),
            'last_name' => $faker->lastName(),
            'email' => $email,
            'user_name' => $faker->unique()->userName(),
            'password' => $password,
            'assign_group' => 1,
            'primary_dpt' => 1,
            'active' => 1,
            'role' => 'agent',
            'agent_tzone' => 81,
        ]);
        $user->save();

        // Check if data is inserted
        $this->assertDatabaseHas('users', ['email' => $email]);

        // Authenticate as the created user
        $this->actingAs($user);

        $this->assertAuthenticated();

    }
        /** @test */
        public
        function it_can_display_the_article_index_page()
        {

            $response = $this->get(route('article.index'));

            $response->assertStatus(200);
        }

        public
        function testStoreArticleWithCategories()
        {

            // Create a Category model for testing
            $data = [
                'name' => 'Test Category',
                'description' => 'Test Category Description',
            ];

            $validator = Validator::make($data, (new CategoryRequest())->rules());

            $this->assertTrue($validator->passes());

            $response = $this->post(route('category.store'), $data);

            $response->assertStatus(302);
            $response->assertSessionHas('success');
            $this->assertDatabaseHas('kb_category', $data);
            $category = Category::latest()->first();

            // Article data
            $articleData = [
                'name' => 'Test Article',
                'description' => 'Test Article Description',
                'category_id' => $category->id,
                'year' => '2023',
                'month' => '10',
                'day' => '03',
                'hour' => '12',
                'minute' => '30',
            ];

            $articleRequest = new ArticleRequest($articleData);

            // Act
            try {
                $validator = Validator::make($articleData, (new ArticleRequest())->rules());

                $this->assertTrue($validator->passes());
                $response = $this->post(route('article.store'), $articleData);
                $response->assertStatus(200);
            } catch (Exception $e) {
                $response = null;
            }

            // Assert
            if ($response) {
                $response->assertStatus(200); // Check if the response status code is a redirect (302)

                $article = Article::latest()->first();

                $article_relationship = new Relationship();

                $article_relationship->category_id = $category->id;
                $article_relationship->article_id = $article->id;
                $article_relationship->save();

                // Verify that the article was created and the category relationship exists
                $this->assertDatabaseHas('kb_article', [
                    'name' => $articleData['name'],
                    'slug' => Str::slug($articleData['name'], '-'),
                    'publish_time' => $articleData['year'] . '-' . $articleData['month'] . '-' . $articleData['day'] . ' ' . $articleData['hour'] . ':' . $articleData['minute'] . ':00',
                ]);

                // Check if the category relationship exists
                $this->assertDatabaseHas('kb_article_relationship', [
                    'category_id' => $category->id,
                    'article_id' => Article::latest()->first()->id, // Get the ID of the latest created article
                ]);
            } else {
                $this->fail('Exception thrown: ' . $e->getMessage());
            }
        }

        public
        function testEditArticle()
        {

            // Arrange
            $article = Article::latest()->first(); // Create a sample Article for testing
            $relationship = Relationship::latest()->first(); // Create a sample Relationship for testing
            $category = Category::latest()->first(); // Create a sample Category for testing

            $assign = $relationship->where('article_id', 'id')->pluck('category_id');
            $category = $category->pluck('id', 'name');

            $response = $this->get(
                "/article/{$article->id}/edit",
                ['category' => $category,
                    'article' => $article,
                    'assign' => $assign,
                ]
            );
            $response->assertStatus(200);
        }

        public
        function testUpdateArticle()
        {

            $article = Article::latest()->first();
            $category = Category::latest()->first();

            $data = [
                'id' => $article->id,
                'name' => 'Updated Article Name',
                'description' => 'Updated Description',
                'slug' => Str::slug('Updated Article Name', '-'),
                'category_id' => [1, 2],
                'year' => '2023',
                'month' => '10',
                'day' => '03',
                'hour' => '2',
                'minute' => '20',
            ];

            $validator = Validator::make($data, (new ArticleUpdate())->rules());

            $this->assertTrue($validator->passes());

            $response = $this->put(route('article.update', $article->id, $data));

            $response->assertStatus(302);

            $article_relationship = Relationship::latest()->first();
            $article_relationship = $article_relationship->where('article_id', $article->id);
            $article_relationship->delete();

            $article = Article::latest()->first();
            $relation = new Relationship();
            $relation->category_id = $category->id;
            $relation->article_id = $article->id;
            $relation->save();
        }

        /** @test */
        public
        function it_can_delete_a_category()
        {

            // Create a sample article, relationship
            $article = Article::latest()->first();
            $relationship = Relationship::find($article->id);

            // Ensure the destroy route works as expected

            $response = $this->get("/article/delete/{$article->slug}");

            // Assert that success message is flashed
            $response->assertSessionHas('success', Lang::get('lang.article_deleted_successfully'));

            // Create a category
            $category = Category::latest()->first();

            // Create a related relationship (you may need to adjust this based on your actual relationships)
            $relation = Relationship::find($category->id);

            // Call the destroy method with the category ID
            $response = $this->get("/category/delete/{$category->id}");

            // Assert that the category is deleted from the database
            $this->assertDatabaseMissing('kb_category', ['id' => $category->id]);
        }

        public
        function it_cannot_delete_a_article_if_related()
        {

            // Create a category
            $article = Article::find(1);

            // Call the destroy method with the category ID (without creating related records)
            $response = $this->get("/article/delete/{$article->slug}");

            // Assert that the category is not deleted from the database
            $this->assertDatabaseHas('kb_article', ['id' => $article->id]);

            // Assert that the response is a redirect
            $response->assertRedirect();

            // Assert that the response has a failure message
            $response->assertSessionHas('fails', Lang::get('lang.article_not_deleted'));
        }
    }