துல்லியமான யூனிட்

Alice Dupont

வியாழன், 26 டிசம்பர், 2024 ’அன்று’ முற்பகல் 11:19:19

அலகு சோதனையில் மாஸ்டரிங் சூழல் அடிப்படையிலான கொடி மதிப்பீடு

யூனிட் டெஸ்டிங் என்பது நம்பகமான மென்பொருள் மேம்பாட்டின் ஒரு மூலக்கல்லாகும், ஆனால் LaunchDarkly போன்ற மூன்றாம் தரப்பு கருவிகளை ஒருங்கிணைப்பது தனித்துவமான சவால்களை அறிமுகப்படுத்தலாம். ஒரு பொதுவான சூழ்நிலையில் அம்சக் கொடிகளால் பாதிக்கப்படும் குறியீடு பாதைகளை சோதனை செய்வது அடங்கும். சோதனை நிகழ்வுகளில் வெவ்வேறு கொடி மதிப்புகள் உங்களுக்குத் தேவைப்படும்போது, துல்லியமாக சூழலை உள்ளமைப்பது அவசியமாகிறது. 🎯

இந்த வழிகாட்டியில், யூனிட் சோதனைகளின் போது LaunchDarkly கொடியின் நடத்தையை கட்டுப்படுத்தும் பிரத்தியேகங்களுக்கு நாங்கள் முழுக்கு போடுகிறோம். ஒரு கொடியை அமைக்க வேண்டும் என்று கற்பனை செய்து பாருங்கள் உண்மை அனைத்து சோதனை நிகழ்வுகளுக்கும், ஒன்றைத் தவிர. சரியான சூழல் பண்புக்கூறுகளை உருவாக்குவது இதை அடைவதற்கான திறவுகோலாகும், இருப்பினும் உகந்த அமைப்பைக் கண்டறிவது ஒரு தளம் வழிசெலுத்துவது போல் உணரலாம்.

விளக்குவதற்கு, "பீட்டா சோதனையாளர்கள்" என்று கொடியிடப்பட்ட பயனர்களுக்கு தயாரிப்பு அம்சம் முடக்கப்பட்டிருக்க வேண்டும், அதே நேரத்தில் மற்ற அனைவருக்கும் செயல்படுத்தப்படும் ஒரு கற்பனையான சூழ்நிலையைக் கவனியுங்கள். இந்த நுணுக்கமான தேவையை இந்த நிபந்தனைகளை மதிக்கும் வலுவான சோதனை தரவு மற்றும் கொடி மாறுபாடுகளை உருவாக்குவதன் மூலம் மட்டுமே பூர்த்தி செய்ய முடியும்.

நிஜ உலக எடுத்துக்காட்டில் நடப்பதன் மூலம், யூனிட் சோதனைகளில் OpenFeature உடன் LaunchDarkly இன் SDK ஐப் பயன்படுத்துவதற்கான சவால்கள் மற்றும் தீர்வுகளைத் திறக்கிறோம். நடைமுறைப் படிகள் மற்றும் எடுத்துக்காட்டுகளுடன், சூழல் சார்ந்த கொடி மதிப்பீட்டின் கலையில் தேர்ச்சி பெறுவீர்கள், மேலும் உங்கள் சோதனைத் திறனை அடுத்த கட்டத்திற்கு எடுத்துச் செல்வீர்கள். 🚀

