Forem: Isra Skyler

Crush Bugs with Laravel Contract-Based Testing

Isra Skyler — Fri, 03 Nov 2023 12:27:26 +0000

As an experienced Laravel developer at Hybrid Web Agency, reliability is core to every project I take on. While testing is mandatory, traditional methods sometimes fall short on complex work with changing requirements.
That's why I've adopted contract-based testing to validate new features and squash bugs before delivery. By defining intended behaviors and expected outputs, contracts ensure my code works as planned - now and later.
This focus on quality has paid dividends for clients. Budgets hold steady as rework decreases. Users enjoy seamless experiences and confidence, with freedom to adjust scope down the line.
In this post, I'll demonstrate how contract testing improved one application. From setup to maintenance, see how shifting left on quality boosts deliverables and strengthens client relationships. Once you know the process - You will be much more confident before you Hire Laravel Developers in Everett.

What are Contract Tests?

Contract testing is an approach that validates public APIs by specifying expected app behaviors rather than implementation details. Unlike unit or integration tests, contracts asserts code works as intended now and handles future unknown changes.

Contracts define just the public methods and properties of a class - its "contract" with external users. Tests then exercise this public API through realistic usage scenarios and assertions. This separates the "contract" from how it's coded internally.

Some key benefits include:

Focused on critical behaviors: Tests validate crucial expected inputs/outputs rather than testing all code paths. This focuses on important use cases.
Stable over time: Contracts act as documentation and guards against regressions from code changes. Tests still pass as code evolves if output contracts are met.
Reader-focused documentation: Contracts double as living documentation developers can reference to understand how to use classes properly without digging through code.

Here is a simple example contract class for validating a common "CountAll" method:

interface PostRepositoryContract {

  public function countAll(): int;

}

class PostRepositoryContractTest extends TestCase {

  public function testCountAllReturnsInteger() {

    $mock = Mockery::mock(PostRepositoryContract::class);

    $count = $mock->countAll();

    $this->assertInternalType('integer', $count);

  }

}

This contract asserts the method returns an integer without concerning how counting is implemented - keeping tests stable over time.

Setting Up Contract Tests in Laravel

Setting up contract tests in Laravel involves just a few simple steps to get your environment configured.

Installing Necessary Packages

The main package needed is PHPUnit. Run composer require --dev phpunit/phpunit to add it as a development dependency.

You'll also want helper packages like Mockery for generating test doubles. composer require --dev mockery/mockery

Configuring the Testing Environment

Add phpunit.xml to your project root with the basic configuration. This tells PHPUnit where to find your tests.

<?xml version="1.0" encoding="UTF-8"?>
<phpunit>
  <testsuites>
    <testsuite name="App Tests">
      <directory>tests</directory>
    </testsuite>
  </testsuites>
</phpunit>

Generating a Basic Test Stub

Create a tests directory and a sample test file like Feature/UserTest.php. Import necessary classes and traits:

<?php

use PHPUnit\Framework\TestCase;

class FeatureTest extends TestCase
{
  public function setUp(): void
  {
    //...
  }

  public function testExample()
  {

  }

}

Now your environment is ready to start writing focused contract tests!

A Real-World Contract Test Example

To demonstrate contract testing in action, let's look at a real-world example.

Choosing a Class to Test

For this example, we'll focus on a core Repository class that interacts with the database, such as a PostRepository. It retrieves, creates, updates posts and is crucial to our app's functionality.

Defining the Public API Contract

First, we define the public methods and properties the repository exposes with an interface:

interface PostRepositoryInterface {

  public function all();

  public function create(array $data);

  // etc

}

Writing Test Assertions

Next, we create tests that exercise this interface through common usage scenarios:

public function testAllReturnsCollection()
{
  $mock = Mockery::mock(PostRepositoryInterface::class);

  $posts = $mock->all();

  $this->assertInstanceOf(Collection::class, $posts);
}

public function testCreateStoresPost()
{
  $mock = Mockery::mock(PostRepositoryInterface::class);

  $mock->shouldReceive('create')->once();

  $mock->create(['title' => 'Test']);
}

