ककड़ी के चरणों का पुन: उपयोग करें

Question

मैं कुछ ककड़ी चरणों का पुन: उपयोग करना चाहता हूं, लेकिन सही तरीका नहीं खोज सकता।

मैं एक कदम लिखना चाहता हूं:

Given /^I login with (.*) credentials$/ |type|
  # do stuff with type being one of "invalid" or "valid"
end

लेकिन फिर एक और कदम की तरह है:

Given /^I login successfully$
  # call "Given I login with valid credentials"
end

इसलिए उपयोगकर्ता प्रमाणीकरण के परीक्षण में मैं पूर्व का उपयोग कर सकता हूं, लेकिन अधिकांश अन्य स्थानों पर, मैं बाद का उपयोग कर सकता हूं, और वास्तव में कोड को पुन: उपयोग नहीं करना है।

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

Comments

यदि कोई भी भ्रमित है, तो यहां हर कोई रूबी चरण परिभाषा में ब्लॉक doशुरू करने के लिए आवश्यक छोड़ रहा है do...end। यह वास्तव में आवश्यक है।

— शॉन लेब्रोन

Answer 1

अपडेट करें : नीचे वर्णित विधि को पदावनत किया गया है। दूसरे चरण के भीतर से किसी चरण को कॉल करने का अनुशंसित तरीका अब इस तरह दिखता है:

Given /^I login successfully$/
    step "I login with valid credentials" 
end 

---

पुरानी, ​​पदावनत विधि (संदर्भ के लिए):

आप इस तरह से अन्य चरणों से कदम उठा सकते हैं:

Given /^I login successfully$/
  Given "I login with valid credentials"
  Then "I should be logged in"
end

यदि किसी विशेषता के भीतर सभी परिदृश्यों को इसकी आवश्यकता होती है (या अन्य चरण), तो आप सामान्य चरणों के साथ प्रत्येक सुविधाओं के लिए एक पृष्ठभूमि भी जोड़ सकते हैं, जैसे:

Background:
  Given I log in with valid credentials

Scenario: Change my password
  Given I am on the account page

Comments

और भी आसान इस तरह से steps %Q{Given I am logged in}

— जेरकिन

@BrendanDean जब इस उत्तर को स्वीकार किया गया, तो stepsविधि मौजूद नहीं थी। नीचे मेरा जवाब देखें।

— माइकेलवेल्वोफिश

कृपया ध्यान दें कि संयोजन चरणों को अब एक विरोधी पैटर्न माना जाता है और इसे टाला जाना चाहिए। ककड़ी विकी देखें - cucumber.io/docs/guides/ant-patterns/…

— Jan Molak

Answer 2

ध्यान दें कि कदमों के भीतर कॉल करने की विधि ककड़ी के हाल के संस्करणों में बदल गई है, जिसे आप देखेंगे कि क्या आपको त्रुटि मिलती है जैसे "परिभाषा: दिए गए / जब / तब 'का उपयोग चरण परिभाषाओं में किया गया है,' चरण 'का उपयोग करें इसके बजाय अन्य चरणों को कॉल करें: /path/to/step_definitions/foo_steps.rb: 631: `ब्लॉक इन '। देखें ककड़ी विकि जानकारी के लिए।

परिवर्तन का सार यह है कि अब आपको stepया stepsविधियों का उपयोग करना चाहिए ।

When /^I make all my stuff shiny$/
  step "I polish my first thing"
end

When /^I make all my stuff shiny$/
  steps %Q{
    When I polish my first thing
    When I shine my second thing
  }
end

Comments

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

— michaeltwofish

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

— आंद्रेई बोटालोव

hi @michaeltwofish, क्या 2017 में इसमें कोई बदलाव हुआ है? मैं हो रही है syntax error, unexpected tIDENTIFIER, expecting keyword_end stackoverflow.com/questions/43319331/...

— ericn

Answer 3

कदम परिभाषाओं से कदम उठाना एक बुरा अभ्यास है और इसके कुछ नुकसान हैं :

1. यदि परिदृश्य विफल हो जाएगा और नेस्टेड स्टेप इनवोकेशन हैं, तो आपको स्टैक ट्रेस में केवल अंतिम इनवॉल्ड स्टेप परिभाषा मिलेगी। यह पता लगाना कठिन हो सकता है कि अंतिम चरण के स्थान को किस स्थान से बुलाया गया था
2. रूबी विधि की तुलना में स्टेपडेफ को कॉल करना कभी-कभी कठिन होता है
3. रूबी विधियाँ आपको चरण दोष से कॉल करने की तुलना में अधिक शक्ति प्रदान करती हैं

Aslak Hellesøy ने पुन: उपयोग के चरणों के बजाय विश्व में लोकप्रिय कार्यों को निकालने की सिफारिश की । यह उन क्रियाओं को एक स्थान पर अलग-थलग कर देता है, जिससे इस कोड को ढूंढना आसान हो जाता है। आप सामान्य रूप से रूबी वर्गों या मॉड्यूल के लिए भी कोड निकाल सकते हैं।

#/support/world_extensions.rb
module KnowsUser
  def login
    visit('/login')
    fill_in('User name', with: user.name)
    fill_in('Password', with: user.password)
    click_button('Log in')
  end

  def user
    @user ||= User.create!(:name => 'Aslak', :password => 'xyz')
  end
end
World(KnowsUser)

#/step_definitions/authentication_steps.rb
When /^I login$/ do
  login
end

Given /^a logged in user$/ do
  login
end

यहाँ ककड़ी मेलिंग सूची में विषय पर एक उपयोगी चर्चा है - लिंक

Comments

मेरा मानना ​​है कि उपर्युक्त कारणों के लिए यह दृष्टिकोण कॉलिंग या चरण कार्यों की तुलना में बहुत बेहतर है।

— पिसरुक

इसका एक और फायदा है। Idea (या Rubymine) का उपयोग करते हुए, आप आसानी से फ़ंक्शन-परिभाषाओं पर जा सकते हैं, लेकिन चरणों में कदमों {%} पर नहीं।

— स्लिपसेट

यह सेटअप DRY सिद्धांत का पालन भी करता है

— जादूगर

हालाँकि, मैंने चरणों के पुन: उपयोग की समस्या को मारा, मुझे लगता है कि यह सिर्फ बुरा है। लॉगिन बस अलग-अलग चरणों का योग है: "कुछ पर जाएँ", "कुछ भरें"। प्राकृतिक तरीके से पुन: उपयोग किए जाने वाले कदम होंगे, इसके बजाय प्रत्येक चरण को एक फ़ंक्शन में कॉल में परिवर्तित करें। IMO, कदमों के अंदर कॉलिंग में सुधार होना चाहिए।

— dgmora

Answer 4

उद्धरण के बजाय% {} में अपने चरणों को सर्वश्रेष्ठ लपेटें। फिर, आपको दोहरे उद्धरण चिह्नों से बचने की आवश्यकता नहीं है, जिन्हें आपको अक्सर उपयोग करने की आवश्यकता होगी:

Given /^I login successfully$
  step %{I login with valid credentials}
end

Given /^I login with (.*) credentials$/ |type|
  # do stuff with type being one of "invalid" or "valid"
end

Comments

यह एक उत्तर के बजाय एक टिप्पणी होनी चाहिए थी।

— केल्विन

Answer 5

फीचर फाइल में कीवर्ड्स का पुन: उपयोग करें जो कोड पुन: प्रयोज्य प्रदान करेगा।

यह चरण दोषों के भीतर चरण दोष को कॉल करने के लिए अत्यधिक अनुशंसित नहीं है।

मैं अपनी फीचर फाइल इस तरह लिखूंगा,

Scenario Outline: To check login functionality
    Given I login with "<username>" and "<password>"
    Then I "<may or may not>" login successfully

Examples:
    |username|password|may or may not|
    |paul    |123$    |may           |
    |dave    |1111    |may not       |

मेरी चरण परिभाषा में, (यह जावा है)

@Given(I login with \"([^\"]*)\" and \"([^\"]*)\"$)
public void I_login_with_and(String username, String password){

   //login with username and password

}

@Then(I \"([^\"]*)\" login successfully$)
public void I_login_successully_if(String validity){

    if(validity.equals("may")){
        //assert for valid login
    }
    else
    if(validity.equals("may not")){
        //assert for invalid login
    }
}

इस तरह, कोड पुन: प्रयोज्य का एक बहुत कुछ है। आपका वही दिया और फिर मान्य और अमान्य दोनों परिदृश्यों को संभालता है। उसी समय, आपकी सुविधा फ़ाइल पाठकों के लिए समझ में आती है।