கட்டளை	பயன்பாட்டின் உதாரணம்
ldtestdata.DataSource()	இது LaunchDarkly கொடி மதிப்பீடுகளை உருவகப்படுத்துவதற்கான சோதனை தரவு மூலத்தை துவக்குகிறது. சோதனை நோக்கங்களுக்காக நிரல் ரீதியாக கொடி உள்ளமைவுகளை உருவாக்கவும் மாற்றவும் இது அனுமதிக்கிறது.
VariationForKey()	கொடுக்கப்பட்ட சூழல் விசை மற்றும் மதிப்புக்கான குறிப்பிட்ட கொடி மாறுபாட்டை (சரி அல்லது தவறு) வரையறுக்கிறது. குறிப்பிட்ட பண்புக்கூறுகளின் அடிப்படையில் கொடி வித்தியாசமாக செயல்பட வேண்டிய தனிப்பட்ட சோதனை நிகழ்வுகளைக் கையாள இது பயன்படுகிறது.
FallthroughVariation()	குறிப்பிட்ட நிபந்தனைகள் அல்லது இலக்குகள் பொருந்தாதபோது இயல்புநிலை கொடி மாறுபாட்டை அமைக்கிறது. இது கொடி மதிப்பீட்டிற்கான பின்னடைவு நடத்தையை உறுதி செய்கிறது.
ContextBuild()	பயனர் பண்புக்கூறுகள் மற்றும் அநாமதேய கொடிகள் உட்பட கொடி மதிப்பீட்டிற்கான விரிவான சூழலை உருவாக்கப் பயன்படுகிறது. டைனமிக் பயனர் அடிப்படையிலான சோதனைக் காட்சிகளுக்கு இது முக்கியமானது.
NewEvaluationContext()	கொடிகளை மதிப்பிடுவதற்கான சூழலை உருவாக்குகிறது. சோதனைக்காக "வகை" மற்றும் தனிப்பயன் விசை-மதிப்பு ஜோடிகள் போன்ற பண்புக்கூறுகளைக் குறிப்பிட இது அனுமதிக்கிறது.
BoolVariation()	வழங்கப்பட்ட சூழலின் அடிப்படையில் அம்சக் கொடியின் பூலியன் மதிப்பைப் பெறுகிறது. இந்த கட்டளை சோதனைகளின் போது சரியான கொடி மதிப்பீட்டை உறுதி செய்கிறது.
testData.updateFlag()	ஜாவாஸ்கிரிப்ட் எடுத்துக்காட்டில், இது குறிப்பிட்ட மாறுபாடுகள் மற்றும் இலக்குகளுடன் கொடி உள்ளமைவை மாறும் வகையில் மேம்படுத்துகிறது, இது வடிவமைக்கப்பட்ட சோதனையை செயல்படுத்துகிறது.
SetAnonymous()	சூழல் உருவாக்கத்தின் போது ஒரு சூழலை அநாமதேயமாகக் குறிக்கிறது. பயனர் அடையாளங்கள் கொடி மதிப்பீடுகளில் தாக்கத்தை ஏற்படுத்தாத சந்தர்ப்பங்களில் இது பயனுள்ளதாக இருக்கும்.
WithTransactionContext()	பெற்றோர் சூழலுடன் மதிப்பீட்டு சூழலை ஒருங்கிணைக்கிறது. கொடி மதிப்பீட்டின் போது இரண்டு சூழல்களும் ஒன்றாக மதிப்பிடப்படுவதை இது உறுதி செய்கிறது.
init()	Node.js இல் LaunchDarkly SDK கிளையண்டைத் துவக்குகிறது, கொடி உள்ளமைவு மற்றும் மதிப்பீட்டு சேவைகளுடன் தொடர்பு கொள்ள அதைத் தயாரிக்கிறது.

சூழல்-குறிப்பிட்ட கொடி சோதனையின் இயக்கவியலை வெளியிடுதல்

மேலே உள்ள எடுத்துக்காட்டில், முதல் ஸ்கிரிப்ட் என்பது Go-வில் உள்ள பின்தளத்தில் செயல்படுத்தப்படும் போது LaunchDarkly கொடி மதிப்பீடுகளைக் கையாள வடிவமைக்கப்பட்டுள்ளது. அலகு சோதனை. டைனமிக் பயனர் சூழல்களின் அடிப்படையில் பல்வேறு கொடி நடத்தைகளை உருவகப்படுத்துவதே இதன் நோக்கம், தனித்தனியாக வெவ்வேறு காட்சிகளை சோதிப்பதை சாத்தியமாக்குகிறது. `ldtestdata.DataSource()` கட்டளையைப் பயன்படுத்தி ஒரு சோதனை தரவு மூலத்தை உருவாக்குவதன் மூலம் ஸ்கிரிப்ட் தொடங்குகிறது, இது அம்சக் கொடி அமைப்புகளை நிரல் ரீதியாக வரையறுக்கவும் மாற்றவும் அனுமதிக்கிறது. நிஜ உலக உள்ளமைவுகளைப் பிரதிபலிக்கும் வகையில் சோதனைச் சூழலை வடிவமைக்க முடியும் என்பதை இது உறுதி செய்கிறது. 📊

