Pytania na rozmowę kwalifikacyjną PHP Laravel Developer 2026: Kompletny przewodnik przygotowawczy

// Problem N+1: 1 zapytanie dla postów + N zapytań dla autorów
$posts = Post::all();
foreach ($posts as $post) {
    echo $post->author->name; // Wywołuje zapytanie dla każdego posta
}

// Rozwiązanie: Eager loading z with()
$posts = Post::with('author')->get(); // Łącznie 2 zapytania
foreach ($posts as $post) {
    echo $post->author->name; // Brak dodatkowych zapytań
}

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
    
    // Rekordy soft-deleted są domyślnie wykluczane
    // Aby je uwzględnić:
    // Post::withTrashed()->get();
    // Aby pobrać tylko usunięte:
    // Post::onlyTrashed()->get();
}

public function register(): void
{
    // Prosty binding
    $this->app->bind(PaymentGateway::class, StripeGateway::class);
    
    // Singleton - ta sama instancja za każdym razem
    $this->app->singleton(CacheManager::class, function ($app) {
        return new CacheManager($app['config']['cache']);
    });
    
    // Binding kontekstowy
    $this->app->when(PhotoController::class)
              ->needs(Filesystem::class)
              ->give(function () {
                  return Storage::disk('photos');
              });
}

class PostPolicy
{
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id 
            || $user->hasRole('editor');
    }
    
    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id 
            || $user->hasRole('admin');
    }
}

// Użycie w kontrolerze
public function update(Request $request, Post $post)
{
    $this->authorize('update', $post);
    // Kontynuuj aktualizację...
}

Gate::define('access-admin', function (User $user) {
    return $user->is_admin || $user->hasRole('super-admin');
});

// Użycie
if (Gate::allows('access-admin')) {
    // Pokaż panel administracyjny
}

class ProcessPodcast implements ShouldQueue
{
    use Queueable;
    
    public int $tries = 3;
    public int $backoff = 60; // sekundy między próbami
    public int $timeout = 300; // maksymalny czas wykonania
    
    public function __construct(
        public Podcast $podcast
    ) {}
    
    public function handle(AudioProcessor $processor): void
    {
        $processor->process($this->podcast->audio_path);
    }
    
    public function failed(Throwable $exception): void
    {
        // Powiadom administratora o niepowodzeniu
        Log::error('Przetwarzanie podcastu nieudane', [
            'podcast_id' => $this->podcast->id,
            'error' => $exception->getMessage()
        ]);
    }
}

// Wysyłanie zadania
ProcessPodcast::dispatch($podcast)->onQueue('audio');

// Job batching
Bus::batch([
    new ProcessPodcast($podcast1),
    new ProcessPodcast($podcast2),
    new ProcessPodcast($podcast3),
])->then(function (Batch $batch) {
    // Wszystkie zadania zakończone pomyślnie
})->catch(function (Batch $batch, Throwable $e) {
    // Obsługa pierwszego niepowodzenia
})->finally(function (Batch $batch) {
    // Batch zakończony (z sukcesem lub błędem)
})->dispatch();

// Job chaining
Bus::chain([
    new DownloadPodcast($url),
    new ProcessAudio($podcast),
    new PublishPodcast($podcast),
])->dispatch();

class PricingServiceTest extends TestCase
{
    public function test_calculates_discount_correctly(): void
    {
        $service = new PricingService();
        
        $result = $service->calculateDiscount(100, 0.2);
        
        $this->assertEquals(80, $result);
    }
}

// tests/Feature/Http/Controllers/PostControllerTest.php
class PostControllerTest extends TestCase
{
    use RefreshDatabase;
    
    public function test_user_can_create_post(): void
    {
        $user = User::factory()->create();
        
        $response = $this->actingAs($user)
            ->post('/posts', [
                'title' => 'Mój post',
                'content' => 'Zawartość posta'
            ]);
        
        $response->assertRedirect('/posts');
        $this->assertDatabaseHas('posts', [
            'title' => 'Mój post',
            'user_id' => $user->id
        ]);
    }
}

use Illuminate\Support\Facades\Queue;

public function test_podcast_processing_job_is_dispatched(): void
{
    Queue::fake();
    
    $podcast = Podcast::factory()->create();
    
    // Akcja wywołująca zadanie
    $this->post("/podcasts/{$podcast->id}/process");
    
    // Asercje
    Queue::assertPushed(ProcessPodcast::class, function ($job) use ($podcast) {
        return $job->podcast->id === $podcast->id;
    });
    
    Queue::assertPushedOn('audio', ProcessPodcast::class);
}

interface PostRepositoryInterface
{
    public function findPublished(): Collection;
    public function findByAuthor(User $author): Collection;
}

class EloquentPostRepository implements PostRepositoryInterface
{
    public function findPublished(): Collection
    {
        return Post::where('status', 'published')
            ->with('author')
            ->orderByDesc('published_at')
            ->get();
    }
    
    public function findByAuthor(User $author): Collection
    {
        return Post::where('user_id', $author->id)
            ->with('tags')
            ->get();
    }
}

class CreateOrder
{
    public function __construct(
        private PaymentGateway $gateway,
        private OrderRepository $orders
    ) {}
    
    public function execute(User $user, Cart $cart): Order
    {
        $payment = $this->gateway->charge(
            $user,
            $cart->total()
        );
        
        $order = $this->orders->create([
            'user_id' => $user->id,
            'payment_id' => $payment->id,
            'items' => $cart->items(),
            'total' => $cart->total()
        ]);
        
        OrderCreated::dispatch($order);
        
        return $order;
    }
}

// Użycie w kontrolerze
public function store(Request $request, CreateOrder $action)
{
    $order = $action->execute(
        $request->user(),
        Cart::current()
    );
    
    return redirect()->route('orders.show', $order);
}

// Integracja AI SDK
use Illuminate\AI\Facades\AI;

$response = AI::chat()
    ->model('gpt-4')
    ->system('Jesteś pomocnym asystentem.')
    ->user('Wyjaśnij Service Container w Laravel.')
    ->generate();

// PHP Attributes dla tras
#[Route('/posts', methods: ['GET'])]
#[Middleware('auth')]
public function index(): View
{
    return view('posts.index');
}

// Walidacja z Attributes
#[Required]
#[Email]
#[Unique('users', 'email')]
public string $email;