Swift Academy · पाठ

फ़ीचर को मिलाना और परीक्षण करना

Reducer मिलाइए और हर स्थिति का पूरी तरह परीक्षण कीजिए।

पाठ 4, कुल 4 में से13 चरण

फ़ीचर को मिलाना और परीक्षण करना, CoddyKit पर Swift Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Swift Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Swift Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

फीचरों का संयोजन

वास्तविक ऐप कई छोटे फीचरों से बनाए जाते हैं। TCA पैरेंट फीचर में चाइल्ड फीचर समाहित करने देता है, ताकि हर फीचर अपने काम पर केंद्रित रहे और फिर उन्हें एक बड़े समग्र ढाँचे में जोड़ा जा सके। इसके लिए Scope तथा चाइल्ड स्थिति और क्रियाओं को समाहित करने की सुविधा का उपयोग किया जाता है।

संयोजन के कारण ही कंपोज़ेबल आर्किटेक्चर को उसका नाम मिला है।

import ComposableArchitecture

// A parent feature embeds child State and Action,
// then uses Scope to run the child's reducer.

चाइल्ड स्थिति को समाहित करना

पैरेंट की State में चाइल्ड की स्थिति एक गुण के रूप में रहती है। पैरेंट के Action एनम में चाइल्ड की क्रियाओं को समेटने वाला एक केस होता है। यह नेस्टिंग यूआई की नेस्टेड संरचना को दर्शाती है।

यहाँ एक पैरेंट `counter` चाइल्ड को रखता है।

import ComposableArchitecture

@Reducer
struct AppFeature {
    @ObservableState
    struct State: Equatable {
        var counter = CounterFeature.State()
    }
    enum Action {
        case counter(CounterFeature.Action)
    }
    var body: some ReducerOf<Self> { EmptyReducer() }
}

चाइल्ड तक सीमित करना

Scope पैरेंट स्थिति और क्रिया के उस हिस्से पर चाइल्ड रिड्यूसर चलाता है जो उसी से संबंधित है। आप उसे स्थिति की की-पाथ और क्रिया की केस-पाथ देते हैं, फिर चाइल्ड रिड्यूसर देते हैं।

इससे चाइल्ड पैरेंट के `update` लूप से जुड़ जाता है।

import ComposableArchitecture

var body: some ReducerOf<Self> {
    Scope(state: \.counter, action: \.counter) {
        CounterFeature()
    }
    Reduce { state, action in
        // parent-specific logic here
        return .none
    }
}

कई रिड्यूसर का संयोजन

किसी फीचर का body कई रिड्यूसर सूचीबद्ध कर सकता है; TCA हर क्रिया के लिए उन्हें क्रम से चलाता है। इससे आप पैरेंट के अपने Reduce के साथ एक या अधिक Scope रख सकते हैं।

यहाँ दो चाइल्ड और पैरेंट का तर्क साथ-साथ काम करते हैं।

import ComposableArchitecture

var body: some ReducerOf<Self> {
    Scope(state: \.profile, action: \.profile) { ProfileFeature() }
    Scope(state: \.settings, action: \.settings) { SettingsFeature() }
    Reduce { state, action in
        return .none
    }
}

चाइल्ड दृश्यों के लिए स्टोर सीमित करना

व्यू की ओर से देखें तो चाइल्ड व्यू को चाइल्ड के लिए विशेषीकृत स्टोर चाहिए। पैरेंट उसे store.scope के माध्यम से चाइल्ड की स्थिति और क्रिया से जोड़कर बनाता है।

यहाँ पैरेंट व्यू एक सीमित स्टोर `counter` व्यू को देता है।

import ComposableArchitecture
import SwiftUI

struct AppView: View {
    let store: StoreOf<AppFeature>
    var body: some View {
        CounterView(
            store: store.scope(state: \.counter, action: \.counter)
        )
    }
}

TestStore का परिचय

TestStore आपको यह सुनिश्चित करने देता है कि कोई फीचर ठीक-ठीक कैसे व्यवहार करता है। आप क्रियाएँ भेजते हैं और बताते हैं कि स्थिति में कैसे बदलाव होना चाहिए; वास्तविक व्यवहार अलग होने पर परीक्षण विफल हो जाता है। यह संपूर्ण जाँच सूक्ष्म प्रतिगमन पकड़ लेती है।

आप इसे प्रारंभिक स्थिति और रिड्यूसर के साथ सामान्य स्टोर की तरह बनाते हैं।

import ComposableArchitecture
import XCTest

func testIncrement() async {
    let store = await TestStore(initialState: CounterFeature.State()) {
        CounterFeature()
    }
}

स्थिति में बदलाव की जाँच

जब आप TestStore को कोई क्रिया भेजते हैं, तो अपेक्षित बदलाव बताने वाला क्लोज़र देते हैं। परीक्षण तभी सफल होता है जब स्थिति ठीक उसी तरह बदले।

यहाँ बढ़ाने पर गिनती 0 से 1 होनी चाहिए।

import ComposableArchitecture
import XCTest

func testIncrement() async {
    let store = await TestStore(initialState: CounterFeature.State()) {
        CounterFeature()
    }
    await store.send(.incrementTapped) {
        $0.count = 1
    }
}

