പുലുമിക്കൊപ്പം അടിസ്ഥാന സൗകര്യങ്ങൾ കോഡായി പരിശോധിക്കുന്നു. ഭാഗം 2

എല്ലാവർക്കും ഹായ്. ഇന്ന് ഞങ്ങൾ നിങ്ങളുമായി ലേഖനത്തിന്റെ അവസാന ഭാഗം പങ്കിടുന്നു. "പുളുമിക്കൊപ്പം അടിസ്ഥാന സൗകര്യങ്ങൾ ഒരു കോഡായി പരിശോധിക്കുന്നു", ഇതിന്റെ വിവർത്തനം കോഴ്‌സ് വിദ്യാർത്ഥികൾക്കായി പ്രത്യേകം തയ്യാറാക്കിയതാണ് "DevOps പ്രാക്ടീസുകളും ടൂളുകളും".

വിന്യാസ പരിശോധന

ഈ രീതിയിലുള്ള പരിശോധന ശക്തമായ ഒരു സമീപനമാണ് കൂടാതെ ഞങ്ങളുടെ ഇൻഫ്രാസ്ട്രക്ചർ കോഡിന്റെ ആന്തരിക പ്രവർത്തനങ്ങൾ പരിശോധിക്കുന്നതിന് വൈറ്റ് ബോക്സ് ടെസ്റ്റിംഗ് നടത്താൻ ഞങ്ങളെ അനുവദിക്കുന്നു. എന്നിരുന്നാലും, നമുക്ക് പരീക്ഷിക്കാൻ കഴിയുന്നതിനെ ഇത് ഒരു പരിധിവരെ പരിമിതപ്പെടുത്തുന്നു. യഥാർത്ഥ വിന്യാസത്തിന് മുമ്പ് പുലുമി സൃഷ്ടിച്ച ഇൻ-മെമ്മറി വിന്യാസ പദ്ധതിയെ അടിസ്ഥാനമാക്കിയാണ് പരിശോധനകൾ നടത്തുന്നത്, അതിനാൽ വിന്യാസം തന്നെ പരീക്ഷിക്കാൻ കഴിയില്ല. അത്തരം സന്ദർഭങ്ങളിൽ, പുലുമിക്ക് ഒരു ഇന്റഗ്രേഷൻ ടെസ്റ്റ് ഫ്രെയിംവർക്ക് ഉണ്ട്. ഈ രണ്ട് സമീപനങ്ങളും ഒരുമിച്ച് പ്രവർത്തിക്കുന്നു!

പുലുമി ഇന്റഗ്രേഷൻ ടെസ്റ്റിംഗ് ചട്ടക്കൂട് Go- യിൽ എഴുതിയിരിക്കുന്നു, അങ്ങനെയാണ് ഞങ്ങൾ ഞങ്ങളുടെ ആന്തരിക കോഡിന്റെ ഭൂരിഭാഗവും പരിശോധിക്കുന്നത്. മുമ്പ് ചർച്ച ചെയ്ത യൂണിറ്റ് ടെസ്റ്റിംഗ് സമീപനം വൈറ്റ് ബോക്സ് ടെസ്റ്റിംഗ് പോലെയാണെങ്കിലും, ഇന്റഗ്രേഷൻ ടെസ്റ്റിംഗ് ഒരു ബ്ലാക്ക് ബോക്സാണ്. (കഠിനമായ ആന്തരിക പരിശോധനയ്ക്കുള്ള ഓപ്‌ഷനുകളും ഉണ്ട്.) ഈ ചട്ടക്കൂട് സൃഷ്‌ടിച്ചത് ഒരു സമ്പൂർണ്ണ പുലൂമി പ്രോഗ്രാം എടുക്കുന്നതിനും അതിൽ ഒരു പുതിയ സ്റ്റാക്ക് വിന്യസിക്കുക, വ്യതിയാനങ്ങളോടെ അപ്‌ഡേറ്റ് ചെയ്യുക, ഒരുപക്ഷേ ഒന്നിലധികം തവണ ഇല്ലാതാക്കുക എന്നിങ്ങനെയുള്ള വിവിധ ലൈഫ് സൈക്കിൾ പ്രവർത്തനങ്ങൾ നടത്തുന്നതിന് വേണ്ടിയാണ്. . ഞങ്ങൾ അവ പതിവായി പ്രവർത്തിപ്പിക്കുന്നു (ഉദാഹരണത്തിന്, രാത്രിയിൽ) കൂടാതെ സ്ട്രെസ് ടെസ്റ്റുകളായി.

