storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/pkg/safe/safe_test.go (about)

     1  /*
     2   * MinIO Client (C) 2015, 2016, 2017 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 safe
    18  
    19  import (
    20  	"io/ioutil"
    21  	"os"
    22  	"path"
    23  	"testing"
    24  )
    25  
    26  type MySuite struct {
    27  	root string
    28  }
    29  
    30  func (s *MySuite) SetUpSuite(t *testing.T) {
    31  	root, err := ioutil.TempDir(os.TempDir(), "safe_test.go.")
    32  	if err != nil {
    33  		t.Fatal(err)
    34  	}
    35  	s.root = root
    36  }
    37  
    38  func (s *MySuite) TearDownSuite(t *testing.T) {
    39  	err := os.RemoveAll(s.root)
    40  	if err != nil {
    41  		t.Fatal(err)
    42  	}
    43  }
    44  
    45  func TestSafeAbort(t *testing.T) {
    46  	s := &MySuite{}
    47  	s.SetUpSuite(t)
    48  	defer s.TearDownSuite(t)
    49  
    50  	f, err := CreateFile(path.Join(s.root, "testfile-abort"))
    51  	if err != nil {
    52  		t.Fatal(err)
    53  	}
    54  
    55  	_, err = os.Stat(path.Join(s.root, "testfile-abort"))
    56  	if !os.IsNotExist(err) {
    57  		t.Fatal(err)
    58  	}
    59  	err = f.Abort()
    60  	if err != nil {
    61  		t.Fatal(err)
    62  	}
    63  	err = f.Close()
    64  	if err != nil {
    65  		if err.Error() != "close on aborted file" {
    66  			t.Fatal(err)
    67  		}
    68  	}
    69  }
    70  
    71  func TestSafeClose(t *testing.T) {
    72  	s := &MySuite{}
    73  	s.SetUpSuite(t)
    74  	defer s.TearDownSuite(t)
    75  
    76  	f, err := CreateFile(path.Join(s.root, "testfile-close"))
    77  	if err != nil {
    78  		t.Fatal(err)
    79  	}
    80  
    81  	_, err = os.Stat(path.Join(s.root, "testfile-close"))
    82  	if !os.IsNotExist(err) {
    83  		t.Fatal(err)
    84  	}
    85  
    86  	err = f.Close()
    87  	if err != nil {
    88  		t.Fatal(err)
    89  	}
    90  
    91  	_, err = os.Stat(path.Join(s.root, "testfile-close"))
    92  	if err != nil {
    93  		t.Fatal(err)
    94  	}
    95  
    96  	err = os.Remove(path.Join(s.root, "testfile-close"))
    97  	if err != nil {
    98  		t.Fatal(err)
    99  	}
   100  
   101  	err = f.Abort()
   102  	if err != nil {
   103  		if err.Error() != "abort on closed file" {
   104  			t.Fatal(err)
   105  		}
   106  	}
   107  }
   108  
   109  func TestSafe(t *testing.T) {
   110  	s := &MySuite{}
   111  	s.SetUpSuite(t)
   112  	defer s.TearDownSuite(t)
   113  
   114  	f, err := CreateFile(path.Join(s.root, "testfile-safe"))
   115  	if err != nil {
   116  		t.Fatal(err)
   117  	}
   118  
   119  	_, err = os.Stat(path.Join(s.root, "testfile-safe"))
   120  	if !os.IsNotExist(err) {
   121  		t.Fatal(err)
   122  	}
   123  
   124  	err = f.Close()
   125  	if err != nil {
   126  		t.Fatal(err)
   127  	}
   128  
   129  	_, err = f.Write([]byte("Test"))
   130  	if err != nil {
   131  		if err.Error() != "write on closed file" {
   132  			t.Fatal(err)
   133  		}
   134  	}
   135  
   136  	err = f.Close()
   137  	if err != nil {
   138  		if err.Error() != "close on closed file" {
   139  			t.Fatal(err)
   140  		}
   141  	}
   142  
   143  	_, err = os.Stat(path.Join(s.root, "testfile-safe"))
   144  	if err != nil {
   145  		t.Fatal(err)
   146  	}
   147  
   148  	err = os.Remove(path.Join(s.root, "testfile-safe"))
   149  	if err != nil {
   150  		t.Fatal(err)
   151  	}
   152  }
   153  
   154  func TestSafeAbortWrite(t *testing.T) {
   155  	s := &MySuite{}
   156  	s.SetUpSuite(t)
   157  	defer s.TearDownSuite(t)
   158  
   159  	f, err := CreateFile(path.Join(s.root, "purgefile-abort"))
   160  	if err != nil {
   161  		t.Fatal(err)
   162  	}
   163  
   164  	_, err = os.Stat(path.Join(s.root, "purgefile-abort"))
   165  	if !os.IsNotExist(err) {
   166  		t.Fatal(err)
   167  	}
   168  
   169  	err = f.Abort()
   170  	if err != nil {
   171  		t.Fatal(err)
   172  	}
   173  
   174  	_, err = os.Stat(path.Join(s.root, "purgefile-abort"))
   175  	if !os.IsNotExist(err) {
   176  		t.Fatal(err)
   177  	}
   178  
   179  	err = f.Abort()
   180  	if err != nil {
   181  		if err.Error() != "abort on aborted file" {
   182  			t.Fatal(err)
   183  		}
   184  	}
   185  
   186  	_, err = f.Write([]byte("Test"))
   187  	if err != nil {
   188  		if err.Error() != "write on aborted file" {
   189  			t.Fatal(err)
   190  		}
   191  	}
   192  }