தனித்துவமான கட்டளைகளில் ஒன்று `VariationForKey()`, இது பயனர் பண்புக்கூறுகளுக்கு குறிப்பிட்ட கொடி மாறுபாடுகளை வரைபடமாக்குகிறது. எங்கள் விஷயத்தில், 'FallthroughVariation()' ஐப் பயன்படுத்தும் மற்றவர்களுக்கு 'true' என்பதை இயல்பாக அமைக்கும்போது, "disable-flag" என்ற பண்புக்கூறை 'true' என அமைக்கப்பட்டுள்ள பயனர்களுக்கு 'false' என்பதைக் கொடி மதிப்பிடுவதை உறுதிசெய்ய இதைப் பயன்படுத்துகிறோம். குறிப்பிட்ட சில பயனர்களுக்கு பீட்டா அம்சங்கள் முடக்கப்பட்டாலும், மீதமுள்ள மக்களுக்கு இயக்கப்படும் நடைமுறை சூழ்நிலையை இந்த அமைப்பு பிரதிபலிக்கிறது. இந்தக் கட்டளைகளை இணைப்பதன் மூலம், சோதனைகளில் யதார்த்தமான அம்சக் கொடி நடத்தையை உருவகப்படுத்துவதற்கான வலுவான பொறிமுறையை உருவாக்குகிறோம்.

Node.js இல் எழுதப்பட்ட இரண்டாவது ஸ்கிரிப்ட், LaunchDarkly SDK ஐப் பயன்படுத்தி முன்பக்கம் அல்லது மிடில்வேர் பயன்பாடுகளில் கவனம் செலுத்துகிறது. இது மாறுபாடுகள் மற்றும் இலக்கு விதிகளுடன் கொடிகளை மாறும் வகையில் உள்ளமைக்க `testData.updateFlag()` கட்டளையைப் பயன்படுத்துகிறது. எடுத்துக்காட்டாக, கொடி மதிப்பீட்டின் நடத்தையை மாற்ற, "முடக்கு-கொடி" போன்ற குறிப்பிட்ட தனிப்பயன் பண்புக்கூறுகளைக் கொண்ட பயனர்களை நாங்கள் குறிவைக்கிறோம். அம்சம் மாறுதல்கள் அடிக்கடி புதுப்பிக்கப்படும் அல்லது வெவ்வேறு சூழ்நிலைகளில் சோதிக்கப்பட வேண்டிய சூழல்களில் இந்த டைனமிக் உள்ளமைவு மிகவும் பயனுள்ளதாக இருக்கும். அம்சம் வெளியீடுகளின் போது தடையற்ற பயனர் அனுபவங்களை உறுதி செய்வதற்கு இது மிகவும் பயனுள்ளதாக இருக்கும். 🚀

இரண்டு ஸ்கிரிப்ட்களும் பயன்படுத்துவதன் முக்கியமான முக்கியத்துவத்தை நிரூபிக்கின்றன சூழல் சார்ந்த கொடி மதிப்பீடு. Go செயல்படுத்தல் சக்திவாய்ந்த தரவு மூல கையாளுதலுடன் சர்வர் பக்க கட்டுப்பாட்டைக் காட்டுகிறது, அதே நேரத்தில் Node.js எடுத்துக்காட்டு கிளையன்ட் பக்கத்தில் மாறும் கொடி புதுப்பிப்புகளை எடுத்துக்காட்டுகிறது. ஒன்றாக, இந்த அணுகுமுறைகள் LaunchDarkly கொடிகளால் மாற்றப்பட்ட அம்சங்களைச் சோதனை செய்வதற்கான விரிவான தீர்வை வழங்குகிறது. நீங்கள் சோதனை அம்சங்களை வெளியிடும் டெவலப்பராக இருந்தாலும் அல்லது சிக்கலான காட்சிகளை பிழைத்திருத்தினாலும், இந்த ஸ்கிரிப்ட்கள் நம்பகமான மற்றும் சூழல் விழிப்புணர்வு சோதனை பணிப்பாய்வுகளுக்கு அடித்தளமாக செயல்படும். 💡

அலகு சோதனைக்கான சூழல் சார்ந்த கொடி மதிப்பீடு

இந்த ஸ்கிரிப்ட் Go ஐப் பயன்படுத்தி ஒரு பின்தள தீர்வைக் காட்டுகிறது, வெவ்வேறு சோதனை நிகழ்வுகளுக்கு குறிப்பிட்ட கொடி மாறுபாடுகளை உள்ளமைக்க LaunchDarkly SDK ஐ மேம்படுத்துகிறது.

