Cucumber-js: तर्कों को शिथिल करने का विकल्प चरण परिभाषाओं की जाँच करें

मैंने वही अनुरोध किया, #445 देखें :)

@ रियान ५३ , हाँ, मैंने उस पर एक नज़र

आप किस सामान्य प्रसंस्करण तर्क के बारे में बात कर रहे हैं?

ज़रूर। एक उपयोग के मामले में, मैं चाहता हूं कि सभी डेवलपर्स अपनी चरण परिभाषाओं में अभिव्यक्ति संदर्भों का उपयोग करने में सक्षम हों। उदाहरण के लिए 'जब उपयोगकर्ता ${admin} सिस्टम में लॉग इन करता है'।

अब, इस मामले में ${admin} शायद एक JSON फ़ाइल से हल किया जाएगा और समाधान की जिम्मेदारी चरण परिभाषा को लागू करते समय डेवलपर के पास होगी। यदि आप वास्तव में इस तरह के संपत्ति संकल्प को देखते हैं, तो यह सामान्य कोड द्वारा किया जा सकता है, डेवलपर को इसके बारे में बिल्कुल भी जानकारी नहीं है।

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

वर्तमान में, मैं इस तरह के एक सामान्य कार्य को लिखने में सक्षम नहीं होगा क्योंकि ककड़ी के सत्यापन यह सुनिश्चित करेंगे कि फ़ंक्शन में पैरामीटर की सही संख्या है जो मेरे मामले में नहीं होगी क्योंकि मेरा जेनेरिक रैपर फ़ंक्शन किसी नामित तर्क को स्वीकार नहीं करेगा और मैं इसका उपयोग करूँगा 'तर्क' वस्तु।

आशा है कि मैं समझ सकता हूँ। हमारे वर्तमान प्रोजेक्ट में अन्य उपयोग के मामले भी हैं जहां चरण कार्यान्वयन के आसपास एक सामान्य रैपर फ़ंक्शन की आवश्यकता होगी

यदि हम चरण तर्क ट्रॅनफॉर्म लागू करते हैं तो क्या इससे आपकी समस्या हल हो जाएगी: https://github.com/cucumber/cucumber/wiki/Step-Argument-Transforms?

आह हाँ, संभावित रूप से संदर्भ समाधान समस्या का समाधान कर सकता है। हालांकि, मुझे अभी भी अन्य कारणों से चरण कार्यान्वयन के आसपास एक सामान्य रैपर फ़ंक्शन डालने की आवश्यकता है।

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

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

यह फिर से एक सामान्य फ़ंक्शन रैपर के माध्यम से संबोधित करने के लिए एक बहुत ही आसान बात है जिसके लिए ककड़ी द्वारा पैरामीटर जांच को आराम देना पड़ता है।

मैं इस मुद्दे में अब एक दो बार भागा।

सबसे प्रमुख प्रत्येक Then चरण पर retry सहायक को लागू कर रहा है:

cucumber.Then = function(match, callback) {
  const retryingCallback = (...args) => retry(async () => await callback(...args));
  cucumber.Then(match, retryingCallback);
};

मैं इस सहायक का उपयोग अंततः लगातार बैकएंड पर समय के मुद्दों से निपटने के लिए करता हूं। अनिवार्य रूप से, यह प्रत्येक x सेकंड में कॉलबैक निष्पादित करता है जब तक कि y सेकंड बीत चुका न हो या कॉलबैक पास न हो जाए।

दुख की बात है कि इसका कारण बनता है

function has 0 arguments, should have 1 (if synchronous or returning a promise) or 2 (if accepting a callback)

अब मैं जिस विकल्प का उपयोग कर रहा हूं, वह है हेल्पर को हर Then चरण में कॉल करना, जो बहुत सारे कोड दोहराव का कारण बनता है।

this.Then(/^I see that "([^"]*)" does not have a destination$/, async clientName => {
  return retry(async () => {
    const client = await homeView.clientByName(clientName);
    expect(client.destinationName).to.not.exist;
  });
});

एक और मामला एक और आसान है जहां मुझे लॉगिन के लिए एक सहायक कार्य चाहिए।

function loggedIn(username, func) {
  return (...args) => {
    await accounts.login(username);
    return func(...args)
  };
}

