fakestorage

Documentation

Overview

Package fakestorage provides the server that can be used as a target on GCS-dependent tests.

The server provides a method that returns an instance of the storage client that can be used in tests.

Index

• type CreateBucketOpts
• type Object
• type Options
• type Server
  • func NewServer(objects []Object) *Server
  • func NewServerWithHostPort(objects []Object, host string, port uint16) (*Server, error)
  • func NewServerWithOptions(options Options) (*Server, error)
  • func (s *Server) Client() *storage.Client
  • func (s *Server) CreateBucket(name string)
  • func (s *Server) CreateBucketWithOpts(opts CreateBucketOpts)
  • func (s *Server) CreateObject(obj Object)
  • func (s *Server) GetObject(bucketName, objectName string) (Object, error)
  • func (s *Server) GetObjectWithGeneration(bucketName, objectName string, generation int64) (Object, error)
  • func (s *Server) HTTPClient() *http.Client
  • func (s *Server) ListObjects(bucketName, prefix, delimiter string, versions bool) ([]Object, []string, error)
  • func (s *Server) PublicURL() string
  • func (s *Server) Stop()
  • func (s *Server) URL() string

Examples

• Server (With_host_port)
• Server.Client

Types

type CreateBucketOpts

type CreateBucketOpts struct {
	Name              string
	VersioningEnabled bool
}

CreateBucketOpts defines the properties of a bucket you can create with CreateBucketWithOpts()

type Object

type Object struct {
	BucketName      string `json:"-"`
	Name            string `json:"name"`
	ContentType     string `json:"contentType"`
	ContentEncoding string `json:"contentEncoding"`
	Content         []byte `json:"-"`
	// Crc32c checksum of Content. calculated by server when it's upload methods are used.
	Crc32c  string            `json:"crc32c,omitempty"`
	Md5Hash string            `json:"md5hash,omitempty"`
	ACL     []storage.ACLRule `json:"acl,omitempty"`
	// Dates and generation can be manually injected, so you can do assertions on them,
	// or let us fill these fields for you
	Created    time.Time         `json:"created,omitempty"`
	Updated    time.Time         `json:"updated,omitempty"`
	Deleted    time.Time         `json:"deleted,omitempty"`
	Generation int64             `json:"generation,omitempty"`
	Metadata   map[string]string `json:"metadata,omitempty"`
}

Object represents the object that is stored within the fake server.

type Options

type Options struct {
	InitialObjects []Object
	StorageRoot    string
	Scheme         string
	Host           string
	Port           uint16

	// when set to true, the server will not actually start a TCP listener,
	// client requests will get processed by an internal mocked transport.
	NoListener bool

	// Optional external URL, such as https://gcs.127.0.0.1.nip.io:4443
	// Returned in the Location header for resumable uploads
	// The "real" value is https://www.googleapis.com, the JSON API
	// The default is whatever the server is bound to, such as https://0.0.0.0:4443
	ExternalURL string

	// Optional URL for public access
	// An example is "storage.gcs.127.0.0.1.nip.io:4443", which will configure
	// the server to serve objects at:
	// https://storage.gcs.127.0.0.1.nip.io:4443/<bucket>/<object>
	// https://<bucket>.storage.gcs.127.0.0.1.nip.io:4443>/<bucket>/<object>
	// If unset, the default is "storage.googleapis.com", the XML API
	PublicHost string
}

Options are used to configure the server on creation

type Server

type Server struct {
	// contains filtered or unexported fields
}

Server is the fake server.

It provides a fake implementation of the Google Cloud Storage API.

Example (With_host_port)

package main

import (
	"context"
	"fmt"
	"io/ioutil"

	"github.com/fsouza/fake-gcs-server/fakestorage"
)

func main() {
	server, err := fakestorage.NewServerWithHostPort([]fakestorage.Object{
		{
			BucketName: "some-bucket",
			Name:       "some/object/file.txt",
			Content:    []byte("inside the file"),
		},
	}, "127.0.0.1", 8081)
	if err != nil {
		panic(err)
	}
	defer server.Stop()
	client := server.Client()
	object := client.Bucket("some-bucket").Object("some/object/file.txt")
	reader, err := object.NewReader(context.Background())
	if err != nil {
		panic(err)
	}
	defer reader.Close()
	data, err := ioutil.ReadAll(reader)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s", data)
}

Output:

inside the file

func NewServer

func NewServer(objects []Object) *Server

NewServer creates a new instance of the server, pre-loaded with the given objects.

func NewServerWithHostPort

func NewServerWithHostPort(objects []Object, host string, port uint16) (*Server, error)

NewServerWithHostPort creates a new server that listens on a custom host and port

Deprecated: use NewServerWithOptions()

func NewServerWithOptions

func NewServerWithOptions(options Options) (*Server, error)

NewServerWithOptions creates a new server with custom options

func (*Server) Client

func (s *Server) Client() *storage.Client

Client returns a GCS client configured to talk to the server.

Example

package main

import (
	"context"
	"fmt"
	"io/ioutil"

	"github.com/fsouza/fake-gcs-server/fakestorage"
)

func main() {
	server := fakestorage.NewServer([]fakestorage.Object{
		{
			BucketName: "some-bucket",
			Name:       "some/object/file.txt",
			Content:    []byte("inside the file"),
		},
	})
	defer server.Stop()
	client := server.Client()
	object := client.Bucket("some-bucket").Object("some/object/file.txt")
	reader, err := object.NewReader(context.Background())
	if err != nil {
		panic(err)
	}
	defer reader.Close()
	data, err := ioutil.ReadAll(reader)
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s", data)
}

Output:

inside the file

func (*Server) CreateBucket

func (s *Server) CreateBucket(name string)

CreateBucket creates a bucket inside the server, so any API calls that require the bucket name will recognize this bucket.

If the bucket already exists, this method does nothing.

Deprecated: use CreateBucketWithOpts()

func (*Server) CreateBucketWithOpts

func (s *Server) CreateBucketWithOpts(opts CreateBucketOpts)

CreateBucketWithOpts creates a bucket inside the server, so any API calls that require the bucket name will recognize this bucket. Use CreateBucketOpts to customize the options for this bucket

If the bucket already exists, this method does nothing but panics if props differs

func (*Server) CreateObject

func (s *Server) CreateObject(obj Object)

CreateObject stores the given object internally.

If the bucket within the object doesn't exist, it also creates it. If the object already exists, it overrides the object.

func (*Server) GetObject

func (s *Server) GetObject(bucketName, objectName string) (Object, error)

GetObject returns the object with the given name in the given bucket, or an error if the object doesn't exist.

func (*Server) GetObjectWithGeneration

func (s *Server) GetObjectWithGeneration(bucketName, objectName string, generation int64) (Object, error)

GetObjectWithGeneration returns the object with the given name and given generation ID in the given bucket, or an error if the object doesn't exist. If versioning is enabled, archived versions are considered

func (*Server) HTTPClient

func (s *Server) HTTPClient() *http.Client

HTTPClient returns an HTTP client configured to talk to the server.

func (*Server) ListObjects

func (s *Server) ListObjects(bucketName, prefix, delimiter string, versions bool) ([]Object, []string, error)

ListObjects returns a sorted list of objects that match the given criteria, or an error if the bucket doesn't exist.

func (*Server) PublicURL

func (s *Server) PublicURL() string

PublicURL returns the server's public download URL.

func (*Server) Stop

func (s *Server) Stop()

Stop stops the server, closing all connections.

func (*Server) URL

func (s *Server) URL() string

URL returns the server URL.