How to use Reader method of gcs Package

Best Syzkaller code snippet using gcs.Reader

gcs.go

Source:gcs.go

...103}104// ReadFile reads the file from the storage and returns the contents.105func (s *gcsStorage) ReadFile(ctx context.Context, name string) ([]byte, error) {106	object := s.objectName(name)107	rc, err := s.bucket.Object(object).NewReader(ctx)108	if err != nil {109		return nil, errors.Annotatef(err,110			"failed to read gcs file, file info: input.bucket='%s', input.key='%s'",111			s.gcs.Bucket, object)112	}113	defer rc.Close()114	size := rc.Attrs.Size115	var b []byte116	if size < 0 {117		// happened when using fake-gcs-server in integration test118		b, err = io.ReadAll(rc)119	} else {120		b = make([]byte, size)121		_, err = io.ReadFull(rc, b)122	}123	return b, errors.Trace(err)124}125// FileExists return true if file exists.126func (s *gcsStorage) FileExists(ctx context.Context, name string) (bool, error) {127	object := s.objectName(name)128	_, err := s.bucket.Object(object).Attrs(ctx)129	if err != nil {130		if errors.Cause(err) == storage.ErrObjectNotExist { // nolint:errorlint131			return false, nil132		}133		return false, errors.Trace(err)134	}135	return true, nil136}137// Open a Reader by file path.138func (s *gcsStorage) Open(ctx context.Context, path string) (ExternalFileReader, error) {139	object := s.objectName(path)140	handle := s.bucket.Object(object)141	rc, err := handle.NewRangeReader(ctx, 0, -1)142	if err != nil {143		return nil, errors.Annotatef(err,144			"failed to read gcs file, file info: input.bucket='%s', input.key='%s'",145			s.gcs.Bucket, path)146	}147	return &gcsObjectReader{148		storage:   s,149		name:      path,150		objHandle: handle,151		reader:    rc,152		ctx:       ctx,153	}, nil154}155// WalkDir traverse all the files in a dir.156//157// fn is the function called for each regular file visited by WalkDir.158// The first argument is the file path that can be used in `Open`159// function; the second argument is the size in byte of the file determined160// by path.161func (s *gcsStorage) WalkDir(ctx context.Context, opt *WalkOption, fn func(string, int64) error) error {162	if opt == nil {163		opt = &WalkOption{}164	}165	if len(opt.ObjPrefix) != 0 {166		return errors.New("gcs storage not support ObjPrefix for now")167	}168	prefix := path.Join(s.gcs.Prefix, opt.SubDir)169	if len(prefix) > 0 && !strings.HasSuffix(prefix, "/") {170		prefix += "/"171	}172	query := &storage.Query{Prefix: prefix}173	// only need each object's name and size174	err := query.SetAttrSelection([]string{"Name", "Size"})175	if err != nil {176		return errors.Trace(err)177	}178	iter := s.bucket.Objects(ctx, query)179	for {180		attrs, err := iter.Next()181		if err == iterator.Done {182			break183		}184		if err != nil {185			return errors.Trace(err)186		}187		// when walk on specify directory, the result include storage.Prefix,188		// which can not be reuse in other API(Open/Read) directly.189		// so we use TrimPrefix to filter Prefix for next Open/Read.190		path := strings.TrimPrefix(attrs.Name, s.gcs.Prefix)191		// trim the prefix '/' to ensure that the path returned is consistent with the local storage192		path = strings.TrimPrefix(path, "/")193		if err = fn(path, attrs.Size); err != nil {194			return errors.Trace(err)195		}196	}197	return nil198}199func (s *gcsStorage) URI() string {200	return "gcs://" + s.gcs.Bucket + "/" + s.gcs.Prefix201}202// Create implements ExternalStorage interface.203func (s *gcsStorage) Create(ctx context.Context, name string) (ExternalFileWriter, error) {204	object := s.objectName(name)205	wc := s.bucket.Object(object).NewWriter(ctx)206	wc.StorageClass = s.gcs.StorageClass207	wc.PredefinedACL = s.gcs.PredefinedAcl208	return newFlushStorageWriter(wc, &emptyFlusher{}, wc), nil209}210// Rename file name from oldFileName to newFileName.211func (s *gcsStorage) Rename(ctx context.Context, oldFileName, newFileName string) error {212	data, err := s.ReadFile(ctx, oldFileName)213	if err != nil {214		return errors.Trace(err)215	}216	err = s.WriteFile(ctx, newFileName, data)217	if err != nil {218		return errors.Trace(err)219	}220	return s.DeleteFile(ctx, oldFileName)221}222func newGCSStorage(ctx context.Context, gcs *backuppb.GCS, opts *ExternalStorageOptions) (*gcsStorage, error) {223	var clientOps []option.ClientOption224	if opts.NoCredentials {225		clientOps = append(clientOps, option.WithoutAuthentication())226	} else {227		if gcs.CredentialsBlob == "" {228			creds, err := google.FindDefaultCredentials(ctx, storage.ScopeReadWrite)229			if err != nil {230				return nil, errors.Annotatef(berrors.ErrStorageInvalidConfig, "%v Or you should provide '--gcs.credentials_file'", err)231			}232			if opts.SendCredentials {233				if len(creds.JSON) > 0 {234					gcs.CredentialsBlob = string(creds.JSON)235				} else {236					return nil, errors.Annotate(berrors.ErrStorageInvalidConfig,237						"You should provide '--gcs.credentials_file' when '--send-credentials-to-tikv' is true")238				}239			}240			if creds != nil {241				clientOps = append(clientOps, option.WithCredentials(creds))242			}243		} else {244			clientOps = append(clientOps, option.WithCredentialsJSON([]byte(gcs.GetCredentialsBlob())))245		}246	}247	if gcs.Endpoint != "" {248		clientOps = append(clientOps, option.WithEndpoint(gcs.Endpoint))249	}250	if opts.HTTPClient != nil {251		clientOps = append(clientOps, option.WithHTTPClient(opts.HTTPClient))252	}253	client, err := storage.NewClient(ctx, clientOps...)254	if err != nil {255		return nil, errors.Trace(err)256	}257	if !opts.SendCredentials {258		// Clear the credentials if exists so that they will not be sent to TiKV259		gcs.CredentialsBlob = ""260	}261	bucket := client.Bucket(gcs.Bucket)262	// check whether it's a bug before #647, to solve case #2263	// If the storage is set as gcs://bucket/prefix/,264	// the backupmeta is written correctly to gcs://bucket/prefix/backupmeta,265	// but the SSTs are written wrongly to gcs://bucket/prefix//*.sst (note the extra slash).266	// see details about case 2 at https://github.com/pingcap/br/issues/675#issuecomment-753780742267	sstInPrefix := hasSSTFiles(ctx, bucket, gcs.Prefix)268	sstInPrefixSlash := hasSSTFiles(ctx, bucket, gcs.Prefix+"//")269	if sstInPrefixSlash && !sstInPrefix {270		// This is a old bug, but we must make it compatible.271		// so we need find sst in slash directory272		gcs.Prefix += "//"273	}274	return &gcsStorage{gcs: gcs, bucket: bucket}, nil275}276func hasSSTFiles(ctx context.Context, bucket *storage.BucketHandle, prefix string) bool {277	query := storage.Query{Prefix: prefix}278	_ = query.SetAttrSelection([]string{"Name"})279	it := bucket.Objects(ctx, &query)280	for {281		attrs, err := it.Next()282		if err == iterator.Done { // nolint:errorlint283			break284		}285		if err != nil {286			log.Warn("failed to list objects on gcs, will use default value for `prefix`", zap.Error(err))287			break288		}289		if strings.HasSuffix(attrs.Name, ".sst") {290			log.Info("sst file found in prefix slash", zap.String("file", attrs.Name))291			return true292		}293	}294	return false295}296// gcsObjectReader wrap storage.Reader and add the `Seek` method.297type gcsObjectReader struct {298	storage   *gcsStorage299	name      string300	objHandle *storage.ObjectHandle301	reader    io.ReadCloser302	pos       int64303	// reader context used for implement `io.Seek`304	// currently, lightning depends on package `xitongsys/parquet-go` to read parquet file and it needs `io.Seeker`305	// See: https://github.com/xitongsys/parquet-go/blob/207a3cee75900b2b95213627409b7bac0f190bb3/source/source.go#L9-L10306	ctx context.Context307}308// Read implement the io.Reader interface.309func (r *gcsObjectReader) Read(p []byte) (n int, err error) {310	if r.reader == nil {311		rc, err := r.objHandle.NewRangeReader(r.ctx, r.pos, -1)312		if err != nil {313			return 0, errors.Annotatef(err,314				"failed to read gcs file, file info: input.bucket='%s', input.key='%s'",315				r.storage.gcs.Bucket, r.name)316		}317		r.reader = rc318	}319	n, err = r.reader.Read(p)320	r.pos += int64(n)321	return n, err322}323// Close implement the io.Closer interface.324func (r *gcsObjectReader) Close() error {325	if r.reader == nil {326		return nil327	}328	return r.reader.Close()329}330// Seek implement the io.Seeker interface.331//332// Currently, tidb-lightning depends on this method to read parquet file for gcs storage.333func (r *gcsObjectReader) Seek(offset int64, whence int) (int64, error) {334	var realOffset int64335	switch whence {336	case io.SeekStart:337		if offset < 0 {338			return 0, errors.Annotatef(berrors.ErrInvalidArgument, "Seek: offset '%v' out of range.", offset)339		}340		realOffset = offset341	case io.SeekCurrent:342		realOffset = r.pos + offset343		if r.pos < 0 && realOffset >= 0 {344			return 0, errors.Annotatef(berrors.ErrInvalidArgument, "Seek: offset '%v' out of range. current pos is '%v'.", offset, r.pos)345		}346	case io.SeekEnd:347		if offset >= 0 {348			return 0, errors.Annotatef(berrors.ErrInvalidArgument, "Seek: offset '%v' should be negative.", offset)349		}350		// GCS supports `NewRangeReader(ctx, -10, -1)`, which means read the last 10 bytes.351		realOffset = offset352	default:353		return 0, errors.Annotatef(berrors.ErrStorageUnknown, "Seek: invalid whence '%d'", whence)354	}355	if realOffset == r.pos {356		return realOffset, nil357	}358	_ = r.reader.Close()359	r.pos = realOffset360	rc, err := r.objHandle.NewRangeReader(r.ctx, r.pos, -1)361	if err != nil {362		return 0, errors.Annotatef(err,363			"failed to read gcs file, file info: input.bucket='%s', input.key='%s'",364			r.storage.gcs.Bucket, r.name)365	}366	r.reader = rc367	return realOffset, nil368}...