संपूर्णता

डिफ़ॉल्ट रूप से TestStore संपूर्ण होता है: आपको स्थिति में होने वाले हर बदलाव और किसी प्रभाव द्वारा वापस भेजी जाने वाली हर क्रिया का हिसाब देना होता है। जिन बदलावों को संभाला नहीं जाता, वे परीक्षण को विफल कर देते हैं और आपकी जाँचों को विश्वसनीय बनाए रखते हैं।

केंद्रित परीक्षणों के लिए आप store.exhaustivity = .off के साथ इसे कम कठोर कर सकते हैं।

import ComposableArchitecture

// Exhaustive (default): every change must be asserted.
// Relax when you only care about part of the behavior:
store.exhaustivity = .off

प्रभाव से आने वाली क्रियाएँ प्राप्त करना

जब कोई प्रभाव वापस क्रिया भेजता है, तो परीक्षण को उसे receive करना और परिणामस्वरूप स्थिति की जाँच करना आवश्यक है। इससे यह सिद्ध होता है कि असिंक्रोनस प्रवाह शुरू से अंत तक सही काम करता है।

यहाँ पुनः लोड करने पर एक प्रतिक्रिया आती है, जिसका परीक्षण इंतज़ार करके जाँच करता है।

import ComposableArchitecture
import XCTest

func testReload() async {
    let store = await TestStore(initialState: NumberFeature.State()) {
        NumberFeature()
    }
    await store.send(.reload)
    await store.receive(\.response) {
        $0.value = 42
    }
}

परीक्षणों में निर्भरताओं को बदलना

प्रभावों को नियत रखने के लिए TestStore बनाते समय निर्भरताओं को बदल दें। पूर्वानुमेय परिणामों के लिए नकली क्लाइंट या परीक्षण घड़ी दें।

यहाँ संख्या क्लाइंट को ऐसे क्लाइंट से बदला गया है जो हमेशा 42 लौटाता है।

import ComposableArchitecture
import XCTest

func testReload() async {
    let store = await TestStore(initialState: NumberFeature.State()) {
        NumberFeature()
    } withDependencies: {
        $0.numberClient.fetch = { 42 }
    }
    await store.send(.reload)
    await store.receive(\.response) { $0.value = 42 }
}

संयोजित फीचरों का परीक्षण

संयोजन में स्थिति और क्रियाएँ नेस्टेड होती हैं, इसलिए पैरेंट का परीक्षण करने के लिए पैरेंट केस में समेटी गई चाइल्ड क्रियाएँ भेजी जाती हैं। वही संपूर्ण जाँचें लागू होती हैं और पूरे ट्री का सत्यापन करती हैं।

यहाँ पैरेंट अपने `scope` के माध्यम से `counter` को बढ़ाने वाली क्रिया प्राप्त करता है।

import ComposableArchitecture
import XCTest

func testChildInParent() async {
    let store = await TestStore(initialState: AppFeature.State()) {
        AppFeature()
    }
    await store.send(.counter(.incrementTapped)) {
        $0.counter.count = 1
    }
}

त्वरित जाँच: TestStore का व्यवहार

याद कीजिए कि डिफ़ॉल्ट TestStore आपकी जाँचों से क्या अपेक्षा करता है।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: संयोजन और परीक्षण

आपने TCA के सभी प्रमुख औज़ार पूरे कर लिए हैं:

Scope पैरेंट स्थिति और क्रिया के एक हिस्से पर चाइल्ड रिड्यूसर चलाता है, और एक ही body में कई रिड्यूसर जोड़े जा सकते हैं।
store.scope चाइल्ड व्यू को उसका अपना विशेषीकृत स्टोर देता है।
TestStore आपके द्वारा send की गई क्रियाओं पर स्थिति में हुए बदलावों की ठीक-ठीक जाँच करता है।
यह डिफ़ॉल्ट रूप से संपूर्ण होता है और प्रभाव से संचालित क्रियाओं के लिए receive का उपयोग करता है।
नियत परीक्षणों के लिए withDependencies से निर्भरताएँ बदलें।

अब आप कंपोज़ेबल आर्किटेक्चर के साथ फीचर बना, जोड़ और उनका कठोरता से परीक्षण कर सकते हैं।

import ComposableArchitecture

// Recap: Scope to compose, TestStore to verify.
// Exhaustive assertions + injected fakes = confidence.

शुरुआत निःशुल्क

एआई शिक्षक के साथ Swift सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 122
पाठ: 409

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “फ़ीचर को मिलाना और परीक्षण करना” पाठ निःशुल्क है?

हाँ — Swift Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “फ़ीचर को मिलाना और परीक्षण करना” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Swift Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“फ़ीचर को मिलाना और परीक्षण करना” में मैं क्या सीखूँगा?

Reducer मिलाइए और हर स्थिति का पूरी तरह परीक्षण कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Swift Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Swift Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Swift Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“फ़ीचर को मिलाना और परीक्षण करना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Swift Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Swift Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

State, Action और Reducer
Store और SwiftUI एकीकरण
Effects और Dependencies
फ़ीचर को मिलाना और परीक्षण करना

← Swift Academy पर वापस जाएँ