Running Tests

Now simply run phpunit! These contract tests validate our code's public behaviors independently of implementation details.

Let's see how this approach improves our code quality over time.

Common Contracts to Test

There are some key areas of a typical Laravel application that benefit most from contract testing:

Database Models & Repositories

Classes that interact with the database like Eloquent models and repository interfaces are perfect for contract testing. Validate expected behaviors for fetching, updating and relating data without depending on the backend.

API Controllers

API surfaces define your application's public contract with external consumers. Test controller methods adhere to formats, require expected parameters, and return anticipated payloads and status codes.

Mailables & Notifications

Notifications and mailables send critical communications. Contract test these by asserting views and data are rendered properly without transport concerns muddying tests.

Core Application Services

Services encapsulate much of your application's business logic. Test service contracts return expected payloads and exceptions for a variety of input scenarios. This validates coreworkflows independently of UI logic.

By focusing tests on these common artifacts, you can have confidence in critical contracts even as code evolves. Tests act as both validation and living documentation of intentions and boundaries for key classes.

Maintenance and Continuous Testing

Contract tests provide ongoing value beyond initial development:

Refactoring Without Breaking Contracts

Since tests focus on public APIs, internal refactors and optimizations won't cause failures if they don't change public behavior specifications. This allows safe changes over time.

Versioning/Breaking Changes Clearly

Before introducing breaking changes, update contracts by removing/modifying methods or arguments. This signals tests and consumers explicitly to change accordingly.

Integrating with Continuous Integration

Add PHPUnit runs to your CI/CD pipeline. Now contract tests prevent regressions from being deployed automatically. Team members receive immediate feedback from failures.

As codebases evolve rapidly, contracts catch where internal changes alter intended external behaviors. They document restrictions that maintain backwards compatibility over versions.

With contracts, releasing with confidence is attainable. Refactors, features and optimizations land safely while preserving established public interfaces. Tests act as living documentation reflecting how code works and is meant to be used.

Conclusion

Through every phase of development, from initial specs to ongoing maintenance, quality must remain the highest priority. Contract tests provide the structure and assurance that promises to users are kept, even as circumstances change.

By clarifying expectations instead of implementation, contracts make code understandable from any perspective. They facilitate safe evolution, ensuring the present works as before while allowing imagination for what's next.

Most of all, contract testing transforms relationships. Where fear of breakage once restricted progress, shared expectations built on honesty and respect empower risk-taking. Developers and customers walk together toward a same destination, bold yet careful in each step.

This partnership of clarity and care is what raises a simple application to the level of trusted companion. When reliability is guaranteed, so too is the freedom to learn, grow and achieve ever more together. That is the true promise of contract testing in Laravel and beyond.

Rules to Reuse Laravel Code Like a Pro

Isra Skyler — Thu, 02 Nov 2023 15:25:00 +0000

Hey everyone, Isra here! I'm excited to share my tips for making reusable code.

When I first started coding, I would write big messy programs that I couldn't change later. Yuck! Then I learned to break my code into smaller pieces that could be used over and over.

The other day, a client wanted help with their website. After using some reusable code, they finished way faster! They were so happy that they said, We need to hire Laravel Developers in Seattle.

Now I want to teach you how to make your own reusable code. There are easy ways to share functions and classes between programs. We'll look at traits, interfaces and packages too.

Turning your code into building blocks is fun. Other people can use the blocks in their programs too! Who knows, maybe clients will want to hire you in Seattle after seeing your reusable code skills.

Let's get started! I'll show you my best techniques. By the end, you'll be an expert at reusable code like me. I'm excited for you to start sharing your code and helping more people.

Extract Logic into Reusable Classes

Let's talk about taking parts of your code and putting them into classes! This is so useful when you find yourself writing the same things over and over.

Examples of common reusable classes

For example, say you always validate user data the same way. You could make a UserValidator class with methods like validateName().

class UserValidator {
  public function validateName($name) {
    // validation logic
  }
}

Another idea is a Mapper class that changes data from one format to another.

Guidelines for designing reusable classes

