開発スタッフがアプリ関連の最新技術やニュースをご紹介します。

UUIDs, or Universally Unique Identifiers, are strings of characters used to uniquely identify information in computer systems. They play a crucial role in various applications, from databases to distributed systems. In this blog, we will explore the different versions of UUIDs, each designed for specific use cases and scenarios.

1. UUID Basics

Before delving into the versions, it’s essential to understand the basic structure of a UUID. A UUID is a 128-bit number typically represented as a 32-character hexadecimal string, separated by hyphens into five groups. The uniqueness of UUIDs is achieved by combining timestamps, node information, and random or pseudo-random numbers.

2. UUID Version 1: Time-based UUIDs

UUID version 1 is based on the current timestamp and the unique node (typically a MAC address) to ensure uniqueness. The timestamp component allows sorting and ordering of UUIDs based on their creation time. While effective, the reliance on a timestamp makes it less suitable for scenarios where privacy and security are top priorities.

3. UUID Version 2: DCE Security UUIDs

Version 2 is similar to Version 1 but includes additional information related to the POSIX UID/GID and POSIX timestamps. However, Version 2 is rarely used in practice, and Version 1 is more widely accepted.

4. UUID Version 3 and 5: Name-based UUIDs (MD5 and SHA-1)

These versions are generated by hashing a namespace identifier and a name using MD5 (Version 3) or SHA-1 (Version 5). The resulting hash is then combined with specific bits to form the UUID. While these versions ensure uniqueness within a given namespace, the use of MD5 and SHA-1 has raised security concerns due to vulnerabilities in these hashing algorithms.

5. UUID Version 4: Random UUIDs

Version 4 UUIDs are generated using random or pseudo-random numbers. This version prioritizes randomness over time-based information, making it suitable for scenarios where ordering is less critical, and privacy is a priority. The randomness is achieved through the use of a random number generator.

6. UUID Version 6: Modified Version 1

A newer addition, Version 6 combines the best of both Version 1 and Version 4. It includes timestamp information for ordering and randomness for improved security. This version is designed to address some of the privacy concerns associated with Version 1.

Conclusion

Understanding the different versions of UUIDs is essential for choosing the right type based on the specific requirements of your application. Whether you prioritize time-based ordering, security, or randomness, there’s a UUID version designed to meet your needs. As technology evolves, so do UUID specifications, ensuring that these unique identifiers continue to play a vital role in the ever-expanding digital landscape.

Asahi

Tweet

In the ever-evolving landscape of web development, Node.js has established itself as a robust and scalable platform. One of the frameworks that has gained popularity within the Node.js ecosystem is Adonis.js. In this blog post, we’ll look into the world of Adonis.js, its key features, and the benefits that make it stand out in the crowded realm of web development.

Adonis.js is a full-featured, MVC (Model-View-Controller) framework for Node.js that takes inspiration from the elegant Laravel framework for PHP. The influence of Laravel is evident in Adonis.js’s syntax and the way it embraces conventions to simplify development. If you’re already familiar with Laravel, exploring Adonis.js should feel like a natural progression.

Key Features

1. Lucid ORM

   Adonis.js comes bundled with Lucid, its own Object-Relational Mapping (ORM) system. Lucid simplifies database interactions, allowing developers to work with databases using a fluent and easy-to-understand syntax. This makes it a breeze to perform database operations and relationships.

2. Powerful CLI

   The Command Line Interface (CLI) in Adonis.js is a developer’s best friend. It provides a set of powerful commands that automate common tasks, such as creating controllers, models, and migrations. This CLI significantly boosts productivity by eliminating the need for repetitive manual tasks.

3. Middleware

   Adonis.js embraces the concept of middleware, enabling developers to write reusable code that can be executed during the request-response lifecycle. Middleware in Adonis.js can be applied globally or on a per-route basis, providing flexibility and control over the application’s flow.

4. Authentication and Authorization

   Building secure applications is a top priority, and Adonis.js makes it easier with its built-in authentication and authorization system. It supports a variety of authentication methods and allows developers to define roles and permissions, ensuring that sensitive data is protected.

