ਪੁਲੁਮੀ ਦੇ ਨਾਲ ਕੋਡ ਦੇ ਤੌਰ 'ਤੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਜਾਂਚ ਕਰਨਾ। ਭਾਗ 2

ਸਾਰਿਆਂ ਨੂੰ ਸਤਿ ਸ਼੍ਰੀ ਅਕਾਲ. ਅੱਜ ਅਸੀਂ ਤੁਹਾਡੇ ਨਾਲ ਲੇਖ ਦਾ ਅੰਤਮ ਹਿੱਸਾ ਸਾਂਝਾ ਕਰ ਰਹੇ ਹਾਂ। "ਪਲੂਮੀ ਦੇ ਨਾਲ ਕੋਡ ਦੇ ਰੂਪ ਵਿੱਚ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਜਾਂਚ", ਜਿਸ ਦਾ ਅਨੁਵਾਦ ਕੋਰਸ ਦੇ ਵਿਦਿਆਰਥੀਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ "DevOps ਅਭਿਆਸ ਅਤੇ ਸਾਧਨ".

ਤੈਨਾਤੀ ਟੈਸਟਿੰਗ

ਟੈਸਟਿੰਗ ਦੀ ਇਹ ਸ਼ੈਲੀ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪਹੁੰਚ ਹੈ ਅਤੇ ਸਾਨੂੰ ਸਾਡੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਕੋਡ ਦੇ ਅੰਦਰੂਨੀ ਕੰਮਕਾਜ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਵ੍ਹਾਈਟ ਬਾਕਸ ਟੈਸਟਿੰਗ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਕੁਝ ਹੱਦ ਤੱਕ ਸੀਮਤ ਕਰਦਾ ਹੈ ਕਿ ਅਸੀਂ ਕੀ ਟੈਸਟ ਕਰ ਸਕਦੇ ਹਾਂ। ਟੈਸਟ ਅਸਲ ਤੈਨਾਤੀ ਤੋਂ ਪਹਿਲਾਂ ਪੁਲੁਮੀ ਦੁਆਰਾ ਬਣਾਈ ਗਈ ਇਨ-ਮੈਮੋਰੀ ਤੈਨਾਤੀ ਯੋਜਨਾ ਦੇ ਅਧਾਰ ਤੇ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਇਸਲਈ ਤੈਨਾਤੀ ਦੀ ਖੁਦ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ। ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਲਈ, ਪੁਲੁਮੀ ਕੋਲ ਏਕੀਕਰਣ ਟੈਸਟ ਫਰੇਮਵਰਕ ਹੈ। ਅਤੇ ਇਹ ਦੋ ਤਰੀਕੇ ਇਕੱਠੇ ਕੰਮ ਕਰਦੇ ਹਨ!

ਪੁਲੁਮੀ ਏਕੀਕਰਣ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਗੋ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਜਿਸ ਤਰ੍ਹਾਂ ਅਸੀਂ ਆਪਣੇ ਜ਼ਿਆਦਾਤਰ ਅੰਦਰੂਨੀ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ। ਜਦੋਂ ਕਿ ਪਹਿਲਾਂ ਚਰਚਾ ਕੀਤੀ ਗਈ ਯੂਨਿਟ ਟੈਸਟਿੰਗ ਪਹੁੰਚ ਵਾਈਟ ਬਾਕਸ ਟੈਸਟਿੰਗ ਵਰਗੀ ਸੀ, ਏਕੀਕਰਣ ਟੈਸਟਿੰਗ ਇੱਕ ਬਲੈਕ ਬਾਕਸ ਹੈ। (ਕਠੋਰ ਅੰਦਰੂਨੀ ਜਾਂਚ ਲਈ ਵਿਕਲਪ ਵੀ ਹਨ।) ਇਹ ਫਰੇਮਵਰਕ ਇੱਕ ਸੰਪੂਰਨ ਪੁਲੁਮੀ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲੈਣ ਅਤੇ ਇਸ 'ਤੇ ਵੱਖ-ਵੱਖ ਜੀਵਨ-ਚੱਕਰ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਕਰਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਸੀ, ਜਿਵੇਂ ਕਿ ਸਕ੍ਰੈਚ ਤੋਂ ਇੱਕ ਨਵਾਂ ਸਟੈਕ ਲਗਾਉਣਾ, ਇਸ ਨੂੰ ਭਿੰਨਤਾਵਾਂ ਨਾਲ ਅਪਡੇਟ ਕਰਨਾ, ਅਤੇ ਇਸਨੂੰ ਮਿਟਾਉਣਾ, ਸੰਭਵ ਤੌਰ 'ਤੇ ਕਈ ਵਾਰ। . ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਚਲਾਉਂਦੇ ਹਾਂ (ਉਦਾਹਰਨ ਲਈ, ਰਾਤ ​​ਨੂੰ) ਅਤੇ ਤਣਾਅ ਦੇ ਟੈਸਟਾਂ ਵਜੋਂ।

