istio: istio.io/istio/pilot/test/mock Index | Files

package mock

import "istio.io/istio/pilot/test/mock"

Index

Package Files

config.go

Variables

var (
    // Types defines the mock config descriptor
    Types = schema.Set{schemas.MockConfig}

    // ExampleVirtualService is an example V2 route rule
    ExampleVirtualService = &networking.VirtualService{
        Hosts: []string{"prod", "test"},
        Http: []*networking.HTTPRoute{
            {
                Route: []*networking.HTTPRouteDestination{
                    {
                        Destination: &networking.Destination{
                            Host: "job",
                        },
                        Weight: 80,
                    },
                },
            },
        },
    }

    ExampleServiceEntry = &networking.ServiceEntry{
        Hosts:      []string{"*.google.com"},
        Resolution: networking.ServiceEntry_NONE,
        Ports: []*networking.Port{
            {Number: 80, Name: "http-name", Protocol: "http"},
            {Number: 8080, Name: "http2-name", Protocol: "http2"},
        },
    }

    ExampleGateway = &networking.Gateway{
        Servers: []*networking.Server{
            {
                Hosts: []string{"google.com"},
                Port:  &networking.Port{Name: "http", Protocol: "http", Number: 10080},
            },
        },
    }

    // ExampleDestinationRule is an example destination rule
    ExampleDestinationRule = &networking.DestinationRule{
        Host: "ratings",
        TrafficPolicy: &networking.TrafficPolicy{
            LoadBalancer: &networking.LoadBalancerSettings{
                LbPolicy: new(networking.LoadBalancerSettings_Simple),
            },
        },
    }

    // ExampleHTTPAPISpec is an example HTTPAPISpec
    ExampleHTTPAPISpec = &mccpb.HTTPAPISpec{
        Attributes: &mpb.Attributes{
            Attributes: map[string]*mpb.Attributes_AttributeValue{
                "api.service": {Value: &mpb.Attributes_AttributeValue_StringValue{StringValue: "petstore"}},
            },
        },
        Patterns: []*mccpb.HTTPAPISpecPattern{{
            Attributes: &mpb.Attributes{
                Attributes: map[string]*mpb.Attributes_AttributeValue{
                    "api.operation": {Value: &mpb.Attributes_AttributeValue_StringValue{StringValue: "getPet"}},
                },
            },
            HttpMethod: "GET",
            Pattern: &mccpb.HTTPAPISpecPattern_UriTemplate{
                UriTemplate: "/pets/{id}",
            },
        }},
        ApiKeys: []*mccpb.APIKey{{
            Key: &mccpb.APIKey_Header{
                Header: "X-API-KEY",
            },
        }},
    }

    // ExampleHTTPAPISpecBinding is an example HTTPAPISpecBinding
    ExampleHTTPAPISpecBinding = &mccpb.HTTPAPISpecBinding{
        Services: []*mccpb.IstioService{
            {
                Name:      "foo",
                Namespace: "bar",
            },
        },
        ApiSpecs: []*mccpb.HTTPAPISpecReference{
            {
                Name:      "petstore",
                Namespace: "default",
            },
        },
    }

    // ExampleQuotaSpec is an example QuotaSpec
    ExampleQuotaSpec = &mccpb.QuotaSpec{
        Rules: []*mccpb.QuotaRule{{
            Match: []*mccpb.AttributeMatch{{
                Clause: map[string]*mccpb.StringMatch{
                    "api.operation": {
                        MatchType: &mccpb.StringMatch_Exact{
                            Exact: "getPet",
                        },
                    },
                },
            }},
            Quotas: []*mccpb.Quota{{
                Quota:  "fooQuota",
                Charge: 2,
            }},
        }},
    }

    // ExampleQuotaSpecBinding is an example QuotaSpecBinding
    ExampleQuotaSpecBinding = &mccpb.QuotaSpecBinding{
        Services: []*mccpb.IstioService{
            {
                Name:      "foo",
                Namespace: "bar",
            },
        },
        QuotaSpecs: []*mccpb.QuotaSpecBinding_QuotaSpecReference{
            {
                Name:      "fooQuota",
                Namespace: "default",
            },
        },
    }

    // ExampleAuthenticationPolicy is an example authentication Policy
    ExampleAuthenticationPolicy = &authn.Policy{
        Targets: []*authn.TargetSelector{{
            Name: "hello",
        }},
        Peers: []*authn.PeerAuthenticationMethod{{
            Params: &authn.PeerAuthenticationMethod_Mtls{
                Mtls: &authn.MutualTls{},
            },
        }},
    }

    // ExampleServiceRole is an example rbac service role
    ExampleServiceRole = &rbac.ServiceRole{Rules: []*rbac.AccessRule{
        {
            Services: []string{"service0"},
            Methods:  []string{"GET", "POST"},
            Constraints: []*rbac.AccessRule_Constraint{
                {Key: "key", Values: []string{"value"}},
                {Key: "key", Values: []string{"value"}},
            },
        },
        {
            Services: []string{"service0"},
            Methods:  []string{"GET", "POST"},
            Constraints: []*rbac.AccessRule_Constraint{
                {Key: "key", Values: []string{"value"}},
                {Key: "key", Values: []string{"value"}},
            },
        },
    }}

    // ExampleServiceRoleBinding is an example rbac service role binding
    ExampleServiceRoleBinding = &rbac.ServiceRoleBinding{
        Subjects: []*rbac.Subject{
            {User: "User0", Group: "Group0", Properties: map[string]string{"prop0": "value0"}},
            {User: "User1", Group: "Group1", Properties: map[string]string{"prop1": "value1"}},
        },
        RoleRef: &rbac.RoleRef{Kind: "ServiceRole", Name: "ServiceRole001"},
    }

    // ExampleRbacConfig is an example rbac config
    ExampleRbacConfig = &rbac.RbacConfig{
        Mode: rbac.RbacConfig_ON,
    }

    // ExampleAuthorizationPolicy is an example AuthorizationPolicy
    ExampleAuthorizationPolicy = &authz.AuthorizationPolicy{
        Selector: &api.WorkloadSelector{
            MatchLabels: map[string]string{
                "app":     "httpbin",
                "version": "v1",
            },
        },
    }
)

func CheckCacheEvents Uses

func CheckCacheEvents(store model.ConfigStore, cache model.ConfigStoreCache, namespace string, n int, t *testing.T)

CheckCacheEvents validates operational invariants of a cache

func CheckCacheFreshness Uses

func CheckCacheFreshness(cache model.ConfigStoreCache, namespace string, t *testing.T)

CheckCacheFreshness validates operational invariants of a cache

func CheckCacheSync Uses

func CheckCacheSync(store model.ConfigStore, cache model.ConfigStoreCache, namespace string, n int, t *testing.T)

CheckCacheSync validates operational invariants of a cache against the non-cached client.

func CheckIstioConfigTypes Uses

func CheckIstioConfigTypes(store model.ConfigStore, namespace string, t *testing.T)

CheckIstioConfigTypes validates that an empty store can ingest Istio config objects

func CheckMapInvariant Uses

func CheckMapInvariant(r model.ConfigStore, t *testing.T, namespace string, n int)

CheckMapInvariant validates operational invariants of an empty config registry

func Compare Uses

func Compare(a, b model.Config) bool

Compare checks two configs ignoring revisions and creation time

func Make Uses

func Make(namespace string, i int) model.Config

Make creates a mock config indexed by a number

Package mock imports 21 packages (graph). Updated 2019-10-19. Refresh now. Tools for package owners.