(ഞങ്ങൾ ഞങ്ങൾ അതിൽ പ്രവർത്തിക്കുകയാണ്, അതുവഴി സമാന സംയോജന പരിശോധന കഴിവുകൾ ഭാഷകളുടെ പ്രാദേശിക SDK-യിൽ ലഭ്യമാണ്. നിങ്ങളുടെ പുലുമി പ്രോഗ്രാം ഏത് ഭാഷയിലാണ് എഴുതിയിരിക്കുന്നത് എന്നത് പരിഗണിക്കാതെ തന്നെ നിങ്ങൾക്ക് ഗോ ഇന്റഗ്രേഷൻ ടെസ്റ്റിംഗ് ഫ്രെയിംവർക്ക് ഉപയോഗിക്കാം).

ഈ ചട്ടക്കൂട് ഉപയോഗിച്ച് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ പരിശോധിക്കാം:

• നിങ്ങളുടെ പ്രോജക്റ്റ് കോഡ് വാക്യഘടനാപരമായി ശരിയാണ് കൂടാതെ പിശകുകളില്ലാതെ പ്രവർത്തിക്കുന്നു.
• സ്റ്റാക്കും രഹസ്യ കോൺഫിഗറേഷൻ ക്രമീകരണങ്ങളും പ്രവർത്തിക്കുകയും ശരിയായി വ്യാഖ്യാനിക്കുകയും ചെയ്യുന്നു.
• നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന ക്ലൗഡ് ദാതാവിൽ നിങ്ങളുടെ പ്രോജക്റ്റ് വിജയകരമായി വിന്യസിക്കാനാകും.
• നിങ്ങളുടെ പ്രോജക്റ്റ് പ്രാരംഭ അവസ്ഥയിൽ നിന്ന് N മറ്റ് സംസ്ഥാനങ്ങളിലേക്ക് വിജയകരമായി അപ്‌ഗ്രേഡുചെയ്യാനാകും.
• നിങ്ങളുടെ പ്രോജക്റ്റ് വിജയകരമായി നശിപ്പിക്കാനും നിങ്ങളുടെ ക്ലൗഡ് ദാതാവിൽ നിന്ന് നീക്കം ചെയ്യാനും കഴിയും.

നമുക്ക് ഉടൻ കാണാനാകുന്നതുപോലെ, റൺടൈം മൂല്യനിർണ്ണയം നടത്താനും ഈ ചട്ടക്കൂട് ഉപയോഗിക്കാം.

ലളിതമായ ഇന്റഗ്രേഷൻ ടെസ്റ്റ്

ഇത് പ്രവർത്തനക്ഷമമായി കാണുന്നതിന്, ഞങ്ങൾ റിപ്പോസിറ്ററിയിലേക്ക് നോക്കും pulumi/examples, ഞങ്ങളുടെ ടീമും പുലുമി കമ്മ്യൂണിറ്റിയും ഞങ്ങളുടെ സ്വന്തം പുൾ അഭ്യർത്ഥനകൾ, കമ്മിറ്റുകൾ, രാത്രികാല ബിൽഡുകൾ എന്നിവ പരീക്ഷിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു.

ഞങ്ങളുടെ ലളിതമായ ഒരു പരീക്ഷണം ചുവടെയുണ്ട് S3 ബക്കറ്റും മറ്റ് ചില വസ്തുക്കളും നൽകുന്ന ഉദാഹരണം:

example_test.go:

package test
 
import (
    "os"
    "path"
    "testing"
 
    "github.com/pulumi/pulumi/pkg/testing/integration"
)
 
func TestExamples(t *testing.T) {
    awsRegion := os.Getenv("AWS_REGION")
    if awsRegion == "" {
        awsRegion = "us-west-1"
    }
    cwd, _ := os.Getwd()
    integration.ProgramTest(t, &integration.ProgramTestOptions{
        Quick:       true,
        SkipRefresh: true,
        Dir:         path.Join(cwd, "..", "..", "aws-js-s3-folder"),
        Config: map[string]string{
            "aws:region": awsRegion,
        },
    })
}

