pullerErr:  nil,
			qps:        0.0,
			burst:      0,
			expected: []pullerExpects{
				{[]string{"GetImageRef", "PullImage", "GetImageSize"}, nil, true, true},
				{[]string{"GetImageRef", "PullImage", "GetImageSize"}, nil, true, true},
				{[]string{"GetImageRef", "PullImage", "GetImageSize"}, nil, true, true},
			}},
		// missing image, error PullNever
		{containerImage: "missing_image",

}

// GetImageSize mocks base method.
func (m *MockRuntime) GetImageSize(ctx context.Context, image container.ImageSpec) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImageSize", ctx, image)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageSize indicates an expected call of GetImageSize.

		var size uint64
		if err == nil && imageRef != "" {
			// Getting the image size with best effort, ignoring the error.
			size, _ = pip.imageService.GetImageSize(ctx, spec)
		}
		pullChan <- pullResult{
			imageRef:     imageRef,
			imageSize:    size,
			err:          err,
			pullDuration: time.Since(startTime),
		}
	}()
}

		if i.ID == image.Image {
			return i.ID, nil
		}
	}
	return "", f.InspectErr
}

func (f *FakeRuntime) GetImageSize(_ context.Context, image kubecontainer.ImageSpec) (uint64, error) {
	f.Lock()
	defer f.Unlock()

	f.CalledFunctions = append(f.CalledFunctions, "GetImageSize")
	return 0, f.Err
}

func (f *FakeRuntime) ListImages(_ context.Context) ([]kubecontainer.Image, error) {
	f.Lock()

		klog.ErrorS(err, "Failed to get image status", "image", image.Image)
		return "", err
	}
	if resp.Image == nil {
		return "", nil
	}
	return resp.Image.Id, nil
}

func (m *kubeGenericRuntimeManager) GetImageSize(ctx context.Context, image kubecontainer.ImageSpec) (uint64, error) {
	resp, err := m.imageService.ImageStatus(ctx, toRuntimeAPIImageSpec(image), false)
	if err != nil {

	assert.NoError(t, err)

	const imageSize = uint64(64)
	fakeImageService.SetFakeImageSize(imageSize)
	image := "busybox"
	fakeImageService.SetFakeImages([]string{image})
	actualSize, err := fakeManager.GetImageSize(ctx, kubecontainer.ImageSpec{Image: image})
	assert.NoError(t, err)
	assert.Equal(t, imageSize, actualSize)
}

func TestGetImageRefImageNotAvailableLocally(t *testing.T) {
	ctx := context.Background()

	ImageStats(ctx context.Context) (*ImageStats, error)
	// ImageFsInfo returns a list of file systems for containers/images
	ImageFsInfo(ctx context.Context) (*runtimeapi.ImageFsInfoResponse, error)
	// GetImageSize returns the size of the image
	GetImageSize(ctx context.Context, image ImageSpec) (uint64, error)
}

// Attacher interface allows to attach a container.
type Attacher interface {