ProHoster > බ්ලොග් > පරිපාලනය > පුලුමි සමඟ කේතය ලෙස යටිතල පහසුකම් පරීක්ෂා කිරීම. 2 කොටස

පුලුමි සමඟ කේතය ලෙස යටිතල පහසුකම් පරීක්ෂා කිරීම. 2 කොටස

ආයුබෝවන් සියල්ලටම. අද අපි ඔබ සමඟ බෙදා ගන්නේ ලිපියේ අවසාන කොටසයි. "පුළුමි සමඟ කේතය ලෙස යටිතල පහසුකම් පරීක්ෂා කිරීම", එහි පරිවර්තනය පාඨමාලා සිසුන් සඳහා විශේෂයෙන් සකස් කරන ලදී "DevOps භාවිතයන් සහ මෙවලම්".

පුලුමි සමඟ කේතය ලෙස යටිතල පහසුකම් පරීක්ෂා කිරීම. 2 කොටස

යෙදවීම පරීක්ෂා කිරීම

මෙම පරීක්ෂණ විලාසය ප්‍රබල ප්‍රවේශයක් වන අතර අපගේ යටිතල පහසුකම් කේතයේ අභ්‍යන්තර ක්‍රියාකාරිත්වය පරීක්ෂා කිරීම සඳහා සුදු කොටු පරීක්ෂාව සිදු කිරීමට අපට ඉඩ සලසයි. කෙසේ වෙතත්, එය අපට පරීක්ෂා කළ හැකි දේ තරමක් සීමා කරයි. සත්‍ය යෙදවීමට පෙර පුළුමි විසින් නිර්මාණය කරන ලද මතකයේ යෙදවීමේ සැලැස්ම මත පදනම්ව පරීක්ෂණ සිදු කරනු ලබන අතර එම නිසා යෙදවීමම පරීක්ෂා කළ නොහැක. එවැනි අවස්ථා සඳහා, Pulumi සතුව ඒකාබද්ධ පරීක්ෂණ රාමුවක් ඇත. මෙම ප්‍රවේශයන් දෙක එකට හොඳින් ක්‍රියා කරයි!

Pulumi ඒකාබද්ධතා පරීක්ෂණ රාමුව Go හි ලියා ඇත, අපි අපගේ අභ්‍යන්තර කේතයන් බොහොමයක් පරීක්ෂා කරන්නේ කෙසේද යන්නයි. කලින් සාකච්ඡා කරන ලද ඒකක පරීක්ෂණ ප්‍රවේශය සුදු පෙට්ටි පරීක්ෂාවට සමාන වූ අතර, ඒකාබද්ධතා පරීක්ෂණය කළු පෙට්ටියකි. (දැඩි අභ්‍යන්තර පරීක්ෂණ සඳහා විකල්ප ද ඇත.) මෙම රාමුව නිර්මාණය කර ඇත්තේ සම්පූර්ණ පුලුමි වැඩසටහනක් ගෙන ඒ මත නව තොගයක් මුල සිටම යෙදවීම, වෙනස්කම් සමඟ යාවත්කාලීන කිරීම සහ එය මකා දැමීම වැනි විවිධ ජීවන චක්‍ර මෙහෙයුම් සිදු කිරීම සඳහා ය. . අපි ඒවා නිතිපතා (උදාහරණයක් ලෙස, රාත්රියේදී) සහ ආතති පරීක්ෂණ ලෙස ක්රියාත්මක කරමු.

(අප අපි එය මත වැඩ කරමින් සිටිමු, භාෂා වල ස්වදේශික SDK හි සමාන ඒකාබද්ධතා පරීක්ෂණ හැකියාවන් ලබා ගත හැකි වන පරිදි. ඔබගේ Pulumi වැඩසටහන ලියා ඇති භාෂාව කුමක් වුවත් ඔබට Go integration testing framework භාවිතා කළ හැක).

