Elixir og Phoenix: Skalerbar backend-udvikling · Lektion

Enhedstest med ExUnit

Skriv hurtige og pålidelige enhedstests til Deres Elixir-moduler og -funktioner med den indbyggede ExUnit-framework.

Lektion 1 af 410 trin

Enhedstest med ExUnit er en gratis Elixir og Phoenix: Skalerbar backend-udvikling-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Elixir og Phoenix: Skalerbar backend-udvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

Introduktion til ExUnit

Velkommen til enhedstest med ExUnit! ExUnit er Elixirs indbyggede testrammeværk, der er udviklet til at hjælpe dig med at skrive pålidelig og vedligeholdelsesvenlig kode.

Enhedstest fokuserer på små, isolerede dele af din kode, f.eks. individuelle funktioner eller moduler. De sikrer, at hver komponent fungerer som forventet, så du kan være tryg ved at udvide din applikation.

Din første ExUnit-test

Elixir-testfiler ender typisk med _test.exs og placeres i en test/-mappe. I filen bruger du use ExUnit.Case for at få testfunktionaliteten med.

En testblok starter med test "description" do ... end. Her er et enkelt eksempel:

defmodule MyMath do
  def add(a, b), do: a + b
end

defmodule MyMathTest do
  use ExUnit.Case, async: true

  test "adds two numbers correctly" do
    assert MyMath.add(1, 2) == 3
  end
end

Kontrol med `assert`

Den mest almindelige påstand i ExUnit er assert. Den kontrollerer, om et udtryk evalueres til en sandhedsværdi (alt andet end false eller nil).

Du bruger den ofte til at sammenligne forventede resultater med de faktiske resultater.

defmodule Calculator do
  def multiply(a, b), do: a * b
end

defmodule CalculatorTest do
  use ExUnit.Case, async: true

  test "multiplies positive numbers" do
    assert Calculator.multiply(2, 3) == 6
  end

  test "multiplies by zero" do
    assert Calculator.multiply(5, 0) == 0
  end
end

Afvisning med `refute`

Nogle gange vil du sikre dig, at noget ikke er sandt. Det er her, refute kommer ind i billedet. Den er det modsatte af assert.

refute lykkes, hvis argumentet evalueres til en falsk værdi (false eller nil).

defmodule Validator do
  def is_negative(num), do: num < 0
end

defmodule ValidatorTest do
  use ExUnit.Case, async: true

  test "refutes positive numbers as negative" do
    refute Validator.is_negative(10)
    refute Validator.is_negative(0)
  end

  test "asserts negative numbers" do
    assert Validator.is_negative(-5)
  end
end

Test af undtagelser

Hvad nu, hvis din funktion skal rejse en fejl under bestemte betingelser? assert_raise lader dig teste dette!

Du angiver den forventede type af undtagelsen og eventuelt en besked sammen med en funktion, der skal udløse fejlen.

defmodule Divider do
  def divide(a, b) do
    if b == 0, do: raise(ArgumentError, "Cannot divide by zero"), else: a / b
  end
end

defmodule DividerTest do
  use ExUnit.Case, async: true

  test "raises ArgumentError for division by zero" do
    assert_raise ArgumentError, "Cannot divide by zero", fn ->
      Divider.divide(10, 0)
    end
  end
end

Opsætning af testkontekst

Mange test har brug for en fælles opsætning, f.eks. oprettelse af en midlertidig ressource eller en mock-bruger. ExUnits setup-callback køres før hver test i et modul.

Den skal returnere {:ok, assigns}, hvor assigns er en nøgleordsliste eller et map, som er tilgængeligt i argumenterne til din testfunktion.

defmodule UserProfileTest do
  use ExUnit.Case, async: true

  setup do
    # This runs before each test
    user = %{id: 101, name: "Jane Doe", email: "jane@example.com"}
    {:ok, user: user, admin: true}
  end

  test "user has a name", %{user: user} do
    assert user.name == "Jane Doe"
  end

  test "context includes admin flag", %{admin: admin_status} do
    assert admin_status == true
  end
end

Gruppering af test med `describe`

Efterhånden som dine testfiler vokser, vil du måske gruppere relaterede test logisk. Makroen describe hjælper med at organisere test i et modul, så din testsamling bliver mere overskuelig.

Du kan endda indlejre describe-blokke!

defmodule StringUtils do
  def capitalize(str), do: String.capitalize(str)
  def reverse(str), do: String.reverse(str)
end

defmodule StringUtilsTest do
  use ExUnit.Case, async: true

  describe "capitalize/1" do
    test "capitalizes first letter" do
      assert StringUtils.capitalize("hello") == "Hello"
    end

    test "handles empty string" do
      assert StringUtils.capitalize("") == ""
    end
  end

  describe "reverse/1" do
    test "reverses a string" do
      assert StringUtils.reverse("world") == "dlrow"
    end
  end
end

Kørsel af dine test

Når du har skrevet dine test, er det enkelt at køre dem ved hjælp af Elixirs build-værktøj, Mix.

Sådan kører du alle test i dit projekt: mix test
Sådan kører du test i en bestemt fil: mix test test/my_module_test.exs
Sådan kører du en bestemt test efter linjenummer: mix test test/my_module_test.exs:10
Sådan kører du test, der matcher en beskrivelse: mix test --only "adds two numbers"

ExUnit-udfordring

Overvej følgende Elixir-modul, der er udviklet til at kontrollere, om et tal er ulige. Hvilken ExUnit-påstand tester korrekt, om NumberChecker.is_odd(5) returnerer true?

defmodule NumberChecker do
  def is_odd(n) when is_integer(n) do
    rem(n, 2) != 0
  end
end

Besvar den i den interaktive lektion

Opsummering af enhedstest

Flot klaret! Du har gennemgået grundprincipperne i enhedstest med ExUnit.

ExUnit er Elixirs indbyggede testrammeværk.
Test defineres i _test.exs-filer ved hjælp af use ExUnit.Case.
assert kontrollerer sandhedsværdier, mens refute kontrollerer falske værdier.
assert_raise bekræfter, at bestemte undtagelser bliver rejst.
setup-callbacks forbereder konteksten for dine test.
describe-blokke hjælper med at organisere relaterede test.
Du kører test ved hjælp af mix test.

Disse færdigheder er afgørende, når du vil opbygge robuste og pålidelige Elixir-applikationer!

Gratis at komme i gang

Lær Elixir med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Enhedstest med ExUnit” gratis?

Ja — hele teksten til “Enhedstest med ExUnit” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Elixir og Phoenix: Skalerbar backend-udvikling-kurset, skal du opgradere til CoddyKit PRO. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Enhedstest med ExUnit”?

Skriv hurtige og pålidelige enhedstests til Deres Elixir-moduler og -funktioner med den indbyggede ExUnit-framework. Du øver dig i Elixir og Phoenix: Skalerbar backend-udvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Elixir og Phoenix: Skalerbar backend-udvikling?

Der kræves ingen tidligere erfaring. Elixir og Phoenix: Skalerbar backend-udvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Enhedstest med ExUnit”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Elixir og Phoenix: Skalerbar backend-udvikling-lektion?

Ja. Alle Elixir og Phoenix: Skalerbar backend-udvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Enhedstest med ExUnit
Integrationstest af Phoenix-applikationer
Mocking, stubs og testdata
Egenskabsbaseret testning med StreamData

← Tilbage til Elixir og Phoenix: Skalerbar backend-udvikling