Czy Mongo działa?

Żeby sprawdzić status MongoDB, wystarczy uruchomić komendę:

Dla wersji Mongo < 2.6:

sudo service mongodb status

lub:

Dla wersji Mongo >= 2.6:

sudo service mongod status

Status

Jeśli działa w odpowiedzi dostaniesz:

● mongod.service - MongoDB Database Server
   Loaded: loaded (/lib/systemd/system/mongod.service; disabled; vendor preset: enabled)
   Active: active (running) since Fri 2023-08-18 01:50:08 EDT; 18s ago
     Docs: https://docs.mongodb.org/manual
 Main PID: 4585 (mongod)
   CGroup: /system.slice/mongod.service
           └─4585 /usr/bin/mongod --config /etc/mongod.conf

A jeśli nie działa to:

● mongod.service - MongoDB Database Server
     Loaded: loaded (/lib/systemd/system/mongod.service; disabled; vendor preset: enabled)
     Active: inactive (dead)
       Docs: https://docs.mongodb.org/manual

Czym jest Optional?

Swift daje programiście do ręki typ danych o nazwie Optional, który służy do przechowania jakiejś wartości lub nic (nil). Ten typ można porównać do pudełka, które może coś posiadać lub będzie puste.

Jest to przydatne szczególnie wtedy, gdy nie jesteśmy pewni, czy do zmiennej przypisana zostania jakaś wartość.

Domyślną wartością dla Optional jest nil — co oznacza brak wartości.

Jeśli zmienna oznaczona jako Optional ma wartość, jest ona opakowana przez typ Optional.

Jak stworzyć Optional?

Typ Optional można stworzyć na kilka sposobów:

var a: Optional<String> = "Test 1"
var b: String? = "Test 2"
var c: String! = "Test 3"
var d: String?
var e: String!

print(a) // Optional("Test 1")
print(b) // Optional("Test 2")
print(c) // Optional("Test 3")
print(d) // nil
print(e) // nil

Jak widać każda zmienna, która nie jest nil — która ma wartość, jest opakowana w Optional. Jak dostać się do tej wartości?

Jak pobrać wartość z Optional?

String i Optional (lub: String?) to dwa różne typy danych! Na Optional powinieneś patrzeć, jak na kontener, który może coś zawierać bądź nie (nil).

Dostęp do wartości Optional

Jeśli zmienna/stała przechowuje nil dostęp do niej łatwy. Żeby wyłuskać wartość z Optional, możesz napisać:

var a: String? = "Test 1"
print(a!) // Test 1

Zauważ, że jeśli napiszesz:

var a: String? = "Test 1"
print(a) // Optional<Test 1>

masz dostęp do Optional, które zawiera wartość.

Optional rozpakowany

Taki zapis:

var a: String! = "Test 1"
print(a) // Test 1

sprawia, że Optional zostanie stworzony. Ale zauważ, żeby pobrać wartość, nie musisz już użyć !.

Z takim zapisem należy uważać:

var a: String!
print(a.count)

W tym przypadku program się wysypie. Ponieważ a jest nil. Dlatego, zanim to użyjesz, warto mieć pewność, że zmienna posiada wartość.

Inny przykład:

var a: String!
var b: String = a

W momencie przypisania a do b program także przestanie działać. Dzieje się tak dlatego, bo a jest nil. Przy próbie przypisania tego do b powoduje błąd. Próba przypisania nil do zmiennej, która nie jest Optional spowoduje błąd.

Jak poradzić sobie z takimi sytuacjami?

Czy Optional ma wartość?

Istnieje kilka sposób na sprawdzenie, czy Optional posiada wartość. Poniżej lista:

Instrukcja if

var a: String?

if a != nil {
  print(a)
}

Instrukcja if-let

var a: String?

if let tempA = a {
  print(tempA)
}

Tutaj tworzona jest zmienna tymczasowa: tempA. Jeśli a nie jest nil do tempA przypisana jest wartość i warunek jest spełniony.