store.go

Source:store.go

...55		return false, err56	}57	return true, nil58}59type gcsReader struct {60	g            *gcs61	objectName   string62	objectReader io.ReadCloser63}64func (r *gcsReader) WriteTo(writer io.Writer) (n int64, err error) {65	return storage.PipeIO(writer, r.objectReader)66}67func (r *gcsReader) Close() error {68	return r.objectReader.Close()69}70func (r *gcsReader) Read(p []byte) (n int, err error) {71	read, err := r.objectReader.Read(p)72	return read, err73}74func (r *gcsReader) ReadAt(p []byte, offset int64) (n int, err error) {75	objectReader, err := r.g.readOnlyClient.Bucket(r.g.bucket).Object(r.objectName).NewRangeReader(76		r.g.ctx, offset, int64(len(p)))77	if err != nil {78		return 0, err79	}80	return objectReader.Read(p)81}82func toSentinelErrors(err error) error {83	// return sentinel errors defined by the status package84	if strings.Contains(err.Error(), "object doesn't exist") {85		return status.ErrNotExists86	}87	return err88}89func (g *gcs) Get(ctx context.Context, objectName string) (io.ReadCloser, error) {90	objectReader, err := g.readOnlyClient.Bucket(g.bucket).Object(objectName).NewReader(ctx)91	if err != nil {92		return nil, toSentinelErrors(err)93	}94	return &gcsReader{95		g:            g,96		objectReader: objectReader,97	}, nil98}99func (g *gcs) GetAttr(ctx context.Context, objectName string) (storage.Attributes, error) {100	attr, err := g.readOnlyClient.Bucket(g.bucket).Object(objectName).Attrs(ctx)101	if err != nil {102		return storage.Attributes{}, err103	}104	return storage.Attributes{105		Created: attr.Created,106		Updated: attr.Updated,107		Owner:   attr.Owner,108	}, nil109}110func (g *gcs) GetAt(ctx context.Context, objectName string) (io.ReaderAt, error) {111	return &gcsReader{112		g:          g,113		objectName: objectName,114	}, nil115}116func (g *gcs) Touch(ctx context.Context, objectName string) error {117	_, err := g.client.Bucket(g.bucket).Object(objectName).Update(ctx, gcsStorage.ObjectAttrsToUpdate{})118	return err119}120type readCloser struct {121	reader io.Reader122}123func (rc readCloser) Read(p []byte) (n int, err error) {124	return rc.reader.Read(p)125}126func (rc readCloser) Close() error {127	return nil128}129func (g *gcs) Put(ctx context.Context, objectName string, reader io.Reader, newObject storage.NewKey) error {130	// Put if not present131	var writer *gcsStorage.Writer132	b := false133	if newObject {134		b = true135	}136	if newObject {137		writer = g.client.Bucket(g.bucket).Object(objectName).If(gcsStorage.Conditions{138			DoesNotExist: b,139		}).NewWriter(ctx)140	} else {141		writer = g.client.Bucket(g.bucket).Object(objectName).NewWriter(ctx)142	}143	_, err := storage.PipeIO(writer, readCloser{reader: reader})144	if err != nil {145		return err146	}147	return writer.Close()148}149func (g *gcs) PutCRC(ctx context.Context, objectName string, reader io.Reader, doesNotExist bool, crc uint32) error {150	// Put if not present151	var writer *gcsStorage.Writer152	if doesNotExist {153		writer = g.client.Bucket(g.bucket).Object(objectName).If(gcsStorage.Conditions{154			DoesNotExist: doesNotExist,155		}).NewWriter(ctx)156	} else {157		writer = g.client.Bucket(g.bucket).Object(objectName).NewWriter(ctx)158	}159	writer.CRC32C = crc160	_, err := storage.PipeIO(writer, readCloser{reader: reader})161	if err != nil {162		return err163	}...

gcs_reader.go

Source:gcs_reader.go

...18	"io"19	"github.com/coreos/etcd-operator/pkg/backup/util"20	"cloud.google.com/go/storage"21)22// ensure gcsReader satisfies reader interface.23var _ Reader = &gcsReader{}24// gcsReader provides Reader implementation for reading a file from GCS25type gcsReader struct {26	ctx context.Context27	gcs *storage.Client28}29// NewGCSReader return a Reader implementation to read a file from GCS in the form of gcsReader30func NewGCSReader(ctx context.Context, gcs *storage.Client) Reader {31	return &gcsReader{ctx, gcs}32}33// Open opens the file on path where path must be in the format "<gcs-bucket-name>/<key>"34func (gcsr *gcsReader) Open(path string) (io.ReadCloser, error) {35	bucket, key, err := util.ParseBucketAndKey(path)36	if err != nil {37		return nil, fmt.Errorf("failed to parse gcs bucket and key: %v", err)38	}39	return gcsr.gcs.Bucket(bucket).Object(key).NewReader(gcsr.ctx)40}...

