Schema::create('users', function (Blueprint $table) {
    $table->increments('id');
    $table->string('name');
    $table->string('email')->unique();
    $table->string('password');
    $table->rememberToken();
    $table->timestamps();
});

Schema::create('threads', function (Blueprint $table) {
    $table->increments('id');
    $table->unsignedInteger('user_id');
    $table->unsignedInteger('channel_id');
    $table->string('title');
    $table->text('body');
    $table->timestamps();
});

Schema::create('channels', function (Blueprint $table) {
    $table->increments('id');
    $table->string('name', 50);
    $table->string('slug', 50);
    $table->timestamps();
    });

<?php

use Faker\Generator as Faker;
/*
|--------------------------------------------------------------------------
| Model Factories
|--------------------------------------------------------------------------
|
| This directory should contain each of the model factory definitions for
| your application. Factories provide a convenient way to generate new
| model instances for testing / seeding your application's database.
|
*/

$factory->define(App\User::class, function (Faker $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'password' => '$2y$10$TKh8H1.PfQx37YgCzwiKb.KjNyWgaHb9cbcoQgdIVFlYg7B77UdFm', // secret
        'remember_token' => str_random(10),
    ];
});

$factory->define(App\Thread::class, function (Faker $faker) {
    return [
        'user_id' => function () {
            return factory(\App\User::class)->create()->id;
        },
        'channel_id' => function () {
            return factory(\App\Channel::class)->create()->id;
        },
        'title' => $faker->sentence,
        'body' => $faker->paragraph,
    ];
});

$factory->define(App\Channel::class, function (Faker $faker) {
    return [
        'name' => $faker->word,
        'slug' => $faker->word,
    ];
});

<?php

namespace Tests\Unit;
use App\Thread;
use App\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Collection;
use Tests\TestCase;

class ThreadTest extends TestCase
{
    use RefreshDatabase;
    protected $thread;

    public function setUp()
    {
        parent::setUp();
        $this->thread = factory(Thread::class)->create();
    }

    /** @test */
    public function a_thread_has_creator()
    {
        $this->assertInstanceOf(User::class, $this->thread->creator);
    }

    /** @test */
    public function a_thread_belongs_to_a_channel()
    {
        $thread = create(Thread::class);
        $this->assertInstanceOf('App\Channel', $thread->channel);
    }
}

phpunit

Failed asserting that null is an instance of class "App\User".
Failed asserting that null is an instance of class "App\Channel".

/**
* Threads belongs to a user/creator.
*
* @return BelongsTo
*/
public function creator()
{
    return $this->belongsTo(User::class, 'user_id');
}

/**
* Threads can belongs to a channel.
*
* @return BelongsTo
*/
public function channel()
{
    return $this->belongsTo(Channel::class);
}

<?php

namespace Tests\Feature;

use App\Activity;
use App\Channel;
use App\Reply;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
use App\Thread;

class CreateThreadsTest extends TestCase
{
    use RefreshDatabase;

    /** @test */
    public function an_authenticated_user_can_create_a_thread()
    {
        // Login
        $this->signIn();

        // create a new thread
        $thread = make(Thread::class);

        // sent request to server
        $response = $this->post('/threads', $thread->toArray());

        // assert see in database
        $this->get($response->headers->get('Location'))
        ->assertSee($thread->title)
        ->assertSee($thread->body);
    }
}

<?php

namespace Tests;

use App\User;
use Illuminate\Foundation\Testing\TestCase as BaseTestCase;

abstract class TestCase extends BaseTestCase
{
    use CreatesApplication;

    protected function signIn($user = null)
    {
        $user = $user ? : create(User::class);

        $this->actingAs($user);

        return $this;
    }
}

<?php

Route::get('/', function () {
return view('welcome');
});
Auth::routes();
Route::post('/threads', 'ThreadsController@store');

<?php

namespace App\Http\Controllers;

use App\Filters\ThreadFilters;
use App\Inspections\Spam;
use App\Thread;
use App\Channel;
use Carbon\Carbon;
use Illuminate\Contracts\View\Factory;
use Illuminate\Database\Query\Builder;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\View\View;

class ThreadsController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth')->except(['index', 'show']);
    }

    /**
    * Store a newly created resource in storage.
    *
    * @param Request $request
    * @param Spam $spam
    * @return Response
    * @throws \Exception
    */
    public function store(Request $request, Spam $spam)
    {
        $this->validate($request, [
            'title' => 'required',
            'body' => 'required',
            'channel_id' => 'required|exists:channels,id',
        ]);

        $spam->detect(request('body'));

        $thread = Thread::create([
            'user_id' => auth()->id(),
            'channel_id' => request('channel_id'),
            'title' => request('title'),
            'body' => request('body'),
        ]);

        return redirect($thread->path())
    }
}

// validation field
/** @test */
public function a_thread_require_a_title()
{
    $this->publishThread(['title' => null])
    ->assertSessionHasErrors('title');
}

/** @test */
public function a_thead_require_body()
{
    $this->publishThread(['body' => null])
    ->assertSessionHasErrors('body');
}


/** @test */
public function a_thread_require_a_valid_channel()
{
    $channels = factory(Channel::class, 2)->create();
    $this->publishThread(['channel_id' => null])
    ->assertSessionHasErrors('channel_id');
    $this->publishThread(['channel_id' => 90])
    ->assertSessionHasErrors('channel_id');
}

// Create new thread function
public function publishThread($overrides = [])
{
    $this->signIn();
    $thread = make(Thread::class, $overrides);
    return $this->post('/threads', $thread->toArray());
}