Elixir 1.7

ExUnit.Callbacks




elixir

ExUnit.Callbacks

एक्सयूनाइट कॉलबैक को परिभाषित करता है।

यह मॉड्यूल setup और setup_all दोनों कॉलबैक, साथ ही on_exit/2 , start_supervised/2 और stop_supervised/1 फ़ंक्शन को stop_supervised/1 करता है।

सेटअप कॉलबैक को मैक्रोज़ के माध्यम से परिभाषित किया जाता है और प्रत्येक को वैकल्पिक रूप से परीक्षण राज्य और मेटाडाटा के साथ एक नक्शा प्राप्त हो सकता है, जिसे आमतौर पर context रूप में संदर्भित किया जाता context । परीक्षण में उपयोग किए जाने वाले संदर्भ को सेटअप कॉलबैक द्वारा ठीक से संरचित मूल्य (नीचे देखें) लौटाकर वैकल्पिक रूप से बढ़ाया जा सकता है।

किसी भी परीक्षण से पहले setup_all कॉलबैक केवल एक बार प्रति मॉड्यूल setup_all जाता है। प्रत्येक परीक्षण से पहले सभी setup कॉलबैक चलाए जाते हैं। यदि परीक्षण मामले में कोई परीक्षण नहीं है या सभी परीक्षणों को फ़िल्टर नहीं किया गया है तो कोई कॉलबैक नहीं चलता है।

setup और setup_all दोनों को एक ब्लॉक द्वारा परिभाषित किया जा सकता है, एक परमाणु फ़ंक्शन को नामांकित करके, या ऐसे परमाणुओं की सूची पास करके। यदि कोई ब्लॉक द्वारा परिभाषित किया गया है, तो इसे पैरामीटर के रूप में निर्दिष्ट करके वर्तमान संदर्भ प्राप्त करने का विकल्प चुन सकते हैं परीक्षण सेटअप को परिभाषित करने के लिए उपयोग किए जाने वाले कार्यों को संदर्भ को एकल तर्क के रूप में स्वीकार करना चाहिए।

एक परीक्षण मॉड्यूल setup_all setup और setup_all कॉलबैक को परिभाषित कर सकता है, और वे उपस्थिति के क्रम में setup_all जाते हैं।

start_supervised/2 का उपयोग पर्यवेक्षक के तहत प्रक्रिया शुरू करने के लिए किया जाता है। पर्यवेक्षक वर्तमान परीक्षण प्रक्रिया से जुड़ा हुआ है। पर्यवेक्षक के साथ-साथ सभी बाल प्रक्रियाओं को किसी भी on_exit/2 कॉलबैक रन से पहले समाप्त करने की गारंटी है।

on_exit/2 कॉलबैक मांग पर पंजीकृत हैं, आमतौर पर एक सेटअप कॉलबैक द्वारा की गई कार्रवाई को पूर्ववत करने के लिए। on_exit/2 भी एक संदर्भ ले सकता है, जिससे कॉलबैक भविष्य में ओवरराइड हो सकता है। एक पंजीकृत on_exit/2 कॉलबैक हमेशा चलता रहता है, जबकि setup और setup_all में विफलताओं को क्रियान्वित करने से सभी शेष सेटअप कॉलबैक बंद हो जाएंगे।

अंत में, setup_all कॉलबैक प्रति मॉड्यूल एक अलग प्रक्रिया में चलता है, जबकि सभी setup कॉलबैक परीक्षण के रूप में उसी प्रक्रिया में चलते हैं। on_exit/2 कॉलबैक हमेशा एक अलग प्रक्रिया में चलते हैं, जैसा कि उनके नाम से निहित है। परीक्षण प्रक्रिया हमेशा कारण के साथ बाहर निकलती है :shutdown , जिसका अर्थ है कि परीक्षण प्रक्रिया से जुड़ी कोई भी प्रक्रिया भी बाहर निकल जाएगी, हालांकि अतुल्यकालिक रूप से। इसलिए तुल्यकालिक समाप्ति की गारंटी के लिए start_supervised/2 का उपयोग करना पसंद किया जाता है।

यहाँ परीक्षण प्रक्रिया के जीवन-चक्र का एक प्रकार है:

  1. परीक्षण प्रक्रिया को जन्म दिया है
  2. यह setup/2 कॉलबैक चलाता है
  3. यह परीक्षण स्वयं चलाता है
  4. यह सभी पर्यवेक्षित प्रक्रियाओं को रोकता है
  5. परीक्षण प्रक्रिया कारण के साथ बाहर निकलती है :shutdown
  6. on_exit/2 कॉलबैक को एक अलग प्रक्रिया में निष्पादित किया जाता है

