इस लेख में, हम डिपेंडेंसी इंजेक्शन प्रोग्रामिंग पैटर्न का उपयोग करके एक कार्यात्मक शैली में स्वच्छ, आसानी से परीक्षण योग्य कोड लिखने का तरीका देखेंगे। बोनस 100% यूनिट टेस्ट कवरेज है।

लेख में इस्तेमाल की जाने वाली शब्दावली

लेख के लेखक को निम्नलिखित शब्दों की ऐसी व्याख्या को ध्यान में रखना होगा, यह समझना कि यह अंतिम सत्य नहीं है और अन्य व्याख्याएं संभव हैं।

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

हम अभ्यास में समझते हैं

एक उदाहरण पर विचार करें। काउंटरों की एक फैक्ट्री जो tick गिनती करती tick । cancel विधि का उपयोग करके काउंटर को रोका जा सकता है।

 const createCounter = ({ ticks, onTick }) => { const state = { currentTick: 1, timer: null, canceled: false } const cancel = () => { if (state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(state.timer) } const onInterval = () => { onTick(state.currentTick++) if (state.currentTick > ticks) { cancel() } } state.timer = setInterval(onInterval, 200) const instance = { cancel } return instance } export default createCounter 

हम मानव-पठनीय, समझने योग्य कोड देखते हैं। लेकिन एक कैच है - उस पर सामान्य यूनिट टेस्ट नहीं लिखे जा सकते। आइए देखें कि रास्ते में क्या है?

1) आप cancel , onInterval अंदर फंक्शन्स तक नहीं पहुँच सकते हैं और उन्हें अलग से टेस्ट कर सकते हैं।

2) onInterval फ़ंक्शन को cancel फ़ंक्शन से अलग से परीक्षण नहीं किया जा सकता है, क्योंकि पहले का दूसरे से सीधा संबंध है।

3) बाहरी निर्भरता clearInterval , clearInterval ।

4) createCounter फ़ंक्शन createCounter अन्य लिंक से अलग से परीक्षण नहीं किया जा सकता है, फिर से सीधे लिंक के कारण।

आइए समस्याओं को हल करें 1) 2) - हम onInterval से cancel , onInterval को onInterval और pool ऑब्जेक्ट के माध्यम से उनके बीच सीधा लिंक तोड़ते हैं।

 export const cancel = pool => { if (pool.state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(pool.state.timer) } export const onInterval = pool => { pool.config.onTick(pool.state.currentTick++) if (pool.state.currentTick > pool.config.ticks) { pool.cancel() } } const createCounter = config => { const pool = { config, state: { currentTick: 1, timer: null, canceled: false } } pool.cancel = cancel.bind(null, pool) pool.onInterval = onInterval.bind(null, pool) pool.state.timer = setInterval(pool.onInterval, 200) const instance = { cancel: pool.cancel } return instance } export default createCounter 

हम समस्या का समाधान 3) करते हैं। हम setInterval , clearInterval पर निर्भरता इंजेक्शन पैटर्न का उपयोग करते हैं और उन्हें pool ऑब्जेक्ट में भी स्थानांतरित करते हैं।

 export const cancel = pool => { const { clearInterval } = pool if (pool.state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(pool.state.timer) } export const onInterval = pool => { pool.config.onTick(pool.state.currentTick++) if (pool.state.currentTick > pool.config.ticks) { pool.cancel() } } const createCounter = (dependencies, config) => { const pool = { ...dependencies, config, state: { currentTick: 1, timer: null, canceled: false } } pool.cancel = cancel.bind(null, pool) pool.onInterval = onInterval.bind(null, pool) const { setInterval } = pool pool.state.timer = setInterval(pool.onInterval, 200) const instance = { cancel: pool.cancel } return instance } export default createCounter.bind(null, { setInterval, clearInterval }) 

अब लगभग सब कुछ ठीक है, लेकिन अभी भी एक समस्या है 4)। अंतिम चरण में, हम अपने प्रत्येक कार्य के लिए निर्भरता इंजेक्शन लागू करते हैं और pool ऑब्जेक्ट के माध्यम से उनके बीच शेष कनेक्शन को तोड़ते हैं। उसी समय, हम एक बड़ी फाइल को कई फाइलों में विभाजित करते हैं, ताकि बाद में यूनिट टेस्ट लिखना आसान हो जाए।

 // index.js import { createCounter } from './create-counter' import { cancel } from './cancel' import { onInterval } from './on-interval' export default createCounter.bind(null, { cancel, onInterval, setInterval, clearInterval }) 

 // create-counter.js export const createCounter = (dependencies, config) => { const pool = { ...dependencies, config, state: { currentTick: 1, timer: null, canceled: false } } pool.cancel = dependencies.cancel.bind(null, pool) pool.onInterval = dependencies.onInterval.bind(null, pool) const { setInterval } = pool pool.state.timer = setInterval(pool.onInterval, 200) const instance = { cancel: pool.cancel } return instance } 

 // on-interval.js export const onInterval = pool => { pool.config.onTick(pool.state.currentTick++) if (pool.state.currentTick > pool.config.ticks) { pool.cancel() } } 

 // cancel.js export const cancel = pool => { const { clearInterval } = pool if (pool.state.canceled) { throw new Error('"Counter" already canceled') } clearInterval(pool.state.timer) } 