ഈ ടെസ്റ്റ് ഒരു ഫോൾഡറിനായി ഒരു സ്റ്റാക്ക് സൃഷ്ടിക്കുന്നതിനും പരിഷ്‌ക്കരിക്കുന്നതിനും നശിപ്പിക്കുന്നതിനുമുള്ള അടിസ്ഥാന ജീവിതചക്രത്തിലൂടെ കടന്നുപോകുന്നു aws-js-s3-folder. പാസായ ഒരു ടെസ്റ്റ് റിപ്പോർട്ട് ചെയ്യാൻ ഒരു മിനിറ്റ് എടുക്കും:

$ go test .
PASS
ok      ... 43.993s

ഈ ടെസ്റ്റുകളുടെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കാൻ നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്. ഓപ്ഷനുകളുടെ പൂർണ്ണമായ ലിസ്റ്റ് കാണുക. ഘടനയിൽ ProgramTestOptions. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ജെയ്ഗർ എൻഡ് പോയിന്റ് ട്രെയ്‌സ് ചെയ്യാൻ കോൺഫിഗർ ചെയ്യാം (Tracing), ടെസ്റ്റിംഗ് നെഗറ്റീവ് ആണെങ്കിൽ ടെസ്റ്റ് പരാജയപ്പെടുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നുവെന്ന് സൂചിപ്പിക്കുക (ExpectFailure), സംസ്ഥാനങ്ങളുടെ തുടർച്ചയായ പരിവർത്തനത്തിനായി പ്രോഗ്രാമിലേക്ക് "എഡിറ്റുകളുടെ" ഒരു പരമ്പര പ്രയോഗിക്കുക (EditDirs) അതോടൊപ്പം തന്നെ കുടുതല്. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ വിന്യാസം പരിശോധിക്കാൻ അവ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നോക്കാം.

റിസോഴ്സ് പ്രോപ്പർട്ടികൾ പരിശോധിക്കുന്നു

മുകളിൽ ചർച്ച ചെയ്ത സംയോജനം ഞങ്ങളുടെ പ്രോഗ്രാം "പ്രവർത്തിക്കുന്നുവെന്ന്" ഉറപ്പാക്കുന്നു-അത് ക്രാഷ് ചെയ്യുന്നില്ല. എന്നാൽ തത്ഫലമായുണ്ടാകുന്ന സ്റ്റാക്കിന്റെ ഗുണവിശേഷതകൾ പരിശോധിക്കണമെങ്കിൽ എന്തുചെയ്യും? ഉദാഹരണത്തിന്, ചില തരത്തിലുള്ള വിഭവങ്ങൾ നൽകിയിട്ടുണ്ട് (അല്ലെങ്കിൽ ഇല്ല) അവയ്ക്ക് ചില ആട്രിബ്യൂട്ടുകൾ ഉണ്ട്.

പാരാമീറ്റർ ExtraRuntimeValidation വേണ്ടി ProgramTestOptions പുലുമി രേഖപ്പെടുത്തിയ വിന്യാസത്തിനു ശേഷമുള്ള അവസ്ഥ പരിശോധിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു, അതിനാൽ ഞങ്ങൾക്ക് കൂടുതൽ പരിശോധനകൾ നടത്താനാകും. കോൺഫിഗറേഷൻ, എക്‌സ്‌പോർട്ട് ചെയ്‌ത ഔട്ട്‌പുട്ട് മൂല്യങ്ങൾ, എല്ലാ ഉറവിടങ്ങളും അവയുടെ പ്രോപ്പർട്ടി മൂല്യങ്ങളും, ഉറവിടങ്ങൾക്കിടയിലുള്ള എല്ലാ ആശ്രിതത്വങ്ങളും ഉൾപ്പെടെ, ഫലമായുണ്ടാകുന്ന സ്റ്റാക്കിന്റെ അവസ്ഥയുടെ പൂർണ്ണമായ സ്‌നാപ്പ്ഷോട്ട് ഇതിൽ ഉൾപ്പെടുന്നു.

ഇതിന്റെ ഒരു അടിസ്ഥാന ഉദാഹരണം കാണുന്നതിന്, ഞങ്ങളുടെ പ്രോഗ്രാം ഒന്ന് സൃഷ്ടിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കാം എസ് 3 ബക്കറ്റ്:

  integration.ProgramTest(t, &integration.ProgramTestOptions{
        // as before...
        ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
            var foundBuckets int
            for _, res := range stack.Deployment.Resources {
                if res.Type == "aws:s3/bucket:Bucket" {
                    foundBuckets++
                }
            }
            assert.Equal(t, 1, foundBuckets, "Expected to find a single AWS S3 Bucket")
        },
    })