Instrukcja guard

var a: String?

guard a {
  return
}

print(a!)

Operator ??

var a: String?

print(a ?? '')

Operator ?? spróbuje pobrać wartość z a. Jeśli jest to nil, zwróci to co podałeś po prawej stronie operatora. W tym przypadku pusty ciąg znaków.

Biblioteka

W tym wpisie podam przykład symulacji kliknięcia za pomocą biblioteki user-event.

Zanim zaczniemy, upewnij się, że masz ją zainstalowaną.

Instalacja

Żeby zainstalować, wywołaj:

npm install --save-dev @testing-library/user-event

Podstawy

Aby zacząć korzystać z user-event, musisz spełnić dwa warunki.

Pierwszy warunek: oznacz test jako asynchroniczny za pomocą async:

test('should ...', async () => {
    ...
});

Drugi warunek: wywołaj metodę setup:

import userEvent from '@testing-library/user-event';

test('should ...', async () => {
    const user = userEvent.setup();
});

Przykład

Komponent:

import {useState} from "react";

export function MyComponent() {
    const [state, setState] = useState(0);

    return (
        <>
            <div>
                {state}
            </div>
            <div>
                <button onClick={() => setState((prevState: number) => prevState + 1)}>Increment</button>
                <button onClick={() => setState((prevState: number) => prevState - 1)}>Decrement</button>
            </div>
        </>
    )
}

Testy:

import {render, screen} from '@testing-library/react'
import userEvent from '@testing-library/user-event';
import {MyComponent} from "./MyComponent";

const { getByRole, getByText } = screen;

test('should increment counter', async () => {
    // given
    const user = userEvent.setup();
    render(<MyComponent />);
    const btnIncrement = getByRole('button', { name: "Increment"});

    // when
    await user.click(btnIncrement);

    // then
    expect(getByText('1')).toBeInTheDocument();
});

test('should decrement counter', async () => {
    // given
    const user = userEvent.setup();
    render(<MyComponent />);
    const btnDecrement = getByRole('button', { name: "Decrement"});

    // when
    await user.click(btnDecrement);

    // then
    expect(getByText('-1')).toBeInTheDocument();
});

Pobieranie referencji

Biblioteka React Testing Library daje programiście do ręki zestaw funkcji, które pozwalają na pobranie referencji do elementu w komponencie.

Te zapytania dzięlą się na trzy grupy:

1. getBy - Zapytanie zwraca referencję do elementu. Dodatkowo zostanie zasygnalizowany błąd w dwóch przypadkach: jeśli referencja nie została znaleziona lub zostało znalezionych więcej niż jeden element.
2. queryBy - Jeśli element nie został znaleziony zwróci null. To zapytanie jest przydatne kiedy potrzebujesz stestować przypadek, że dany element nie istnieje. Zasygnalizuje błąd jeśli zostało znalezionych więcej niż jeden element.
3. findBy - Zwraca Promise, która zawiera referencję do danego elementu. Promise zostanie odrzucona jeśli element nie został odnaleziony lub jeśli znalezionych zostało więcej niż jeden element po upływie 1000 milisekund (1 sekunda). Przydaje się więc w operacjach asynchronicznych.

Jeśli potrzebujesz pobrać więcej niż jeden element po danych kryteriach możesz użyć też: getAllBy, queryAllBy, findAllBy.

Przykłady

getByRole

Służy do pobrania referencji do elementu bazując na roli, jaką pełni element w dokumencie, w rozumieniu szeroko pojętej dostępności (ang.: accessibility). Na przykład czy jest to: przycisk, nagłówek, lista itp.

Przykład:

Komponent:

export function MyComponent() {
    return (
        <>
            <div>
                <h1>My header</h1>
            </div>
        </>
    )
}

Test:

import {render, screen} from '@testing-library/react';
import {MyComponent} from "./MyComponent";