निष्कर्ष

आखिर में हमारे पास क्या है? फाइलों का एक गुच्छा, जिनमें से प्रत्येक में एक साफ फ़ंक्शन होता है। कोड की सादगी और समझदारी थोड़ी खराब हो गई है, लेकिन यह यूनिट परीक्षणों में 100% कवरेज की तस्वीर से मुआवजा से अधिक है।

मैं यह भी नोट करना चाहता हूं कि यूनिट टेस्ट लिखने के लिए हमें require साथ कोई हेरफेर करने की require और फाइल सिस्टम प्राप्त करें। Node.js.

 // cancel.test.js import { cancel } from '../src/cancel' describe('method "cancel"', () => { test('should stop the counter', () => { const state = { canceled: false, timer: 42 } const clearInterval = jest.fn() const pool = { state, clearInterval } cancel(pool) expect(clearInterval).toHaveBeenCalledWith(pool.state.timer) }) test('should throw error: "Counter" already canceled', () => { const state = { canceled: true, timer: 42 } const clearInterval = jest.fn() const pool = { state, clearInterval } expect(() => cancel(pool)).toThrow('"Counter" already canceled') expect(clearInterval).not.toHaveBeenCalled() }) }) 

 // create-counter.test.js import { createCounter } from '../src/create-counter' describe('method "createCounter"', () => { test('should create a counter', () => { const boundCancel = jest.fn() const boundOnInterval = jest.fn() const timer = 42 const cancel = { bind: jest.fn().mockReturnValue(boundCancel) } const onInterval = { bind: jest.fn().mockReturnValue(boundOnInterval) } const setInterval = jest.fn().mockReturnValue(timer) const dependencies = { cancel, onInterval, setInterval } const config = { ticks: 42 } const counter = createCounter(dependencies, config) expect(cancel.bind).toHaveBeenCalled() expect(onInterval.bind).toHaveBeenCalled() expect(setInterval).toHaveBeenCalledWith(boundOnInterval, 200) expect(counter).toHaveProperty('cancel') }) }) 

 // on-interval.test.js import { onInterval } from '../src/on-interval' describe('method "onInterval"', () => { test('should call "onTick"', () => { const onTick = jest.fn() const cancel = jest.fn() const state = { currentTick: 1 } const config = { ticks: 5, onTick } const pool = { onTick, cancel, state, config } onInterval(pool) expect(onTick).toHaveBeenCalledWith(1) expect(pool.state.currentTick).toEqual(2) expect(cancel).not.toHaveBeenCalled() }) test('should call "onTick" and "cancel"', () => { const onTick = jest.fn() const cancel = jest.fn() const state = { currentTick: 5 } const config = { ticks: 5, onTick } const pool = { onTick, cancel, state, config } onInterval(pool) expect(onTick).toHaveBeenCalledWith(5) expect(pool.state.currentTick).toEqual(6) expect(cancel).toHaveBeenCalledWith() }) }) 

केवल अंत तक सभी कार्यों को खोलकर, हम स्वतंत्रता प्राप्त करते हैं।