ഇപ്പോൾ, നമ്മൾ ഗോ ടെസ്റ്റ് നടത്തുമ്പോൾ, അത് ലൈഫ് സൈക്കിൾ ടെസ്റ്റുകളുടെ ബാറ്ററിയിലൂടെ കടന്നുപോകുക മാത്രമല്ല, സ്റ്റാക്ക് വിജയകരമായി വിന്യസിച്ചതിന് ശേഷം, അത് ഫലമായുണ്ടാകുന്ന അവസ്ഥയിൽ ഒരു അധിക പരിശോധന നടത്തുകയും ചെയ്യും.

റൺടൈം ടെസ്റ്റുകൾ

ഇതുവരെ, എല്ലാ പരിശോധനകളും വിന്യാസ സ്വഭാവത്തെയും പുലുമി റിസോഴ്‌സ് മോഡലിനെയും കുറിച്ചുള്ളതാണ്. നിങ്ങളുടെ പ്രൊവിഷൻ ചെയ്ത ഇൻഫ്രാസ്ട്രക്ചർ യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് പരിശോധിക്കണമെങ്കിൽ എന്തുചെയ്യും? ഉദാഹരണത്തിന്, വെർച്വൽ മെഷീൻ പ്രവർത്തിക്കുന്നു, S3 ബക്കറ്റിൽ നമ്മൾ പ്രതീക്ഷിക്കുന്നതും മറ്റും അടങ്ങിയിരിക്കുന്നു.

ഇത് എങ്ങനെ ചെയ്യണമെന്ന് നിങ്ങൾ ഇതിനകം ഊഹിച്ചിരിക്കാം: ഓപ്ഷൻ ExtraRuntimeValidation വേണ്ടി ProgramTestOptions - ഇതിനുള്ള മികച്ച അവസരമാണിത്. ഈ സമയത്ത്, നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ ഉറവിടങ്ങളുടെ പൂർണ്ണമായ അവസ്ഥയിലേക്കുള്ള ആക്‌സസ് ഉള്ള ഒരു ഇഷ്‌ടാനുസൃത Go ടെസ്റ്റ് നിങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നു. ഈ അവസ്ഥയിൽ വെർച്വൽ മെഷീൻ IP വിലാസങ്ങൾ, URL-കൾ, ഫലമായുണ്ടാകുന്ന ക്ലൗഡ് ആപ്ലിക്കേഷനുകളുമായും ഇൻഫ്രാസ്ട്രക്ചറുകളുമായും സംവദിക്കാൻ ആവശ്യമായ എല്ലാ വിവരങ്ങളും ഉൾപ്പെടുന്നു.

ഉദാഹരണത്തിന്, ഞങ്ങളുടെ ടെസ്റ്റ് പ്രോഗ്രാം പ്രോപ്പർട്ടി കയറ്റുമതി ചെയ്യുന്നു webEndpoint ബക്കറ്റ് വിളിച്ചു websiteUrl, നമുക്ക് കോൺഫിഗർ ചെയ്യാൻ കഴിയുന്ന പൂർണ്ണ URL ആണ് index document. കണ്ടെത്താൻ ഞങ്ങൾക്ക് സ്റ്റേറ്റ് ഫയലിലേക്ക് കുഴിക്കാൻ കഴിയുമെങ്കിലും bucket കൂടാതെ ആ പ്രോപ്പർട്ടി നേരിട്ട് വായിക്കുക, എന്നാൽ പല സാഹചര്യങ്ങളിലും ഞങ്ങളുടെ സ്റ്റാക്കുകൾ ഇതുപോലുള്ള ഉപയോഗപ്രദമായ പ്രോപ്പർട്ടികൾ എക്‌സ്‌പോർട്ട് ചെയ്യുന്നു, അത് പരിശോധിക്കുന്നതിന് ഉപയോഗിക്കാൻ ഞങ്ങൾ സൗകര്യപ്രദമാണെന്ന് കണ്ടെത്തുന്നു:

integration.ProgramTest(t, &integration.ProgramTestOptions{
            // as before ...
        ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
            url := "http://" + stack.Outputs["websiteUrl"].(string)
            resp, err := http.Get(url)
            if !assert.NoError(t, err) {
                return
            }
            if !assert.Equal(t, 200, resp.StatusCode) {
                return
            }
            defer resp.Body.Close()
            body, err := ioutil.ReadAll(resp.Body)
            if !assert.NoError(t, err) {
                return
            }
            assert.Contains(t, string(body), "Hello, Pulumi!")
        },
    })

