kubernetes/pkg/controller/endpoint/endpoints_controller_test.go

var alwaysReady

var neverReady

var emptyNodeName

var triggerTime

var triggerTimeString

var oldTriggerTimeString

var ipv4only

var ipv6only

var ipv4ipv6

var ipv6ipv4

func testPod(namespace string, id int, nPorts int, isReady bool, ipFamilies []v1.IPFamily) *v1.Pod {}

func addPods(store cache.Store, namespace string, nPods int, nPorts int, nNotReady int, ipFamilies []v1.IPFamily) {}

func addNotReadyPodsWithSpecifiedRestartPolicyAndPhase(store cache.Store, namespace string, nPods int, nPorts int, restartPolicy v1.RestartPolicy, podPhase v1.PodPhase) {}

func makeTestServer(t *testing.T, namespace string) (*httptest.Server, *utiltesting.FakeHandler) {}

// makeBlockingEndpointTestServer will signal the blockNextAction channel on endpoint "POST", "PUT", and "DELETE"
// requests. "POST" and "PUT" requests will wait on a blockUpdate signal if provided, while "DELETE" requests will wait
// on a blockDelete signal if provided. If controller is nil, an error will be sent in the response.
func makeBlockingEndpointTestServer(t *testing.T, controller *endpointController, endpoint *v1.Endpoints, blockUpdate, blockDelete, blockNextAction chan struct{}

type endpointController

func newController(ctx context.Context, url string, batchPeriod time.Duration) *endpointController {}

func newFakeController(ctx context.Context, batchPeriod time.Duration) (*fake.Clientset, *endpointController) {}

func TestSyncEndpointsItemsPreserveNoSelector(t *testing.T) {}

func TestSyncEndpointsExistingNilSubsets(t *testing.T) {}

func TestSyncEndpointsExistingEmptySubsets(t *testing.T) {}

func TestSyncEndpointsWithPodResourceVersionUpdateOnly(t *testing.T) {}

func TestSyncEndpointsNewNoSubsets(t *testing.T) {}

func TestCheckLeftoverEndpoints(t *testing.T) {}

func TestSyncEndpointsProtocolTCP(t *testing.T) {}

func TestSyncEndpointsHeadlessServiceLabel(t *testing.T) {}

func TestSyncServiceExternalNameType(t *testing.T) {}

func TestSyncEndpointsProtocolUDP(t *testing.T) {}

func TestSyncEndpointsProtocolSCTP(t *testing.T) {}

func TestSyncEndpointsItemsEmptySelectorSelectsAll(t *testing.T) {}

func TestSyncEndpointsItemsEmptySelectorSelectsAllNotReady(t *testing.T) {}

func TestSyncEndpointsItemsEmptySelectorSelectsAllMixed(t *testing.T) {}

func TestSyncEndpointsItemsPreexisting(t *testing.T) {}

func TestSyncEndpointsItemsPreexistingIdentical(t *testing.T) {}

func TestSyncEndpointsItems(t *testing.T) {}

func TestSyncEndpointsItemsWithLabels(t *testing.T) {}

func TestSyncEndpointsItemsPreexistingLabelsChange(t *testing.T) {}

func TestWaitsForAllInformersToBeSynced2(t *testing.T) {}

func TestSyncEndpointsHeadlessService(t *testing.T) {}

func TestSyncEndpointsItemsExcludeNotReadyPodsWithRestartPolicyNeverAndPhaseFailed(t *testing.T) {}

func TestSyncEndpointsItemsExcludeNotReadyPodsWithRestartPolicyNeverAndPhaseSucceeded(t *testing.T) {}

func TestSyncEndpointsItemsExcludeNotReadyPodsWithRestartPolicyOnFailureAndPhaseSucceeded(t *testing.T) {}

func TestSyncEndpointsHeadlessWithoutPort(t *testing.T) {}

func TestPodToEndpointAddressForService(t *testing.T) {}

func TestLastTriggerChangeTimeAnnotation(t *testing.T) {}

func TestLastTriggerChangeTimeAnnotation_AnnotationOverridden(t *testing.T) {}

func TestLastTriggerChangeTimeAnnotation_AnnotationCleared(t *testing.T) {}

// TestPodUpdatesBatching verifies that endpoint updates caused by pod updates are batched together.
// This test uses real time.Sleep, as there is no easy way to mock time in endpoints controller now.
// TODO(mborsz): Migrate this test to mock clock when possible.
func TestPodUpdatesBatching(t *testing.T) {}

// TestPodAddsBatching verifies that endpoint updates caused by pod addition are batched together.
// This test uses real time.Sleep, as there is no easy way to mock time in endpoints controller now.
// TODO(mborsz): Migrate this test to mock clock when possible.
func TestPodAddsBatching(t *testing.T) {}

// TestPodDeleteBatching verifies that endpoint updates caused by pod deletion are batched together.
// This test uses real time.Sleep, as there is no easy way to mock time in endpoints controller now.
// TODO(mborsz): Migrate this test to mock clock when possible.
func TestPodDeleteBatching(t *testing.T) {}

func TestSyncEndpointsServiceNotFound(t *testing.T) {}

func TestSyncServiceOverCapacity(t *testing.T) {}

func TestTruncateEndpoints(t *testing.T) {}

func TestEndpointPortFromServicePort(t *testing.T) {}

// TestMultipleServiceChanges tests that endpoints that are not created because of an out of sync endpoints cache are eventually recreated
// A service will be created. After the endpoints exist, the service will be deleted and the endpoints will not be deleted from the cache immediately.
// After the service is recreated, the endpoints will be deleted replicating an out of sync cache. Expect that eventually the endpoints will be recreated.
func TestMultipleServiceChanges(t *testing.T) {}

// TestMultiplePodChanges tests that endpoints that are not updated because of an out of sync endpoints cache are
// eventually resynced after multiple Pod changes.
func TestMultiplePodChanges(t *testing.T) {}

func TestSyncServiceAddresses(t *testing.T) {}

func TestEndpointsDeletionEvents(t *testing.T) {}

func stringVal(str *string) string {}

// waitForChanReceive blocks up to the timeout waiting for the receivingChan to receive
func waitForChanReceive(t *testing.T, timeout time.Duration, receivingChan chan struct{}

func TestEndpointSubsetsEqualIgnoreResourceVersion(t *testing.T) {}