මෙම රාමුව භාවිතයෙන් වැඩසටහන ක්රියාත්මක කිරීමෙන් ඔබට පහත සඳහන් දෑ පරීක්ෂා කළ හැකිය:

  • ඔබේ ව්‍යාපෘති කේතය වාක්‍යානුකූලව නිවැරදි වන අතර දෝෂයකින් තොරව ධාවනය වේ.
  • අට්ටිය සහ රහස් වින්‍යාස සැකසුම් ක්‍රියා කරන අතර ඒවා නිවැරදිව අර්ථ දක්වා ඇත.
  • ඔබේ ව්‍යාපෘතිය ඔබ කැමති වලාකුළු සපයන්නා තුළ සාර්ථකව යෙදවිය හැක.
  • ඔබේ ව්‍යාපෘතිය ආරම්භක තත්ත්‍වයේ සිට 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")
        },
    })

දැන්, අපි go test ධාවනය කරන විට, එය ජීවන චක්‍ර පරීක්ෂණ බැටරියක් හරහා ගමන් කරනවා පමණක් නොව, තොගය සාර්ථකව යෙදවීමෙන් පසුව, එය ප්‍රතිඵලය වන තත්ත්වය පිළිබඳ අතිරේක පරීක්ෂාවක් සිදු කරනු ඇත.

ධාවන කාල පරීක්ෂණ

මෙතෙක්, සියලුම පරීක්ෂණ සම්පූර්ණයෙන්ම යෙදවීමේ හැසිරීම සහ Pulumi සම්පත් ආකෘතිය පිළිබඳව විය. ඔබේ ප්‍රතිපාදන යටිතල ව්‍යුහය ඇත්ත වශයෙන්ම ක්‍රියාත්මක වන බව සත්‍යාපනය කිරීමට ඔබට අවශ්‍ය නම් කුමක් කළ යුතුද? උදාහරණයක් ලෙස, අතථ්‍ය යන්ත්‍රය ක්‍රියාත්මක වන බව, 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 පරීක්ෂණ විශේෂාංගයක්ම තිබේ.

අඛණ්ඩ යටිතල පහසුකම් ඒකාබද්ධ කිරීම

කේත සමාලෝචනය සඳහා ඉදිරිපත් කිරීමට පෙර ඒවා පරීක්ෂා කිරීමට යටිතල පහසුකම් වෙනස් කිරීම් රාශියක් සිදු කරන විට ලැප්ටොප් එකක පරීක්ෂණ ධාවනය කිරීමට හැකි වීම හොඳය. නමුත් අපි සහ අපගේ බොහෝ ගනුදෙනුකරුවන් සංවර්ධන ජීවන චක්‍රයේ විවිධ අවස්ථා වලදී යටිතල පහසුකම් පරීක්ෂා කරන්නෙමු:

  • ඒකාබද්ධ කිරීමට පෙර පරීක්ෂා කිරීම සඳහා සෑම විවෘත ඇදීමේ ඉල්ලීමකදීම.
  • එක් එක් කැපවීම සඳහා ප්‍රතිචාර වශයෙන්, ඒකාබද්ධ කිරීම නිවැරදිව සිදු කර ඇත්දැයි දෙවරක් පරීක්ෂා කරන්න.
  • අමතර පරීක්ෂණ සඳහා රාත්‍රියේ හෝ සතිපතා වැනි කාලානුරූපව.
  • කාර්ය සාධනය හෝ ආතති පරීක්ෂාවෙහි කොටසක් ලෙස, එය සාමාන්‍යයෙන් දිගු කාලයක් පුරා ක්‍රියාත්මක වන අතර පරීක්ෂණ සමාන්තරව ධාවනය කරයි සහ/හෝ එකම වැඩසටහන කිහිප වතාවක් යොදවයි.

මේ සෑම එකක් සඳහාම, Pulumi ඔබේ ප්‍රියතම අඛණ්ඩ ඒකාබද්ධ කිරීමේ පද්ධතිය සමඟ ඒකාබද්ධ වීමට සහාය දක්වයි. අඛණ්ඩ ඒකාබද්ධතාවයකින්, මෙය ඔබගේ යටිතල පහසුකම් සඳහා ඔබගේ යෙදුම් මෘදුකාංග සඳහා සමාන පරීක්ෂණ ආවරණයක් ලබා දෙයි.