(ਅਸੀਂ ਅਸੀਂ ਇਸ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ, ਤਾਂ ਜੋ ਭਾਸ਼ਾਵਾਂ ਦੇ ਮੂਲ 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 ਕੋਡ ਸੇਵਾਵਾਂ
• Azure DevOps
• ਸਰਕਲ ਸੀ.ਆਈ.
• GitHub ਕਾਰਵਾਈਆਂ
• ਗਿੱਟਲਾਬ ਸੀ.ਆਈ.
• Google ਕਲਾਊਡ ਬਿਲਡ
• ਟ੍ਰੇਵਿਸ

ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਜਾਣਕਾਰੀ ਲਈ, ਕਿਰਪਾ ਕਰਕੇ ਲਈ ਦਸਤਾਵੇਜ਼ ਵੇਖੋ ਲਗਾਤਾਰ ਡਿਲਿਵਰੀ.

ਅਲੌਕਿਕ ਵਾਤਾਵਰਣ

ਇੱਕ ਬਹੁਤ ਹੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਮੌਕਾ ਜੋ ਖੁੱਲ੍ਹਦਾ ਹੈ ਉਹ ਹੈ ਕੇਵਲ ਸਵੀਕ੍ਰਿਤੀ ਜਾਂਚ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਅਲੌਕਿਕ ਵਾਤਾਵਰਣਾਂ ਨੂੰ ਤਾਇਨਾਤ ਕਰਨ ਦੀ ਯੋਗਤਾ। ਸੰਕਲਪ ਪ੍ਰੋਜੈਕਟ ਅਤੇ ਸਟੈਕ ਪੁਲੁਮੀ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਲੱਗ-ਥਲੱਗ ਅਤੇ ਸੁਤੰਤਰ ਵਾਤਾਵਰਣ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਤੈਨਾਤ ਕਰਨ ਅਤੇ ਢਾਹ ਦੇਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਸਭ ਕੁਝ ਸਧਾਰਨ CLI ਕਮਾਂਡਾਂ ਵਿੱਚ ਜਾਂ ਇੱਕ ਏਕੀਕਰਣ ਟੈਸਟਿੰਗ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ।

ਜੇਕਰ ਤੁਸੀਂ GitHub ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਪੁਲੁਮੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ GitHub ਐਪ, ਜੋ ਤੁਹਾਡੀ CI ਪਾਈਪਲਾਈਨ ਦੇ ਅੰਦਰ ਬੇਨਤੀਆਂ ਨੂੰ ਖਿੱਚਣ ਲਈ ਸਵੀਕ੍ਰਿਤੀ ਜਾਂਚ ਨੂੰ ਜੋੜਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰੇਗਾ। ਬਸ GitHub ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ, ਅਤੇ ਪੁਲੁਮੀ ਤੁਹਾਡੇ CI ਅਤੇ ਪੂਲ ਬੇਨਤੀਆਂ ਵਿੱਚ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਪ੍ਰੀਵਿਊ, ਅੱਪਡੇਟ ਅਤੇ ਟੈਸਟਿੰਗ ਨਤੀਜਿਆਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਕਰੇਗਾ:

ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੇ ਮੁੱਖ ਸਵੀਕ੍ਰਿਤੀ ਟੈਸਟਾਂ ਲਈ ਪੁਲੁਮੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਨਵੀਂ ਆਟੋਮੇਸ਼ਨ ਸਮਰੱਥਾਵਾਂ ਪ੍ਰਾਪਤ ਕਰੋਗੇ ਜੋ ਟੀਮ ਦੀ ਉਤਪਾਦਕਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੇਗੀ ਅਤੇ ਤੁਹਾਨੂੰ ਤੁਹਾਡੀਆਂ ਤਬਦੀਲੀਆਂ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਵਿਸ਼ਵਾਸ ਦਿਵਾਉਂਦੀ ਹੈ।

ਨਤੀਜਾ

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਦੇਖਿਆ ਹੈ ਕਿ ਆਮ ਉਦੇਸ਼ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਬਹੁਤ ਸਾਰੀਆਂ ਸੌਫਟਵੇਅਰ ਡਿਵੈਲਪਮੈਂਟ ਤਕਨੀਕਾਂ ਸਾਡੇ ਲਈ ਉਪਲਬਧ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਜੋ ਸਾਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਵਿੱਚ ਉਪਯੋਗੀ ਰਹੀਆਂ ਹਨ। ਉਹਨਾਂ ਵਿੱਚ ਯੂਨਿਟ ਟੈਸਟਿੰਗ, ਏਕੀਕਰਣ ਟੈਸਟਿੰਗ, ਅਤੇ ਵਿਆਪਕ ਰਨਟਾਈਮ ਟੈਸਟਿੰਗ ਕਰਨ ਲਈ ਉਹ ਇਕੱਠੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ। ਟੈਸਟ ਮੰਗ 'ਤੇ ਜਾਂ ਤੁਹਾਡੇ CI ਸਿਸਟਮ ਵਿੱਚ ਚਲਾਉਣ ਲਈ ਆਸਾਨ ਹਨ।

ਪੁਲੁਮੀ - ਓਪਨ ਸੋਰਸ ਸੌਫਟਵੇਅਰ, ਵਰਤਣ ਲਈ ਮੁਫਤ ਅਤੇ ਤੁਹਾਡੀਆਂ ਮਨਪਸੰਦ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਕਲਾਉਡਸ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ - ਅੱਜ ਇਸ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ!

→ ਪਹਿਲਾ ਹਿੱਸਾ

ਸਰੋਤ: www.habr.com