प्रसंग

यदि setup_all या setup एक खोजशब्द सूची, एक मानचित्र, या {:ok, keywords | map} {:ok, keywords | map} , कीवर्ड सूची या मानचित्र को वर्तमान संदर्भ में विलय कर दिया जाएगा और बाद के सभी setup_all , setup और test में उपलब्ध होगा।

रिटर्निंग :ok संदर्भ को अपरिवर्तित छोड़ देता है ( setup और setup_all कॉलबैक में दोनों)।

setup_all से और कुछ भी वापस करने से सभी परीक्षण विफल हो जाएंगे, जबकि setup खराब प्रतिक्रिया से वर्तमान परीक्षण विफल हो जाता है।

उदाहरण

defmodule AssertionTest do
  use ExUnit.Case, async: true

  # "setup_all" is called once per module before any test runs
  setup_all do
    IO.puts "Starting AssertionTest"

    # Context is not updated here
    :ok
  end

  # "setup" is called before each test
  setup do
    IO.puts "This is a setup callback for #{inspect self()}"

    on_exit fn ->
      IO.puts "This is invoked once the test is done. Process: #{inspect self()}"
    end

    # Returns extra metadata to be merged into context
    [hello: "world"]

    # Similarly, any of the following would work:
    #   {:ok, [hello: "world"]}
    #   %{hello: "world"}
    #   {:ok, %{hello: "world"}}
  end

  # Same as above, but receives the context as argument
  setup context do
    IO.puts "Setting up: #{context.test}"
    :ok
  end

  # Setups can also invoke a local or imported function that returns a context
  setup :invoke_local_or_imported_function

  test "always pass" do
    assert true
  end

  test "uses metadata from setup", context do
    assert context[:hello] == "world"
    assert context[:from_named_setup] == true
  end

  defp invoke_local_or_imported_function(context) do
    [from_named_setup: true]
  end
end

सारांश

कार्य

on_exit/2

एक कॉलबैक को परिभाषित करता है जो परीक्षण से बाहर निकलते ही चलता है

setup(block)

एक मामले में प्रत्येक परीक्षण से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है

setup/2

एक मामले में प्रत्येक परीक्षण से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है

setup_all(block)

एक मामले में सभी परीक्षणों से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है

setup_all (var, block)

एक मामले में सभी परीक्षणों से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है

start_supervised! (child_spec_or_module, opts \\ [])

start_supervised/2 समान लेकिन सफलता पर PID लौटाता है और ठीक से शुरू नहीं होने पर उठाता है

start_supervised/2

परीक्षण पर्यवेक्षक के तहत एक बच्चे की प्रक्रिया शुरू करता है

stop_supervised/1

start_supervised/2 माध्यम से एक बच्चे की प्रक्रिया शुरू होती है

कार्य

on_exit (name_or_ref \\ make_ref (), कॉलबैक)

on_exit(term(), (() -> term())) :: :ok | no_return()

एक कॉलबैक को परिभाषित करता है जो परीक्षण से बाहर निकलते ही चलता है।

callback एक ऐसा फ़ंक्शन है जो कॉल करने वाले की तुलना में कोई तर्क नहीं देता है और एक अलग प्रक्रिया में चलता है।

on_exit/2 को आमतौर पर setup और setup_all कॉलबैक से कहा जाता है, अक्सर setup दौरान की गई क्रिया को पूर्ववत करने के लिए। हालाँकि, on_exit/2 को गतिशील रूप से भी कहा जा सकता है, जहां कॉलबैक की गारंटी के लिए एक संदर्भ का उपयोग केवल एक बार किया जाएगा।

सेटअप (ब्लॉक) (मैक्रो)

एक मामले में प्रत्येक परीक्षण से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है।

एक ब्लॉक या परमाणु समारोह के नाम के रूप में पास करें, या ऐसे परमाणुओं की सूची।

परीक्षण के लिए राज्य स्थापित करने के लिए मूल्यों को संदर्भ में विलय किया जा सकता है। विवरण के लिए ऊपर अनुभाग देखें।

उदाहरण

def clean_up_tmp_directory(context) do
  # perform setup
  :ok
end

setup :clean_up_tmp_directory

setup do
  [conn: Plug.Conn.build_conn()]
end

सेटअप (var, ब्लॉक) (मैक्रो)

एक मामले में प्रत्येक परीक्षण से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है।

एक ब्लॉक या परमाणु समारोह के नाम के रूप में पास करें, या ऐसे परमाणुओं की सूची।