package main

import (
    "context"
    "fmt"
    "time"
    ld "github.com/launchdarkly/go-server-sdk/v7"
    "github.com/launchdarkly/go-server-sdk/v7/ldcomponents"
    "github.com/launchdarkly/go-server-sdk/v7/testhelpers/ldtestdata"
)

// Create a test data source and client
func NewTestClient() (*ldtestdata.TestDataSource, *ld.LDClient, error) {
    td := ldtestdata.DataSource()
    config := ld.Config{
        DataSource: td,
        Events:     ldcomponents.NoEvents(),
    }
    client, err := ld.MakeCustomClient("test-sdk-key", config, 5*time.Second)
    if err != nil {
        return nil, nil, err
    }
    return td, client, nil
}

// Configure the test flag with variations
func ConfigureFlag(td *ldtestdata.TestDataSource) {
    td.Update(td.Flag("feature-flag")
        .BooleanFlag()
        .VariationForKey("user", "disable-flag", false)
        .FallthroughVariation(true))
}

// Simulate evaluation based on context
func EvaluateFlag(client *ld.LDClient, context map[string]interface{}) bool {
    evalContext := ld.ContextBuild(context["kind"].(string)).SetAnonymous(true).Build()
    value, err := client.BoolVariation("feature-flag", evalContext, false)
    if err != nil {
        fmt.Println("Error evaluating flag:", err)
        return false
    }
    return value
}

func main() {
    td, client, err := NewTestClient()
    if err != nil {
        fmt.Println("Error creating client:", err)
        return
    }
    defer client.Close()
    ConfigureFlag(td)
    testContext := map[string]interface{}{
        "kind":         "user",
        "disable-flag": true,
    }
    result := EvaluateFlag(client, testContext)
    fmt.Println("Feature flag evaluation result:", result)
}

யூனிட் சோதனைகளில் டார்க்லி கொடிகளை ஏவுதல் முன்பக்கக் கையாளுதல்

இந்த ஸ்கிரிப்ட் டைனமிக் சூழல் மதிப்புகளுடன் அம்சக் கொடி மதிப்பீடுகளை உருவகப்படுத்துவதற்கான JavaScript/Node.js செயல்படுத்தலைக் காட்டுகிறது.

const LaunchDarkly = require('launchdarkly-node-server-sdk');

async function setupClient() {
    const client = LaunchDarkly.init('test-sdk-key');
    await client.waitForInitialization();
    return client;
}

async function configureFlag(client) {
    const data = client.testData();
    data.updateFlag('feature-flag', {
        variations: [true, false],
        fallthrough: { variation: 0 },
        targets: [
            { variation: 1, values: ['disable-flag'] }
        ]
    });
}

async function evaluateFlag(client, context) {
    const value = await client.variation('feature-flag', context, false);
    console.log('Flag evaluation result:', value);
    return value;
}

async function main() {
    const client = await setupClient();
    await configureFlag(client);
    const testContext = {
        key: 'user-123',
        custom: { 'disable-flag': true }
    };
    await evaluateFlag(client, testContext);
    client.close();
}

main().catch(console.error);

மேம்பட்ட சூழல் உள்ளமைவுகளுடன் LaunchDarkly சோதனையை மேம்படுத்துகிறது

LaunchDarkly இல் அம்சக் கொடிகளுடன் பணிபுரியும் போது, மேம்பட்டது சூழல் கட்டமைப்புகள் உங்கள் சோதனை துல்லியத்தை கணிசமாக மேம்படுத்த முடியும். கொடிகளை மாற்றுவதற்கான அடிப்படை செயல்பாடு நேரடியானது என்றாலும், நிஜ-உலகப் பயன்பாடுகள் பெரும்பாலும் பயனர் பண்புக்கூறுகள் அல்லது சுற்றுச்சூழல் காரணிகளின் அடிப்படையில் நுணுக்கமான மதிப்பீடுகளைக் கோருகின்றன. எடுத்துக்காட்டாக, "உள் சோதனையாளர்கள்" போன்ற குறிப்பிட்ட பயனர் குழுக்களுக்கான அம்சத்தை நீங்கள் முடக்க வேண்டியிருக்கலாம், அதே நேரத்தில் அதை மற்ற அனைவருக்கும் நேரலையில் வைத்திருக்கலாம். இதற்கு பல பண்புகளை மாறும் வகையில் கணக்கிடும் வலுவான சூழல்களை உருவாக்க வேண்டும். 🚀