Benefits of Adonis.js

1. Productivity Boost

   The combination of a powerful CLI and an expressive syntax significantly accelerates the development process. Adonis.js empowers developers to focus on building features rather than spending time on boilerplate code.

2. Convention over Configuration

   Adonis.js follows the convention over configuration paradigm, which means developers can achieve a lot with minimal configuration. This promotes consistency across projects and reduces the cognitive load associated with complex setups.

3. Scalability

   With its modular structure and support for MVC architecture, Adonis.js is well-suited for building scalable applications. As your project grows, the framework provides a solid foundation for maintaining clean and organized code.

Conclusion

As you explore Adonis.js, the Laravel-inspired framework for Node.js, you’ll likely appreciate the seamless transition if you’re already familiar with Laravel. From the elegant syntax to the powerful CLI, built-in features like Lucid ORM and its clear documentation, Adonis.js stands out as a framework that combines simplicity with robust capabilities, taking cues from one of PHP’s most beloved frameworks.

Hope you enjoy that. Happy coding, fellas!

Asahi

Tweet

Laravel empowers developers to build efficient and robust APIs effortlessly. Feature testing is an indispensable aspect of ensuring the reliability and functionality of our APIs, especially when it involves user CRUD operations. In this blog post, we’ll take a step-by-step journey through the code to feature test a User CRUD API in Laravel.

Step 1: Setting Up the Test Environment

Create a test class file with the following command.

php artisan make:test UserCrudApiTest

The test class file created can be found at tests/Feature/UserCrudApiTest.php and codes are as follows.

<?php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Tests\TestCase;

class UserCrudApiTest extends TestCase
{
    /**
     * A basic feature test example.
     *
     * @return void
     */
    public function test_example()
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
}

Step 2: Define and modify the Test Class

Import necessary classes and traits. And remove default test_example method.

<?php

namespace Tests\Feature;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Tests\TestCase;
use App\Models\User;

class UserCrudApiTest extends TestCase
{
    use RefreshDatabase;
}

The `UserCrudApiTest` class is declared, extending `TestCase` and using `RefreshDatabase` for database isolation.

`RefreshDatabase` ensures a clean database state for each test, and `TestCase` is the base test case class. `User` is imported to create and interact with user models.

Step 3: Testing User Creation

public function test_user_can_be_created()
{
    $userData = [
        'name' => 'John Doe',
        'email' => 'john@example.com',
        'password' => bcrypt('password123'),
    ];

    $response = $this->json('POST', '/api/users', $userData);

    $response->assertStatus(201)
             ->assertJson([
                 'name' => 'John Doe',
                 'email' => 'john@example.com',
             ]);

    $this->assertDatabaseHas('users', [
        'name' => 'John Doe',
        'email' => 'john@example.com',
    ]);
}

This method tests the creation of a user. The `$this->json(‘POST’, ‘/api/users’, $userData)` line sends a POST request to create a user with the specified data. Assertions ensure a successful response, correct JSON structure, and that the user is stored in the database.

Step 4: Testing User Retrieval

public function test_user_can_be_retrieved()
{
    $user = factory(User::class)->create();

    $response = $this->json('GET', "/api/users/{$user->id}");

    $response->assertStatus(200)
             ->assertJson([
                 'name' => $user->name,
                 'email' => $user->email,
             ]);
}

This method tests the retrieval of a user. A user is created using the factory, and a GET request is made to fetch the user’s details. Assertions verify a successful response and the correctness of the returned data.

Step 5: Testing User Update

public function test_user_can_be_updated()
{
    $user = factory(User::class)->create();

    $updateData = [
        'name' => 'Updated Name',
        'email' => 'updated.email@example.com',
    ];

    $response = $this->json('PUT', "/api/users/{$user->id}", $updateData);

    $response->assertStatus(200)
             ->assertJson($updateData);

    $this->assertDatabaseHas('users', [
        'id' => $user->id,
        'name' => 'Updated Name',
        'email' => 'updated.email@example.com',
    ]);
}

