github.com/qiniu/go-sdk/v7@v7.27.0/storagev2/objects/directory_test.go (about)

     1  //go:build unit
     2  // +build unit
     3  
     4  package objects_test
     5  
     6  import (
     7  	"context"
     8  	"encoding/json"
     9  	"net/http"
    10  	"net/http/httptest"
    11  	"strings"
    12  	"testing"
    13  	"time"
    14  
    15  	"github.com/qiniu/go-sdk/v7/storagev2/apis/get_objects"
    16  	"github.com/qiniu/go-sdk/v7/storagev2/credentials"
    17  	"github.com/qiniu/go-sdk/v7/storagev2/http_client"
    18  	"github.com/qiniu/go-sdk/v7/storagev2/objects"
    19  	"github.com/qiniu/go-sdk/v7/storagev2/region"
    20  )
    21  
    22  func TestDirectoryListEntriesWithoutRecurse(t *testing.T) {
    23  	counted := 0
    24  	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
    25  		switch r.Method {
    26  		case http.MethodGet:
    27  			if r.URL.Path == "/list" {
    28  				rw.Header().Add("X-ReqId", "fakereqid")
    29  				rw.Header().Set("Content-Type", "application/json")
    30  				var (
    31  					jsonData []byte
    32  					err      error
    33  					query    = r.URL.Query()
    34  				)
    35  				if query.Get("bucket") != "bucket1" {
    36  					t.Fatalf("unexpected bucket")
    37  				}
    38  				if query.Get("prefix") != "" {
    39  					t.Fatalf("unexpected prefix")
    40  				}
    41  				if query.Get("delimiter") != "/" {
    42  					t.Fatalf("unexpected delimiter")
    43  				}
    44  				if query.Get("limit") != "" {
    45  					t.Fatalf("unexpected limit")
    46  				}
    47  				switch counted {
    48  				case 0:
    49  					if query.Get("marker") != "" {
    50  						t.Fatalf("unexpected marker")
    51  					}
    52  					jsonData, err = json.Marshal(&get_objects.Response{
    53  						Marker:         "testmarker1",
    54  						CommonPrefixes: []string{"test1/", "test2/"},
    55  						Items: []get_objects.ListedObjectEntry{{
    56  							Key:      "file1",
    57  							PutTime:  time.Now().UnixNano() / 100,
    58  							Hash:     "testhash1",
    59  							Size:     4 * 1024 * 1024,
    60  							MimeType: "application/json",
    61  						}},
    62  					})
    63  				case 1:
    64  					if query.Get("marker") != "testmarker1" {
    65  						t.Fatalf("unexpected marker")
    66  					}
    67  					jsonData, err = json.Marshal(&get_objects.Response{
    68  						CommonPrefixes: []string{"test3/", "test4/"},
    69  						Items: []get_objects.ListedObjectEntry{{
    70  							Key:      "file2",
    71  							PutTime:  time.Now().UnixNano() / 100,
    72  							Hash:     "testhash1",
    73  							Size:     4 * 1024 * 1024,
    74  							MimeType: "application/json",
    75  						}},
    76  					})
    77  				default:
    78  					t.Fatalf("unexpected request")
    79  				}
    80  				counted += 1
    81  				if err != nil {
    82  					t.Fatal(err)
    83  				}
    84  				rw.Write(jsonData)
    85  			} else {
    86  				t.Fatalf("unexpected path")
    87  			}
    88  			if !strings.HasPrefix(r.Header.Get("Authorization"), "Qiniu testak:") {
    89  				t.Fatalf("unexpected authorization")
    90  			}
    91  		default:
    92  			t.Fatalf("unexpected method: %s", r.Method)
    93  		}
    94  	}))
    95  	defer server.Close()
    96  
    97  	objectsManager := objects.NewObjectsManager(&objects.ObjectsManagerOptions{
    98  		Options: http_client.Options{
    99  			Credentials: credentials.NewCredentials("testak", "testsk"),
   100  			Regions:     &region.Region{Rsf: region.Endpoints{Preferred: []string{server.URL}}},
   101  		},
   102  	})
   103  	directory := objectsManager.Bucket("bucket1").Directory("", "")
   104  	listed := make(map[string]*objects.ObjectDetails)
   105  	err := directory.ListEntries(context.Background(), nil, func(de *objects.Entry) error {
   106  		if de.DirectoryName != "" {
   107  			listed[de.DirectoryName] = nil
   108  		} else {
   109  			listed[de.Object.Name] = de.Object
   110  		}
   111  		return nil
   112  	})
   113  	if err != nil {
   114  		t.Fatal(err)
   115  	}
   116  	if len(listed) != 6 {
   117  		t.Fatalf("unexpected listed length")
   118  	}
   119  	if obj, ok := listed["test1/"]; !ok || obj != nil {
   120  		t.Fatalf("unexpected directory list1")
   121  	}
   122  	if obj, ok := listed["test2/"]; !ok || obj != nil {
   123  		t.Fatalf("unexpected directory list2")
   124  	}
   125  	if obj, ok := listed["test3/"]; !ok || obj != nil {
   126  		t.Fatalf("unexpected directory list3")
   127  	}
   128  	if obj, ok := listed["test4/"]; !ok || obj != nil {
   129  		t.Fatalf("unexpected directory list4")
   130  	}
   131  	if obj, ok := listed["file1"]; !ok || obj == nil {
   132  		t.Fatalf("unexpected object file1")
   133  	}
   134  	if obj, ok := listed["file2"]; !ok || obj == nil {
   135  		t.Fatalf("unexpected object file2")
   136  	}
   137  }
   138  
   139  func TestDirectoryListEntriesWithRecurse(t *testing.T) {
   140  	counted := 0
   141  	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
   142  		switch r.Method {
   143  		case http.MethodGet:
   144  			if r.URL.Path == "/list" {
   145  				rw.Header().Set("Content-Type", "application/json")
   146  				rw.Header().Add("X-ReqId", "fakereqid")
   147  				var (
   148  					jsonData []byte
   149  					err      error
   150  					query    = r.URL.Query()
   151  				)
   152  				if query.Get("bucket") != "bucket1" {
   153  					t.Fatalf("unexpected bucket")
   154  				}
   155  				if query.Get("delimiter") != "/" {
   156  					t.Fatalf("unexpected delimiter")
   157  				}
   158  				if query.Get("limit") != "" {
   159  					t.Fatalf("unexpected limit")
   160  				}
   161  				switch counted {
   162  				case 0:
   163  					if query.Get("prefix") != "" {
   164  						t.Fatalf("unexpected prefix")
   165  					}
   166  					if query.Get("marker") != "" {
   167  						t.Fatalf("unexpected marker")
   168  					}
   169  					jsonData, err = json.Marshal(&get_objects.Response{
   170  						Marker:         "testmarker1",
   171  						CommonPrefixes: []string{"test1/"},
   172  						Items: []get_objects.ListedObjectEntry{{
   173  							Key:      "file1",
   174  							PutTime:  time.Now().UnixNano() / 100,
   175  							Hash:     "testhash1",
   176  							Size:     4 * 1024 * 1024,
   177  							MimeType: "application/json",
   178  						}},
   179  					})
   180  				case 1:
   181  					if query.Get("prefix") != "" {
   182  						t.Fatalf("unexpected prefix")
   183  					}
   184  					if query.Get("marker") != "testmarker1" {
   185  						t.Fatalf("unexpected marker")
   186  					}
   187  					jsonData, err = json.Marshal(&get_objects.Response{
   188  						CommonPrefixes: []string{"test2/"},
   189  						Items: []get_objects.ListedObjectEntry{{
   190  							Key:      "file2",
   191  							PutTime:  time.Now().UnixNano() / 100,
   192  							Hash:     "testhash1",
   193  							Size:     4 * 1024 * 1024,
   194  							MimeType: "application/json",
   195  						}},
   196  					})
   197  				case 2:
   198  					if query.Get("prefix") != "test1/" {
   199  						t.Fatalf("unexpected prefix")
   200  					}
   201  					if query.Get("marker") != "" {
   202  						t.Fatalf("unexpected marker")
   203  					}
   204  					jsonData, err = json.Marshal(&get_objects.Response{
   205  						Items: []get_objects.ListedObjectEntry{{
   206  							Key:      "test1/file1",
   207  							PutTime:  time.Now().UnixNano() / 100,
   208  							Hash:     "testhash1",
   209  							Size:     4 * 1024 * 1024,
   210  							MimeType: "application/json",
   211  						}},
   212  					})
   213  				case 3:
   214  					if query.Get("prefix") != "test2/" {
   215  						t.Fatalf("unexpected prefix")
   216  					}
   217  					if query.Get("marker") != "" {
   218  						t.Fatalf("unexpected marker")
   219  					}
   220  					jsonData, err = json.Marshal(&get_objects.Response{
   221  						Items: []get_objects.ListedObjectEntry{{
   222  							Key:      "test2/file2",
   223  							PutTime:  time.Now().UnixNano() / 100,
   224  							Hash:     "testhash1",
   225  							Size:     4 * 1024 * 1024,
   226  							MimeType: "application/json",
   227  						}},
   228  					})
   229  				default:
   230  					t.Fatalf("unexpected request")
   231  				}
   232  				counted += 1
   233  				if err != nil {
   234  					t.Fatal(err)
   235  				}
   236  				rw.Write(jsonData)
   237  			} else {
   238  				t.Fatalf("unexpected path")
   239  			}
   240  			if !strings.HasPrefix(r.Header.Get("Authorization"), "Qiniu testak:") {
   241  				t.Fatalf("unexpected authorization")
   242  			}
   243  		default:
   244  			t.Fatalf("unexpected method: %s", r.Method)
   245  		}
   246  	}))
   247  	defer server.Close()
   248  
   249  	objectsManager := objects.NewObjectsManager(&objects.ObjectsManagerOptions{
   250  		Options: http_client.Options{
   251  			Credentials: credentials.NewCredentials("testak", "testsk"),
   252  			Regions:     &region.Region{Rsf: region.Endpoints{Preferred: []string{server.URL}}},
   253  		},
   254  	})
   255  	directory := objectsManager.Bucket("bucket1").Directory("", "")
   256  	listed := make(map[string]*objects.ObjectDetails)
   257  	err := directory.ListEntries(context.Background(), &objects.ListEntriesOptions{
   258  		Recursive: true,
   259  	}, func(de *objects.Entry) error {
   260  		if de.DirectoryName != "" {
   261  			listed[de.DirectoryName] = nil
   262  		} else {
   263  			listed[de.Object.Name] = de.Object
   264  		}
   265  		return nil
   266  	})
   267  	if err != nil {
   268  		t.Fatal(err)
   269  	}
   270  	if len(listed) != 6 {
   271  		t.Fatalf("unexpected listed length")
   272  	}
   273  	if obj, ok := listed["test1/"]; !ok || obj != nil {
   274  		t.Fatalf("unexpected directory list1")
   275  	}
   276  	if obj, ok := listed["test2/"]; !ok || obj != nil {
   277  		t.Fatalf("unexpected directory list2")
   278  	}
   279  	if obj, ok := listed["file1"]; !ok || obj == nil {
   280  		t.Fatalf("unexpected object file1")
   281  	}
   282  	if obj, ok := listed["file2"]; !ok || obj == nil {
   283  		t.Fatalf("unexpected object file2")
   284  	}
   285  	if obj, ok := listed["test1/file1"]; !ok || obj == nil {
   286  		t.Fatalf("unexpected object file1")
   287  	}
   288  	if obj, ok := listed["test2/file2"]; !ok || obj == nil {
   289  		t.Fatalf("unexpected object file2")
   290  	}
   291  }
   292  
   293  func TestDirectoryListEntriesWithSkipDir(t *testing.T) {
   294  	counted := 0
   295  	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
   296  		switch r.Method {
   297  		case http.MethodGet:
   298  			if r.URL.Path == "/list" {
   299  				rw.Header().Set("Content-Type", "application/json")
   300  				rw.Header().Add("X-ReqId", "fakereqid")
   301  				var (
   302  					jsonData []byte
   303  					err      error
   304  					query    = r.URL.Query()
   305  				)
   306  				if query.Get("bucket") != "bucket1" {
   307  					t.Fatalf("unexpected bucket")
   308  				}
   309  				if query.Get("delimiter") != "/" {
   310  					t.Fatalf("unexpected delimiter")
   311  				}
   312  				if query.Get("limit") != "" {
   313  					t.Fatalf("unexpected limit")
   314  				}
   315  				switch counted {
   316  				case 0:
   317  					if query.Get("prefix") != "" {
   318  						t.Fatalf("unexpected prefix")
   319  					}
   320  					if query.Get("marker") != "" {
   321  						t.Fatalf("unexpected marker")
   322  					}
   323  					jsonData, err = json.Marshal(&get_objects.Response{
   324  						Marker:         "testmarker1",
   325  						CommonPrefixes: []string{"test1/"},
   326  						Items: []get_objects.ListedObjectEntry{{
   327  							Key:      "file1",
   328  							PutTime:  time.Now().UnixNano() / 100,
   329  							Hash:     "testhash1",
   330  							Size:     4 * 1024 * 1024,
   331  							MimeType: "application/json",
   332  						}},
   333  					})
   334  				case 1:
   335  					if query.Get("prefix") != "" {
   336  						t.Fatalf("unexpected prefix")
   337  					}
   338  					if query.Get("marker") != "testmarker1" {
   339  						t.Fatalf("unexpected marker")
   340  					}
   341  					jsonData, err = json.Marshal(&get_objects.Response{
   342  						CommonPrefixes: []string{"test2/"},
   343  						Items: []get_objects.ListedObjectEntry{{
   344  							Key:      "file2",
   345  							PutTime:  time.Now().UnixNano() / 100,
   346  							Hash:     "testhash1",
   347  							Size:     4 * 1024 * 1024,
   348  							MimeType: "application/json",
   349  						}},
   350  					})
   351  				case 2:
   352  					if query.Get("prefix") != "test1/" {
   353  						t.Fatalf("unexpected prefix")
   354  					}
   355  					if query.Get("marker") != "" {
   356  						t.Fatalf("unexpected marker")
   357  					}
   358  					jsonData, err = json.Marshal(&get_objects.Response{
   359  						Items: []get_objects.ListedObjectEntry{{
   360  							Key:      "test1/file1",
   361  							PutTime:  time.Now().UnixNano() / 100,
   362  							Hash:     "testhash1",
   363  							Size:     4 * 1024 * 1024,
   364  							MimeType: "application/json",
   365  						}, {
   366  							Key:      "test1/file2",
   367  							PutTime:  time.Now().UnixNano() / 100,
   368  							Hash:     "testhash1",
   369  							Size:     4 * 1024 * 1024,
   370  							MimeType: "application/json",
   371  						}},
   372  					})
   373  				default:
   374  					t.Fatalf("unexpected request")
   375  				}
   376  				counted += 1
   377  				if err != nil {
   378  					t.Fatal(err)
   379  				}
   380  				rw.Write(jsonData)
   381  			} else {
   382  				t.Fatalf("unexpected path")
   383  			}
   384  			if !strings.HasPrefix(r.Header.Get("Authorization"), "Qiniu testak:") {
   385  				t.Fatalf("unexpected authorization")
   386  			}
   387  		default:
   388  			t.Fatalf("unexpected method: %s", r.Method)
   389  		}
   390  	}))
   391  	defer server.Close()
   392  
   393  	objectsManager := objects.NewObjectsManager(&objects.ObjectsManagerOptions{
   394  		Options: http_client.Options{
   395  			Credentials: credentials.NewCredentials("testak", "testsk"),
   396  			Regions:     &region.Region{Rsf: region.Endpoints{Preferred: []string{server.URL}}},
   397  		},
   398  	})
   399  	directory := objectsManager.Bucket("bucket1").Directory("", "")
   400  	listed := make(map[string]*objects.ObjectDetails)
   401  	err := directory.ListEntries(context.Background(), &objects.ListEntriesOptions{
   402  		Recursive: true,
   403  	}, func(de *objects.Entry) error {
   404  		if de.DirectoryName != "" {
   405  			listed[de.DirectoryName] = nil
   406  			if de.DirectoryName == "test2/" {
   407  				return objects.SkipDir
   408  			}
   409  		} else {
   410  			listed[de.Object.Name] = de.Object
   411  			if de.Object.Name == "test1/file1" {
   412  				return objects.SkipDir
   413  			}
   414  		}
   415  		return nil
   416  	})
   417  	if err != nil {
   418  		t.Fatal(err)
   419  	}
   420  	if len(listed) != 5 {
   421  		t.Fatalf("unexpected listed length")
   422  	}
   423  	if obj, ok := listed["test1/"]; !ok || obj != nil {
   424  		t.Fatalf("unexpected directory list1")
   425  	}
   426  	if obj, ok := listed["test2/"]; !ok || obj != nil {
   427  		t.Fatalf("unexpected directory list2")
   428  	}
   429  	if obj, ok := listed["file1"]; !ok || obj == nil {
   430  		t.Fatalf("unexpected object file1")
   431  	}
   432  	if obj, ok := listed["file2"]; !ok || obj == nil {
   433  		t.Fatalf("unexpected object file2")
   434  	}
   435  	if obj, ok := listed["test1/file1"]; !ok || obj == nil {
   436  		t.Fatalf("unexpected object file1")
   437  	}
   438  }