ഞങ്ങളുടെ മുൻ റൺടൈം പരിശോധനകൾ പോലെ, ഈ ചെക്ക് സ്റ്റാക്ക് ഉയർത്തിയ ഉടൻ തന്നെ നടപ്പിലാക്കും, എല്ലാം ഒരു ലളിതമായ കോളിന് മറുപടിയായി go test. അത് മഞ്ഞുമലയുടെ അഗ്രം മാത്രമാണ് - നിങ്ങൾക്ക് കോഡിൽ എഴുതാൻ കഴിയുന്ന എല്ലാ Go ടെസ്റ്റ് ഫീച്ചറുകളും ലഭ്യമാണ്.

തുടർച്ചയായ ഇൻഫ്രാസ്ട്രക്ചർ ഇന്റഗ്രേഷൻ

കോഡ് അവലോകനത്തിനായി സമർപ്പിക്കുന്നതിന് മുമ്പ് ലാപ്‌ടോപ്പിൽ ടെസ്റ്റുകൾ പരീക്ഷിക്കാൻ ധാരാളം അടിസ്ഥാന സൗകര്യ മാറ്റങ്ങൾ വരുത്തുമ്പോൾ അത് പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്നത് നല്ലതാണ്. എന്നാൽ ഞങ്ങളും ഞങ്ങളുടെ പല ക്ലയന്റുകളും വികസന ജീവിതചക്രത്തിന്റെ വിവിധ ഘട്ടങ്ങളിൽ അടിസ്ഥാന സൗകര്യങ്ങൾ പരിശോധിക്കുന്നു:

• ലയിപ്പിക്കുന്നതിന് മുമ്പുള്ള എല്ലാ തുറന്ന പുൾ അഭ്യർത്ഥനയിലും.
• ഓരോ പ്രതിബദ്ധതയ്ക്കും മറുപടിയായി, ലയനം ശരിയായി നടന്നിട്ടുണ്ടോ എന്ന് രണ്ടുതവണ പരിശോധിക്കുക.
• ആനുകാലികമായി, അധിക പരിശോധനയ്ക്കായി രാത്രിയിലോ ആഴ്ചയിലോ പോലെ.
• പ്രകടനത്തിന്റെയോ സ്ട്രെസ് ടെസ്റ്റിംഗിന്റെയോ ഭാഗമായി, ഇത് സാധാരണയായി ഒരു നീണ്ട കാലയളവിൽ പ്രവർത്തിക്കുകയും സമാന്തരമായി ടെസ്റ്റുകൾ നടത്തുകയും കൂടാതെ/അല്ലെങ്കിൽ ഒരേ പ്രോഗ്രാം ഒന്നിലധികം തവണ വിന്യസിക്കുകയും ചെയ്യുന്നു.

ഇവയിൽ ഓരോന്നിനും, നിങ്ങളുടെ പ്രിയപ്പെട്ട തുടർച്ചയായ ഏകീകരണ സംവിധാനവുമായുള്ള സംയോജനത്തെ പുലുമി പിന്തുണയ്ക്കുന്നു. തുടർച്ചയായ സംയോജനത്തിലൂടെ, ഇത് നിങ്ങളുടെ ഇൻഫ്രാസ്ട്രക്ചറിനായി നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സോഫ്‌റ്റ്‌വെയറിനുള്ള അതേ ടെസ്റ്റ് കവറേജ് നൽകുന്നു.

സാധാരണ സിഐ സിസ്റ്റങ്ങൾക്ക് പുലുമിക്ക് പിന്തുണയുണ്ട്. അവയിൽ ചിലത് ഇതാ:

• AWS കോഡ് സേവനങ്ങൾ
• അസുർ ഡെവൊപ്‌സ്
• സർക്കിൾസിഐ
• GitHub പ്രവർത്തനങ്ങൾ
• ജിറ്റ്‌ലാബ് സി.ഐ
• Google ക്ലൗഡ് ബിൽഡ്
• ട്രാവിസ്

കൂടുതൽ വിശദമായ വിവരങ്ങൾക്ക്, ദയവായി ഡോക്യുമെന്റേഷൻ പരിശോധിക്കുക തുടർച്ചയായ ഡെലിവറി.

എഫെമറൽ പരിസ്ഥിതികൾ

