refactor unit test and add mem delimiter support

pkg/object/mem.go

@@ -130,16 +130,36 @@ func (m *memStore) Delete(key string) error {
 }
 
 func (m *memStore) List(prefix, marker, delimiter string, limit int64) ([]Object, error) {
-	if delimiter != "" {
-		return nil, notSupportedDelimiter
-	}
 	m.Lock()
 	defer m.Unlock()
 
 	objs := make([]Object, 0)
+	var exist = make(map[string]struct{})
 	for k := range m.objects {
 		if strings.HasPrefix(k, prefix) && k > marker {
 			o := m.objects[k]
+			if delimiter != "" {
+				noPrefixKey := strings.TrimPrefix(k, prefix)
+				if strings.Contains(noPrefixKey, delimiter) {
+					commonPrefix := prefix + noPrefixKey[:strings.Index(noPrefixKey, delimiter)+1]
+					if _, ok := exist[commonPrefix]; !ok {
+						objs = append(objs, &file{
+							obj{
+								commonPrefix,
+								0,
+								time.Unix(0, 0),
+								true,
+							},
+							o.owner,
+							o.group,
+							o.mode,
+							false,
+						})
+						exist[commonPrefix] = struct{}{}
+					}
+					continue
+				}
+			}
 			f := &file{
 				obj{
 					k,

pkg/object/object_storage_test.go

@@ -172,21 +172,38 @@ func testStorage(t *testing.T, s ObjectStorage) {
 		}
 	}
 
+	defer s.Delete("a/a")
 	if err := s.Put("a/a", bytes.NewReader(br)); err != nil {
 		t.Fatalf("PUT failed: %s", err.Error())
 	}
-	defer s.Delete("a/a")
-	if err := s.Put("b/b", bytes.NewReader(br)); err != nil {
+	defer s.Delete("a/a1")
+	if err := s.Put("a/a1", bytes.NewReader(br)); err != nil {
 		t.Fatalf("PUT failed: %s", err.Error())
 	}
 	defer s.Delete("b/b")
-	if obs, err := s.List("", "", "/", 10); err != nil && !errors.Is(err, notSupported) {
+	if err := s.Put("b/b", bytes.NewReader(br)); err != nil {
+		t.Fatalf("PUT failed: %s", err.Error())
+	}
+	defer s.Delete("b/b1")
+	if err := s.Put("b/b1", bytes.NewReader(br)); err != nil {
+		t.Fatalf("PUT failed: %s", err.Error())
+	}
+	defer s.Delete("c/")
+	if err := s.Put("c/", bytes.NewReader(nil)); err != nil {
+		t.Fatalf("PUT failed: %s", err.Error())
+	}
+	if obs, err := s.List("", "", "/", 10); err != nil && !errors.Is(err, notSupportedDelimiter) {
 		t.Fatalf("list with delimiter: %s", err)
-	} else if len(obs) != 3 {
+	} else {
+		if len(obs) != 4 {
+			t.Fatalf("list with delimiter should return four results but got %d", len(obs))
+		}
+		keys := []string{"a/", "b/", "c/", "test"}
 		for i, o := range obs {
-			t.Logf("%d %s", i, o.Key())
+			if o.Key() != keys[i] {
+				t.Fatalf("should get key %s but got %s", keys[i], o.Key())
+			}
 		}
-		t.Fatalf("list with delimiter returned: %d  %+v", len(obs), obs)
 	}
 
 	// test redis cluster list all api