When making reusable classes, keep them focused on one thing. The validator class is just for validation.

Also make sure the classes don't rely on things outside itself. The validator shouldn't care where the data comes from.

Try to plan for how others may use your class too. Add descriptive names and comments to your code.

Reusable classes help DRY up your code (Don't Repeat Yourself). Just include the class and call the methods you need.

Use Traits for Common Behaviors

Traits are really handy for putting together bits of code that you want to include in different classes.

Examples of reusable traits

A common trait is SoftDeletes, which adds "deleted_at" and scopes to check for deleted objects.

trait SoftDeletes {

  public function scopeWithTrashed($query) {
    return $query->withTrashed();
  }

  // other deletion methods
}

Creating well-designed traits

When making traits, keep them focused on one behavior. SoftDeletes should only deal with deleting/restoring.

Avoid hard dependencies and external data in your traits. They should work anywhere they are used.

Add documentation so others understand the trait's purpose and how to use it correctly.

Traits are great for modeling cross-cutting concerns like timestamps, slugs, or other repetitive tasks. Keep your classes light by moving shared logic into reusable traits!

Bundle Logic into Packages

When you have a lot of reusable code, it's time to package it up!

When to create packages

If you find yourself including the same files in multiple projects, that's a sign it's package material. Anything others could download and use too.

Folder structure and namespaces

Packages generally follow a simple folder structure and namespaces so they are easy to use. Having a good readme helps explain how to install and use it.

Using existing packages as references

Check out popular open source packages like Laravel packages or others on Packagist. You can see examples of code organization, documentation and distribution that help users adopt it smoothly.

Packaging your code keeps it organized and lets you share that usefulness with the whole community. Others can simply install it with Composer and get your reusable magic!

Leverage Laravel Components

Laravel already gives us amazing tools to build on!

Core Laravel components

Some major ones are Eloquent for databases, Collections for arrays, and Blades for views. These were made to be extended.

Building on core components

For example, you could build a JSON API by adding methods to the Eloquent Model class. Or extend Blade with custom directives for your templates.

Collections are so useful - you'll find yourself wanting to add reusable methods there too.

The framework does the heavy lifting so focus on your custom logic. Leverage the solid foundations Laravel provides to easily create reusable solutions.

Distribute with Composer

Once your package is ready, Composer makes it easy to share!

Introduction to Composer

Composer manages PHP dependencies. To use a package, you just add it to your composer.json file.

"require": {
  "vendor/package": "^1.0"
}

Publishing packages to Packagist

Upload your package to Packagist so anyone can find it with a search.

Including packages in projects

From the project folder, run composer install to download. Then in PHP use:

require_once 'vendor/autoload.php';

$class = new Vendor\Package\Class;

With Composer, your packages can be used by anyone with a single command. Distribute that reusable goodness far and wide!

Here are the interfaces sections with code examples:

Standardize Contracts with Interfaces

Interfaces provide a common contract for classes to follow.

Benefits of interfaces

They allow classes to be interchangeable if they follow the same interface. Great for testing too.

Common interface examples

A CrudInterface could mandate find/create/update methods:

interface CrudInterface {

  public function find(int $id);

  public function create(array $data);

  public function update(int $id, array $data);

}

A ModelInterface may expect properties like $table and relations:

interface ModelInterface {

  public function getTable();

  public function relations();

}

Interfaces ensure classes work the same way even if internal logic varies. They let code depend on standardized behaviors.

Contracts promote code consistency, testability and reuse across applications. Define expected class APIs with interfaces!

Conclusion

Writing reusable code has really improved my craft as a developer. It used to be that I would just build one-off scripts and functions without much thought for how others could leverage my work. But since learning techniques like extracting logic, using interfaces and publishing packages, I've found so much more satisfaction in my code.

Nothing fills me with more pride than hearing how a package I created helped someone else complete a project faster or build something really cool. And it's rewarding to maintain reusable code over time, adding new features and keeping it useful for an ever-growing audience. More than that, focusing on reusability has made me a better problem solver. I understand code organization and design patterns at a deeper level now.

Most of all, producing reusable code that spreads value to others has uncovered for me the true joy of this profession. While the work itself can be challenging at times, remembering why we do it makes all the difference. I'm thrilled to be part of uplifting the developer community in this small way, and I hope sharing these lessons proves equally helpful for your journey too.

Buttery-Smooth infinite scrolling with Laravel

Isra Skyler — Thu, 02 Nov 2023 14:51:37 +0000

As an experienced Laravel developer, I've been on a quest to find the perfect solution for smooth infinite scrolling. Many approaches failed under heavy usage until I successfully optimized a client's website. They needed thousands of products to stream continuously for their shoppers. Once I implemented my technique, even our most heavily populated categories breezed by effortlessly. The client was ecstatic and immediately decided to hire Laravel Developers in Bellevue to expand their flagship store. And now, I'm eager to share the secrets that led to their incredible success. In this piece, I'll guide you through crafting lightning-fast infinite scrolling, meeting the needs of even the most scroll-hungry users. Picture this: improved performance means happier customers and fewer headaches. Doesn't that sound appealing?

Laying the Groundwork

For this project, I opted for the latest Laravel 8 release for its blade components and improved routing. I also utilized Bootstrap for basic styling, jQuery for simplified DOM manipulation, and the Infinite Scroll library for smooth loading.

Folder Structure

My file organization mirrored Laravel's default structure with a few custom tweaks:

app/
- Models
- Http/Controllers
database/
- migrations
- seeds
resources/
- js/
- css/
- views/

Setting Up the Database

The products were fetched from a SQLite database. I created a 'products' table with fields like id, title, and image using migrations.

Designing the Database

For this demo, I designed a simple 'products' database with only three fields: id, title, and image. The id is an auto-incrementing primary key, while title and image are text fields.

Creating the Models

Eloquent models served as the object-oriented interface to interact with the database. I generated a 'Product' model corresponding to the products table:

class Product extends Model {
    protected $fillable = ['title', 'image'];
    protected $table = 'products';
}

With the models and schema ready, the next step was to build a RESTful API to serve the product data.

Creating the API

Building the Pagination Controller

I generated an API controller to handle requests for paginated products data:

php artisan make:controller Api/ProductController

Writing the API Endpoint

The controller method accepted a page parameter to determine the data slice:

public function index($page) {
    $perPage = 12;
    $products = Product::paginate($perPage);
    return response()->json($products);
}

Testing with Postman confirmed the correct pagination of large product result sets to support eventual infinite scrolling of records.

Implementing Infinite Scroll

Adding the Infinite Scroll Plugin

I installed the jQuery Infinite Scroll plugin through NPM and added it to my main JS file.

Configuring Plugin Settings

The plugin required specification of the container to monitor for scrolling and where to insert new content.

Calling the API on Scroll

Each scroll triggered a new request to fetch the subsequent page.

Displaying Loaded Products

The response data was used to build and insert new product elements into the container, activating the infinite scroll.

Additional Enhancements

Handling Loading State

I added a loading indicator to replace products during data loading.

Automatic vs. Manual Scrolling

The plugin supported both behaviors; I chose manual scrolling for better user control.

Filtering Search Results

A search box allowed users to dynamically filter results using query parameters that modified the dataset.

Optimizing Performance

To prevent duplicate requests, I checked for ongoing loading by the user before subsequent scrolls. Additionally, response data was cached in memory for identical future queries, resulting in a seamless infinite loading experience for catalogs with thousands of products.

Conclusion

The journey to create performant infinite scroll in Laravel was an incredible learning experience. Breaking down the problem into incremental steps made the solution surprisingly straightforward. What initially seemed a frustration with a sluggish user experience transformed into a fascinating technical challenge. My hope is that you now feel empowered to apply these techniques to your own Laravel projects. Beyond the code, the most fulfilling part was witnessing how a small optimization could significantly enhance the end user experience. Undoubtedly, there's always room for improvement. As site traffic and data volumes grow, more advanced caching, database patterns, and front-end logic might become necessary. However, this approach serves as an excellent starting point before delving into complex solutions. Remember, when endless scrolling appears impossible, with a touch of ingenuity, Laravel makes it surprisingly achievable. Keep learning, keep building, and relish the satisfaction of well-crafted projects. May your future development ventures be as rewarding as this one was for me.

The Rebel Language That Rules the Web

Isra Skyler — Mon, 25 Sep 2023 14:10:08 +0000

So, picture this: I used to be that coder who raised an eyebrow at PHP. All those Silicon Valley tech enthusiasts and YouTube stars couldn't stop singing praises for the 'cooler' languages like Python and JavaScript. They made it sound like PHP was just a relic of the past. But then, I stepped into the real world of coding, working on projects for actual businesses, and guess what? The stats told a different story – PHP was everywhere, especially in the realm of small businesses. I was starting to work at Hybrid and everyday, the most work we had was on PHP.

Then I thought let’s be a rebel, just like PHP. When everyone says that PHP is dead, let's talk about why it is still hanging on. What you read was not a clickbait but a serious conversation pending for a long time. Let's spill all the beans on why that is so, even when the cool kids look the other way. Plus, I'll share my secret sauce for choosing the right language for your projects – it's all about facts, not fads. Brace yourself, it's bound to be an eye-opener! 😉

What Makes PHP A Juggernaut?

In 2023, PHP commands a whopping 78% of websites globally. Yes, you read that right – nearly 4 out of 5 websites rely on PHP. And when it comes to content management systems, WordPress, built in PHP, reigns supreme with a staggering 60% market share.

But why does PHP persist? Well, its user-friendly nature is a big reason. For newcomers and small businesses entering the web game, PHP offers a gentle learning curve – no complex frameworks or dependencies needed. Just find a server that supports it, upload your PHP files, and you're good to go.

PHP also found its footing during the web's infancy, catering to startups hungry for rapid, cost-effective development. While other languages focused on the big league enterprise, PHP democratized web building for the underdogs.

Once entrenched, technology is hard to dislodge. Millions of PHP sites stand because migration would be colossal. With such a vast PHP ecosystem, it's a pragmatic choice for many.

Modern PHP (versions 5.6, 7.x, and 8.x) is no slouch. It's secure, scalable, and enterprise-ready. PHP 8, the latest iteration, packs even more punch for complex systems.

Sure, other languages have dazzled – Java, C#, Python, Ruby, JavaScript, Go – each with its niche. But PHP thrives in real-world scenarios, despite its elitist detractors.

Why Such Hate?

So, why does PHP bear the brunt of developer disdain, even as it powers a significant chunk of the web?

Much of the flak stems from PHP's humble beginnings as a beginner-friendly language. Born in the '90s, its simplicity aimed to welcome newcomers to web development. However, this led to it being labeled as an "amateur" or "toy" language, a favorite target for prestigious devs.

Compare PHP's accessibility to languages like Java, C#, and Python, designed for enterprise-level complexity. The latter seemed like the choice of the pros. PHP bashers used it as a badge of superiority – "I'd never touch PHP."

PHP's inconsistent syntax didn't help its case, with quirks that became fodder for ridicule.

Hipsters reveled in hating on PHP as overhyped and mainstream. It became the cool, rebellious stance among coders to scorn it.

But behind the scenes, PHP quietly evolved. Object-oriented features in PHP 5, the rise of frameworks like Laravel, performance boosts in PHP 7, and enterprise-ready PHP 8 painted a different picture.

Yet, first impressions linger. PHP's early reputation as unsophisticated stuck with purists, more focused on theory than real-world results.

In reality, no language is universally "better" or "worse." Each has its place. But developers can be opinionated. PHP's accessible roots made it an easy target for snobbery.

Then there is another factor, Boomers. All the boomers who are developers since ancient times or know a bit about development just only want PHP. Like our company provides PHP development Services in Seattle and the most of our clients who want us to work with them on Laravel or PHP are boomers. So this association also gives a hint that it is a relic of past.

What Language Should You Choose?

So when it comes to choosing languages for your own projects, how do you cut through the hype and technical elitism to make the best choice?

First, take a hard look at your specific goals, target audience, timeline, budget and business needs. Are you a small startup trying to build an MVP as quickly and cheaply as possible? Or an established enterprise with long term scalability concerns? Identify your constraints.

Then, examine the ecosystem surrounding each language. For example, while Ruby on Rails may be elegant, there's a smaller pool of developers skilled in it which could make hiring difficult. Meanwhile, Java has a massive ecosystem but also more ceremony around frameworks like Spring.

Look critically at the dependencies and tooling too. For instance, JavaScript's npm was notoriously fragile, causing "dependency hell" when packages broke. Languages with more oversight like C# avoid this issue.

Also consider hosting and deployment factors. PHP is easy to host anywhere. But deploying, say, a complex Dockerized microservices app requires more orchestration.

Legacy technology plays a role too. Rewriting an older PHP system into a trendy new stack may not be worth the resources. Enhancing it incrementally could be smarter.

And don't overlook language familiarity in your own team. Leveraging existing skills boosts productivity dramatically. A less popular language may have a steeper learning curve.

Beyond that, analyze usage statistics in your industry rather than broad hype. While Python may be very popular overall, is PHP or .NET more common for the types of applications you build? Let real-world data guide you.

Most importantly, don't let peer pressure sway you. Developers can become religious about their preferred languages for emotional rather than practical reasons. Make a rational choice based on evidence.

Every language brings distinct advantages that make it suitable for certain use cases. The "best" choice depends on context. For example, while I love Python's elegance, for web-based business apps I often turn to PHP or JavaScript for their ubiquity.

Every technology has downsides too. But used strategically, even imperfect tools can build something incredible. Focus on the business problem first, then choose the language that pragmatically makes the most sense.

Don't Believe the Hype - Examine the Evidence

So what are the key lessons we can learn from taking an honest look at PHP's ongoing prominence compared to the hype around trendier languages?

Focus on statistics, not opinions.

Programming language discourse online can get extremely inflammatory and tribal. But rather than getting sucked into the zealotry, stay objective. Look at hard data on usage and job demand to see the full picture. The numbers don't lie.

Evaluate tools in context.

No language is the unequivocal "best" or "worst" universally. Each has pros and cons that make it suitable for different purposes. Make choices based on your specific constraints and use cases, not abstraction.

Right tool for the job.

Given the same task, an artisan woodworker and a mechanical engineer would use very different tools. Similarly, different languages excel at certain jobs. Select what pragmatically makes the most sense.

Don't reinvent the wheel.

Before discarding legacy systems to jump on trends, consider incremental improvement. A bird in the hand is worth two in the bush. Refactoring working code into new tech may not be worth it.

Beware the hype cycle.

Developers chase after the hot new thing constantly. But early-stage languages lack maturity and stability. Their pitfalls aren't yet known. Proven languages have already dealt with growth pains.

Stay flexible.

Languages come and go. Frameworks rise and fall. Sticking dogmatically to just one narrow skillset leaves you vulnerable. Maintain breadth across languages and embrace learning.
Watch for elitism. Some developers disparage certain languages irrationally to sound sophisticated. But use by beginners doesn't make a language inherently bad. Judge tools by their utility alone.

Focus on transferable skills.

While syntax differs, core concepts like logic and problem-solving translate across languages. Invest in honing those rather than fixating on one language.

At the end of the day, no one language or technology will ever dominate all use cases. As developers, we have an incredible array of tools at our fingertips, each with strengths suited for particular applications. Stay open-minded, focus on business value, and let real data guide your technology choices. The hype will fade, but good code endures. Peace! ✌

References

PHP usage statistics: https://w3techs.com/technologies/details/pl-php
WordPress market share: https://w3techs.com/technologies/details/cm-wordpress
PHP versions: https://www.php.net/releases/ Latest PHP 8.2 features: https://www.php.net/releases/8.2/en.php
Laravel framework: https://laravel.com npm dependency issues: https://npm.github.io/how-npm-works-docs/theory-and-design/dependency-hell.html
JavaScript frameworks: https://expressjs.com, https://angular.io
Web development basics: https://www.w3schools.com/