Pulumi හට පොදු CI පද්ධති සඳහා සහය ඇත. ඒවායින් කිහිපයක් මෙන්න:

වඩාත් සවිස්තරාත්මක තොරතුරු සඳහා, කරුණාකර ලේඛන බලන්න අඛණ්ඩ භාරදීම.

තාවකාලික පරිසරයන්

විවෘත වන ඉතා ප්‍රබල අවස්ථාවක් වන්නේ පිළිගැනීමේ පරීක්ෂණ අරමුණු සඳහා පමණක් තාවකාලික පරිසරයන් යෙදවීමේ හැකියාවයි. සංකල්පය ව්යාපෘති සහ තොග Pulumi නිර්මාණය කර ඇත්තේ සම්පූර්ණයෙන්ම හුදකලා වූ සහ ස්වාධීන පරිසරයන් පහසුවෙන් යෙදවීමට සහ ඉරා දැමීමට, සියල්ල සරල CLI විධාන කිහිපයකින් හෝ ඒකාබද්ධතා පරීක්ෂණ රාමුවක් භාවිතා කරමිනි.

ඔබ GitHub භාවිතා කරන්නේ නම්, Pulumi පිරිනැමේ GitHub යෙදුම, එය ඔබගේ CI නල මාර්ගය තුළ ඉල්ලීම් ඇද ගැනීමට පිළිගැනීමේ පරීක්ෂණ සම්බන්ධ කිරීමට ඔබට උපකාරී වනු ඇත. GitHub ගබඩාවේ යෙදුම ස්ථාපනය කරන්න, සහ Pulumi යටිතල පහසුකම් පෙරදසුන්, යාවත්කාලීන කිරීම් සහ පරීක්ෂණ ප්‍රතිඵල පිළිබඳ තොරතුරු ඔබේ CI සහ සංචිත ඉල්ලීම්වලට එක් කරයි:

පුලුමි සමඟ කේතය ලෙස යටිතල පහසුකම් පරීක්ෂා කිරීම. 2 කොටස

ඔබ ඔබේ මූලික පිළිගැනීමේ පරීක්ෂණ සඳහා Pulumi භාවිතා කරන විට, කණ්ඩායම් ඵලදායිතාව වැඩි දියුණු කරන සහ ඔබේ වෙනස්කම්වල ගුණාත්මකභාවය පිළිබඳ විශ්වාසයක් ලබා දෙන නව ස්වයංක්‍රීයකරණ හැකියාවන් ඔබට ලැබෙනු ඇත.

ප්රතිඵලය

මෙම ලිපියෙන්, සාමාන්‍ය කාර්ය ක්‍රමලේඛන භාෂා භාවිතා කිරීමෙන්, අපගේ යෙදුම් සංවර්ධනය කිරීමේදී ප්‍රයෝජනවත් වූ බොහෝ මෘදුකාංග සංවර්ධන ක්‍රම අපට ලබා ගත හැකි බව අපි දුටුවෙමු. ඒවාට ඒකක පරීක්‍ෂණය, ඒකාබද්ධතා පරීක්‍ෂණය සහ පුළුල් ධාවන කාල පරීක්‍ෂණයක් සිදු කිරීමට ඔවුන් එක්ව ක්‍රියා කරන ආකාරය ඇතුළත් වේ. ඉල්ලුම මත හෝ ඔබේ CI පද්ධතිය තුළ පරීක්ෂණ ධාවනය කිරීම පහසුය.

පුලුමි - විවෘත මූලාශ්‍ර මෘදුකාංග, භාවිතා කිරීමට නොමිලේ සහ ඔබගේ ප්‍රියතම ක්‍රමලේඛන භාෂා සහ වලාකුළු සමඟ ක්‍රියා කරයි - අද එය උත්සාහ කරන්න!

→ පළමු කොටස

මූලාශ්රය: www.habr.com

අදහස් එක් කරන්න