🎏 👨🏻‍🚀 ⏬ डेटाबेस से डेटा क्वेरी करने के लिए एक टीम का विकास

यह कहानी की एक निरंतरता है जो यहां शुरू हुई, और यहां और यहां जारी रही।

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

describe('requestHandler', () => { const createStore = require('redux').createStore; const reducers = require('../../src/reducers.js'); const DbMock = require('../mocks/DbMock'); const db = new DbMock(); const rules = require('../../src/rules'); const dbRequest = require('../../src/storage/dbRequest'); let request = null, store = null, context = null; beforeEach(() => { store = createStore(reducers); context = { db, store, rules }; request = dbRequest.bind(context, [ 'user' ]); expect(store.getState().user).toBeNull(); expect(store.getState().error).toEqual([]); }); it('should get user from database', (done) => { const assert = checkUser.bind(context, [ done ]); store.subscribe(assert); store.dispatch({type: 'NOTE', note: { Id: 1, UserRecordId: 1 }}); request(); }); function checkUser(args) { const state = store.getState(); if(state.user === null) return; const user = state.user; expect(user.Id).toEqual(1); expect(user.Name).toEqual('Jack'); const checkIsCompleted = args[0]; checkIsCompleted(); } });

मैं परीक्षण चलाता हूं और संदेश प्राप्त करता हूं कि नियमों के साथ मॉड्यूल नहीं मिला। एक बार फिर, हैंडलर को नियमों से क्या निकालने की आवश्यकता होगी?

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

नियमों का सेट मुझे एक शब्दकोश ( Map ) लगता है, जिसमें कुंजी राज्य कंटेनर की संपत्ति का नाम होगी और मैं संभवतः पहली इकाई परीक्षण तैयार करूंगा:

 describe('rules', () => { const rules = require('../src/rules'); it('should contain user rules', () => { const rule = rules.get('user'); expect(rule.table).toEqual('users'); }); });

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

 const makeRules = () => { const rules = new Map(); rules.set('user', { table: 'users' }); return rules; }; module.exports = makeRules();

मैं परीक्षण चलाता हूं, और मैं देखता हूं कि मेरे हैंडलर क्रैश के लिए केवल परीक्षण, हालांकि त्रुटि अब अलग है। हालाँकि, मैं इस परीक्षण पर बाद में लौटूंगा, जब मेरे पास तैयार शब्दकोश में कम से कम एक पूर्ण नियम होगा।

मैं नियम शब्दकोश परीक्षण को थोड़ा संशोधित करूंगा। मैं एक कोड जोड़ूंगा जो एक डिस्पैचर विधि की उपस्थिति की जांच करता है जो डेटाबेस क्वेरी को निष्पादित करने में त्रुटि को संभालता है:

 describe('rules', () => { const rules = require('../src/rules'); it('should contain user rules', () => { const rule = rules.get('user'); expect(rule.table).toEqual('users'); expect(rule.onError.name).toEqual('dispatchError'); expect(typeof rule.onError).toEqual('function'); }); });

मैं परीक्षण चलाता हूं, सुनिश्चित करें कि मेरे पास फिर से दो असफल परीक्षण हैं, और नियम शब्दकोश बनाने के लिए कारखाना विधि कोड को अंतिम रूप देने के लिए वापस लौटें। मैं फ़ंक्शन को पहले नियम के ऑब्जेक्ट शाब्दिक में जोड़ता हूं:

 const makeRules = () => { const rules = new Map(); rules.set('user', { table: 'users', onError: function dispatchError(error, store) { const action = { type: 'ERROR', error }; store.dispatch(action); } }); return rules; }; module.exports = makeRules();

फिर से परीक्षण चल रहा है। नया नियम टुकड़ा परीक्षण को सफलतापूर्वक पास करता है, इसलिए मैं सभी शेष नियमों के लिए चेक जोड़ने का निर्णय लेता हूं:

 describe('rules', () => { const rules = require('../src/rules'); it('should contain user rules', () => { const rule = rules.get('user'); expect(rule.table).toEqual('users'); expect(rule.onError.name).toEqual('dispatchError'); expect(typeof rule.onError).toEqual('function'); expect(rule.onSuccess.name).toEqual('dispatchUser'); expect(typeof rule.onSuccess).toEqual('function'); expect(rule.query.name).toEqual('getUserQuery'); expect(typeof rule.query).toEqual('function'); }); });

मैं परीक्षण चलाता हूं। नियम शब्दकोश के लिए निर्धारित परीक्षण फिर से एक त्रुटि फेंकता है। मैं कोड लिख रहा हूँ:

 const makeRules = () => { const rules = new Map(); rules.set('user', { table: 'users', onError: function dispatchError(error, store) { const action = { type: 'ERROR', error }; store.dispatch(action); }, onSuccess: function dispatchUser(user, store) { const action = { type: 'USER', user }; store.dispatch(action); }, query: function getUserQuery(store) { const state = store.getState(); if(state.note === null) return null; return { Id: state.note.UserRecordId }; } }); return rules; }; module.exports = makeRules();

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

 function dbRequest(args){ const key = args[0]; const getQuery = this.rules.get(key).query; const dispatchUser = this.rules.get(key).onSuccess; const dispatchError = this.rules.get(key).onError; const tableName = this.rules.get(key).table; const table = this.db.Model.extend({ tableName: tableName }); const state = this.store.getState(); if(state[key] !== null) return; const query = getQuery(this.store); if(query === null) return; table.where(query).fetch().then((item) => { dispatchUser(item, this.store); }).catch((error) => { dispatchError(error, this.store); }); } module.exports = dbRequest;

चल रहा है परीक्षण ... ड्रम रोल! और मुझे हरे रंग के बिंदुओं की एक पंक्ति दिखाई देती है। सभी परीक्षण सफलतापूर्वक पूरे हुए। और इसलिए मैं उस सेट में एक और परीक्षण DbMock जो त्रुटि से निपटने की शुद्धता की जांच करता है, जब तक कि मैं यह नहीं भूल गया हूं कि मेरे छद्म DbMock एक त्रुटि वापस DbMock , मुझे उसे 555 के बराबर Id साथ प्रविष्टि के लिए पूछना होगा:

 it('should add error in store state', (done) => { const assert = checkErrorHasBeenAdded.bind(context, [ done ]); store.subscribe(assert); store.dispatch({type: 'NOTE', note: { Id: 1, UserRecordId: 555 }}); request(); }); function checkErrorHasBeenAdded(args){ const state = store.getState(); if(state.error.length === 0) return; const error = state.error; expect(Array.isArray(error)).toBeTruthy(); expect(error.length).toEqual(1); expect(error[0].message).toEqual('Something goes wrong!'); const checkIsCompleted = args[0]; checkIsCompleted(); }

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

डेटाबेस से डेटा क्वेरी करने के लिए एक टीम का विकास - भाग 4, समापन

More articles: