Autofixture: जटिल बाधाओं के साथ एक वस्तु उत्पन्न करें

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

धैर्य के लिए धन्यवाद, धुन बनाए रखें :पलक:

नमस्ते,
उस पर कोई खबर?
कोई दबाव नहीं (मुझे ड्रिल पता है , साथ ही यह वास्तव में अवरुद्ध नहीं है, मुझे वास्तव में कुछ शिक्षित सलाह चाहिए), यह सिर्फ यह जानना है कि क्या आपके पास कुछ दृश्यता है।
बहुत - बहुत धन्यवाद!

शुभ दिवस! अंत में मैंने उत्तर देने के लिए थोड़ा सा प्रकार आवंटित किया - बेहद देर से उत्तर के लिए खेद है

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

• एक सार्वजनिक कंस्ट्रक्टर या एक स्थिर फ़ैक्टरी विधि की तलाश करें (स्थिर विधि जो वर्तमान प्रकार का एक उदाहरण लौटाती है)।
• कंस्ट्रक्टर तर्कों को हल करें और उदाहरण को सक्रिय करें।
• लिखने योग्य सार्वजनिक संपत्तियों और फ़ील्ड को जेनरेट किए गए मानों से भरें।

वर्तमान दृष्टिकोण के साथ, जैसा कि आपने पहले देखा था, आप किसी तरह निर्भरता की बाधाओं को नियंत्रित नहीं कर सकते।

विशिष्ट प्रकारों को कैसे बनाया जाए, यह निर्दिष्ट करने के लिए हमारे पास कुछ अनुकूलन बिंदु हैं, लेकिन वे अपेक्षाकृत सरल हैं और उन जटिल नियमों का समर्थन नहीं करते हैं।

AutoFixture में इस तरह की संरचना का उदाहरण उत्पन्न करने का सबसे अच्छा तरीका क्या होगा? मेरा मतलब है, मैं स्पष्ट रूप से एक अनुकूलन लिखूंगा, लेकिन आप वहां क्या डालेंगे?

• क्या आप यादृच्छिक इनट्स और लूप उत्पन्न करेंगे जब तक कि उनमें से एक प्राइम न हो (या निश्चित रूप से एक प्राइम जेनरेटिंग एल्गोरिदम निष्पादित करें)? यह इस तरह की बाधा के लिए स्वीकार्य हो सकता है, लेकिन अगर बाधा का पालन करना अधिक मुश्किल था, तो यह तेजी से महंगा हो जाएगा।

• क्या आप कुछ स्वीकार्य मूल्यों की एक सीमित सूची प्रदान करेंगे?

खैर, दुर्भाग्य से मुझे यहां चांदी की गोली नहीं दिख रही है और दृष्टिकोण स्थिति पर निर्भर करता है। यदि आप बहुत अधिक यादृच्छिक होने के लिए मूल्य पर भरोसा नहीं करते हैं, या एकल एसयूटी केवल 1-2 अभाज्य संख्याओं का उपभोग करता है, तो अभाज्य संख्याओं को हार्डकोड करना और उनमें से चुनना ठीक हो सकता है (हमारे पास ElementsBulider<> अंतर्निहित सहायक है उन मामलों के लिए)। दूसरी ओर, यदि आपको अभाज्य संख्याओं की एक बड़ी सूची की आवश्यकता है और आप लंबे अभाज्य संख्या अनुक्रमों के साथ काम करते हैं, तो संभवतः उन्हें गतिशील रूप से उत्पन्न करने के लिए एक एल्गोरिथ्म को कोड करना बेहतर है।

इसके अलावा, अब मान लें कि मैं कुछ ऐसा उदाहरण बनाने की कोशिश कर रहा हूं जो कई तर्क लेता है जो सैद्धांतिक रूप से व्यक्तिगत रूप से यादृच्छिक हो सकता है, लेकिन यह उनके बीच कुछ सत्यापन करेगा (उदाहरण के लिए argA केवल मूल्यों की इस श्रेणी में हो सकता है यदि argB सत्य है, और argC को argA मान के आधार पर विभिन्न सत्यापन नियमों का पालन करना चाहिए, या argC.X संपत्ति को argA.X संपत्ति से मेल खाना चाहिए, कुछ सामान जैसे)।

आप इस मामले में क्या करेंगे?

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

मेरे सिर के ऊपर, मैं कहूंगा कि मैं आमतौर पर निम्नलिखित रणनीति की सिफारिश करता हूं:

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

इस तरह आप आंतरिक वास्तुकला का बहुत अधिक खंडन नहीं करेंगे और यह स्पष्ट होगा कि यह कैसे काम करता है। बेशक, संभावित रूप से यह तरीका बहुत ही क्रियात्मक है।

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

आइए @ploeh से उनके विचार भी पूछें। आमतौर पर मार्क के उत्तर गहरे होते हैं और वह परिणामों को हल करने के बजाय पहले मूल कारण खोजने की कोशिश करते हैं

यदि आपके पास और प्रश्न हैं - कृपया पूछें! उनका जवाब देने के लिए मेरा हमेशा स्वागत रहेगा।

पीएस एफडब्ल्यूआईडब्ल्यू, मैंने आपको एक नमूना प्रदान करने का फैसला किया, जहां मैंने ऑटोफिक्चर के साथ खेलने और इसी तरह की समस्या को हल करने की कोशिश की (मैंने इसे सरल रखने की कोशिश की और यह आपके मामले में पूरी तरह से काम नहीं कर सकता है):

```सी#
सिस्टम का उपयोग करना;
ऑटोफिक्चर का उपयोग करना;
AutoFixture.Xunit2 का उपयोग करना;
Xunit का उपयोग करना;

नेमस्पेस ऑटोफिक्चरप्लेग्राउंड
{
सार्वजनिक स्थैतिक वर्ग
{
सार्वजनिक स्थैतिक बूल IsPrime (int संख्या)
{
// https://stackoverflow.com/a/15743238/2009373 से कॉपी किया गया

        if (number <= 1) return false;
        if (number == 2) return true;
        if (number % 2 == 0) return false;

        var boundary = (int) Math.Floor(Math.Sqrt(number));

        for (int i = 3; i <= boundary; i += 2)
        {
            if (number % i == 0) return false;
        }

        return true;
    }
}

public class DepA
{
    public int Value { get; set; }
}

public class DepB
{
    public int PrimeNumber { get; }
    public int AnyOtherValue { get; }

    public DepB(int primeNumber, int anyOtherValue)
    {
        if (!Util.IsPrime(primeNumber))
            throw new ArgumentOutOfRangeException(nameof(primeNumber), primeNumber, "Number is not prime.");

        PrimeNumber = primeNumber;
        AnyOtherValue = anyOtherValue;
    }
}

public class DepC
{
    public DepA DepA { get; }
    public DepB DepB { get; }

    public DepC(DepA depA, DepB depB)
    {
        if (depB.PrimeNumber < depA.Value)
            throw new ArgumentException("Second should be larger than first.");

        DepA = depA;
        DepB = depB;
    }

    public int GetPrimeNumber() => DepB.PrimeNumber;
}

public class Issue1067
{
    [Theory, CustomAutoData]
    public void ShouldReturnPrimeNumberFromDepB(DepC sut)
    {
        var result = sut.GetPrimeNumber();

        Assert.Equal(sut.DepB.PrimeNumber, result);
    }
}

public class CustomAutoData : AutoDataAttribute
{
    public CustomAutoData() : base(() =>
    {
        var fixture = new Fixture();

        // Add prime numbers generator, returning numbers from the predefined list
        fixture.Customizations.Add(new ElementsBuilder<PrimeNumber>(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41));

        // Customize DepB to pass prime numbers only to ctor
        fixture.Customize<DepB>(c => c.FromFactory((PrimeNumber pn, int anyNumber) => new DepB(pn, anyNumber)));

        // Customize DepC, so that depA.Value is always less than depB.PrimeNumber
        fixture.Customize<DepC>(c => c.FromFactory((DepA depA, DepB depB, byte diff) =>
        {
            depA.Value = depB.PrimeNumber - diff;
            return new DepC(depA, depB);
        }));

        return fixture;
    })
    {
    }
}

/// <summary>
/// A helper type to represent a prime number, so that you can resolve prime numbers 
/// </summary>
public readonly struct PrimeNumber
{
    public int Value { get; }

    public PrimeNumber(int value)
    {
        Value = value;
    }

    public static implicit operator int(PrimeNumber prime) => prime.Value;
    public static implicit operator PrimeNumber(int value) => new PrimeNumber(value);
}

}
```

नमस्ते @zvirja

वाह, विस्तृत उत्तर के लिए धन्यवाद, यह वास्तव में दिलचस्प है। मुझे कुछ परीक्षण करने होंगे और अनुमान लगाना होगा कि यह क्या करने योग्य है या नहीं, लेकिन यह सब बहुत अच्छा है।

मुझे नहीं लगता कि मेरे पास संभालने के लिए इतनी सारी निर्भरताएं हैं, इसलिए आपका दृष्टिकोण जाने का एक अच्छा तरीका हो सकता है। बेशक, अगर @ploeh में कुछ और जोड़ने के लिए होता है, तो मुझे सम्मानित किया जाएगा

फिर से धन्यवाद, अच्छा काम करते रहो!

AutoFixture और संपत्ति-आधारित परीक्षण दोनों के साथ मेरा अनुभव यह है कि इस तरह के मुद्दों को हल करने के लिए अनिवार्य रूप से दो तरीके हैं:

• छनन
• एल्गोरिथम निर्माण

(जैसा कि मैं लिख रहा हूं, मेरा अंतर्ज्ञान बताता है कि ये क्रमशः _catamorphisms_ और _anamorphisms_ हो सकते हैं, लेकिन मुझे इसके बारे में कुछ और सोचना होगा, इसलिए यह एक तरफ ज्यादातर मेरे लिए एक नोट है।)

यदि _most_ यादृच्छिक रूप से उत्पन्न मान किसी भी बाधा के अनुरूप फिट होंगे, तो मौजूदा जनरेटर का उपयोग करना, लेकिन कभी-कभी अनुपयुक्त मूल्य को फेंकना, समस्या को हल करने का सबसे आसान तरीका हो सकता है।

यदि, दूसरी ओर, एक फ़िल्टर का अर्थ सबसे अधिक यादृच्छिक डेटा को फेंकना होगा, तो आपको इसके बजाय एक एल्गोरिथम के साथ आना होगा, जो शायद यादृच्छिक बीज मानों के आधार पर, ऐसे मान उत्पन्न करेगा जो प्रश्न में बाधाओं को फिट करते हैं।

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

कोई भी दोनों तरीकों से अभाज्य संख्या की आवश्यकता को पूरा कर सकता है।

फ़िल्टर दृष्टिकोण अप्रतिबंधित संख्याओं को उत्पन्न करना होगा, और तब तक संख्याओं को फेंक देना होगा जब तक कि आपको एक ऐसा न मिल जाए, जो वास्तव में एक प्रमुख है।

एल्गोरिथम दृष्टिकोण एक अभाज्य संख्या उत्पन्न करने के लिए एक प्रमुख चलनी की तरह एक एल्गोरिथ्म का उपयोग करना होगा। हालांकि, यह यादृच्छिक नहीं है, इसलिए कोई यह जानना चाहेगा कि इसे यादृच्छिक कैसे किया जाए।

ऑटोफिक्चर में सीमित मूल्यों से निपटने के तरीके का समग्र प्रश्न लगभग तुरंत सामने आया जब अन्य लोगों ने पुस्तकालय को देखना शुरू कर दिया, और मैंने तब एक लेख लिखा था जिसे मैं अभी भी संदर्भित करता हूं: http://blog.ploeh.dk/2009/ 05/01/डीलिंग विथ विवश इनपुट

एक दूसरे से संबंधित अनेक मूल्यों के प्रश्न के संबंध में, मैं कोई सामान्य मार्गदर्शन नहीं देना चाहता। इस प्रकार के प्रश्न अक्सर XY समस्याएं होती हैं। कई मामलों में, एक बार जब मैं बारीकियों को समझ लेता हूं, तो एक वैकल्पिक डिजाइन न केवल ऑटोफिक्चर के साथ समस्याओं को हल कर सकता है, बल्कि उत्पादन कोड आधार भी।

यहां तक ​​​​कि XY समस्याओं की उपस्थिति में, हालांकि, अभी भी ऐसी स्थितियां होने जा रही हैं जहां यह एक वैध चिंता हो सकती है, लेकिन मैं केस-दर-मामला आधार पर उनसे निपटूंगा, जैसा कि मेरे अनुभव में, वे हैं दुर्लभ।

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

@ploeh इस उत्तर के लिए बहुत बहुत धन्यवाद, जो उन दृष्टिकोणों की पुष्टि करता है जिन पर मैं विचार कर रहा था (और आपने मुझे कैटा- और एनामोर्फिज्म 😃 के बारे में उत्सुक बना दिया)।
मैं पूरी तरह से सहमत हूं कि अन्योन्याश्रित मूल्य ज्यादातर एक XY समस्या है (कम से कम मेरे मामले में), बात यह है कि जब विरासत (अवांछित ) कोड पर काम करते हैं, तो उन मूल्यों से निपटना कुछ परीक्षण लिखने के लिए एक अच्छी शुरुआत थी, जब तक कि हम प्राप्त नहीं करते इसे ठीक से रिफलेक्टर करने का समय।

वैसे भी, आपके दोनों उत्तर समस्या को काफी अच्छी तरह से संबोधित करते हैं, मुझे लगता है कि मैं वहां से जाने के लिए अच्छा हूं।
धन्यवाद!

बीटीडब्लू, मैं यह उल्लेख करना भूल गया कि मेरा मतलब केवल @zvirja के अतिरिक्त मेरा उत्तर था। यह वहां पहले से ही एक अच्छा जवाब है

मैंने इसे किसी अन्य तरीके से नहीं लिया