This method tests updating a user’s details. A user is created, and a PUT request updates the user’s data. Assertions check for a successful response, the correctness of the returned JSON, and the updated data in the database.

Step 6: Testing User Deletion

public function test_user_can_be_deleted()
{
    $user = factory(User::class)->create();

    $response = $this->json('DELETE', "/api/users/{$user->id}");

    $response->assertStatus(204);

    $this->assertDatabaseMissing('users', ['id' => $user->id]);
}

This method tests the deletion of a user. A user is created, and a DELETE request is made to delete the user. Assertions ensure a successful response and confirm that the user is no longer present in the database.

After writing the necessary test methods, we can test with the following artisan command.

php artisan test --filter UserCrudApiTest

This command uses the --filter option to specify a particular test class, in this case, UserCrudApiTest. Only the tests within the UserCrudApiTest class will be executed.

The --filter option can also be used to run specific methods within a test class. For example:

php artisan test --filter UserCrudApiTest::test_user_can_be_created

Also php artisan test can be used to run all the tests in the application (all test files under tests dir).

Conclusion

Feature testing User CRUD operations in a Laravel API provides confidence in the functionality and reliability of the endpoints. Each step, from setup to testing each CRUD operation, contributes to a robust testing suite that helps maintain a high standard of code quality in our Laravel applications.

Hope you enjoy that.

Asahi

Tweet

Unit testing is a crucial aspect of any robust software development process. In Laravel, a popular PHP framework, writing unit tests is not only easy but also highly encouraged. In this tutorial, we will go through the basics of writing unit tests in Laravel, ensuring the reliability and stability of the individual code units.

Prerequisites

Before diving into writing unit tests, make sure the following prerequisites be installed:

1. Composer

2. Laravel Installed

3. PHPUnit

Setting Up a Laravel Project

Use the following commands to set up a new project:

composer create-project --prefer-dist laravel/laravel my-laravel-app

cd my-laravel-app

Creating a Unit Test

Laravel provides a convenient Artisan command to generate a test class. Let’s create a simple unit test for a hypothetical `Calculator` class:

php artisan make:test CalculatorTest --unit

This will generate a test file located at `tests/Unit/CalculatorTest.php`. Open the file and you’ll see a basic test structure.

Writing a Unit Test

Now, let’s write a unit test for a basic addition method in our `Calculator` class. Open `CalculatorTest.php` and modify it as follows:

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;
use App\Calculator;

class CalculatorTest extends TestCase
{
    public function testAddition()
    {
        $calculator = new Calculator();
        $result = $calculator->add(2, 3);

        $this->assertEquals(5, $result);
    }
}

In this example, assume we have a `Calculator` class in the `app` directory with an `add` method like that.

namespace App;

class Calculator
{
    public function add($a, $b)
    {
        return $a + $b;
    }
}

Running Unit Tests

To run the unit tests, use the following command:

php artisan test

This will execute all the tests in the `tests` directory.

Assertions

Laravel provides a variety of assertions that can be used in the tests. In this example, we used `assertEquals` to verify that the addition method returns the expected result. Explore other assertions and details in the official documentation https://laravel.com/docs/10.x/testing.

Conclusion

We’ve just written a first unit test in Laravel. As the application grows, writing tests for individual code units will become an integral part of the development process, ensuring that the code remains maintainable and reliable. Hope you enjoy that.

Asahi

Tweet

MongoDB is now officially in charge of the Laravel framework’s community-driven MongoDB integration! This signals a commitment to regular updates, enhancing functionality, fixing bugs, and ensuring compatibility with the latest releases of both Laravel and MongoDB.

Formerly recognized as jenssegers/laravel-mongodb, this library expands Eloquent, Laravel’s ORM, providing PHP developers working with MongoDB a seamless experience through Eloquent models, query builders, and transactions.

For those eager to integrate MongoDB with the Laravel framework, explore the most recent release of this library, which introduces support for Laravel 10 – Laravel MongoDB 4.0.0. If you’re embarking on MongoDB PHP projects, a tutorial on constructing a Laravel + MongoDB back-end service and comprehensive library documentation are readily available here.

By Asahi

Tweet