test('some test', () => {
    // given
    const { getByRole } = screen;
    render(<MyComponent />);
    const heading = getByRole('heading');

    // when - then
    expect(heading).toHaveTextContent('My header');
});

Można też pobrać element na podstawie jego nazwy:

Komponent:

import {useState} from "react";

export function MyComponent() {
    const [state, setState] = useState(0);

    return (
        <>
            <div>
                <h1>{state}</h1>
            </div>
            <div>
                <button onClick={() => setState((prevState: number) => prevState + 1)}>Increment</button>
                <button onClick={() => setState((prevState: number) => prevState - 1)}>Decrement</button>
            </div>
        </>
    )
}

Żeby zdobyć referencję dla przycisku o nazwie: Increment wystaczy napisać:

const btnIncrement = getByRole('button', { name: /Increment/i});

Zauważ, że użyte zostało tutaj wyrażenie regularne.

Można też po prostu napisać:

const btnIncrement = getByRole('button', { name: "Increment" });

getByLabelText

Dokumentacja zaleca używania tej funkcji, gdy potrzebujesz mieć dostęp do pola z formularza.

Zwykle każde pole ma własną etykietę (a przynajmniej powinno mieć). Więc naturalne jest, że będziemy szukać danego pola po jego etykiecie.

Przykład:

Komponent:

export function MyComponent() {
    return (
        <>
            <form>
                <label htmlFor="name">Name</label>
                <input id="name" value="Default name" />
            </form>
        </>
    )
}

Test:

import {render, screen} from '@testing-library/react';
import {MyComponent} from "./MyComponent";

test('should field has default value', () => {
    // given
    const { getByLabelText } = screen;
    render(<MyComponent />);
    const field = getByLabelText('Name');

    // when - then
    expect(field).toHaveValue('Default name');
});

getByDisplayValue

Jest podobne do getByLabelText różnica jest taka, że ta funkcja znajdzie Ci referencję, do elementu formularza na podstawie wartości, którą to pole zawiera.

Komponent:

export function MyComponent() {
    return (
        <>
            <form>
                <label htmlFor="name">Name</label>
                <input id="name" value="Default name" />
            </form>
        </>
    )
}

Test:

import {render, screen} from '@testing-library/react';
import {MyComponent} from "./MyComponent";

test('should field has default value', () => {
    // given
    const { getByDisplayValue } = screen;
    render(<MyComponent />);
    const field = getByDisplayValue('Default name');

    // when - then
    expect(field).toBeInTheDocument();
});

getByText

Tej funkcji należy używać, gdy chcemy pobrać referencję do elementów, które nie są interkatywne. Jak na przykład div'y, akapity itp.

Przykład:

Komponent:

import {useState} from "react";

export function MyComponent() {
    const [counter] = useState(10);

    return (
        <>
            <h1>Counter: {counter}</h1>
        </>
    )
}

Test:

import {render, screen} from '@testing-library/react';
import {MyComponent} from "./MyComponent";

test('should counter be 10 as default', () => {
    // given
    const { getByText } = screen;
    render(<MyComponent />);
    const counter = getByText('Counter: 10');

    // when - then
    expect(counter).toBeInTheDocument();
});

W lipcu opublikowałem 4 wpisy:

Blog

1. Motyw graficzny

React

1. Do czego służy memo?

MongoDB

1. Jak skasować kolekcję?

Opublikowałem jeden komiks:

1. The Comfort Zone

Przeczytałem dwie książki:

1. Pogrzebany olbrzym - Kazuo Ishiguro
2. Elegia dla bidoków - J. D. Vance

Przesłuchałem pięć audiobook'ów:

1. 1000+ Little Things Happy Successful People Do Differently - Marc Chernoff, Angel Chernoff
2. Mind Management, Not Time Management - David Kadavy
3. The Pathless Path - Paul Millerd
4. Drobiazgi takie jak te - Claire Keegan
5. Martwe lwy - Mick Herron