परीक्षण के लिए राज्य स्थापित करने के लिए मूल्यों को संदर्भ में विलय किया जा सकता है। विवरण के लिए ऊपर अनुभाग देखें।

उदाहरण

setup context do
  [conn: Plug.Conn.build_conn()]
end

setup_all (ब्लॉक) (मैक्रो)

एक मामले में सभी परीक्षणों से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है।

एक ब्लॉक या परमाणु समारोह के नाम के रूप में पास करें, या ऐसे परमाणुओं की सूची।

परीक्षण के लिए राज्य स्थापित करने के लिए मूल्यों को संदर्भ में विलय किया जा सकता है। विवरण के लिए ऊपर अनुभाग देखें।

उदाहरण

def clean_up_tmp_directory(context) do
  # perform setup
  :ok
end

setup_all :clean_up_tmp_directory

setup_all do
  [conn: Plug.Conn.build_conn()]
end

setup_all (var, block) (मैक्रो)

एक मामले में सभी परीक्षणों से पहले चलाए जाने वाले कॉलबैक को परिभाषित करता है।

एक ब्लॉक या परमाणु समारोह के नाम के रूप में पास करें, या ऐसे परमाणुओं की सूची।

परीक्षण के लिए राज्य स्थापित करने के लिए मूल्यों को संदर्भ में विलय किया जा सकता है। विवरण के लिए ऊपर अनुभाग देखें।

उदाहरण

setup_all context do
  [conn: Plug.Conn.build_conn()]
end

start_supervised! (child_spec_or_module, opts \\ []) (1.6.0 से)

start_supervised!(
  Supervisor.child_spec() | module() | {module(), term()},
  keyword()
) :: pid()

start_supervised/2 समान लेकिन सफलता पर PID लौटाता है और ठीक से शुरू नहीं होने पर उठाता है।

start_supervised (child_spec_or_module, opts \\ []) (1.5.0 से)

start_supervised(
  Supervisor.child_spec() | module() | {module(), term()},
  keyword()
) :: Supervisor.on_start_child()

परीक्षण पर्यवेक्षक के तहत एक बच्चे की प्रक्रिया शुरू करता है।

यह एक बच्चे के विनिर्देश या मॉड्यूल की अपेक्षा करता है, जो Supervisor.start_link/2 को दिए गए समान है। उदाहरण के लिए, यदि आपका एप्लिकेशन चलकर एक पर्यवेक्षण ट्री शुरू करता है:

Supervisor.start_link([MyServer, {OtherSupervisor, ...}], ...)

आप परीक्षण द्वारा उन प्रक्रियाओं को अलग-थलग करके चालू कर सकते हैं:

start_supervised(MyServer)
start_supervised({OtherSupervisor, :initial_value})

यदि दिए गए बच्चे की प्रक्रिया के लिए बाल विनिर्देश को बदलने की आवश्यकता है, तो एक कीवर्ड सूची भी दी जा सकती है:

start_supervised({MyServer, :initial_value}, restart: :temporary)

बाल विनिर्देशों और उपलब्ध विनिर्देशन कुंजियों पर चर्चा के लिए Supervisor मॉड्यूल देखें।

परीक्षण पर्यवेक्षक के तहत एक प्रक्रिया शुरू करने का लाभ यह है कि यह अगले परीक्षण शुरू होने से पहले बाहर निकलने की गारंटी है। इसके अलावा, क्योंकि बाल प्रक्रिया की देखरेख की जाती है, इसलिए क्रैश के मामले में इसे फिर से शुरू किया जाएगा :restart बाल विनिर्देश में :restart रणनीति, भले ही मैन्युअल रूप से बंद कर दी गई हो। इसलिए, start_supervised/2 समाप्ति के बिना पुनरारंभ के साथ शुरू की गई प्रक्रिया की गारंटी करने के लिए, stop_supervised/1

यह फ़ंक्शन सफलता के मामले में {:ok, pid} देता है, अन्यथा यह {:error, reason}

stop_supervised (आईडी) (1.5.0 के बाद से)

stop_supervised(id :: term()) :: :ok | {:error, :not_found}

start_supervised/2 माध्यम से एक बच्चे की प्रक्रिया शुरू होती है।

यह फ़ंक्शन बाल विनिर्देश में id अपेक्षा करता है। उदाहरण के लिए:

{:ok, _} = start_supervised(MyServer)
:ok = stop_supervised(MyServer)

यह रिटर्न :ok अगर ऐसी id साथ एक पर्यवेक्षित प्रक्रिया है, तो {:error, :not_found} अन्यथा।