this.Then(/^someone logged in as "([^"]*)" sees a destination named "([^"]*)"$/, loggedIn(assert.destinationExists));

इसके अलावा यह मुझे बहुत सारे कोड डुप्लिकेशन बचाएगा।

अंत में, मैं किसी बिंदु पर एक सूट जोड़ना चाहता हूं जो मेरे सभी स्वीकृति परीक्षण चलाता है, लेकिन प्रत्येक Then कॉलबैक से पहले सर्वर को पुनरारंभ करता है (यह सुनिश्चित करने के लिए कि सर्वर पुनरारंभ चीजों को गड़बड़ नहीं करता है)। फिर से, बहुत सारे दोहराव।

पीएस पुनः प्रयास करें सहायक:

const patience = 250;
const interval = 5;

function delay(time) {
  return new Promise(function (fulfill) {
    setTimeout(fulfill, time);
  });
}

async function attempt(start, func) {
  const attemptDate = new Date();
  try {
    return await func();
  } catch (errr) {
    const timeElapsed = attemptDate.getTime() - start.getTime();
    if (timeElapsed < patience) {
      await delay(interval);
      return await attempt(start, func);
    } else {
      throw errr;
    }
  }
}

export async function retry(func) {
  const start = new Date();
  return await attempt(start, func);
}

_संपादित करें_

इसके चारों ओर अपना रास्ता हैक करने की कोशिश की:

function splat(func) {
  return (one, two, three, four, five, six, seven, eight, nine, ten) => {
    if (typeof ten !== 'undefined') {
      return func(one, two, three, four, five, six, seven, eight, nine, ten);
    } else if (typeof nine !== 'undefined') {
      return func(one, two, three, four, five, six, seven, eight, nine);
    } else if (typeof eight !== 'undefined') {
      return func(one, two, three, four, five, six, seven, eight);
    } else if (typeof seven !== 'undefined') {
      return func(one, two, three, four, five, six, seven);
    } else if (typeof six !== 'undefined') {
      return func(one, two, three, four, five, six);
    } else if (typeof five !== 'undefined') {
      return func(one, two, three, four, five);
    } else if (typeof four !== 'undefined') {
      return func(one, two, three, four);
    } else if (typeof three !== 'undefined') {
      return func(one, two, three);
    } else if (typeof two !== 'undefined') {
      return func(one, two);
    } else if (typeof one !== 'undefined') {
      return func(one);
    } else {
      return func();
    }
  };
}

cucumber.Then = function(match, callback) {
  const retryingCallback = splat((...args) => retry(async () => await callback(...args)));
  cucumber.Then(match, retryingCallback);
};

लेकिन

function has 10 arguments, should have 1 (if synchronous or returning a promise) or 2 (if accepting a callback)

मुझे उदास पांडा बनाना

लंबाई बनाए रखने के लिए फ़ंक्शन को लपेटने का एक उदाहरण यहां दिया गया है। अच्छा होगा यदि केवल एक छोटा नोड मॉड्यूल हो जो आपके लिए यह करे।

सलाह के लिये धन्यवाद! यह काम करता है यदि आप प्रति चरण परिभाषा में तर्कों की संख्या निर्दिष्ट करते हैं, है ना?

उदाहरण के लिए

this.Then(/^someone logged in as "([^"]*)" sees a destination named "([^"]*)"$/, createProxy(loggedIn(assert.destinationExists), 2));

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

त्रुटि को बंद करने में सक्षम होने की तुलना में अभी भी वास्तव में अजीब लगता है। :मासूम:

मुझे लगता है कि आप उस फ़ंक्शन के एक प्रकार का उपयोग कर सकते हैं जहां proxyLength में गुजरने के बजाय आप केवल उस फ़ंक्शन में पास हो जाते हैं जिसे आप लपेट रहे हैं और function.length ।

बढ़िया सुझाव, धन्यवाद!

मुझे काम करने के लिए निम्न जैसा कुछ मिला:

cucumber.Then = function(match, callback) {
  cucumber.Then(match, retryProxy(callback));
};

function retryProxy(func) {
  const numberOfArgs = func.length;
  switch (numberOfArgs) {
    case 0: return () => retry(func);
    case 1: return (a) => retry(func, a);
    case 2: return (a, b) => retry(func, a, b);
    case 3: return (a, b, c) => retry(func, a, b, c);
    case 4: return (a, b, c, d) => retry(func, a, b, c, d);
    case 5: return (a, b, c, d, e) => retry(func, a, b, c, d, e);
  }
}

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

खुशी है कि अब मैं अपनी चरण परिभाषाओं में कोई समायोजन किए बिना मिडलवेयर जोड़ सकता हूं!

@thomasvanlankveld जैसा कि आप जानते हैं, मुझे यह पुस्तकालय मिला है जो इसे एक विशिष्ट कार्य लंबाई देने के लिए एक फ़ंक्शन को लपेटता है: https://github.com/blakeembrey/arity

@ सुशील-आरएक्सआर क्या आप मूल फ़ंक्शन लंबाई को बनाए रखने के लिए अपने सामान्य फ़ंक्शन रैपर में कुछ ऐसा कर सकते हैं?

2.0.0-rc.1 अब आप एक सामान्य फंक्शन रैपर जोड़ सकते हैं। इसमें मूल कार्य लंबाई को बनाए रखने की अंतर्निहित कार्यक्षमता भी है।

इस थ्रेड को स्वचालित रूप से लॉक कर दिया गया है क्योंकि इसे बंद करने के बाद हाल ही में कोई गतिविधि नहीं हुई है। कृपया संबंधित बग के लिए एक नया मुद्दा खोलें।