પુલુમી સાથે કોડ તરીકે ઈન્ફ્રાસ્ટ્રક્ચરનું પરીક્ષણ. ભાગ 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 અમને પુલુમી દ્વારા નોંધાયેલ પોસ્ટ-ડિપ્લોયમેન્ટ સ્ટેટ જોવાની મંજૂરી આપે છે જેથી અમે વધારાની તપાસ કરી શકીએ. આમાં પરિણામી સ્ટેકની સ્થિતિનો સંપૂર્ણ સ્નેપશોટનો સમાવેશ થાય છે, જેમાં રૂપરેખાંકન, નિકાસ કરેલ આઉટપુટ મૂલ્યો, તમામ સંસાધનો અને તેમની મિલકતના મૂલ્યો અને સંસાધનો વચ્ચેની તમામ અવલંબનનો સમાવેશ થાય છે.

આનું મૂળભૂત ઉદાહરણ જોવા માટે, ચાલો તપાસીએ કે અમારો પ્રોગ્રામ એક બનાવે છે 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 સિસ્ટમ્સ માટે સપોર્ટ છે. અહીં તેમાંથી કેટલાક છે:

• AWS કોડ સેવાઓ
• એઝુર ડેવઓપ્સ
• સર્કલસી
• GitHub ક્રિયાઓ
• ગિટલેબ સી.આઈ.
• ગૂગલ ક્લાઉડ બિલ્ડ
• ટ્રેવિસ

વધુ વિગતવાર માહિતી માટે, કૃપા કરીને દસ્તાવેજીકરણનો સંદર્ભ લો સતત ડિલિવરી.

ક્ષણિક પર્યાવરણ

એક ખૂબ જ શક્તિશાળી તક કે જે ખુલે છે તે માત્ર સ્વીકૃતિ પરીક્ષણ હેતુઓ માટે ક્ષણિક વાતાવરણને જમાવવાની ક્ષમતા છે. ખ્યાલ પ્રોજેક્ટ્સ અને સ્ટેક્સ પુલુમીને સંપૂર્ણપણે અલગ અને સ્વતંત્ર વાતાવરણમાં સરળતાથી જમાવટ કરવા અને તોડી પાડવા માટે ડિઝાઇન કરવામાં આવી છે, બધા થોડા સરળ CLI આદેશોમાં અથવા એકીકરણ પરીક્ષણ ફ્રેમવર્કનો ઉપયોગ કરીને.

જો તમે GitHub નો ઉપયોગ કરો છો, તો પુલુમી ઓફર કરે છે GitHub એપ્લિકેશન, જે તમને તમારી CI પાઇપલાઇનમાં વિનંતીઓ ખેંચવા માટે સ્વીકૃતિ પરીક્ષણને જોડવામાં મદદ કરશે. ફક્ત GitHub રિપોઝીટરીમાં એપ્લિકેશન ઇન્સ્ટોલ કરો, અને પુલુમી તમારા CI અને પૂલ વિનંતીઓમાં ઇન્ફ્રાસ્ટ્રક્ચર પૂર્વાવલોકનો, અપડેટ્સ અને પરીક્ષણ પરિણામો વિશેની માહિતી ઉમેરશે:

જ્યારે તમે તમારા મુખ્ય સ્વીકૃતિ પરીક્ષણો માટે પુલુમીનો ઉપયોગ કરો છો, ત્યારે તમે નવી ઓટોમેશન ક્ષમતાઓ મેળવશો જે ટીમની ઉત્પાદકતામાં સુધારો કરશે અને તમારા ફેરફારોની ગુણવત્તામાં તમને વિશ્વાસ આપશે.

પરિણામ

આ લેખમાં, અમે જોયું છે કે સામાન્ય હેતુની પ્રોગ્રામિંગ ભાષાઓનો ઉપયોગ કરીને, ઘણી સોફ્ટવેર ડેવલપમેન્ટ તકનીકો અમને ઉપલબ્ધ થાય છે જે અમારી એપ્લિકેશનો વિકસાવવામાં ઉપયોગી છે. તેમાં એકમ પરીક્ષણ, એકીકરણ પરીક્ષણ અને વ્યાપક રનટાઇમ પરીક્ષણ કરવા માટે તેઓ કેવી રીતે એકસાથે કામ કરે છે તેનો સમાવેશ થાય છે. માંગ પ્રમાણે અથવા તમારી CI સિસ્ટમમાં ટેસ્ટ ચલાવવા માટે સરળ છે.

પુલુમી - ઓપન સોર્સ સોફ્ટવેર, વાપરવા માટે મફત અને તમારી મનપસંદ પ્રોગ્રામિંગ ભાષાઓ અને ક્લાઉડ્સ સાથે કામ કરે છે - આજે જ અજમાવી જુઓ!

→ પ્રથમ ભાગ

સોર્સ: www.habr.com