storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/cmd/lock-rest-server-common_test.go (about)

     1  /*
     2   * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package cmd
    18  
    19  import (
    20  	"os"
    21  	"reflect"
    22  	"sync"
    23  	"testing"
    24  
    25  	"storj.io/minio/pkg/dsync"
    26  )
    27  
    28  // Helper function to create a lock server for testing
    29  func createLockTestServer(t *testing.T) (string, *lockRESTServer, string) {
    30  	obj, fsDir, err := prepareFS()
    31  	if err != nil {
    32  		t.Fatal(err)
    33  	}
    34  	if err = newTestConfig(globalMinioDefaultRegion, obj); err != nil {
    35  		t.Fatalf("unable initialize config file, %s", err)
    36  	}
    37  
    38  	locker := &lockRESTServer{
    39  		ll: &localLocker{
    40  			mutex:   sync.Mutex{},
    41  			lockMap: make(map[string][]lockRequesterInfo),
    42  		},
    43  	}
    44  	creds := globalActiveCred
    45  	token, err := authenticateNode(creds.AccessKey, creds.SecretKey, "")
    46  	if err != nil {
    47  		t.Fatal(err)
    48  	}
    49  	return fsDir, locker, token
    50  }
    51  
    52  // Test function to remove lock entries from map based on name & uid combination
    53  func TestLockRpcServerRemoveEntry(t *testing.T) {
    54  	testPath, locker, _ := createLockTestServer(t)
    55  	defer os.RemoveAll(testPath)
    56  
    57  	lockRequesterInfo1 := lockRequesterInfo{
    58  		Owner:           "owner",
    59  		Writer:          true,
    60  		UID:             "0123-4567",
    61  		Timestamp:       UTCNow(),
    62  		TimeLastRefresh: UTCNow(),
    63  	}
    64  	lockRequesterInfo2 := lockRequesterInfo{
    65  		Owner:           "owner",
    66  		Writer:          true,
    67  		UID:             "89ab-cdef",
    68  		Timestamp:       UTCNow(),
    69  		TimeLastRefresh: UTCNow(),
    70  	}
    71  
    72  	locker.ll.lockMap["name"] = []lockRequesterInfo{
    73  		lockRequesterInfo1,
    74  		lockRequesterInfo2,
    75  	}
    76  
    77  	lri := locker.ll.lockMap["name"]
    78  
    79  	// test unknown uid
    80  	if locker.ll.removeEntry("name", dsync.LockArgs{
    81  		Owner: "owner",
    82  		UID:   "unknown-uid",
    83  	}, &lri) {
    84  		t.Errorf("Expected %#v, got %#v", false, true)
    85  	}
    86  
    87  	if !locker.ll.removeEntry("name", dsync.LockArgs{
    88  		Owner: "owner",
    89  		UID:   "0123-4567",
    90  	}, &lri) {
    91  		t.Errorf("Expected %#v, got %#v", true, false)
    92  	} else {
    93  		gotLri := locker.ll.lockMap["name"]
    94  		expectedLri := []lockRequesterInfo{lockRequesterInfo2}
    95  		if !reflect.DeepEqual(expectedLri, gotLri) {
    96  			t.Errorf("Expected %#v, got %#v", expectedLri, gotLri)
    97  		}
    98  	}
    99  
   100  	if !locker.ll.removeEntry("name", dsync.LockArgs{
   101  		Owner: "owner",
   102  		UID:   "89ab-cdef",
   103  	}, &lri) {
   104  		t.Errorf("Expected %#v, got %#v", true, false)
   105  	} else {
   106  		gotLri := locker.ll.lockMap["name"]
   107  		expectedLri := []lockRequesterInfo(nil)
   108  		if !reflect.DeepEqual(expectedLri, gotLri) {
   109  			t.Errorf("Expected %#v, got %#v", expectedLri, gotLri)
   110  		}
   111  	}
   112  }