സ്വീകാര്യത പരിശോധനാ ആവശ്യങ്ങൾക്കായി മാത്രം എഫെമെറൽ പരിതസ്ഥിതികൾ വിന്യസിക്കാനുള്ള കഴിവാണ് തുറക്കുന്ന വളരെ ശക്തമായ ഒരു അവസരം. ആശയം പദ്ധതികളും സ്റ്റാക്കുകളും പൂർണ്ണമായും ഒറ്റപ്പെട്ടതും സ്വതന്ത്രവുമായ ചുറ്റുപാടുകളെ എളുപ്പത്തിൽ വിന്യസിക്കാനും തകർക്കാനും, എല്ലാം കുറച്ച് ലളിതമായ CLI കമാൻഡുകളിലോ ഒരു ഇന്റഗ്രേഷൻ ടെസ്റ്റിംഗ് ചട്ടക്കൂട് ഉപയോഗിച്ചോ ആണ് പുലുമി രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.

നിങ്ങൾ GitHub ഉപയോഗിക്കുകയാണെങ്കിൽ, പുലുമി വാഗ്ദാനം ചെയ്യുന്നു GitHub ആപ്പ്, നിങ്ങളുടെ CI പൈപ്പ്ലൈനിനുള്ളിൽ അഭ്യർത്ഥനകൾ പിൻവലിക്കാൻ സ്വീകാര്യത പരിശോധനയെ ബന്ധിപ്പിക്കാൻ ഇത് നിങ്ങളെ സഹായിക്കും. GitHub റിപ്പോസിറ്ററിയിൽ ആപ്ലിക്കേഷൻ ഇൻസ്റ്റാൾ ചെയ്താൽ മതി, നിങ്ങളുടെ CI, പൂൾ അഭ്യർത്ഥനകളിലേക്ക് ഇൻഫ്രാസ്ട്രക്ചർ പ്രിവ്യൂകൾ, അപ്‌ഡേറ്റുകൾ, ടെസ്റ്റിംഗ് ഫലങ്ങൾ എന്നിവയെ കുറിച്ചുള്ള വിവരങ്ങൾ Pulumi ചേർക്കും:

നിങ്ങളുടെ പ്രധാന സ്വീകാര്യത പരിശോധനകൾക്കായി നിങ്ങൾ പുലുമി ഉപയോഗിക്കുമ്പോൾ, ടീമിന്റെ ഉൽപ്പാദനക്ഷമത മെച്ചപ്പെടുത്തുകയും നിങ്ങളുടെ മാറ്റങ്ങളുടെ ഗുണനിലവാരത്തിൽ നിങ്ങൾക്ക് ആത്മവിശ്വാസം നൽകുകയും ചെയ്യുന്ന പുതിയ ഓട്ടോമേഷൻ കഴിവുകൾ നിങ്ങൾക്ക് ലഭിക്കും.

ഫലം

ഈ ലേഖനത്തിൽ, പൊതുവായ ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഉപയോഗിക്കുന്നതിലൂടെ, ഞങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിന് ഉപയോഗപ്രദമായ നിരവധി സോഫ്റ്റ്വെയർ ഡെവലപ്മെന്റ് ടെക്നിക്കുകൾ നമുക്ക് ലഭ്യമാകുന്നത് ഞങ്ങൾ കണ്ടു. യൂണിറ്റ് ടെസ്റ്റിംഗ്, ഇന്റഗ്രേഷൻ ടെസ്റ്റിംഗ്, വിപുലമായ റൺടൈം ടെസ്റ്റിംഗ് നടത്താൻ അവർ ഒരുമിച്ച് പ്രവർത്തിക്കുന്നത് എന്നിവ ഉൾപ്പെടുന്നു. ആവശ്യാനുസരണം അല്ലെങ്കിൽ നിങ്ങളുടെ CI സിസ്റ്റത്തിൽ ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കാൻ എളുപ്പമാണ്.

പുലുമി - ഓപ്പൺ സോഴ്‌സ് സോഫ്‌റ്റ്‌വെയർ, ഉപയോഗിക്കാൻ സൌജന്യവും നിങ്ങളുടെ പ്രിയപ്പെട്ട പ്രോഗ്രാമിംഗ് ഭാഷകളുമായും ക്ലൗഡുകളുമായും പ്രവർത്തിക്കുന്നു - ഇന്ന് തന്നെ പരീക്ഷിക്കൂ!

→ ആദ്യ ഭാഗം

അവലംബം: www.habr.com