LaunchDarkly இன் கவனிக்கப்படாத ஆனால் சக்திவாய்ந்த அம்சம் பயனர், சாதனம் அல்லது பயன்பாடு போன்ற பல சூழல் வகைகளுக்கான ஆதரவாகும். இந்த அம்சத்தைப் பயன்படுத்துவதன் மூலம், பயனர் கணக்குகள் மற்றும் அநாமதேய அமர்வுகளுக்கு இடையில் வேறுபாடு காண்பது போன்ற நிஜ உலக காட்சிகளை உருவகப்படுத்த உங்களை அனுமதிக்கிறது. அலகு சோதனைகளில், போன்ற கருவிகளைப் பயன்படுத்தி இந்த விரிவான சூழல்களில் தேர்ச்சி பெறலாம் NewEvaluationContext, இது "அநாமதேய: உண்மை" அல்லது எட்ஜ்-கேஸ் சோதனைக்கான தனிப்பயன் கொடிகள் போன்ற பண்புகளைக் குறிப்பிட உங்களை அனுமதிக்கிறது. இந்த உள்ளமைவுகள் உங்கள் சோதனைகளின் மீது நுணுக்கமான கட்டுப்பாட்டை செயல்படுத்துகின்றன, உற்பத்தியில் எதிர்பாராத நடத்தைகள் இல்லை என்பதை உறுதி செய்கிறது.

மற்றொரு மேம்பட்ட அம்சம், கூட்டு விதிகளைப் பயன்படுத்தி கொடி இலக்கிடுதல் ஆகும். உதாரணமாக, இணைப்பதன் மூலம் பூலியன் கொடி உடன் VariationForKey, குறிப்பிட்ட பிராந்தியத்தில் உள்ள பயனர்களுக்கு மட்டும் சோதனை செய்தல் அல்லது பிரீமியம் உறுப்பினர்களாகக் கொடியிடப்பட்ட பயனர்கள் போன்ற தனிப்பட்ட சூழல்களுக்கு ஏற்றவாறு மிகவும் குறிப்பிட்ட விதிகளை நீங்கள் உருவாக்கலாம். உங்கள் அலகு சோதனைகள் சிக்கலான தொடர்புகளை திறம்பட உருவகப்படுத்த முடியும் என்பதை இது உறுதி செய்கிறது. இந்த உத்திகளை உங்கள் பணிப்பாய்வுகளில் ஒருங்கிணைப்பது நம்பகத்தன்மையை மேம்படுத்துவதோடு மட்டுமல்லாமல், வரிசைப்படுத்தலின் போது பிழைகளைக் குறைத்து, உங்கள் சோதனைச் செயல்முறையை மிகவும் வலிமையாகவும் திறமையாகவும் ஆக்குகிறது. 🌟

மாஸ்டரிங் சூழல் அடிப்படையிலான சோதனை: அடிக்கடி கேட்கப்படும் கேள்விகள்

