అందరికి వందనాలు. ఈ రోజు మేము మీతో వ్యాసం యొక్క చివరి భాగాన్ని పంచుకుంటాము. , దీని అనువాదం కోర్సు విద్యార్థుల కోసం ప్రత్యేకంగా తయారు చేయబడింది .
విస్తరణ పరీక్ష
ఈ పరీక్ష శైలి ఒక శక్తివంతమైన విధానం మరియు మా ఇన్‌ఫ్రాస్ట్రక్చర్ కోడ్ యొక్క అంతర్గత పనితీరును పరీక్షించడానికి వైట్ బాక్స్ టెస్టింగ్‌ని నిర్వహించడానికి మమ్మల్ని అనుమతిస్తుంది. అయితే, ఇది మనం పరీక్షించగలవాటిని కొంతవరకు పరిమితం చేస్తుంది. వాస్తవ విస్తరణకు ముందు పులుమి సృష్టించిన ఇన్-మెమరీ డిప్లాయ్‌మెంట్ ప్లాన్ ఆధారంగా పరీక్షలు నిర్వహించబడతాయి మరియు అందువల్ల విస్తరణ పరీక్షించబడదు. అటువంటి సందర్భాలలో, పులుమికి ఏకీకరణ పరీక్ష ఫ్రేమ్‌వర్క్ ఉంది. మరియు ఈ రెండు విధానాలు కలిసి పని చేస్తాయి!
Pulumi ఇంటిగ్రేషన్ టెస్టింగ్ ఫ్రేమ్‌వర్క్ గోలో వ్రాయబడింది, ఈ విధంగా మేము మా అంతర్గత కోడ్‌ను చాలా వరకు పరీక్షిస్తాము. గతంలో చర్చించిన యూనిట్ టెస్టింగ్ విధానం వైట్ బాక్స్ టెస్టింగ్ లాగా ఉండగా, ఇంటిగ్రేషన్ టెస్టింగ్ అనేది బ్లాక్ బాక్స్. (కఠినమైన అంతర్గత పరీక్షకు ఎంపికలు కూడా ఉన్నాయి.) ఈ ఫ్రేమ్‌వర్క్ పూర్తి పులుమి ప్రోగ్రామ్‌ను తీసుకోవడానికి మరియు దానిపై వివిధ లైఫ్‌సైకిల్ ఆపరేషన్‌లను నిర్వహించడానికి సృష్టించబడింది, అంటే మొదటి నుండి కొత్త స్టాక్‌ను అమలు చేయడం, వైవిధ్యాలతో దాన్ని నవీకరించడం మరియు దానిని తొలగించడం, బహుశా అనేక సార్లు . మేము వాటిని క్రమం తప్పకుండా (ఉదాహరణకు, రాత్రి సమయంలో) మరియు ఒత్తిడి పరీక్షలుగా అమలు చేస్తాము.
(మేము , భాషల స్థానిక SDKలో ఒకే విధమైన ఏకీకరణ పరీక్ష సామర్థ్యాలు అందుబాటులో ఉంటాయి. మీరు మీ పులుమి ప్రోగ్రామ్ వ్రాసిన భాషతో సంబంధం లేకుండా Go ఇంటిగ్రేషన్ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ని ఉపయోగించవచ్చు).
ఈ ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి ప్రోగ్రామ్‌ను అమలు చేయడం ద్వారా మీరు ఈ క్రింది వాటిని తనిఖీ చేయవచ్చు:
- మీ ప్రాజెక్ట్ కోడ్ సింటాక్టికల్‌గా సరైనది మరియు లోపాలు లేకుండా నడుస్తుంది.
- స్టాక్ మరియు సీక్రెట్స్ కాన్ఫిగరేషన్ సెట్టింగ్‌లు పని చేస్తాయి మరియు సరిగ్గా వివరించబడతాయి.
- మీకు నచ్చిన క్లౌడ్ ప్రొవైడర్‌లో మీ ప్రాజెక్ట్ విజయవంతంగా అమలు చేయబడుతుంది.
- మీ ప్రాజెక్ట్ ప్రారంభ స్థితి నుండి N ఇతర రాష్ట్రాలకు విజయవంతంగా అప్‌గ్రేడ్ చేయబడుతుంది.
- మీ ప్రాజెక్ట్ విజయవంతంగా నాశనం చేయబడుతుంది మరియు మీ క్లౌడ్ ప్రొవైడర్ నుండి తీసివేయబడుతుంది.
మేము త్వరలో చూడబోతున్నట్లుగా, ఈ ఫ్రేమ్‌వర్క్ రన్‌టైమ్ ధ్రువీకరణను నిర్వహించడానికి కూడా ఉపయోగించవచ్చు.
సాధారణ ఇంటిగ్రేషన్ పరీక్ష
ఇది చర్యలో చూడటానికి, మేము రిపోజిటరీని చూస్తాము pulumi/examples, మా బృందం మరియు పులుమి సంఘం మా స్వంత పుల్ అభ్యర్థనలు, కమిట్‌లు మరియు రాత్రిపూట నిర్మాణాలను పరీక్షించడానికి దీనిని ఉపయోగిస్తుంది.
మా యొక్క సరళీకృత పరీక్ష క్రింద ఉంది :
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 పులుమి ద్వారా నమోదు చేయబడిన పోస్ట్-డిప్లాయ్‌మెంట్ స్థితిని చూడటానికి మమ్మల్ని అనుమతిస్తుంది కాబట్టి మేము అదనపు తనిఖీలను చేయవచ్చు. ఇది కాన్ఫిగరేషన్, ఎగుమతి చేయబడిన అవుట్‌పుట్ విలువలు, అన్ని వనరులు మరియు వాటి ఆస్తి విలువలు మరియు వనరుల మధ్య అన్ని డిపెండెన్సీలతో సహా ఫలిత స్టాక్ స్థితి యొక్క పూర్తి స్నాప్‌షాట్‌ను కలిగి ఉంటుంది.
దీని యొక్క ప్రాథమిక ఉదాహరణను చూడటానికి, మా ప్రోగ్రామ్ ఒకదాన్ని సృష్టిస్తుందో లేదో చూద్దాం S3 బకెట్:
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 - దీనికి ఇది ఒక గొప్ప అవకాశం. ఈ సమయంలో, మీరు మీ ప్రోగ్రామ్ వనరుల పూర్తి స్థితికి యాక్సెస్‌తో అనుకూల గో పరీక్షను అమలు చేస్తారు. ఈ స్థితిలో వర్చువల్ మెషిన్ 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. మరియు ఇది మంచుకొండ యొక్క కొన మాత్రమే-మీరు కోడ్‌లో వ్రాయగల ప్రతి గో పరీక్ష ఫీచర్ అందుబాటులో ఉంది.
నిరంతర ఇన్‌ఫ్రాస్ట్రక్చర్ ఇంటిగ్రేషన్
ల్యాప్‌టాప్‌లో పరీక్షలను అమలు చేయగలగడం మంచిది, వాటిని కోడ్ సమీక్ష కోసం సమర్పించే ముందు వాటిని పరీక్షించడానికి చాలా మౌలిక సదుపాయాల మార్పులు జరుగుతున్నాయి. కానీ మేము మరియు మా ఖాతాదారులలో చాలామంది అభివృద్ధి జీవిత చక్రం యొక్క వివిధ దశలలో మౌలిక సదుపాయాలను పరీక్షిస్తాము:
- విలీనం చేయడానికి ముందు పరీక్ష కోసం ప్రతి ఓపెన్ పుల్ అభ్యర్థనలో.
- ప్రతి నిబద్ధతకు ప్రతిస్పందనగా, విలీనం సరిగ్గా జరిగిందో లేదో ఒకటికి రెండుసార్లు తనిఖీ చేయండి.
- క్రమానుగతంగా, అదనపు పరీక్ష కోసం రాత్రి లేదా వారానికోసారి.
- పనితీరు లేదా ఒత్తిడి పరీక్షలో భాగంగా, ఇది సాధారణంగా చాలా కాలం పాటు నడుస్తుంది మరియు పరీక్షలను సమాంతరంగా అమలు చేస్తుంది మరియు/లేదా ఒకే ప్రోగ్రామ్‌ను అనేకసార్లు అమలు చేస్తుంది.
వీటిలో ప్రతిదానికి, పులుమి మీకు ఇష్టమైన నిరంతర ఇంటిగ్రేషన్ సిస్టమ్‌తో ఏకీకరణకు మద్దతు ఇస్తుంది. నిరంతర ఏకీకరణతో, ఇది మీ అప్లికేషన్ సాఫ్ట్‌వేర్ కోసం మీ మౌలిక సదుపాయాలకు అదే పరీక్ష కవరేజీని అందిస్తుంది.
సాధారణ CI సిస్టమ్‌లకు పులుమికి మద్దతు ఉంది. వాటిలో కొన్ని ఇక్కడ ఉన్నాయి:
మరింత వివరణాత్మక సమాచారం కోసం, దయచేసి డాక్యుమెంటేషన్‌ను చూడండి .
ఎఫెమెరల్ ఎన్విరాన్మెంట్స్
అంగీకార పరీక్ష ప్రయోజనాల కోసం మాత్రమే అశాశ్వత వాతావరణాలను అమలు చేయగల సామర్థ్యం చాలా శక్తివంతమైన అవకాశం. భావన Pulumi పూర్తిగా వివిక్త మరియు స్వతంత్ర వాతావరణాలను సులభంగా అమలు చేయడానికి మరియు కూల్చివేయడానికి రూపొందించబడింది, అన్నీ కొన్ని సాధారణ CLI ఆదేశాలలో లేదా ఇంటిగ్రేషన్ టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ను ఉపయోగిస్తాయి.
మీరు GitHub ఉపయోగిస్తే, Pulumi అందిస్తుంది , ఇది మీ CI పైప్‌లైన్‌లో అభ్యర్థనలను లాగడానికి అంగీకార పరీక్షను కనెక్ట్ చేయడంలో మీకు సహాయపడుతుంది. GitHub రిపోజిటరీలో అప్లికేషన్‌ను ఇన్‌స్టాల్ చేయండి మరియు Pulumi మీ CI మరియు పూల్ అభ్యర్థనలకు ఇన్‌ఫ్రాస్ట్రక్చర్ ప్రివ్యూలు, అప్‌డేట్‌లు మరియు టెస్టింగ్ ఫలితాల గురించి సమాచారాన్ని జోడిస్తుంది:
మీరు మీ ప్రధాన అంగీకార పరీక్షల కోసం Pulumiని ఉపయోగించినప్పుడు, మీరు కొత్త ఆటోమేషన్ సామర్థ్యాలను పొందుతారు, ఇది జట్టు ఉత్పాదకతను మెరుగుపరుస్తుంది మరియు మీ మార్పుల నాణ్యతపై మీకు విశ్వాసాన్ని ఇస్తుంది.
ఫలితం
ఈ వ్యాసంలో, సాధారణ ప్రయోజన ప్రోగ్రామింగ్ భాషలను ఉపయోగించడం ద్వారా, మా అప్లికేషన్‌లను అభివృద్ధి చేయడంలో ఉపయోగపడే అనేక సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ టెక్నిక్‌లు మనకు అందుబాటులో ఉన్నాయని మేము చూశాము. వాటిలో యూనిట్ టెస్టింగ్, ఇంటిగ్రేషన్ టెస్టింగ్ మరియు విస్తృతమైన రన్‌టైమ్ టెస్టింగ్ చేయడానికి అవి ఎలా కలిసి పని చేస్తాయి. డిమాండ్‌పై లేదా మీ CI సిస్టమ్‌లో పరీక్షలు సులభంగా అమలు చేయబడతాయి.
పులుమి - ఓపెన్ సోర్స్ సాఫ్ట్‌వేర్, ఉపయోగించడానికి ఉచితం మరియు మీకు ఇష్టమైన ప్రోగ్రామింగ్ భాషలు మరియు క్లౌడ్‌లతో పని చేస్తుంది - !
→
మూలం: www.habr.com