Reader

Using AI Code Generation

1import (2func main() {3	ctx := context.Background()4	client, err := storage.NewClient(ctx)5	if err != nil {6		log.Fatal(err)7	}8	bucket := client.Bucket("my-bucket")9	object := bucket.Object("my-object")10	rc, err := object.NewReader(ctx)11	if err != nil {12		log.Fatal(err)13	}14	defer rc.Close()15	buf := make([]byte, 1024)16	for {17		n, err := rc.Read(buf)18		if err == io.EOF {19		}20		if err != nil {21			log.Fatal(err)22		}23		fmt.Println(string(buf[:n]))24	}25}26import (27func main() {28	ctx := context.Background()29	client, err := storage.NewClient(ctx)30	if err != nil {31		log.Fatal(err)32	}33	bucket := client.Bucket("my-bucket")34	object := bucket.Object("my-object")35	wc := object.NewWriter(ctx)36	wc.ACL = []storage.ACLRule{{Entity: storage.AllUsers, Role: storage.RoleReader}}37	if _, err := io.Copy(wc, strings.NewReader("Hello World")); err != nil {38		log.Fatal(err)39	}40	if err := wc.Close(); err != nil {41		log.Fatal(err)42	}43}44import (45func main() {46	ctx := context.Background()47	client, err := storage.NewClient(ctx)48	if err != nil {49		log.Fatal(err)50	}51	bucket := client.Bucket("my-bucket")52	object := bucket.Object("my-object")53	if err := object.Delete(ctx); err != nil {54		log.Fatal(err)55	}56}57import (58func main() {59	ctx := context.Background()

Reader

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    client, err := storage.NewClient(ctx, option.WithServiceAccountFile("/home/username/service_account.json"))5    if err != nil {6        fmt.Println("Error creating client")7        fmt.Println(err)8        os.Exit(1)9    }10    bucket := client.Bucket("my-bucket")11    object := bucket.Object("my-object")12    r, err := object.NewReader(ctx)13    if err != nil {14        fmt.Println("Error creating reader")15        fmt.Println(err)16        os.Exit(1)17    }18    defer r.Close()19    if _, err := io.Copy(os.Stdout, r); err != nil {20        fmt.Println("Error copying object")21        fmt.Println(err)22        os.Exit(1)23    }24}25const {Storage} = require('@google-cloud/storage');26const storage = new Storage();27exports.helloGCS = (event, context) => {28  const file = event.data;29  console.log(`File ${file.name} uploaded.`);30};

Reader

Using AI Code Generation

1import (2type GCS struct {3}4func NewGCS(ctx context.Context, projectID, bucketName string) (*GCS, error) {5	client, err := storage.NewClient(ctx, option.WithScopes(storage.ScopeFullControl))6	if err != nil {7	}8	return &GCS{9		bucket: client.Bucket(bucketName),10	}, nil11}12func main() {13	jsonKey := os.Getenv("GOOGLE_APPLICATION_CREDENTIALS")14	if jsonKey == "" {15		log.Fatal("GOOGLE_APPLICATION_CREDENTIALS environment variable must be set.")16	}17	ctx := context.Background()18	client, err := google.DefaultClient(ctx, storage.ScopeFullControl)19	if err != nil {20		log.Fatalf("Unable to get authenticated client: %v", err)21	}22	gcs, err := NewGCS(ctx, "my-project", "my-bucket")23	if err != nil {24		log.Fatalf("Unable to create gcs client: %v", err)25	}26	f, err := os.Create("test.txt")27	if err != nil {28		log.Fatalf("Failed to create file: %v", err)29	}30	defer f.Close()31	if _, err := f.Write([]byte("Hello GCS!")); err != nil {32		log.Fatalf("Failed to write to file: %v", err)33	}34	wc := gcs.bucket.Object("test.txt").NewWriter(ctx)35	if _, err := io.Copy(wc, f); err != nil {36		log.Fatalf("Failed to upload file: %v", err)37	}38	if err := wc.Close(); err != nil {39		log.Fatalf("Failed to close: %v

Reader

Using AI Code Generation

1func main() {2    ctx := context.Background()3    client, err := storage.NewClient(ctx)4    if err != nil {5        log.Fatal(err)6    }7    defer client.Close()8    bucket := client.Bucket("bucket-name")9    object := bucket.Object("object-name")10    r, err := object.NewReader(ctx)11    if err != nil {12        log.Fatal(err)13    }14    defer r.Close()15    if _, err := io.Copy(os.Stdout, r); err != nil {16        log.Fatal(err)17    }18}19func main() {20    ctx := context.Background()21    client, err := storage.NewClient(ctx)22    if err != nil {23        log.Fatal(err)24    }25    defer client.Close()26    bucket := client.Bucket("bucket-name")27    object := bucket.Object("object-name")28    r, err := object.NewReader(ctx)29    if err != nil {30        log.Fatal(err)31    }32    defer r.Close()33    if _, err := io.Copy(os.Stdout, r); err != nil {34        log.Fatal(err)35    }36}37func main() {38    ctx := context.Background()39    client, err := storage.NewClient(ctx)40    if err != nil {41        log.Fatal(err)42    }43    defer client.Close()44    bucket := client.Bucket("bucket-name")45    object := bucket.Object("object-name")46    r, err := object.NewReader(ctx)47    if err != nil {48        log.Fatal(err)49    }50    defer r.Close()51    if _, err := io.Copy(os.Stdout, r); err != nil {52        log.Fatal(err)53    }54}55func main() {56    ctx := context.Background()57    client, err := storage.NewClient(ctx)58    if err != nil {59        log.Fatal(err)60    }61    defer client.Close()62    bucket := client.Bucket("bucket-name")63    object := bucket.Object("object-name")64    r, err := object.NewReader(ctx)65    if err != nil {66        log.Fatal(err)67    }68    defer r.Close()69    if _, err := io.Copy(os.Stdout, r); err != nil {70        log.Fatal(err)71    }72}

Reader

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    client, err := storage.NewClient(ctx)5    if err != nil {6        fmt.Println("error:", err)7    }8    defer client.Close()9    reader, err := client.Bucket(bucket).Object(file).NewReader(ctx)10    if err != nil {11        fmt.Println("error:", err)12    }13    defer reader.Close()14    buf := make([]byte, 1024)15    for {16        n, err := reader.Read(buf)17        if err != nil {18        }19        fmt.Print(string(buf[:n]))20    }21}22import (23func main() {24    ctx := context.Background()25    client, err := storage.NewClient(ctx)26    if err != nil {27        fmt.Println("error:", err)28    }29    defer client.Close()30    reader, err := client.Bucket(bucket).Object(file).NewReader(ctx)31    if err != nil {32        fmt.Println("error:", err)33    }34    defer reader.Close()35    buf := make([]byte, 1024)36    for {37        n, err := reader.Read(buf)38        if err != nil {39        }40        fmt.Print(string(buf[:n]))41    }42}43import (44func main() {45    ctx := context.Background()46    client, err := storage.NewClient(ctx)47    if err != nil {48        fmt.Println("error:", err)49    }50    defer client.Close()51    reader, err := client.Bucket(bucket).Object(file).NewReader(ctx)52    if err != nil {53        fmt.Println("error:", err)54    }

Reader

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    client, err := storage.NewClient(ctx)5    if err != nil {6        fmt.Println(err)7    }8    bucket := client.Bucket(bucketName)9    object := bucket.Object(objectName)10    r, err := object.NewReader(ctx)11    if err != nil {12        fmt.Println(err)13    }14    if _, err := io.Copy(os.Stdout, r); err != nil {15        fmt.Println(err)16    }17    if err := r.Close(); err != nil {18        fmt.Println(err)19    }20}21import (22func main() {23    ctx := context.Background()24    client, err := storage.NewClient(ctx)25    if err != nil {26        fmt.Println(err)27    }28    bucket := client.Bucket(bucketName)29    object := bucket.Object(objectName)30    r, err := object.NewReader(ctx)31    if err != nil {32        fmt.Println(err)

Reader

Using AI Code Generation

1func TestReader(t *testing.T) {2}3func TestWriter(t *testing.T) {4}5func TestReader(t *testing.T) {6}7func TestWriter(t *testing.T) {8}

Reader

Using AI Code Generation

1import (2func main() {3    ctx := context.Background()4    client, err := storage.NewClient(ctx)5    if err != nil {6        log.Fatal(err)7    }8    bucket := client.Bucket("my-bucket")9    object := bucket.Object("my-object")10    r, err := object.NewReader(ctx)11    if err != nil {12        log.Fatal(err)13    }14    defer r.Close()15    if _, err := io.Copy(os.Stdout, r); err != nil {16        log.Fatal(err)17    }18}19import (20func main() {21    ctx := context.Background()22    client, err := storage.NewClient(ctx)23    if err != nil {24        log.Fatal(err)25    }26    bucket := client.Bucket("my-bucket")27    object := bucket.Object("my-object")28    r, err := object.NewReader(ctx)29    if err != nil {30        log.Fatal(err)31    }32    defer r.Close()33    data, err := ioutil.ReadAll(r)34    if err != nil {35        log.Fatal(err)36    }37    fmt.Println(string(data))38}39import (40func main() {41    ctx := context.Background()42    client, err := storage.NewClient(ctx)43    if err != nil {44        log.Fatal(err)45    }46    bucket := client.Bucket("my-bucket")

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.