LaunchDarkly சூழல் என்றால் என்ன?
ஒரு LaunchDarkly சூழல் என்பது பயனர் அல்லது சாதன பண்புக்கூறுகள் போன்ற கொடி மதிப்பிடப்படும் நிறுவனத்தைப் பற்றிய மெட்டாடேட்டாவைக் குறிக்கிறது. பயன்படுத்தவும் NewEvaluationContext சோதனைகளில் இந்தத் தரவை மாறும் வகையில் வரையறுக்க.
ஒரு கொடிக்கு வெவ்வேறு மாறுபாடுகளை எவ்வாறு அமைப்பது?
நீங்கள் பயன்படுத்தலாம் VariationForKey சூழல் பண்புகளின் அடிப்படையில் குறிப்பிட்ட விளைவுகளை வரையறுக்க. எடுத்துக்காட்டாக, "disable-flag: true" என்பதை அமைப்பது அந்தப் பண்புக்கூறுக்கு `false` என்பதை வழங்கும்.
ஒரே நேரத்தில் பல சூழல்களைச் சோதிக்க முடியுமா?
ஆம், LaunchDarkly பல சூழல் சோதனையை ஆதரிக்கிறது. பயன்படுத்தவும் SetAnonymous அநாமதேய பயனர்கள் மற்றும் உள்நுழைந்த பயனர்கள் போன்ற வெவ்வேறு பயனர் அமர்வுகளை உருவகப்படுத்த தனிப்பயன் பண்புக்கூறுகளுடன்.
கொடி இலக்கில் உள்ள கூட்டு விதிகள் என்ன?
ஒரு குறிப்பிட்ட இடத்தில் பயனர் இருப்பது மற்றும் பிரீமியம் கணக்கு வைத்திருப்பது போன்ற பல நிபந்தனைகளை இணைக்க கூட்டு விதிகள் அனுமதிக்கின்றன. பயன்படுத்தவும் BooleanFlag மற்றும் மேம்பட்ட காட்சிகளுக்கான நிபந்தனை இலக்கு.
சோதனைகளில் ஏற்படும் பின்னடைவு மாறுபாடுகளை நான் எவ்வாறு கையாள்வது?
பயன்படுத்தவும் FallthroughVariation குறிப்பிட்ட இலக்கு விதி பொருந்தாத போது இயல்புநிலை நடத்தையை வரையறுக்க. இது விளிம்பு நிலைகளில் கணிக்கக்கூடிய கொடி மதிப்பீட்டை உறுதி செய்கிறது.

கொடி அடிப்படையிலான சோதனை உத்திகளை செம்மைப்படுத்துதல்

யூனிட் சோதனைகளுக்கு LaunchDarkly கொடிகளை உள்ளமைப்பது ஒரு சவாலாகவும் வாய்ப்பாகவும் இருக்கிறது. துல்லியமான சூழல்களை உருவாக்குவதன் மூலம், டெவலப்பர்கள் பல்வேறு பயனர் காட்சிகளுக்கு வலுவான மற்றும் மீண்டும் பயன்படுத்தக்கூடிய சோதனைகளை உருவாக்க முடியும். இந்தச் செயல்முறை அம்சங்கள் நம்பகத்தன்மையுடன் இயக்கப்பட்டிருப்பதையோ அல்லது முடக்கப்பட்டிருப்பதையோ உறுதிசெய்கிறது, இது நேரடி சூழல்களில் சாத்தியமான பிழைகளைக் குறைக்கிறது. 🌟

போன்ற மேம்பட்ட கருவிகள் பூலியன் கொடி மற்றும் VariationForKey நுணுக்கமான நடத்தைகளை வரையறுக்க குழுக்களுக்கு அதிகாரம் அளித்து, சோதனைகளை மிகவும் ஆற்றல்மிக்கதாகவும் பயனுள்ளதாகவும் மாற்றுகிறது. கட்டமைக்கப்பட்ட அணுகுமுறையுடன், உங்கள் சோதனைகள் நிஜ உலக பயன்பாட்டு நிகழ்வுகளை பிரதிபலிக்கின்றன, உங்கள் கோட்பேஸை வலுப்படுத்துகின்றன மற்றும் பயனர் திருப்தியை மேம்படுத்துகின்றன.

ஆதாரங்கள் மற்றும் குறிப்புகள்

LaunchDarkly Go SDK மற்றும் அதன் பயன்பாடு பற்றிய விவரங்களை இங்கே காணலாம் டார்க்லி கோ SDK ஐ துவக்கவும் .
அம்சக் கொடி நிர்வாகத்திற்கு OpenFeature SDK ஐப் பயன்படுத்துவது பற்றிய தகவல் இங்கே கிடைக்கிறது OpenFeature அதிகாரப்பூர்வ ஆவணம் .
LaunchDarkly இல் சோதனை தரவு மூலங்களை அமைப்பது பற்றி மேலும் அறிக டார்க்லி சோதனை தரவு ஆதாரங்களைத் தொடங்கவும் .
நடைமுறை எடுத்துக்காட்டுகளுடன் மேம்பட்ட அம்சக் கொடி மேலாண்மை உத்திகளை ஆராயுங்கள் மார்ட்டின் ஃபோலரின் கட்டுரை அம்சம் மாறுகிறது .

துல்லியமான யூனிட் சோதனைக் காட்சிகளுக்காக LaunchDarkly கொடிகளை உள்ளமைக்கிறது